ewintr
/
planner
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

delete

This commit is contained in:
Erik Winter 2024-11-28 07:20:41 +01:00
parent b39a2dee48
commit 662d8de191
6 changed files with 163 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
plan/command/add.go
View File

@ -32,7 +32,7 @@ func NewAdd(localRepo storage.LocalID, eventRepo storage.Event, syncRepo storage
}
}
func (add *Add) Parse(main []string, flags map[string]string) error {
func (add *Add) Execute(main []string, flags map[string]string) error {
if len(main) == 0 || main[0] != "add" {
return ErrWrongCommand
}
@ -69,10 +69,10 @@ func (add *Add) Parse(main []string, flags map[string]string) error {
}
}
return nil
return add.do()
}
func (add *Add) Do() error {
func (add *Add) do() error {
as := add.argSet
start := as.GetTime(FlagOn)
if as.IsSet(FlagAt) {

26
plan/command/add_test.go
View File

@ -25,13 +25,12 @@ func TestAdd(t *testing.T) {
name string
main []string
flags map[string]string
expParseErr bool
expErr bool
expEvent item.Event
expDoErr bool
}{
{
name: "empty",
expParseErr: true,
expErr: true,
},
{
name: "title missing",
@ -39,12 +38,12 @@ func TestAdd(t *testing.T) {
flags: map[string]string{
command.FlagOn: aDateStr,
},
expParseErr: true,
expErr: true,
},
{
name: "date missing",
main: []string{"add", "some", "title"},
expParseErr: true,
expErr: true,
},
{
name: "only date",
@ -101,7 +100,7 @@ func TestAdd(t *testing.T) {
command.FlagOn: aDateStr,
command.FlagFor: anHourStr,
},
expParseErr: true,
expErr: true,
},
} {
t.Run(tc.name, func(t *testing.T) {
@ -109,21 +108,14 @@ func TestAdd(t *testing.T) {
localRepo := memory.NewLocalID()
syncRepo := memory.NewSync()
cmd := command.NewAdd(localRepo, eventRepo, syncRepo)
actParseErr := cmd.Parse(tc.main, tc.flags) != nil
if tc.expParseErr != actParseErr {
t.Errorf("exp %v, got %v", tc.expParseErr, actParseErr)
actParseErr := cmd.Execute(tc.main, tc.flags) != nil
if tc.expErr != actParseErr {
t.Errorf("exp %v, got %v", tc.expErr, actParseErr)
}
if tc.expParseErr {
if tc.expErr {
return
}
actDoErr := cmd.Do() != nil
if tc.expDoErr != actDoErr {
t.Errorf("exp %v, got %v", tc.expDoErr, actDoErr)
}
if tc.expDoErr {
return
}
actEvents, err := eventRepo.FindAll()
if err != nil {
t.Errorf("exp nil, got %v", err)

7
plan/command/command.go
View File

@ -14,8 +14,7 @@ const (
)
type Command interface {
Parse([]string, map[string]string) error
Do() error
Execute([]string, map[string]string) error
}
type CLI struct {
@ -28,14 +27,12 @@ func (cli *CLI) Run(args []string) error {
return err
}
for _, c := range cli.Commands {
err := c.Parse(main, flags)
err := c.Execute(main, flags)
switch {
case errors.Is(err, ErrWrongCommand):
continue
case err != nil:
return err
default:
return c.Do()
}
}

52
plan/command/delete.go
View File

@ -2,39 +2,47 @@ package command
import (
"fmt"
"strconv"
"github.com/urfave/cli/v2"
"go-mod.ewintr.nl/planner/plan/storage"
)
var DeleteCmd = &cli.Command{
Name: "delete",
Usage: "Delete an event",
Flags: []cli.Flag{
&cli.IntFlag{
Name: "localID",
Aliases: []string{"l"},
Usage: "The local id of the event",
Required: true,
},
},
type Delete struct {
localIDRepo storage.LocalID
eventRepo storage.Event
syncRepo storage.Sync
localID int
}
func NewDeleteCmd(localRepo storage.LocalID, eventRepo storage.Event, syncRepo storage.Sync) *cli.Command {
DeleteCmd.Action = func(cCtx *cli.Context) error {
return Delete(localRepo, eventRepo, syncRepo, cCtx.Int("localID"))
func NewDelete(localIDRepo storage.LocalID, eventRepo storage.Event, syncRepo storage.Sync) Command {
return &Delete{
localIDRepo: localIDRepo,
eventRepo: eventRepo,
syncRepo: syncRepo,
}
return DeleteCmd
}
func Delete(localRepo storage.LocalID, eventRepo storage.Event, syncRepo storage.Sync, localID int) error {
func (del *Delete) Execute(main []string, flags map[string]string) error {
if len(main) < 2 || main[0] != "delete" {
return ErrWrongCommand
}
localID, err := strconv.Atoi(main[1])
if err != nil {
return fmt.Errorf("not a local id: %v", main[1])
}
del.localID = localID
return del.do()
}
func (del *Delete) do() error {
var id string
idMap, err := localRepo.FindAll()
idMap, err := del.localIDRepo.FindAll()
if err != nil {
return fmt.Errorf("could not get local ids: %v", err)
}
for eid, lid := range idMap {
if localID == lid {
if del.localID == lid {
id = eid
}
}
@ -42,11 +50,11 @@ func Delete(localRepo storage.LocalID, eventRepo storage.Event, syncRepo storage
return fmt.Errorf("could not find local id")
}
if err := eventRepo.Delete(id); err != nil {
if err := del.eventRepo.Delete(id); err != nil {
return fmt.Errorf("could not delete event: %v", err)
}
e, err := eventRepo.Find(id)
e, err := del.eventRepo.Find(id)
if err != nil {
return fmt.Errorf("could not get event: %v", err)
}
@ -55,7 +63,7 @@ func Delete(localRepo storage.LocalID, eventRepo storage.Event, syncRepo storage
if err != nil {
return fmt.Errorf("could not convert event to sync item: %v", err)
}
if err := syncRepo.Store(it); err != nil {
if err := del.syncRepo.Store(it); err != nil {
return fmt.Errorf("could not store sync item: %v", err)
}
return nil

6
plan/command/update.go
View File

@ -33,7 +33,7 @@ func NewUpdate(localIDRepo storage.LocalID, eventRepo storage.Event, syncRepo st
}
}
func (update *Update) Parse(main []string, flags map[string]string) error {
func (update *Update) Execute(main []string, flags map[string]string) error {
if len(main) < 2 || main[0] != "update" {
return ErrWrongCommand
}
@ -57,10 +57,10 @@ func (update *Update) Parse(main []string, flags map[string]string) error {
}
update.argSet = as
return nil
return update.do()
}
func (update *Update) Do() error {
func (update *Update) do() error {
as := update.argSet
var id string
idMap, err := update.localIDRepo.FindAll()

204
plan/command/update_test.go
View File

@ -11,7 +11,7 @@ import (
"go-mod.ewintr.nl/planner/plan/storage/memory"
)
func TestUpdate(t *testing.T) {
func TestUpdateExecute(t *testing.T) {
t.Parallel()
eid := "c"
@ -22,7 +22,7 @@ func TestUpdate(t *testing.T) {
}
title := "title"
start := time.Date(2024, 10, 6, 10, 0, 0, 0, time.UTC)
// twoHour, err := time.ParseDuration("2h")
twoHour, err := time.ParseDuration("2h")
if err != nil {
t.Errorf("exp nil, got %v", err)
}
@ -33,17 +33,16 @@ func TestUpdate(t *testing.T) {
main []string
flags map[string]string
expEvent item.Event
expParseErr bool
expDoErr bool
expErr bool
}{
{
name: "no args",
expParseErr: true,
expErr: true,
},
{
name: "not found",
localID: 1,
expParseErr: true,
expErr: true,
},
{
name: "name",
@ -58,91 +57,98 @@ func TestUpdate(t *testing.T) {
},
},
},
// {
// name: "invalid on",
// localID: lid,
// flags: map[string]string{
// "on": "invalid",
// },
// expParseErr: true,
// },
// {
// name: "on",
// localID: lid,
// flags: map[string]string{
// "on": "2024-10-02",
// },
// expEvent: item.Event{
// ID: eid,
// EventBody: item.EventBody{
// Title: title,
// Start: time.Date(2024, 10, 2, 10, 0, 0, 0, time.UTC),
// Duration: oneHour,
// },
// },
// },
// {
// name: "invalid at",
// localID: lid,
// flags: map[string]string{
// "at": "invalid",
// },
// expParseErr: true,
// },
// {
// name: "at",
// localID: lid,
// flags: map[string]string{
// "at": "11:00",
// },
// expEvent: item.Event{
// ID: eid,
// EventBody: item.EventBody{
// Title: title,
// Start: time.Date(2024, 10, 6, 11, 0, 0, 0, time.UTC),
// Duration: oneHour,
// },
// },
// },
// {
// name: "on and at",
// localID: lid,
// flags: map[string]string{
// "on": "2024-10-02",
// "at": "11:00",
// },
// expEvent: item.Event{
// ID: eid,
// EventBody: item.EventBody{
// Title: title,
// Start: time.Date(2024, 10, 2, 11, 0, 0, 0, time.UTC),
// Duration: oneHour,
// },
// },
// },
// {
// name: "invalid for",
// localID: lid,
// flags: map[string]string{
// "for": "invalid",
// },
// expParseErr: true,
// },
// {
// name: "for",
// localID: lid,
// flags: map[string]string{
// "for": "2h",
// },
// expEvent: item.Event{
// ID: eid,
// EventBody: item.EventBody{
// Title: title,
// Start: time.Date(2024, 10, 6, 10, 0, 0, 0, time.UTC),
// Duration: twoHour,
// },
// },
// },
{
name: "invalid on",
localID: lid,
main: []string{"update", fmt.Sprintf("%d", lid)},
flags: map[string]string{
"on": "invalid",
},
expErr: true,
},
{
name: "on",
localID: lid,
main: []string{"update", fmt.Sprintf("%d", lid)},
flags: map[string]string{
"on": "2024-10-02",
},
expEvent: item.Event{
ID: eid,
EventBody: item.EventBody{
Title: title,
Start: time.Date(2024, 10, 2, 10, 0, 0, 0, time.UTC),
Duration: oneHour,
},
},
},
{
name: "invalid at",
localID: lid,
main: []string{"update", fmt.Sprintf("%d", lid)},
flags: map[string]string{
"at": "invalid",
},
expErr: true,
},
{
name: "at",
localID: lid,
main: []string{"update", fmt.Sprintf("%d", lid)},
flags: map[string]string{
"at": "11:00",
},
expEvent: item.Event{
ID: eid,
EventBody: item.EventBody{
Title: title,
Start: time.Date(2024, 10, 6, 11, 0, 0, 0, time.UTC),
Duration: oneHour,
},
},
},
{
name: "on and at",
localID: lid,
main: []string{"update", fmt.Sprintf("%d", lid)},
flags: map[string]string{
"on": "2024-10-02",
"at": "11:00",
},
expEvent: item.Event{
ID: eid,
EventBody: item.EventBody{
Title: title,
Start: time.Date(2024, 10, 2, 11, 0, 0, 0, time.UTC),
Duration: oneHour,
},
},
},
{
name: "invalid for",
localID: lid,
main: []string{"update", fmt.Sprintf("%d", lid)},
flags: map[string]string{
"for": "invalid",
},
expErr: true,
},
{
name: "for",
localID: lid,
main: []string{"update", fmt.Sprintf("%d", lid)},
flags: map[string]string{
"for": "2h",
},
expEvent: item.Event{
ID: eid,
EventBody: item.EventBody{
Title: title,
Start: time.Date(2024, 10, 6, 10, 0, 0, 0, time.UTC),
Duration: twoHour,
},
},
},
} {
t.Run(tc.name, func(t *testing.T) {
eventRepo := memory.NewEvent()
@ -163,19 +169,11 @@ func TestUpdate(t *testing.T) {
}
cmd := command.NewUpdate(localIDRepo, eventRepo, syncRepo)
actParseErr := cmd.Parse(tc.main, tc.flags) != nil
if tc.expParseErr != actParseErr {
t.Errorf("exp %v, got %v", tc.expParseErr, actParseErr)
actParseErr := cmd.Execute(tc.main, tc.flags) != nil
if tc.expErr != actParseErr {
t.Errorf("exp %v, got %v", tc.expErr, actParseErr)
}
if tc.expParseErr {
return
}
actDoErr := cmd.Do() != nil
if tc.expDoErr != actDoErr {
t.Errorf("exp %v, got %v", tc.expDoErr, actDoErr)
}
if tc.expDoErr {
if tc.expErr {
return
}