plan/command/add.go

@@ -3,59 +3,111 @@ package command
 import (
 	"fmt"
 	"strings"
-	"time"
 
 	"github.com/google/uuid"
 	"go-mod.ewintr.nl/planner/item"
+	"go-mod.ewintr.nl/planner/plan/storage"
 )
 
-func NewAdd(main []string, fields map[string]string) (Command, error) {
+type Add struct {
-	if len(main) == 0 || main[0] != "add" {
+	localIDRepo storage.LocalID
-		return nil, ErrWrongCommand
+	taskRepo    storage.Task
-	}
+	syncRepo    storage.Sync
-	main = main[1:]
+	argSet      *ArgSet
-	if len(main) == 0 {
-		return nil, fmt.Errorf("%w: title is required for add", ErrInvalidArg)
 }
 
-	tsk := item.Task{
+func NewAdd(localRepo storage.LocalID, taskRepo storage.Task, syncRepo storage.Sync) Command {
-		ID: uuid.New().String(),
+	return &Add{
-		TaskBody: item.TaskBody{
+		localIDRepo: localRepo,
-			Title: strings.Join(main, ","),
+		taskRepo:    taskRepo,
+		syncRepo:    syncRepo,
+		argSet: &ArgSet{
+			Flags: map[string]Flag{
+				FlagOn:  &FlagDate{},
+				FlagAt:  &FlagTime{},
+				FlagFor: &FlagDuration{},
+				FlagRec: &FlagRecurrer{},
+			},
 		},
 	}
+}
 
-	if val, ok := fields[FieldDate]; ok {
+func (add *Add) Execute(main []string, flags map[string]string) error {
-		d := item.NewDateFromString(val)
+	if len(main) == 0 || main[0] != "add" {
-		if d.IsZero() {
+		return ErrWrongCommand
-			return nil, fmt.Errorf("%w: could not parse date", ErrInvalidArg)
 	}
-		tsk.Date = d
+	as := add.argSet
+	if len(main) > 1 {
+		as.Main = strings.Join(main[1:], " ")
 	}
-	if val, ok := fields[FieldTime]; ok {
+	for k := range as.Flags {
-		t := item.NewTimeFromString(val)
+		v, ok := flags[k]
-		if t.IsZero() {
+		if !ok {
-			return nil, fmt.Errorf("%w: could not parse time", ErrInvalidArg)
+			continue
 		}
-		tsk.Time = t
+		if err := as.Set(k, v); err != nil {
+			return fmt.Errorf("could not set %s: %v", k, err)
 		}
-	if val, ok := fields[FieldDuration]; ok {
+	}
-		d, err := time.ParseDuration(val)
+	if as.Main == "" {
+		return fmt.Errorf("%w: title is required", ErrInvalidArg)
+	}
+	if !as.IsSet(FlagOn) {
+		return fmt.Errorf("%w: date is required", ErrInvalidArg)
+	}
+	if !as.IsSet(FlagAt) && as.IsSet(FlagFor) {
+		return fmt.Errorf("%w: can not have duration without start time", ErrInvalidArg)
+	}
+	if as.IsSet(FlagAt) && !as.IsSet(FlagFor) {
+		if err := as.Flags[FlagFor].Set("1h"); err != nil {
+			return fmt.Errorf("could not set duration to one hour")
+		}
+	}
+	if !as.IsSet(FlagAt) && !as.IsSet(FlagFor) {
+		if err := as.Flags[FlagFor].Set("24h"); err != nil {
+			return fmt.Errorf("could not set duration to 24 hours")
+		}
+	}
+
+	return add.do()
+}
+
+func (add *Add) do() error {
+	as := add.argSet
+	rec := as.GetRecurrer(FlagRec)
+	tsk := item.Task{
+		ID:       uuid.New().String(),
+		Date:     as.GetDate(FlagOn),
+		Recurrer: rec,
+		TaskBody: item.TaskBody{
+			Title:    as.Main,
+			Time:     as.GetTime(FlagAt),
+			Duration: as.GetDuration(FlagFor),
+		},
+	}
+	if rec != nil {
+		tsk.RecurNext = rec.First()
+	}
+
+	if err := add.taskRepo.Store(tsk); err != nil {
+		return fmt.Errorf("could not store event: %v", err)
+	}
+
+	localID, err := add.localIDRepo.Next()
 	if err != nil {
-			return nil, fmt.Errorf("%w: could not parse duration", ErrInvalidArg)
+		return fmt.Errorf("could not create next local id: %v", err)
 	}
-		tsk.Duration = d
+	if err := add.localIDRepo.Store(tsk.ID, localID); err != nil {
-	}
+		return fmt.Errorf("could not store local id: %v", err)
-	if val, ok := fields[FieldRecurrer]; ok {
-		rec := item.NewRecurrer(val)
-		if rec == nil {
-			return nil, fmt.Errorf("%w: could not parse recurrer", ErrInvalidArg)
-		}
-		tsk.Recurrer = rec
-		tsk.RecurNext = tsk.Recurrer.First()
 	}
 
-	return &Store{
+	it, err := tsk.Item()
-		task: tsk,
+	if err != nil {
-	}, nil
+		return fmt.Errorf("could not convert event to sync item: %v", err)
+	}
+	if err := add.syncRepo.Store(it); err != nil {
+		return fmt.Errorf("could not store sync item: %v", err)
+	}
+
+	return nil
 }

plan/command/add_test.go

@@ -33,7 +33,7 @@ func TestAdd(t *testing.T) {
 			name: "title missing",
 			main: []string{"add"},
 			flags: map[string]string{
-				command.FieldDate: aDate.String(),
+				command.FlagOn: aDate.String(),
 			},
 			expErr: true,
 		},
@@ -46,7 +46,7 @@ func TestAdd(t *testing.T) {
 			name: "only date",
 			main: []string{"add", "title"},
 			flags: map[string]string{
-				command.FieldDate: aDate.String(),
+				command.FlagOn: aDate.String(),
 			},
 			expTask: item.Task{
 				ID:   "title",
@@ -61,9 +61,9 @@ func TestAdd(t *testing.T) {
 			name: "date, time and duration",
 			main: []string{"add", "title"},
 			flags: map[string]string{
-				command.FieldDate:  aDate.String(),
+				command.FlagOn:  aDate.String(),
-				command.FieldTime:  aTime.String(),
+				command.FlagAt:  aTime.String(),
-				command.FieldDuration: anHourStr,
+				command.FlagFor: anHourStr,
 			},
 			expTask: item.Task{
 				ID:   "title",
@@ -79,8 +79,8 @@ func TestAdd(t *testing.T) {
 			name: "date and duration",
 			main: []string{"add", "title"},
 			flags: map[string]string{
-				command.FieldDate:  aDate.String(),
+				command.FlagOn:  aDate.String(),
-				command.FieldDuration: anHourStr,
+				command.FlagFor: anHourStr,
 			},
 			expErr: true,
 		},

plan/command/command.go

@@ -1,28 +1,21 @@
 package command
 
 import (
+	"errors"
 	"fmt"
 	"strings"
-
-	"go-mod.ewintr.nl/planner/plan/storage"
 )
 
 const (
-	FieldTitle    = "title"
+	FlagTitle = "title"
-	FieldDate     = "date"
+	FlagOn    = "on"
-	FieldTime     = "time"
+	FlagAt    = "at"
-	FieldDuration = "duration"
+	FlagFor   = "for"
-	FieldRecurrer = "recurrer"
+	FlagRec   = "rec"
 )
 
-type Dependencies struct {
-	LocalIDRepo storage.LocalID
-	TaskRepo    storage.Task
-	SyncRepo    storage.Sync
-}
-
 type Command interface {
-	Do(deps Dependencies) error
+	Execute([]string, map[string]string) error
 }
 
 type CLI struct {
@@ -30,21 +23,21 @@ type CLI struct {
 }
 
 func (cli *CLI) Run(args []string) error {
-	// main, flags, err := ParseFlags(args)
+	main, flags, err := ParseFlags(args)
-	// if err != nil {
+	if err != nil {
-	// 	return err
+		return err
-	// }
+	}
-	// for _, c := range cli.Commands {
+	for _, c := range cli.Commands {
-	// 	err := c.Execute(main, flags)
+		err := c.Execute(main, flags)
-	// 	switch {
+		switch {
-	// 	case errors.Is(err, ErrWrongCommand):
+		case errors.Is(err, ErrWrongCommand):
-	// 		continue
+			continue
-	// 	case err != nil:
+		case err != nil:
-	// 		return err
+			return err
-	// 	default:
+		default:
-	// 		return nil
+			return nil
-	// 	}
+		}
-	// }
+	}
 
 	return fmt.Errorf("could not find matching command")
 }

plan/command/store.go

@@ -1,50 +0,0 @@
-package command
-
-import (
-	"fmt"
-	"time"
-
-	"go-mod.ewintr.nl/planner/item"
-)
-
-type StoreParams struct {
-	Title    string
-	Date     item.Date
-	Time     item.Time
-	Duration time.Duration
-	Recurrer item.Recurrer
-}
-
-type Store struct {
-	task item.Task
-}
-
-func NewStore(task item.Task) *Store {
-	return &Store{
-		task: task,
-	}
-}
-
-func (store *Store) Do(deps Dependencies) error {
-	if err := deps.TaskRepo.Store(store.task); err != nil {
-		return fmt.Errorf("could not store event: %v", err)
-	}
-
-	localID, err := deps.LocalIDRepo.Next()
-	if err != nil {
-		return fmt.Errorf("could not create next local id: %v", err)
-	}
-	if err := deps.LocalIDRepo.Store(store.task.ID, localID); err != nil {
-		return fmt.Errorf("could not store local id: %v", err)
-	}
-
-	it, err := store.task.Item()
-	if err != nil {
-		return fmt.Errorf("could not convert event to sync item: %v", err)
-	}
-	if err := deps.SyncRepo.Store(it); err != nil {
-		return fmt.Errorf("could not store sync item: %v", err)
-	}
-
-	return nil
-}

plan/command/update.go

@@ -4,20 +4,30 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
+
+	"go-mod.ewintr.nl/planner/plan/storage"
 )
 
-func NewUpdate(main []string, fields map[string]string) (Command, error) {
+type Update struct {
+	localIDRepo storage.LocalID
+	taskRepo    storage.Task
+	syncRepo    storage.Sync
+	argSet      *ArgSet
+	localID     int
+}
+
+func NewUpdate(localIDRepo storage.LocalID, taskRepo storage.Task, syncRepo storage.Sync) Command {
 	return &Update{
 		localIDRepo: localIDRepo,
 		taskRepo:    taskRepo,
 		syncRepo:    syncRepo,
 		argSet: &ArgSet{
 			Flags: map[string]Flag{
-				FieldTitle:    &FlagString{},
+				FlagTitle: &FlagString{},
-				FieldDate:     &FlagDate{},
+				FlagOn:    &FlagDate{},
-				FieldTime:     &FlagTime{},
+				FlagAt:    &FlagTime{},
-				FieldDuration: &FlagDuration{},
+				FlagFor:   &FlagDuration{},
-				FieldRecurrer: &FlagRecurrer{},
+				FlagRec:   &FlagRecurrer{},
 			},
 		},
 	}
@@ -74,17 +84,17 @@ func (update *Update) do() error {
 	if as.Main != "" {
 		tsk.Title = as.Main
 	}
-	if as.IsSet(FieldDate) {
+	if as.IsSet(FlagOn) {
-		tsk.Date = as.GetDate(FieldDate)
+		tsk.Date = as.GetDate(FlagOn)
 	}
-	if as.IsSet(FieldTime) {
+	if as.IsSet(FlagAt) {
-		tsk.Time = as.GetTime(FieldTime)
+		tsk.Time = as.GetTime(FlagAt)
 	}
-	if as.IsSet(FieldDuration) {
+	if as.IsSet(FlagFor) {
-		tsk.Duration = as.GetDuration(FieldDuration)
+		tsk.Duration = as.GetDuration(FlagFor)
 	}
-	if as.IsSet(FieldRecurrer) {
+	if as.IsSet(FlagRec) {
-		tsk.Recurrer = as.GetRecurrer(FieldRecurrer)
+		tsk.Recurrer = as.GetRecurrer(FlagRec)
 	}
 
 	if !tsk.Valid() {

plan/service/service.go

@@ -1 +0,0 @@
-package service