Dump changes

pkg/brainbuffer/domain/scheduling/pattern.go

@@ -0,0 +1,112 @@
+package scheduling
+
+import (
+	apperrors "brainbuffer/pkg/brainbuffer/infrastructure/errors"
+	"github.com/pkg/errors"
+	"github.com/robfig/cron/v3"
+	"time"
+)
+
+type Pattern string
+
+func (pattern Pattern) NextTime(fromTime time.Time) (*time.Time, error) {
+	schedule, err := pattern.Parse()
+	if err != nil {
+		return nil, err
+	}
+
+	nextTime := schedule.Next(fromTime)
+
+	return &nextTime, nil
+}
+
+func (pattern Pattern) NextTimesUntil(fromTime time.Time, untilTime time.Time) ([]time.Time, error) {
+	schedule, err := pattern.Parse()
+	if err != nil {
+		return nil, err
+	}
+
+	nextTimes := make([]time.Time, 0, 0)
+
+	for nextTime := schedule.Next(fromTime); nextTime.Before(untilTime); nextTime = schedule.Next(nextTime) {
+		nextTimes = append(nextTimes, nextTime)
+	}
+
+	return nextTimes, nil
+}
+
+func (pattern Pattern) NextNTimes(fromTime time.Time, n int) ([]time.Time, error) {
+	schedule, err := pattern.Parse()
+	if err != nil {
+		return nil, err
+	}
+
+	nextTimes := make([]time.Time, n)
+
+	for nextTime, i := schedule.Next(fromTime), 0; i < n; i++ {
+		nextTimes = append(nextTimes, nextTime)
+		nextTime = schedule.Next(nextTime)
+	}
+
+	return nextTimes, nil
+}
+
+func (pattern Pattern) MatchesTime(t time.Time, precision time.Duration) (*time.Time, error) {
+	if precision > 24*time.Hour {
+		return nil, errors.New("unsupported precision value")
+	}
+
+	matchingTime, err := pattern.NextTime(time.Now())
+	if err != nil {
+		return nil, err
+	}
+
+	truncMatchingTime := matchingTime.Truncate(precision)
+	truncT := t.Truncate(precision)
+
+	for !truncMatchingTime.Equal(truncT) && truncMatchingTime.Before(truncT) {
+		matchingTime, _ = pattern.NextTime(*matchingTime)
+		truncMatchingTime = matchingTime.Truncate(precision)
+	}
+
+	if truncMatchingTime.Equal(truncT) {
+		return matchingTime, nil
+	} else {
+		return nil, nil
+	}
+}
+
+func (pattern Pattern) Parse() (cron.Schedule, error) {
+	schedule, err := cron.ParseStandard(string(pattern))
+	if err != nil {
+		return nil, apperrors.UnknownError{Err: err}
+	}
+
+	return schedule, nil
+}
+
+type Patterns []Pattern
+
+func (patterns Patterns) NextTime(fromTime time.Time) (*time.Time, Pattern, error) {
+	nextTimes := make(map[Pattern]time.Time)
+
+	for i, val := range patterns {
+		nextTime, err := patterns[i].NextTime(fromTime)
+		if err != nil {
+			return nil, "", err
+		}
+
+		nextTimes[val] = *nextTime
+	}
+
+	earliestNextTime := nextTimes[patterns[0]]
+	earliestNextTimePattern := patterns[0]
+	for k, v := range nextTimes {
+		if v.Before(earliestNextTime) {
+			earliestNextTime = v
+			earliestNextTimePattern = k
+		}
+	}
+
+	return &earliestNextTime, earliestNextTimePattern, nil
+}

pkg/brainbuffer/domain/scheduling/pattern_test.go

@@ -0,0 +1,62 @@
+package scheduling
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"time"
+)
+
+func TestNextTime(t *testing.T) {
+	pattern := Pattern("0 * * * *")
+
+	now := time.Now()
+
+	nextTime, _ := pattern.NextTime(now)
+
+	assert.True(t, now.Add(time.Hour).Truncate(time.Hour).Equal(*nextTime))
+}
+
+func TestNextTimeUntil(t *testing.T) {
+	pattern := Pattern("0 0 * * *")
+
+	now := time.Now()
+
+	nextTimes, _ := pattern.NextTimesUntil(now, now.Add(5*24*time.Hour))
+
+	assert.True(t, len(nextTimes) == 5)
+}
+
+func TestMatchesTime(t *testing.T) {
+	testCases := []struct {
+		pattern   Pattern
+		expected  time.Time
+		precision time.Duration
+	}{
+		{
+			pattern:   Pattern("0 * * * *"),
+			expected:  time.Now().Add(time.Hour).Truncate(time.Hour),
+			precision: time.Hour,
+		},
+		{
+			pattern:   Pattern("5 4 * * *"),
+			expected:  time.Now().Add(24 * time.Hour),
+			precision: 24 * time.Hour,
+		},
+	}
+
+	for _, testCase := range testCases {
+		matchingTime, _ := testCase.pattern.MatchesTime(testCase.expected, testCase.precision)
+
+		assert.NotNil(t, matchingTime)
+	}
+}
+
+func TestNotMatchesTime(t *testing.T) {
+	pattern := Pattern("0 * * * *")
+
+	nextHour := time.Now().Add(time.Hour + 30*time.Minute)
+
+	matchingTime, _ := pattern.MatchesTime(nextHour, time.Minute)
+
+	assert.Nil(t, matchingTime)
+}