use event IDs

internal/control/cli/add.go

@@ -138,7 +138,7 @@ func (command *AddCommand) Execute(args []string) error {
 	fmt.Println("writing to:")
 	for _, event := range events {
 		fmt.Printf(" + %s\n", event.String())
-		err := provider.AddEvent(event)
+		_, err := provider.AddEvent(event)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "ERROR: could not add event to provider (%s)\n", err.Error())
 		}

internal/control/data.go

@@ -67,9 +67,9 @@ type ControlData struct {
 
 	EnvData EnvData
 
-	CurrentDate  model.Date
-	CurrentEvent *model.Event
-	Weather      weather.Handler
+	CurrentDate    model.Date
+	CurrentEventID *model.EventID
+	Weather        weather.Handler
 
 	EventEditor *editors.Composite
 	TaskEditor  *editors.Composite
@@ -90,7 +90,7 @@ type ControlData struct {
 	EventEditMode edit.EventEditMode
 
 	MouseEditState            edit.MouseEditState
-	MouseEditedEvent          *model.Event
+	MouseEditedEventID        *model.EventID
 	CurrentMoveStartingOffset time.Duration
 }
 

internal/model/backlog.go

@@ -55,7 +55,7 @@ func (t Task) toBaseTask() BaseTask {
 
 // BacklogStored.
 type BacklogStored struct {
-	TasksByCategory map[CategoryName][]BaseTask `yaml:",inline"`
+	TasksByCategory map[string][]BaseTask `yaml:",inline"`
 }
 
 // BaseTask.
@@ -70,12 +70,12 @@ type BaseTask struct {
 func (b *Backlog) Write(w io.Writer) error {
 
 	toBeWritten := BacklogStored{
-		TasksByCategory: map[CategoryName][]BaseTask{},
+		TasksByCategory: map[string][]BaseTask{},
 	}
 	for _, task := range b.Tasks {
 		categoryName := task.Category.Name
-		toBeWritten.TasksByCategory[categoryName] = append(
-			toBeWritten.TasksByCategory[categoryName],
+		toBeWritten.TasksByCategory[string(categoryName)] = append(
+			toBeWritten.TasksByCategory[string(categoryName)],
 			task.toBaseTask(),
 		)
 	}
@@ -128,7 +128,7 @@ func BacklogFromReader(r io.Reader, categoryGetter func(CategoryName) Category)
 	b := &Backlog{Tasks: []*Task{}}
 	for cat, tasks := range stored.TasksByCategory {
 		for _, task := range tasks {
-			b.Tasks = append(b.Tasks, toTask(cat, task))
+			b.Tasks = append(b.Tasks, toTask(CategoryName(cat), task))
 		}
 	}
 

internal/model/event.go

@@ -4,8 +4,11 @@ import (
 	"time"
 )
 
+type EventID = string
+
 // ...
 type Event struct {
+	ID    EventID   `dpedit:",ignore"`
 	Name  string    `dpedit:"name"`
 	Cat   Category  `dpedit:"category"` // TODO: change to just category name
 	Start time.Time `dpedit:",ignore"`
@@ -17,23 +20,14 @@ func (e *Event) Duration() time.Duration {
 	return e.End.Sub(e.Start)
 }
 
-// ...
-func (e *Event) Clone() Event {
-	return Event{
-		Name:  e.Name,
-		Cat:   e.Cat,
-		Start: e.Start,
-		End:   e.End,
-	}
-}
-
 func (e *Event) String() string {
+	id := e.ID
 	start := e.Start.String()
 	end := e.End.String()
 	catName := e.Cat.Name
 	eventName := e.Name
 
-	return (start + "|" + end + "|" + string(catName) + "|" + eventName)
+	return (id + "|" + start + "|" + end + "|" + string(catName) + "|" + eventName)
 }
 
 // ...

internal/model/event_list.go

@@ -150,10 +150,20 @@ func (l *EventList) getEventsBefore(event *Event) []*Event {
 	return result
 }
 
+func cloneEvent(e *Event) Event {
+	return Event{
+		ID:    e.ID,
+		Name:  e.Name,
+		Cat:   e.Cat,
+		Start: e.Start,
+		End:   e.End,
+	}
+}
+
 func (l *EventList) Clone() EventList {
 	cloned := make([]*Event, len(l.Events))
 	for i := range l.Events {
-		c := l.Events[i].Clone()
+		c := cloneEvent(l.Events[i])
 		cloned[i] = &c
 	}
 	return EventList{Events: cloned}
@@ -255,7 +265,7 @@ func (l *EventList) Flatten() {
 		if l.Events[next].IsContainedIn(l.Events[current]) {
 			if l.Events[next].Cat.Priority > l.Events[current].Cat.Priority {
 				// clone the current event for the remainder after the next event
-				currentRemainder := l.Events[current].Clone()
+				currentRemainder := cloneEvent(l.Events[current])
 				currentRemainder.Start = l.Events[next].End
 
 				// trim the current until the next event

internal/storage/provider.go

@@ -6,8 +6,6 @@ import (
 	"github.com/ja-he/dayplan/internal/model"
 )
 
-type EventIdentifier = *model.Event // TODO: need an ID of some sort for this
-
 // DataProvider is the abstracted data provider, which can be implemented over
 // various storage systems.
 //
@@ -19,30 +17,31 @@ type EventIdentifier = *model.Event // TODO: need an ID of some sort for this
 //     potentially configure the desired behaviour of automatically storing
 //     changes to the backend or waiting for commits.
 type DataProvider interface {
-	AddEvent(model.Event) error
+	AddEvent(model.Event) (model.EventID, error)
 
-	RemoveEvent(EventIdentifier) error
-	RemoveEvents([]EventIdentifier) error
+	RemoveEvent(model.EventID) error
+	RemoveEvents([]model.EventID) error
 
+	GetEvent(model.EventID) (*model.Event, error)
 	GetEventAfter(time.Time) (*model.Event, error)
 	GetEventBefore(time.Time) (*model.Event, error)
-	GetPrecedingEvent(EventIdentifier, time.Time) (*model.Event, error)
-	GetFollowingEvent(EventIdentifier, time.Time) (*model.Event, error)
+	GetPrecedingEvent(model.EventID) (*model.Event, error)
+	GetFollowingEvent(model.EventID) (*model.Event, error)
 	GetEventsCoveringTimerange(start, end time.Time) ([]*model.Event, error)
 
-	SplitEvent(EventIdentifier, time.Time) error
-	SetEventStart(EventIdentifier, time.Time) error
-	SetEventEnd(EventIdentifier, time.Time) error
-	SetEventTimes(EventIdentifier, time.Time, time.Time) error
-	OffsetEventStart(EventIdentifier, time.Duration) error
-	OffsetEventEnd(EventIdentifier, time.Duration) error
-	OffsetEventTimes(EventIdentifier, time.Duration) error
-	SnapEventStart(EventIdentifier, time.Duration) error
-	SnapEventEnd(EventIdentifier, time.Duration) error
-	SnapEventTimes(EventIdentifier, time.Duration) error
-	SetEventTitle(EventIdentifier, string) error
-	SetEventCategory(EventIdentifier, model.Category) error
-	SetEventAllData(EventIdentifier, model.Event) error
+	SplitEvent(model.EventID, time.Time) error
+	SetEventStart(model.EventID, time.Time) error
+	SetEventEnd(model.EventID, time.Time) error
+	SetEventTimes(model.EventID, time.Time, time.Time) error
+	OffsetEventStart(model.EventID, time.Duration) (time.Time, error)
+	OffsetEventEnd(model.EventID, time.Duration) (time.Time, error)
+	OffsetEventTimes(model.EventID, time.Duration) (time.Time, time.Time, error)
+	SnapEventStart(model.EventID, time.Duration) (time.Time, error)
+	SnapEventEnd(model.EventID, time.Duration) (time.Time, error)
+	SnapEventTimes(model.EventID, time.Duration) (time.Time, time.Time, error)
+	SetEventTitle(model.EventID, string) error
+	SetEventCategory(model.EventID, model.Category) error
+	SetEventAllData(model.EventID, model.Event) error
 
 	SumUpTimespanByCategory(start time.Time, end time.Time) map[model.CategoryName]time.Duration
 

internal/storage/providers/files_provider.go

@@ -8,17 +8,21 @@ import (
 	"sync"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 
 	"github.com/ja-he/dayplan/internal/model"
-	"github.com/ja-he/dayplan/internal/storage"
 )
 
 const notSameDayEventErrorMsg = string("event does not start and end on the same day")
 
 var fileDateNamingRegex = regexp.MustCompile(`^\d{4}-\d{2}-\d{2}$`)
 
+var filesProviderIDGenerator = func() model.EventID {
+	return uuid.NewString()
+}
+
 // FilesDataProvider ...
 type FilesDataProvider struct {
 	BasePath string
@@ -76,31 +80,37 @@ func (p *FilesDataProvider) getFileHandler(date model.Date) (*fileHandler, error
 
 // AddEvent ...
 // TODO: doc AddEvent
-func (p *FilesDataProvider) AddEvent(e model.Event) error {
+func (p *FilesDataProvider) AddEvent(e model.Event) (model.EventID, error) {
 	if !eventStartsAndEndsOnSameDate(&e) {
-		return fmt.Errorf(notSameDayEventErrorMsg)
+		return "", fmt.Errorf(notSameDayEventErrorMsg)
 	}
 	d := model.DateFromGotime(e.Start)
 	fh, err := p.getFileHandler(d)
 	if err != nil {
-		return fmt.Errorf("error loading file handler for date (%w)", err)
+		return "", fmt.Errorf("error loading file handler for date (%w)", err)
 	}
 	fh.AddEvent(&e)
-	return nil
+	return filesProviderIDGenerator(), nil
 }
 
 // TODO: doc RemoveEvent
-func (p *FilesDataProvider) RemoveEvent(storage.EventIdentifier) error {
+func (p *FilesDataProvider) RemoveEvent(model.EventID) error {
 	p.log.Fatal().Msg("TODO IMPL(RemoveEvent)")
 	return nil
 }
 
 // TODO: doc RemoveEvents
-func (p *FilesDataProvider) RemoveEvents([]storage.EventIdentifier) error {
+func (p *FilesDataProvider) RemoveEvents([]model.EventID) error {
 	p.log.Fatal().Msg("TODO IMPL(RemoveEvents)")
 	return nil
 }
 
+// TODO: doc GetEvent
+func (p *FilesDataProvider) GetEvent(id model.EventID) (*model.Event, error) {
+	p.log.Fatal().Msg("TODO IMPL(GetEvent)")
+	return nil, nil
+}
+
 // GetEventAfter retrieves the first event after the specified time.
 func (p *FilesDataProvider) GetEventAfter(t time.Time) (*model.Event, error) {
 	p.log.Debug().Msgf("getting first event after %s", t.String())
@@ -173,13 +183,13 @@ func (p *FilesDataProvider) GetEventBefore(t time.Time) (*model.Event, error) {
 }
 
 // TODO: doc GetPrecedingEvent
-func (p *FilesDataProvider) GetPrecedingEvent(storage.EventIdentifier, time.Time) (*model.Event, error) {
+func (p *FilesDataProvider) GetPrecedingEvent(model.EventID) (*model.Event, error) {
 	p.log.Fatal().Msg("TODO IMPL(GetPrecedingEvent)")
 	return nil, nil
 }
 
 // TODO: doc GetFollowingEvent
-func (p *FilesDataProvider) GetFollowingEvent(storage.EventIdentifier, time.Time) (*model.Event, error) {
+func (p *FilesDataProvider) GetFollowingEvent(model.EventID) (*model.Event, error) {
 	p.log.Fatal().Msg("TODO IMPL(GetFollowingEvent)")
 	return nil, nil
 }
@@ -247,79 +257,79 @@ func (p *FilesDataProvider) GetEventsCoveringTimerange(start, end time.Time) ([]
 }
 
 // TODO: doc SplitEvent
-func (p *FilesDataProvider) SplitEvent(storage.EventIdentifier, time.Time) error {
+func (p *FilesDataProvider) SplitEvent(model.EventID, time.Time) error {
 	p.log.Fatal().Msg("TODO IMPL(SplitEvent)")
 	return nil
 }
 
 // TODO: doc SetEventStart
-func (p *FilesDataProvider) SetEventStart(storage.EventIdentifier, time.Time) error {
+func (p *FilesDataProvider) SetEventStart(model.EventID, time.Time) error {
 	p.log.Fatal().Msg("TODO IMPL(SetEventStart)")
 	return nil
 }
 
 // TODO: doc SetEventEnd
-func (p *FilesDataProvider) SetEventEnd(storage.EventIdentifier, time.Time) error {
+func (p *FilesDataProvider) SetEventEnd(model.EventID, time.Time) error {
 	p.log.Fatal().Msg("TODO IMPL(SetEventEnd)")
 	return nil
 }
 
 // TODO: doc SetEventTimes
-func (p *FilesDataProvider) SetEventTimes(storage.EventIdentifier, time.Time, time.Time) error {
+func (p *FilesDataProvider) SetEventTimes(model.EventID, time.Time, time.Time) error {
 	p.log.Fatal().Msg("TODO IMPL(SetEventTimes)")
 	return nil
 }
 
 // TODO: doc OffsetEventStart
-func (p *FilesDataProvider) OffsetEventStart(storage.EventIdentifier, time.Duration) error {
+func (p *FilesDataProvider) OffsetEventStart(model.EventID, time.Duration) (time.Time, error) {
 	p.log.Fatal().Msg("TODO IMPL(OffsetEventStart)")
-	return nil
+	return time.Time{}, nil
 }
 
 // TODO: doc OffsetEventEnd
-func (p *FilesDataProvider) OffsetEventEnd(storage.EventIdentifier, time.Duration) error {
+func (p *FilesDataProvider) OffsetEventEnd(model.EventID, time.Duration) (time.Time, error) {
 	p.log.Fatal().Msg("TODO IMPL(OffsetEventEnd)")
-	return nil
+	return time.Time{}, nil
 }
 
 // TODO: doc OffsetEventTimes
-func (p *FilesDataProvider) OffsetEventTimes(storage.EventIdentifier, time.Duration) error {
+func (p *FilesDataProvider) OffsetEventTimes(model.EventID, time.Duration) (time.Time, time.Time, error) {
 	p.log.Fatal().Msg("TODO IMPL(OffsetEventTimes)")
-	return nil
+	return time.Time{}, time.Time{}, nil
 }
 
 // TODO: doc SnapEventStart
-func (p *FilesDataProvider) SnapEventStart(storage.EventIdentifier, time.Duration) error {
+func (p *FilesDataProvider) SnapEventStart(model.EventID, time.Duration) (time.Time, error) {
 	p.log.Fatal().Msg("TODO IMPL(SnapEventStart)")
-	return nil
+	return time.Time{}, nil
 }
 
 // TODO: doc SnapEventEnd
-func (p *FilesDataProvider) SnapEventEnd(storage.EventIdentifier, time.Duration) error {
+func (p *FilesDataProvider) SnapEventEnd(model.EventID, time.Duration) (time.Time, error) {
 	p.log.Fatal().Msg("TODO IMPL(SnapEventEnd)")
-	return nil
+	return time.Time{}, nil
 }
 
 // TODO: doc SnapEventTimes
-func (p *FilesDataProvider) SnapEventTimes(storage.EventIdentifier, time.Duration) error {
+func (p *FilesDataProvider) SnapEventTimes(model.EventID, time.Duration) (time.Time, time.Time, error) {
 	p.log.Fatal().Msg("TODO IMPL(SnapEventTimes)")
-	return nil
+	return time.Time{}, time.Time{}, nil
 }
 
 // TODO: doc SetEventTitle
-func (p *FilesDataProvider) SetEventTitle(storage.EventIdentifier, string) error {
+func (p *FilesDataProvider) SetEventTitle(model.EventID, string) error {
 	p.log.Fatal().Msg("TODO IMPL(SetEventTitle)")
 	return nil
 }
 
 // TODO: doc SetEventCategory
-func (p *FilesDataProvider) SetEventCategory(storage.EventIdentifier, model.Category) error {
+func (p *FilesDataProvider) SetEventCategory(model.EventID, model.Category) error {
 	p.log.Fatal().Msg("TODO IMPL(SetEventCategory)")
 	return nil
 }
 
 // TODO: doc SetEventAllData
-func (p *FilesDataProvider) SetEventAllData(storage.EventIdentifier, model.Event) error {
+func (p *FilesDataProvider) SetEventAllData(model.EventID, model.Event) error {
 	p.log.Fatal().Msg("TODO IMPL(SetEventAllData)")
 	return nil
 }