day

.gitignore

@@ -1,3 +1 @@
-test.db*
+*.db*
-plannersync
-plan

Makefile

@@ -7,5 +7,15 @@ sync-run:
 sync-debug:
 	cd sync/service && dlv debug . -- -dbname localhost -dbport 5432 -dbname planner -dbuser test -dbpassword test -port 8092 -key testKey
 
+sync-build:
+	go build -o dist/plannersync ./sync/service/
+
+sync-deploy:
+	ssh server sudo /usr/bin/systemctl stop plannersync.service
+	scp dist/plannersync server:/usr/local/bin/plannersync
+	ssh server sudo /usr/bin/systemctl start plannersync.service
+
 database:
 	docker run -e POSTGRES_USER=test -e POSTGRES_PASSWORD=test -e POSTGRES_DB=planner -p 5432:5432 postgres:16
+
+

item/date.go

@@ -0,0 +1,279 @@
+package item
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+)
+
+const (
+	DateFormat = "2006-01-02"
+)
+
+func Today() Date {
+	year, month, day := time.Now().Date()
+	return NewDate(year, int(month), day)
+}
+
+type Weekdays []time.Weekday
+
+func (wds Weekdays) Len() int      { return len(wds) }
+func (wds Weekdays) Swap(i, j int) { wds[j], wds[i] = wds[i], wds[j] }
+func (wds Weekdays) Less(i, j int) bool {
+	if wds[i] == time.Sunday {
+		return false
+	}
+	if wds[j] == time.Sunday {
+		return true
+	}
+
+	return int(wds[i]) < int(wds[j])
+}
+
+func (wds Weekdays) Unique() Weekdays {
+	mwds := map[time.Weekday]bool{}
+	for _, wd := range wds {
+		mwds[wd] = true
+	}
+	newWds := Weekdays{}
+	for wd := range mwds {
+		newWds = append(newWds, wd)
+	}
+	sort.Sort(newWds)
+
+	return newWds
+}
+
+type Date struct {
+	t time.Time
+}
+
+func (d *Date) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.String())
+}
+
+func (d *Date) UnmarshalJSON(data []byte) error {
+	dateString := ""
+	if err := json.Unmarshal(data, &dateString); err != nil {
+		return err
+	}
+	nd := NewDateFromString(dateString)
+	d.t = nd.Time()
+
+	return nil
+}
+
+func NewDate(year, month, day int) Date {
+
+	if year == 0 || month == 0 || month > 12 || day == 0 {
+		return Date{}
+	}
+
+	var m time.Month
+	switch month {
+	case 1:
+		m = time.January
+	case 2:
+		m = time.February
+	case 3:
+		m = time.March
+	case 4:
+		m = time.April
+	case 5:
+		m = time.May
+	case 6:
+		m = time.June
+	case 7:
+		m = time.July
+	case 8:
+		m = time.August
+	case 9:
+		m = time.September
+	case 10:
+		m = time.October
+	case 11:
+		m = time.November
+	case 12:
+		m = time.December
+	}
+
+	t := time.Date(year, m, day, 0, 0, 0, 0, time.UTC)
+
+	return Date{
+		t: t,
+	}
+}
+
+func NewDateFromString(date string) Date {
+	date = strings.ToLower(strings.TrimSpace(date))
+
+	switch date {
+	case "":
+		fallthrough
+	case "no-date":
+		fallthrough
+	case "no date":
+		return Date{}
+	case "today":
+		return Today()
+	case "tod":
+		return Today()
+	case "tomorrow":
+		return Today().AddDays(1)
+	case "tom":
+		return Today().AddDays(1)
+	}
+
+	t, err := time.Parse("2006-01-02", fmt.Sprintf("%.10s", date))
+	if err == nil {
+		return Date{t: t}
+	}
+
+	newWeekday, ok := ParseWeekday(date)
+	if !ok {
+		return Date{}
+	}
+	daysToAdd := findDaysToWeekday(Today().Weekday(), newWeekday)
+
+	return Today().Add(daysToAdd)
+}
+
+func findDaysToWeekday(current, wanted time.Weekday) int {
+	daysToAdd := int(wanted) - int(current)
+	if daysToAdd <= 0 {
+		daysToAdd += 7
+	}
+
+	return daysToAdd
+}
+
+func (d Date) DaysBetween(d2 Date) int {
+	tDate := d2
+	end := d
+	if !end.After(tDate) {
+		end = d2
+		tDate = d
+	}
+
+	days := 0
+	for {
+		if tDate.Add(days).Equal(end) {
+			return days
+		}
+		days++
+	}
+}
+
+func (d Date) String() string {
+	if d.t.IsZero() {
+		return "no date"
+	}
+
+	return strings.ToLower(d.t.Format(DateFormat))
+}
+
+// func (d Date) Human() string {
+// 	switch {
+// 	case d.IsZero():
+// 		return "-"
+// 	case d.Equal(Today()):
+// 		return "today"
+// 	case d.Equal(Today().Add(1)):
+// 		return "tomorrow"
+// 	case d.After(Today()) && Today().Add(8).After(d):
+// 		return strings.ToLower(d.t.Format("Monday"))
+// 	default:
+// 		return strings.ToLower(d.t.Format(DateFormat))
+// 	}
+// }
+
+func (d Date) IsZero() bool {
+	return d.t.IsZero()
+}
+
+func (d Date) Time() time.Time {
+	return d.t
+}
+
+func (d Date) Weekday() time.Weekday {
+	return d.t.Weekday()
+}
+
+func (d Date) Day() int {
+	return d.t.Day()
+}
+
+func (d Date) Add(days int) Date {
+	year, month, day := d.t.Date()
+	return NewDate(year, int(month), day+days)
+}
+
+func (d Date) AddMonths(addMonths int) Date {
+	year, mmonth, day := d.t.Date()
+	month := int(mmonth)
+	for m := 1; m <= addMonths; m++ {
+		month += 1
+		if month == 12 {
+			year += 1
+			month = 1
+		}
+	}
+
+	return NewDate(year, month, day)
+}
+
+func (d Date) Equal(ud Date) bool {
+	return d.t.Equal(ud.Time())
+}
+
+// After reports whether d is after ud
+func (d Date) After(ud Date) bool {
+	return d.t.After(ud.Time())
+}
+
+func (d Date) AddDays(amount int) Date {
+	year, month, date := d.t.Date()
+
+	return NewDate(year, int(month), date+amount)
+}
+
+func ParseWeekday(wd string) (time.Weekday, bool) {
+	switch lowerAndTrim(wd) {
+	case "monday":
+		return time.Monday, true
+	case "mon":
+		return time.Monday, true
+	case "tuesday":
+		return time.Tuesday, true
+	case "tue":
+		return time.Tuesday, true
+	case "wednesday":
+		return time.Wednesday, true
+	case "wed":
+		return time.Wednesday, true
+	case "thursday":
+		return time.Thursday, true
+	case "thu":
+		return time.Thursday, true
+	case "friday":
+		return time.Friday, true
+	case "fri":
+		return time.Friday, true
+	case "saturday":
+		return time.Saturday, true
+	case "sat":
+		return time.Saturday, true
+	case "sunday":
+		return time.Sunday, true
+	case "sun":
+		return time.Sunday, true
+	default:
+		return time.Monday, false
+	}
+}
+
+func lowerAndTrim(str string) string {
+	return strings.TrimSpace(strings.ToLower(str))
+}

item/date_test.go

@@ -0,0 +1,327 @@
+package item_test
+
+import (
+	"sort"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"go-mod.ewintr.nl/planner/item"
+)
+
+func TestWeekdaysSort(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		input item.Weekdays
+		exp   item.Weekdays
+	}{
+		{
+			name: "empty",
+		},
+		{
+			name:  "one",
+			input: item.Weekdays{time.Tuesday},
+			exp:   item.Weekdays{time.Tuesday},
+		},
+		{
+			name:  "multiple",
+			input: item.Weekdays{time.Wednesday, time.Tuesday, time.Monday},
+			exp:   item.Weekdays{time.Monday, time.Tuesday, time.Wednesday},
+		},
+		{
+			name:  "sunday is last",
+			input: item.Weekdays{time.Saturday, time.Sunday, time.Monday},
+			exp:   item.Weekdays{time.Monday, time.Saturday, time.Sunday},
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			sort.Sort(tc.input)
+			if diff := cmp.Diff(tc.exp, tc.input); diff != "" {
+				t.Errorf("(-exp, +got)%s\n", diff)
+			}
+		})
+	}
+}
+
+func TestWeekdaysUnique(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		input item.Weekdays
+		exp   item.Weekdays
+	}{
+		{
+			name:  "empty",
+			input: item.Weekdays{},
+			exp:   item.Weekdays{},
+		},
+		{
+			name:  "single",
+			input: item.Weekdays{time.Monday},
+			exp:   item.Weekdays{time.Monday},
+		},
+		{
+			name:  "no doubles",
+			input: item.Weekdays{time.Monday, time.Tuesday, time.Wednesday},
+			exp:   item.Weekdays{time.Monday, time.Tuesday, time.Wednesday},
+		},
+		{
+			name:  "doubles",
+			input: item.Weekdays{time.Monday, time.Monday, time.Wednesday, time.Monday},
+			exp:   item.Weekdays{time.Monday, time.Wednesday},
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if diff := cmp.Diff(tc.exp, tc.input.Unique()); diff != "" {
+				t.Errorf("(-exp, +got)%s\n", diff)
+			}
+		})
+	}
+}
+
+func TestNewDateFromString(t *testing.T) {
+	t.Parallel()
+
+	t.Run("simple", func(t *testing.T) {
+		for _, tc := range []struct {
+			name  string
+			input string
+			exp   item.Date
+		}{
+			{
+				name: "empty",
+				exp:  item.Date{},
+			},
+			{
+				name:  "no date",
+				input: "no date",
+				exp:   item.Date{},
+			},
+			{
+				name:  "short",
+				input: "2021-01-30",
+				exp:   item.NewDate(2021, 1, 30),
+			},
+		} {
+			t.Run(tc.name, func(t *testing.T) {
+				if diff := cmp.Diff(tc.exp, item.NewDateFromString(tc.input)); diff != "" {
+					t.Errorf("(-exp, +got)%s\n", diff)
+				}
+			})
+		}
+	})
+
+	t.Run("day name", func(t *testing.T) {
+		monday := item.Today().Add(1)
+		for {
+			if monday.Weekday() == time.Monday {
+				break
+			}
+			monday = monday.Add(1)
+		}
+		for _, tc := range []struct {
+			name  string
+			input string
+		}{
+			{
+				name:  "dayname lowercase",
+				input: "monday",
+			},
+			{
+				name:  "dayname capitalized",
+				input: "Monday",
+			},
+			{
+				name:  "dayname short",
+				input: "mon",
+			},
+		} {
+			t.Run(tc.name, func(t *testing.T) {
+				if diff := cmp.Diff(monday, item.NewDateFromString(tc.input)); diff != "" {
+					t.Errorf("(-exp, +got)%s\n", diff)
+				}
+			})
+		}
+	})
+
+	t.Run("relative days", func(t *testing.T) {
+		for _, tc := range []struct {
+			name string
+			exp  item.Date
+		}{
+			{
+				name: "today",
+				exp:  item.Today(),
+			},
+			{
+				name: "tod",
+				exp:  item.Today(),
+			},
+			{
+				name: "tomorrow",
+				exp:  item.Today().Add(1),
+			},
+			{
+				name: "tom",
+				exp:  item.Today().Add(1),
+			},
+		} {
+			t.Run(tc.name, func(t *testing.T) {
+				if diff := cmp.Diff(tc.exp, item.NewDateFromString(tc.name)); diff != "" {
+					t.Errorf("(-exp, +got)%s\n", diff)
+				}
+			})
+		}
+	})
+}
+
+func TestDateDaysBetween(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		name string
+		d1   item.Date
+		d2   item.Date
+		exp  int
+	}{
+		{
+			name: "same",
+			d1:   item.NewDate(2021, 6, 23),
+			d2:   item.NewDate(2021, 6, 23),
+		},
+		{
+			name: "one",
+			d1:   item.NewDate(2021, 6, 23),
+			d2:   item.NewDate(2021, 6, 24),
+			exp:  1,
+		},
+		{
+			name: "many",
+			d1:   item.NewDate(2021, 6, 23),
+			d2:   item.NewDate(2024, 3, 7),
+			exp:  988,
+		},
+		{
+			name: "edge",
+			d1:   item.NewDate(2020, 12, 30),
+			d2:   item.NewDate(2021, 1, 3),
+			exp:  4,
+		},
+		{
+			name: "reverse",
+			d1:   item.NewDate(2021, 6, 23),
+			d2:   item.NewDate(2021, 5, 23),
+			exp:  31,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if tc.exp != tc.d1.DaysBetween(tc.d2) {
+				t.Errorf("exp %v, got %v", tc.exp, tc.d1.DaysBetween(tc.d2))
+			}
+		})
+	}
+}
+
+func TestDateString(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		date item.Date
+		exp  string
+	}{
+		{
+			name: "zero",
+			date: item.NewDate(0, 0, 0),
+			exp:  "no date",
+		},
+		{
+			name: "normal",
+			date: item.NewDate(2021, 5, 30),
+			exp:  "2021-05-30",
+		},
+		{
+			name: "normalize",
+			date: item.NewDate(2021, 5, 32),
+			exp:  "2021-06-01",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if tc.exp != tc.date.String() {
+				t.Errorf("exp %v, got %v", tc.exp, tc.date.String())
+			}
+		})
+	}
+}
+
+// func TestDateHuman(t *testing.T) {
+// 	for _, tc := range []struct {
+// 		name string
+// 		date task.Date
+// 		exp  string
+// 	}{
+// 		{
+// 			name: "zero",
+// 			date: task.NewDate(0, 0, 0),
+// 			exp:  "-",
+// 		},
+// 		{
+// 			name: "default",
+// 			date: task.NewDate(2020, 1, 1),
+// 			exp:  "2020-01-01 (wednesday)",
+// 		},
+// 		{
+// 			name: "today",
+// 			date: task.Today(),
+// 			exp:  "today",
+// 		},
+// 		{
+// 			name: "tomorrow",
+// 			date: task.Today().Add(1),
+// 			exp:  "tomorrow",
+// 		},
+// 	} {
+// 		t.Run(tc.name, func(t *testing.T) {
+// 			test.Equals(t, tc.exp, tc.date.Human())
+// 		})
+// 	}
+// }
+
+func TestDateIsZero(t *testing.T) {
+	t.Parallel()
+
+	if !(item.Date{}.IsZero()) {
+		t.Errorf("exp true, got false")
+	}
+	if item.NewDate(2021, 6, 24).IsZero() {
+		t.Errorf("exp false, got true")
+	}
+}
+
+func TestDateAfter(t *testing.T) {
+	t.Parallel()
+
+	day := item.NewDate(2021, 1, 31)
+	for _, tc := range []struct {
+		name string
+		tDay item.Date
+		exp  bool
+	}{
+		{
+			name: "after",
+			tDay: item.NewDate(2021, 1, 30),
+			exp:  true,
+		},
+		{
+			name: "on",
+			tDay: day,
+		},
+		{
+			name: "before",
+			tDay: item.NewDate(2021, 2, 1),
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if diff := cmp.Diff(tc.exp, day.After(tc.tDay)); diff != "" {
+				t.Errorf("(-exp, +got)%s\n", diff)
+			}
+		})
+	}
+}

item/event.go

@@ -52,7 +52,7 @@ func (e *EventBody) UnmarshalJSON(data []byte) error {
 
 type Event struct {
 	ID        string    `json:"id"`
-	Recurrer  *Recur    `json:"recurrer"`
+	Recurrer  Recurrer  `json:"recurrer"`
 	RecurNext time.Time `json:"recurNext"`
 	EventBody
 }
@@ -103,9 +103,9 @@ func (e Event) Valid() bool {
 	if e.Duration.Seconds() < 1 {
 		return false
 	}
-	if e.Recurrer != nil && !e.Recurrer.Valid() {
+	// if e.Recurrer != nil && !e.Recurrer.Valid() {
-		return false
+	// 	return false
-	}
+	// }
 
 	return true
 }

item/event_test.go

@@ -1,213 +1,205 @@
 package item_test
 
-import (
+// func TestNewEvent(t *testing.T) {
-	"testing"
+// 	t.Parallel()
-	"time"
 
-	"github.com/google/go-cmp/cmp"
+// 	oneHour, err := time.ParseDuration("1h")
-	"go-mod.ewintr.nl/planner/item"
+// 	if err != nil {
-)
+// 		t.Errorf("exp nil, got %v", err)
+// 	}
+// 	for _, tc := range []struct {
+// 		name     string
+// 		it       item.Item
+// 		expEvent item.Event
+// 		expErr   bool
+// 	}{
+// 		{
+// 			name: "wrong kind",
+// 			it: item.Item{
+// 				ID:   "a",
+// 				Kind: item.KindTask,
+// 				Body: `{
+//   "title":"title",
+//   "start":"2024-09-20T08:00:00Z",
+//   "duration":"1h"
+// }`,
+// 			},
+// 			expErr: true,
+// 		},
+// 		{
+// 			name: "invalid json",
+// 			it: item.Item{
+// 				ID:   "a",
+// 				Kind: item.KindEvent,
+// 				Body: `{"id":"a"`,
+// 			},
+// 			expErr: true,
+// 		},
+// 		{
+// 			name: "valid",
+// 			it: item.Item{
+// 				ID:   "a",
+// 				Kind: item.KindEvent,
+// 				Recurrer: &item.Recur{
+// 					Start:  time.Date(2024, 12, 8, 9, 0, 0, 0, time.UTC),
+// 					Period: item.PeriodDay,
+// 					Count:  1,
+// 				},
+// 				Body: `{
+//   "title":"title",
+//   "start":"2024-09-20T08:00:00Z",
+//   "duration":"1h"
+// }`,
+// 			},
+// 			expEvent: item.Event{
+// 				ID: "a",
+// 				Recurrer: &item.Recur{
+// 					Start:  time.Date(2024, 12, 8, 9, 0, 0, 0, time.UTC),
+// 					Period: item.PeriodDay,
+// 					Count:  1,
+// 				},
+// 				EventBody: item.EventBody{
+// 					Title:    "title",
+// 					Start:    time.Date(2024, 9, 20, 8, 0, 0, 0, time.UTC),
+// 					Duration: oneHour,
+// 				},
+// 			},
+// 		},
+// 	} {
+// 		t.Run(tc.name, func(t *testing.T) {
+// 			actEvent, actErr := item.NewEvent(tc.it)
+// 			if tc.expErr != (actErr != nil) {
+// 				t.Errorf("exp nil, got %v", actErr)
+// 			}
+// 			if tc.expErr {
+// 				return
+// 			}
+// 			if diff := cmp.Diff(tc.expEvent, actEvent); diff != "" {
+// 				t.Errorf("(exp +, got -)\n%s", diff)
+// 			}
+// 		})
+// 	}
+// }
 
-func TestNewEvent(t *testing.T) {
+// func TestEventItem(t *testing.T) {
-	t.Parallel()
+// 	t.Parallel()
 
-	oneHour, err := time.ParseDuration("1h")
+// 	oneHour, err := time.ParseDuration("1h")
-	if err != nil {
+// 	if err != nil {
-		t.Errorf("exp nil, got %v", err)
+// 		t.Errorf("exp nil, got %v", err)
-	}
+// 	}
-	for _, tc := range []struct {
+// 	for _, tc := range []struct {
-		name     string
+// 		name    string
-		it       item.Item
+// 		event   item.Event
-		expEvent item.Event
+// 		expItem item.Item
-		expErr   bool
+// 		expErr  bool
-	}{
+// 	}{
-		{
+// 		{
-			name: "wrong kind",
+// 			name: "empty",
-			it: item.Item{
+// 			expItem: item.Item{
-				ID:   "a",
+// 				Kind:    item.KindEvent,
-				Kind: item.KindTask,
+// 				Updated: time.Time{},
-				Body: `{
+// 				Body:    `{"start":"0001-01-01T00:00:00Z","duration":"0s","title":""}`,
-  "title":"title",
+// 			},
-  "start":"2024-09-20T08:00:00Z",
+// 		},
-  "duration":"1h" 
+// 		{
-}`,
+// 			name: "normal",
-			},
+// 			event: item.Event{
-			expErr: true,
+// 				ID: "a",
-		},
+// 				EventBody: item.EventBody{
-		{
+// 					Title:    "title",
-			name: "invalid json",
+// 					Start:    time.Date(2024, 9, 23, 8, 0, 0, 0, time.UTC),
-			it: item.Item{
+// 					Duration: oneHour,
-				ID:   "a",
+// 				},
-				Kind: item.KindEvent,
+// 			},
-				Body: `{"id":"a"`,
+// 			expItem: item.Item{
-			},
+// 				ID:      "a",
-			expErr: true,
+// 				Kind:    item.KindEvent,
-		},
+// 				Updated: time.Time{},
-		{
+// 				Body:    `{"start":"2024-09-23T08:00:00Z","duration":"1h0m0s","title":"title"}`,
-			name: "valid",
+// 			},
-			it: item.Item{
+// 		},
-				ID:   "a",
+// 	} {
-				Kind: item.KindEvent,
+// 		t.Run(tc.name, func(t *testing.T) {
-				Recurrer: &item.Recur{
+// 			actItem, actErr := tc.event.Item()
-					Start:  time.Date(2024, 12, 8, 9, 0, 0, 0, time.UTC),
+// 			if tc.expErr != (actErr != nil) {
-					Period: item.PeriodDay,
+// 				t.Errorf("exp nil, got %v", actErr)
-					Count:  1,
+// 			}
-				},
+// 			if tc.expErr {
-				Body: `{
+// 				return
-  "title":"title",
+// 			}
-  "start":"2024-09-20T08:00:00Z",
+// 			if diff := cmp.Diff(tc.expItem, actItem); diff != "" {
-  "duration":"1h" 
+// 				t.Errorf("(exp+, got -)\n%s", diff)
-}`,
+// 			}
-			},
+// 		})
-			expEvent: item.Event{
+// 	}
-				ID: "a",
+// }
-				Recurrer: &item.Recur{
-					Start:  time.Date(2024, 12, 8, 9, 0, 0, 0, time.UTC),
-					Period: item.PeriodDay,
-					Count:  1,
-				},
-				EventBody: item.EventBody{
-					Title:    "title",
-					Start:    time.Date(2024, 9, 20, 8, 0, 0, 0, time.UTC),
-					Duration: oneHour,
-				},
-			},
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			actEvent, actErr := item.NewEvent(tc.it)
-			if tc.expErr != (actErr != nil) {
-				t.Errorf("exp nil, got %v", actErr)
-			}
-			if tc.expErr {
-				return
-			}
-			if diff := cmp.Diff(tc.expEvent, actEvent); diff != "" {
-				t.Errorf("(exp +, got -)\n%s", diff)
-			}
-		})
-	}
-}
 
-func TestEventItem(t *testing.T) {
+// func TestEventValidate(t *testing.T) {
-	t.Parallel()
+// 	t.Parallel()
 
-	oneHour, err := time.ParseDuration("1h")
+// 	oneHour, err := time.ParseDuration("1h")
-	if err != nil {
+// 	if err != nil {
-		t.Errorf("exp nil, got %v", err)
+// 		t.Errorf("exp nil, got %v", err)
-	}
+// 	}
-	for _, tc := range []struct {
-		name    string
-		event   item.Event
-		expItem item.Item
-		expErr  bool
-	}{
-		{
-			name: "empty",
-			expItem: item.Item{
-				Kind:    item.KindEvent,
-				Updated: time.Time{},
-				Body:    `{"start":"0001-01-01T00:00:00Z","duration":"0s","title":""}`,
-			},
-		},
-		{
-			name: "normal",
-			event: item.Event{
-				ID: "a",
-				EventBody: item.EventBody{
-					Title:    "title",
-					Start:    time.Date(2024, 9, 23, 8, 0, 0, 0, time.UTC),
-					Duration: oneHour,
-				},
-			},
-			expItem: item.Item{
-				ID:      "a",
-				Kind:    item.KindEvent,
-				Updated: time.Time{},
-				Body:    `{"start":"2024-09-23T08:00:00Z","duration":"1h0m0s","title":"title"}`,
-			},
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			actItem, actErr := tc.event.Item()
-			if tc.expErr != (actErr != nil) {
-				t.Errorf("exp nil, got %v", actErr)
-			}
-			if tc.expErr {
-				return
-			}
-			if diff := cmp.Diff(tc.expItem, actItem); diff != "" {
-				t.Errorf("(exp+, got -)\n%s", diff)
-			}
-		})
-	}
-}
 
-func TestEventValidate(t *testing.T) {
+// 	for _, tc := range []struct {
-	t.Parallel()
+// 		name  string
+// 		event item.Event
+// 		exp   bool
+// 	}{
+// 		{
+// 			name: "empty",
+// 		},
+// 		{
+// 			name: "missing title",
+// 			event: item.Event{
+// 				ID: "a",
+// 				EventBody: item.EventBody{
+// 					Start:    time.Date(2024, 9, 20, 8, 0, 0, 0, time.UTC),
+// 					Duration: oneHour,
+// 				},
+// 			},
+// 		},
+// 		{
+// 			name: "no date",
+// 			event: item.Event{
+// 				ID: "a",
+// 				EventBody: item.EventBody{
+// 					Title:    "title",
+// 					Start:    time.Date(0, 0, 0, 8, 0, 0, 0, time.UTC),
+// 					Duration: oneHour,
+// 				},
+// 			},
+// 		},
+// 		{
+// 			name: "no duration",
+// 			event: item.Event{
+// 				ID: "a",
+// 				EventBody: item.EventBody{
+// 					Title: "title",
+// 					Start: time.Date(2024, 9, 20, 8, 0, 0, 0, time.UTC),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			name: "valid",
+// 			event: item.Event{
+// 				ID: "a",
+// 				EventBody: item.EventBody{
+// 					Title:    "title",
+// 					Start:    time.Date(2024, 9, 20, 8, 0, 0, 0, time.UTC),
+// 					Duration: oneHour,
+// 				},
+// 			},
+// 			exp: true,
+// 		},
+// 	} {
+// 		t.Run(tc.name, func(t *testing.T) {
+// 			if act := tc.event.Valid(); tc.exp != act {
+// 				t.Errorf("exp %v, got %v", tc.exp, act)
+// 			}
 
-	oneHour, err := time.ParseDuration("1h")
+// 		})
-	if err != nil {
+// 	}
-		t.Errorf("exp nil, got %v", err)
+// }
-	}
-
-	for _, tc := range []struct {
-		name  string
-		event item.Event
-		exp   bool
-	}{
-		{
-			name: "empty",
-		},
-		{
-			name: "missing title",
-			event: item.Event{
-				ID: "a",
-				EventBody: item.EventBody{
-					Start:    time.Date(2024, 9, 20, 8, 0, 0, 0, time.UTC),
-					Duration: oneHour,
-				},
-			},
-		},
-		{
-			name: "no date",
-			event: item.Event{
-				ID: "a",
-				EventBody: item.EventBody{
-					Title:    "title",
-					Start:    time.Date(0, 0, 0, 8, 0, 0, 0, time.UTC),
-					Duration: oneHour,
-				},
-			},
-		},
-		{
-			name: "no duration",
-			event: item.Event{
-				ID: "a",
-				EventBody: item.EventBody{
-					Title: "title",
-					Start: time.Date(2024, 9, 20, 8, 0, 0, 0, time.UTC),
-				},
-			},
-		},
-		{
-			name: "valid",
-			event: item.Event{
-				ID: "a",
-				EventBody: item.EventBody{
-					Title:    "title",
-					Start:    time.Date(2024, 9, 20, 8, 0, 0, 0, time.UTC),
-					Duration: oneHour,
-				},
-			},
-			exp: true,
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			if act := tc.event.Valid(); tc.exp != act {
-				t.Errorf("exp %v, got %v", tc.exp, act)
-			}
-
-		})
-	}
-}

item/item.go

@@ -22,7 +22,7 @@ type Item struct {
 	Kind      Kind      `json:"kind"`
 	Updated   time.Time `json:"updated"`
 	Deleted   bool      `json:"deleted"`
-	Recurrer  *Recur    `json:"recurrer"`
+	Recurrer  Recurrer  `json:"recurrer"`
 	RecurNext time.Time `json:"recurNext"`
 	Body      string    `json:"body"`
 }

item/recur.go

@@ -1,61 +1,312 @@
 package item
 
 import (
-	"slices"
+	"fmt"
+	"strconv"
+	"strings"
 	"time"
 )
 
-type RecurPeriod string
+type Recurrer interface {
-
+	RecursOn(date Date) bool
-const (
+	String() string
-	PeriodDay   RecurPeriod = "day"
-	PeriodMonth RecurPeriod = "month"
-)
-
-var ValidPeriods = []RecurPeriod{PeriodDay, PeriodMonth}
-
-type Recur struct {
-	Start  time.Time   `json:"start"`
-	Period RecurPeriod `json:"period"`
-	Count  int         `json:"count"`
 }
 
-func (r *Recur) On(date time.Time) bool {
+func NewRecurrer(recurStr string) Recurrer {
-	switch r.Period {
+	terms := strings.Split(recurStr, ",")
-	case PeriodDay:
+	if len(terms) < 2 {
-		return r.onDays(date)
+		return nil
-	case PeriodMonth:
-		return r.onMonths(date)
-	default:
-		return false
 	}
+
+	start := NewDateFromString(terms[0])
+	if start.IsZero() {
+		return nil
+	}
+
+	terms = terms[1:]
+	for i, t := range terms {
+		terms[i] = strings.TrimSpace(t)
+	}
+
+	for _, parseFunc := range []func(Date, []string) (Recurrer, bool){
+		ParseDaily, ParseEveryNDays, ParseWeekly, ParseBiweekly,
+		ParseEveryNWeeks, ParseEveryNMonths,
+	} {
+		if recur, ok := parseFunc(start, terms); ok {
+			return recur
+		}
+	}
+
+	return nil
 }
 
-func (r *Recur) onDays(date time.Time) bool {
+type Daily struct {
-	if r.Start.After(date) {
+	Start Date
+}
+
+// yyyy-mm-dd, daily
+func ParseDaily(start Date, terms []string) (Recurrer, bool) {
+	if len(terms) < 1 {
+		return nil, false
+	}
+
+	if terms[0] != "daily" {
+		return nil, false
+	}
+
+	return Daily{
+		Start: start,
+	}, true
+}
+
+func (d Daily) RecursOn(date Date) bool {
+	return date.Equal(d.Start) || date.After(d.Start)
+}
+
+func (d Daily) String() string {
+	return fmt.Sprintf("%s, daily", d.Start.String())
+}
+
+type EveryNDays struct {
+	Start Date
+	N     int
+}
+
+// yyyy-mm-dd, every 3 days
+func ParseEveryNDays(start Date, terms []string) (Recurrer, bool) {
+	if len(terms) != 1 {
+		return EveryNDays{}, false
+	}
+
+	terms = strings.Split(terms[0], " ")
+	if len(terms) != 3 || terms[0] != "every" || terms[2] != "days" {
+		return EveryNDays{}, false
+	}
+
+	n, err := strconv.Atoi(terms[1])
+	if err != nil {
+		return EveryNDays{}, false
+	}
+
+	return EveryNDays{
+		Start: start,
+		N:     n,
+	}, true
+}
+
+func (nd EveryNDays) RecursOn(date Date) bool {
+	if nd.Start.After(date) {
 		return false
 	}
 
-	testDate := r.Start
+	testDate := nd.Start
 	for {
-		if testDate.Equal(date) {
+		switch {
+		case testDate.Equal(date):
+			return true
+		case testDate.After(date):
+			return false
+		default:
+			testDate = testDate.Add(nd.N)
+		}
+	}
+}
+
+func (nd EveryNDays) String() string {
+	return fmt.Sprintf("%s, every %d days", nd.Start.String(), nd.N)
+}
+
+type Weekly struct {
+	Start    Date
+	Weekdays Weekdays
+}
+
+// yyyy-mm-dd, weekly, wednesday & saturday & sunday
+func ParseWeekly(start Date, terms []string) (Recurrer, bool) {
+	if len(terms) < 2 {
+		return nil, false
+	}
+
+	if terms[0] != "weekly" {
+		return nil, false
+	}
+
+	wds := Weekdays{}
+	for _, wdStr := range strings.Split(terms[1], "&") {
+		wd, ok := ParseWeekday(wdStr)
+		if !ok {
+			continue
+		}
+		wds = append(wds, wd)
+	}
+	if len(wds) == 0 {
+		return nil, false
+	}
+
+	return Weekly{
+		Start:    start,
+		Weekdays: wds.Unique(),
+	}, true
+}
+
+func (w Weekly) RecursOn(date Date) bool {
+	if w.Start.After(date) {
+		return false
+	}
+
+	for _, wd := range w.Weekdays {
+		if wd == date.Weekday() {
 			return true
 		}
-		if testDate.After(date) {
-			return false
-		}
-
-		dur := time.Duration(r.Count) * 24 * time.Hour
-		testDate = testDate.Add(dur)
 	}
+
+	return false
 }
 
-func (r *Recur) onMonths(date time.Time) bool {
+func (w Weekly) String() string {
-	if r.Start.After(date) {
+	weekdayStrs := []string{}
+	for _, wd := range w.Weekdays {
+		weekdayStrs = append(weekdayStrs, wd.String())
+	}
+	weekdayStr := strings.Join(weekdayStrs, " & ")
+
+	return fmt.Sprintf("%s, weekly, %s", w.Start.String(), strings.ToLower(weekdayStr))
+}
+
+type Biweekly struct {
+	Start   Date
+	Weekday time.Weekday
+}
+
+// yyyy-mm-dd, biweekly, wednesday
+func ParseBiweekly(start Date, terms []string) (Recurrer, bool) {
+	if len(terms) < 2 {
+		return nil, false
+	}
+
+	if terms[0] != "biweekly" {
+		return nil, false
+	}
+
+	wd, ok := ParseWeekday(terms[1])
+	if !ok {
+		return nil, false
+	}
+
+	return Biweekly{
+		Start:   start,
+		Weekday: wd,
+	}, true
+}
+
+func (b Biweekly) RecursOn(date Date) bool {
+	if b.Start.After(date) {
 		return false
 	}
 
-	tDate := r.Start
+	if b.Weekday != date.Weekday() {
+		return false
+	}
+
+	// find first
+	tDate := b.Start
+	for {
+		if tDate.Weekday() == b.Weekday {
+			break
+		}
+		tDate = tDate.AddDays(1)
+	}
+
+	// add weeks
+	for {
+		switch {
+		case tDate.Equal(date):
+			return true
+		case tDate.After(date):
+			return false
+		}
+		tDate = tDate.AddDays(14)
+	}
+}
+
+func (b Biweekly) String() string {
+	return fmt.Sprintf("%s, biweekly, %s", b.Start.String(), strings.ToLower(b.Weekday.String()))
+}
+
+type EveryNWeeks struct {
+	Start Date
+	N     int
+}
+
+// yyyy-mm-dd, every 3 weeks
+func ParseEveryNWeeks(start Date, terms []string) (Recurrer, bool) {
+	if len(terms) != 1 {
+		return nil, false
+	}
+
+	terms = strings.Split(terms[0], " ")
+	if len(terms) != 3 || terms[0] != "every" || terms[2] != "weeks" {
+		return nil, false
+	}
+	n, err := strconv.Atoi(terms[1])
+	if err != nil || n < 1 {
+		return nil, false
+	}
+
+	return EveryNWeeks{
+		Start: start,
+		N:     n,
+	}, true
+}
+
+func (enw EveryNWeeks) RecursOn(date Date) bool {
+	if enw.Start.After(date) {
+		return false
+	}
+	if enw.Start.Equal(date) {
+		return true
+	}
+
+	intervalDays := enw.N * 7
+	return enw.Start.DaysBetween(date)%intervalDays == 0
+}
+
+func (enw EveryNWeeks) String() string {
+	return fmt.Sprintf("%s, every %d weeks", enw.Start.String(), enw.N)
+}
+
+type EveryNMonths struct {
+	Start Date
+	N     int
+}
+
+// yyyy-mm-dd, every 3 months
+func ParseEveryNMonths(start Date, terms []string) (Recurrer, bool) {
+	if len(terms) != 1 {
+		return nil, false
+	}
+
+	terms = strings.Split(terms[0], " ")
+	if len(terms) != 3 || terms[0] != "every" || terms[2] != "months" {
+		return nil, false
+	}
+	n, err := strconv.Atoi(terms[1])
+	if err != nil {
+		return nil, false
+	}
+
+	return EveryNMonths{
+		Start: start,
+		N:     n,
+	}, true
+}
+
+func (enm EveryNMonths) RecursOn(date Date) bool {
+	if enm.Start.After(date) {
+		return false
+	}
+
+	tDate := enm.Start
 	for {
 		if tDate.Equal(date) {
 			return true
@@ -63,23 +314,11 @@ func (r *Recur) onMonths(date time.Time) bool {
 		if tDate.After(date) {
 			return false
 		}
-
+		tDate = tDate.AddMonths(enm.N)
-		y, m, d := tDate.Date()
-		tDate = time.Date(y, m+time.Month(r.Count), d, 0, 0, 0, 0, time.UTC)
 	}
+
 }
 
-func (r *Recur) NextAfter(old time.Time) time.Time {
+func (enm EveryNMonths) String() string {
-	day, _ := time.ParseDuration("24h")
+	return fmt.Sprintf("%s, every %d months", enm.Start.String(), enm.N)
-	test := old.Add(day)
-	for {
-		if r.On(test) || test.After(time.Date(2500, 1, 1, 0, 0, 0, 0, time.UTC)) {
-			return test
-		}
-		test.Add(day)
-	}
-}
-
-func (r *Recur) Valid() bool {
-	return r.Start.IsZero() || !slices.Contains(ValidPeriods, r.Period)
 }

item/recur_test.go

@@ -1,105 +1,417 @@
 package item_test
 
-import (
+// func TestDaily(t *testing.T) {
-	"testing"
+// 	daily := task.Daily{
-	"time"
+// 		Start: task.NewDate(2021, 1, 31), // a sunday
+// 	}
+// 	dailyStr := "2021-01-31 (sunday), daily"
 
-	"go-mod.ewintr.nl/planner/item"
+// 	t.Run("parse", func(t *testing.T) {
-)
+// 		test.Equals(t, daily, task.NewRecurrer(dailyStr))
+// 	})
 
-func TestRecur(t *testing.T) {
+// 	t.Run("string", func(t *testing.T) {
-	t.Parallel()
+// 		test.Equals(t, dailyStr, daily.String())
+// 	})
 
-	t.Run("days", func(t *testing.T) {
+// 	t.Run("recurs_on", func(t *testing.T) {
-		r := item.Recur{
+// 		for _, tc := range []struct {
-			Start:  time.Date(2024, 12, 1, 0, 0, 0, 0, time.UTC),
+// 			name string
-			Period: item.PeriodDay,
+// 			date task.Date
-			Count:  5,
+// 			exp  bool
-		}
+// 		}{
-		day := 24 * time.Hour
+// 			{
+// 				name: "before",
+// 				date: task.NewDate(2021, 1, 30),
+// 			},
+// 			{
+// 				name: "on",
+// 				date: daily.Start,
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "after",
+// 				date: task.NewDate(2021, 2, 1),
+// 				exp:  true,
+// 			},
+// 		} {
+// 			t.Run(tc.name, func(t *testing.T) {
+// 				test.Equals(t, tc.exp, daily.RecursOn(tc.date))
+// 			})
+// 		}
+// 	})
+// }
 
-		for _, tc := range []struct {
+// func TestEveryNDays(t *testing.T) {
-			name string
+// 	every := task.EveryNDays{
-			date time.Time
+// 		Start: task.NewDate(2022, 6, 8),
-			exp  bool
+// 		N:     5,
-		}{
+// 	}
-			{
+// 	everyStr := "2022-06-08 (wednesday), every 5 days"
-				name: "before",
-				date: time.Date(202, 1, 1, 0, 0, 0, 0, time.UTC),
-			},
-			{
-				name: "start",
-				date: r.Start,
-				exp:  true,
-			},
-			{
-				name: "after true",
-				date: r.Start.Add(15 * day),
-				exp:  true,
-			},
-			{
-				name: "after false",
-				date: r.Start.Add(16 * day),
-			},
-		} {
-			t.Run(tc.name, func(t *testing.T) {
-				if act := r.On(tc.date); tc.exp != act {
-					t.Errorf("exp %v, got %v", tc.exp, act)
-				}
-			})
-		}
-	})
 
-	t.Run("months", func(t *testing.T) {
+// 	t.Run("parse", func(t *testing.T) {
-		r := item.Recur{
+// 		test.Equals(t, every, task.NewRecurrer(everyStr))
-			Start:  time.Date(2021, 2, 3, 0, 0, 0, 0, time.UTC),
+// 	})
-			Period: item.PeriodMonth,
-			Count:  3,
-		}
 
-		for _, tc := range []struct {
+// 	t.Run("string", func(t *testing.T) {
-			name string
+// 		test.Equals(t, everyStr, every.String())
-			date time.Time
+// 	})
-			exp  bool
-		}{
-			{
-				name: "before start",
-				date: time.Date(2021, 1, 27, 0, 0, 0, 0, time.UTC),
-			},
-			{
-				name: "on start",
-				date: time.Date(2021, 2, 3, 0, 0, 0, 0, time.UTC),
-				exp:  true,
-			},
-			{
-				name: "8 weeks after",
-				date: time.Date(2021, 3, 31, 0, 0, 0, 0, time.UTC),
-			},
-			{
-				name: "one month",
-				date: time.Date(2021, 3, 3, 0, 0, 0, 0, time.UTC),
-			},
-			{
-				name: "3 months",
-				date: time.Date(2021, 5, 3, 0, 0, 0, 0, time.UTC),
-				exp:  true,
-			},
-			{
-				name: "4 months",
-				date: time.Date(2021, 6, 3, 0, 0, 0, 0, time.UTC),
-			},
-			{
-				name: "6 months",
-				date: time.Date(2021, 8, 3, 0, 0, 0, 0, time.UTC),
-				exp:  true,
-			},
-		} {
-			t.Run(tc.name, func(t *testing.T) {
-				if act := r.On(tc.date); tc.exp != act {
-					t.Errorf("exp %v, got %v", tc.exp, act)
-				}
-			})
-		}
-	})
 
-}
+// 	t.Run("recurs on", func(t *testing.T) {
+// 		for _, tc := range []struct {
+// 			name string
+// 			date task.Date
+// 			exp  bool
+// 		}{
+// 			{
+// 				name: "before",
+// 				date: task.NewDate(2022, 1, 1),
+// 			},
+// 			{
+// 				name: "start",
+// 				date: every.Start,
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "after true",
+// 				date: every.Start.Add(15),
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "after false",
+// 				date: every.Start.Add(16),
+// 			},
+// 		} {
+// 			t.Run(tc.name, func(t *testing.T) {
+// 				test.Equals(t, tc.exp, every.RecursOn(tc.date))
+// 			})
+// 		}
+// 	})
+// }
+
+// func TestParseWeekly(t *testing.T) {
+// 	start := task.NewDate(2021, 2, 7)
+// 	for _, tc := range []struct {
+// 		name      string
+// 		input     []string
+// 		expOk     bool
+// 		expWeekly task.Weekly
+// 	}{
+// 		{
+// 			name: "empty",
+// 		},
+// 		{
+// 			name:  "wrong type",
+// 			input: []string{"daily"},
+// 		},
+// 		{
+// 			name:  "wrong count",
+// 			input: []string{"weeekly"},
+// 		},
+// 		{
+// 			name:  "unknown day",
+// 			input: []string{"weekly", "festivus"},
+// 		},
+// 		{
+// 			name:  "one day",
+// 			input: []string{"weekly", "monday"},
+// 			expOk: true,
+// 			expWeekly: task.Weekly{
+// 				Start: start,
+// 				Weekdays: task.Weekdays{
+// 					time.Monday,
+// 				},
+// 			},
+// 		},
+// 		{
+// 			name:  "multiple days",
+// 			input: []string{"weekly", "monday & thursday & saturday"},
+// 			expOk: true,
+// 			expWeekly: task.Weekly{
+// 				Start: start,
+// 				Weekdays: task.Weekdays{
+// 					time.Monday,
+// 					time.Thursday,
+// 					time.Saturday,
+// 				},
+// 			},
+// 		},
+// 		{
+// 			name:  "wrong order",
+// 			input: []string{"weekly", "sunday & thursday & wednesday"},
+// 			expOk: true,
+// 			expWeekly: task.Weekly{
+// 				Start: start,
+// 				Weekdays: task.Weekdays{
+// 					time.Wednesday,
+// 					time.Thursday,
+// 					time.Sunday,
+// 				},
+// 			},
+// 		},
+// 		{
+// 			name:  "doubles",
+// 			input: []string{"weekly", "sunday & sunday & monday"},
+// 			expOk: true,
+// 			expWeekly: task.Weekly{
+// 				Start: start,
+// 				Weekdays: task.Weekdays{
+// 					time.Monday,
+// 					time.Sunday,
+// 				},
+// 			},
+// 		},
+// 		{
+// 			name:  "one unknown",
+// 			input: []string{"weekly", "sunday & someday"},
+// 			expOk: true,
+// 			expWeekly: task.Weekly{
+// 				Start: start,
+// 				Weekdays: task.Weekdays{
+// 					time.Sunday,
+// 				},
+// 			},
+// 		},
+// 	} {
+// 		t.Run(tc.name, func(t *testing.T) {
+// 			weekly, ok := task.ParseWeekly(start, tc.input)
+// 			test.Equals(t, tc.expOk, ok)
+// 			if tc.expOk {
+// 				test.Equals(t, tc.expWeekly, weekly)
+// 			}
+// 		})
+// 	}
+// }
+
+// func TestWeekly(t *testing.T) {
+// 	weekly := task.Weekly{
+// 		Start: task.NewDate(2021, 1, 31), // a sunday
+// 		Weekdays: task.Weekdays{
+// 			time.Monday,
+// 			time.Wednesday,
+// 			time.Thursday,
+// 		},
+// 	}
+// 	weeklyStr := "2021-01-31 (sunday), weekly, monday & wednesday & thursday"
+
+// 	t.Run("parse", func(t *testing.T) {
+// 		test.Equals(t, weekly, task.NewRecurrer(weeklyStr))
+// 	})
+
+// 	t.Run("string", func(t *testing.T) {
+// 		test.Equals(t, weeklyStr, weekly.String())
+// 	})
+
+// 	t.Run("recurs_on", func(t *testing.T) {
+// 		for _, tc := range []struct {
+// 			name string
+// 			date task.Date
+// 			exp  bool
+// 		}{
+// 			{
+// 				name: "before start",
+// 				date: task.NewDate(2021, 1, 27), // a wednesday
+// 			},
+// 			{
+// 				name: "right weekday",
+// 				date: task.NewDate(2021, 2, 1), // a monday
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "another right day",
+// 				date: task.NewDate(2021, 2, 3), // a wednesday
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "wrong weekday",
+// 				date: task.NewDate(2021, 2, 5), // a friday
+// 			},
+// 		} {
+// 			t.Run(tc.name, func(t *testing.T) {
+// 				test.Equals(t, tc.exp, weekly.RecursOn(tc.date))
+// 			})
+// 		}
+// 	})
+// }
+
+// func TestBiweekly(t *testing.T) {
+// 	biweekly := task.Biweekly{
+// 		Start:   task.NewDate(2021, 1, 31), // a sunday
+// 		Weekday: time.Wednesday,
+// 	}
+// 	biweeklyStr := "2021-01-31 (sunday), biweekly, wednesday"
+
+// 	t.Run("parse", func(t *testing.T) {
+// 		test.Equals(t, biweekly, task.NewRecurrer(biweeklyStr))
+// 	})
+
+// 	t.Run("string", func(t *testing.T) {
+// 		test.Equals(t, biweeklyStr, biweekly.String())
+// 	})
+
+// 	t.Run("recurs_on", func(t *testing.T) {
+// 		for _, tc := range []struct {
+// 			name string
+// 			date task.Date
+// 			exp  bool
+// 		}{
+// 			{
+// 				name: "before start",
+// 				date: task.NewDate(2021, 1, 27), // a wednesday
+// 			},
+// 			{
+// 				name: "wrong weekday",
+// 				date: task.NewDate(2021, 2, 1), // a monday
+// 			},
+// 			{
+// 				name: "odd week count",
+// 				date: task.NewDate(2021, 2, 10), // a wednesday
+// 			},
+// 			{
+// 				name: "right",
+// 				date: task.NewDate(2021, 2, 17), // a wednesday
+// 				exp:  true,
+// 			},
+// 		} {
+// 			t.Run(tc.name, func(t *testing.T) {
+// 				test.Equals(t, tc.exp, biweekly.RecursOn(tc.date))
+// 			})
+// 		}
+// 	})
+// }
+
+// func TestEveryNWeeks(t *testing.T) {
+// 	everyNWeeks := task.EveryNWeeks{
+// 		Start: task.NewDate(2021, 2, 3),
+// 		N:     3,
+// 	}
+// 	everyNWeeksStr := "2021-02-03 (wednesday), every 3 weeks"
+
+// 	t.Run("parse", func(t *testing.T) {
+// 		test.Equals(t, everyNWeeks, task.NewRecurrer(everyNWeeksStr))
+// 	})
+
+// 	t.Run("string", func(t *testing.T) {
+// 		test.Equals(t, everyNWeeksStr, everyNWeeks.String())
+// 	})
+
+// 	t.Run("recurs on", func(t *testing.T) {
+// 		for _, tc := range []struct {
+// 			name string
+// 			date task.Date
+// 			exp  bool
+// 		}{
+// 			{
+// 				name: "before start",
+// 				date: task.NewDate(2021, 1, 27),
+// 			},
+// 			{
+// 				name: "on start",
+// 				date: task.NewDate(2021, 2, 3),
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "wrong day",
+// 				date: task.NewDate(2021, 2, 4),
+// 			},
+// 			{
+// 				name: "one week after",
+// 				date: task.NewDate(2021, 2, 10),
+// 			},
+// 			{
+// 				name: "first interval",
+// 				date: task.NewDate(2021, 2, 24),
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "second interval",
+// 				date: task.NewDate(2021, 3, 17),
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "second interval plus one week",
+// 				date: task.NewDate(2021, 3, 24),
+// 			},
+// 		} {
+// 			t.Run(tc.name, func(t *testing.T) {
+// 				test.Equals(t, tc.exp, everyNWeeks.RecursOn(tc.date))
+// 			})
+// 		}
+// 	})
+// }
+
+// func TestEveryNMonths(t *testing.T) {
+// 	everyNMonths := task.EveryNMonths{
+// 		Start: task.NewDate(2021, 2, 3),
+// 		N:     3,
+// 	}
+// 	everyNMonthsStr := "2021-02-03 (wednesday), every 3 months"
+
+// 	t.Run("parse", func(t *testing.T) {
+// 		test.Equals(t, everyNMonths, task.NewRecurrer(everyNMonthsStr))
+// 	})
+
+// 	t.Run("string", func(t *testing.T) {
+// 		test.Equals(t, everyNMonthsStr, everyNMonths.String())
+// 	})
+
+// 	t.Run("recurs on", func(t *testing.T) {
+// 		for _, tc := range []struct {
+// 			name string
+// 			date task.Date
+// 			exp  bool
+// 		}{
+// 			{
+// 				name: "before start",
+// 				date: task.NewDate(2021, 1, 27),
+// 			},
+// 			{
+// 				name: "on start",
+// 				date: task.NewDate(2021, 2, 3),
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "8 weeks after",
+// 				date: task.NewDate(2021, 3, 31),
+// 			},
+// 			{
+// 				name: "one month",
+// 				date: task.NewDate(2021, 3, 3),
+// 			},
+// 			{
+// 				name: "3 months",
+// 				date: task.NewDate(2021, 5, 3),
+// 				exp:  true,
+// 			},
+// 			{
+// 				name: "4 months",
+// 				date: task.NewDate(2021, 6, 3),
+// 			},
+// 			{
+// 				name: "6 months",
+// 				date: task.NewDate(2021, 8, 3),
+// 				exp:  true,
+// 			},
+// 		} {
+// 			t.Run(tc.name, func(t *testing.T) {
+// 				test.Equals(t, tc.exp, everyNMonths.RecursOn(tc.date))
+// 			})
+// 		}
+// 	})
+
+// 	t.Run("recurs every year", func(t *testing.T) {
+// 		recur := task.EveryNMonths{
+// 			Start: task.NewDate(2021, 3, 1),
+// 			N:     12,
+// 		}
+// 		test.Equals(t, false, recur.RecursOn(task.NewDate(2021, 3, 9)))
+// 	})
+
+// 	t.Run("bug", func(t *testing.T) {
+// 		recur := task.EveryNMonths{
+// 			Start: task.NewDate(2021, 3, 1),
+// 			N:     1,
+// 		}
+// 		test.Equals(t, false, recur.RecursOn(task.NewDate(2021, 11, 3)))
+// 	})
+// }

plan/test-conf.yaml

@@ -0,0 +1,3 @@
+db_path: ./plan.db
+sync_url: http://localhost:8092
+api_key: testKey

sync/service/postgres.go

@@ -66,6 +66,7 @@ func (p *Postgres) Update(i item.Item, ts time.Time) error {
 		if err != nil {
 			return fmt.Errorf("%w: %v", ErrPostgresFailure, err)
 		}
+		i.RecurNext = i.Recurrer.Start
 	} else {
 		recurrerJSON = nil
 	}

sync/service/recur.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"log/slog"
 	"time"
 
@@ -35,21 +36,26 @@ func (r *Recur) Run(interval time.Duration) {
 }
 
 func (r *Recur) Recur() error {
+	r.logger.Info("start looking for recurring items")
 	items, err := r.repoRecur.RecursBefore(time.Now())
 	if err != nil {
 		return err
 	}
+	r.logger.Info("found recurring items", "count", len(items))
 	for _, i := range items {
+		r.logger.Info("processing recurring item", "item", fmt.Sprintf("%+v", i))
 		// spawn instance
 		ne, err := item.NewEvent(i)
 		if err != nil {
 			return err
 		}
+		r.logger.Info("processing recurring event", "event", fmt.Sprintf("%+v", ne))
 		y, m, d := i.RecurNext.Date()
 		ne.ID = uuid.New().String()
 		ne.Recurrer = nil
 		ne.RecurNext = time.Time{}
 		ne.Start = time.Date(y, m, d, ne.Start.Hour(), ne.Start.Minute(), 0, 0, time.UTC)
+		r.logger.Info("created instance of  recurring event", "event", fmt.Sprintf("%+v", ne))
 
 		ni, err := ne.Item()
 		if err != nil {
@@ -58,11 +64,14 @@ func (r *Recur) Recur() error {
 		if err := r.repoSync.Update(ni, time.Now()); err != nil {
 			return err
 		}
+		r.logger.Info("storen instance of  recurring event", "recEventID", ne.ID, "instanceID", ni.ID)
 
 		// set next
-		if err := r.repoRecur.RecursNext(i.ID, i.Recurrer.NextAfter(i.RecurNext), time.Now()); err != nil {
+		next := i.Recurrer.NextAfter(i.RecurNext)
+		if err := r.repoRecur.RecursNext(i.ID, next, time.Now()); err != nil {
 			return err
 		}
+		r.logger.Info("updated recur date", "recEventID", ne.ID, "next", next)
 	}
 	r.logger.Info("processed recurring items", "count", len(items))
 

sync/service/service.go

@@ -39,7 +39,7 @@ func main() {
 		"dbUser": *dbUser,
 	})
 	recurrer := NewRecur(repo, repo, logger)
-	go recurrer.Run(12 * time.Hour)
+	go recurrer.Run(10 * time.Second)
 
 	srv := NewServer(repo, *apiKey, logger)
 	go http.ListenAndServe(fmt.Sprintf(":%s", *apiPort), srv)