feat: add monthly rotation option

devtools/pgmocktime/mocker.go

@@ -152,7 +152,7 @@ func (m *Mocker) Close() error { m.db.Close(); return nil }
 
 // AdvanceTime advances the time by the given duration.
 func (m *Mocker) AdvanceTime(ctx context.Context, d time.Duration) error {
-	m.exec(ctx, `update %s.flux_capacitor set ref_time = current_timestamp, base_time = %s.now() + '%d milliseconds'::interval`, m.safeSchema(), m.safeSchema(), d/time.Millisecond)
+	m.exec(ctx, `update %s.flux_capacitor set ref_time = current_timestamp, base_time = %s.now() + '%d hours'::interval + '%d milliseconds'::interval`, m.safeSchema(), m.safeSchema(), d/time.Hour, (d % time.Hour).Milliseconds())
 	return m.readErr("advance time")
 }
 

devtools/resetdb/datagen.go

@@ -29,7 +29,7 @@ import (
 
 var (
 	timeZones     = []string{"America/Chicago", "Europe/Berlin", "UTC"}
-	rotationTypes = []rotation.Type{rotation.TypeDaily, rotation.TypeHourly, rotation.TypeWeekly}
+	rotationTypes = []rotation.Type{rotation.TypeDaily, rotation.TypeHourly, rotation.TypeWeekly, rotation.TypeMonthly}
 )
 
 type AlertLog struct {

graphql2/graphqlapp/rotation.go

@@ -12,6 +12,7 @@ import (
 	"github.com/target/goalert/search"
 	"github.com/target/goalert/user"
 	"github.com/target/goalert/util"
+	"github.com/target/goalert/util/timeutil"
 	"github.com/target/goalert/validation"
 	"github.com/target/goalert/validation/validate"
 
@@ -378,38 +379,95 @@ func (m *Mutation) UpdateRotation(ctx context.Context, input graphql2.UpdateRota
 }
 
 func (a *Query) CalcRotationHandoffTimes(ctx context.Context, input *graphql2.CalcRotationHandoffTimesInput) ([]time.Time, error) {
-	var result []time.Time
-	var err error
 
-	err = validate.Many(
-		err,
-		validate.Range("count", input.Count, 0, 20),
-		validate.Range("hours", input.ShiftLengthHours, 0, 99999),
-	)
+	err := validate.Range("count", input.Count, 0, 20)
 	if err != nil {
-		return result, err
+		return nil, err
 	}
 
 	loc, err := util.LoadLocation(input.TimeZone)
 	if err != nil {
-		return result, validation.NewFieldError("timeZone", err.Error())
+		return nil, validation.NewFieldError("timeZone", err.Error())
+	}
+
+	if input.ShiftLength != nil && input.ShiftLengthHours != nil {
+		return nil, validation.NewFieldError("shiftLength", "only one of (shiftLength, shiftLengthHours) is allowed")
 	}
 
-	rot := &rotation.Rotation{
-		Start:       input.Handoff.In(loc),
-		ShiftLength: input.ShiftLengthHours,
-		Type:        rotation.TypeHourly,
+	rot := rotation.Rotation{
+		Start: input.Handoff.In(loc),
+	}
+	switch {
+	case input.ShiftLength != nil:
+		err = setRotationShiftFromISO(&rot, input.ShiftLength)
+		if err != nil {
+			return nil, err
+		}
+	case input.ShiftLengthHours != nil:
+		err = validate.Range("hours", *input.ShiftLengthHours, 0, 99999)
+		if err != nil {
+			return nil, err
+		}
+		rot.Type = rotation.TypeHourly
+		rot.ShiftLength = *input.ShiftLengthHours
+	default:
+		return nil, validation.NewFieldError("shiftLength", "must be specified")
 	}
 
 	t := time.Now()
 	if input.From != nil {
 		t = input.From.In(loc)
 	}
 
+	var result []time.Time
 	for len(result) < input.Count {
 		t = rot.EndTime(t)
 		result = append(result, t)
 	}
 
 	return result, nil
 }
+
+// getRotationFromISO determines the rotation type based on the given ISODuration. An error is given if the unsupported year field or multiple non-zero fields are given.
+func setRotationShiftFromISO(rot *rotation.Rotation, dur *timeutil.ISODuration) error {
+
+	// validate only one time field (year, month, days, timepart) is non-zero
+	nonZeroFields := 0
+
+	if dur.YearPart > 0 {
+		// These validation errors are only possible from direct api calls,
+		// thus using ISO standard terminology "designator" to match the spec.
+		return validation.NewFieldError("shiftLength", "year designator not allowed")
+	}
+
+	if dur.MonthPart > 0 {
+		rot.Type = rotation.TypeMonthly
+		rot.ShiftLength = dur.MonthPart
+		nonZeroFields++
+	}
+	if dur.WeekPart > 0 {
+		rot.Type = rotation.TypeWeekly
+		rot.ShiftLength = dur.WeekPart
+		nonZeroFields++
+	}
+	if dur.DayPart > 0 {
+		rot.Type = rotation.TypeDaily
+		rot.ShiftLength = dur.DayPart
+		nonZeroFields++
+	}
+	if dur.HourPart > 0 {
+		rot.Type = rotation.TypeHourly
+		rot.ShiftLength = dur.HourPart
+		nonZeroFields++
+	}
+
+	if nonZeroFields == 0 {
+		return validation.NewFieldError("shiftLength", "must not be zero")
+	}
+	if nonZeroFields > 1 {
+		// Same as above, this error is only possible from direct api calls.
+		return validation.NewFieldError("shiftLength", "only one of (M, W, D, H) is allowed")
+	}
+
+	return nil
+}

graphql2/schema.graphql

@@ -926,6 +926,7 @@ type Rotation {
 }
 
 enum RotationType {
+  monthly
   weekly
   daily
   hourly
@@ -972,7 +973,12 @@ input CalcRotationHandoffTimesInput {
   handoff: ISOTimestamp!
   from: ISOTimestamp
   timeZone: String!
-  shiftLengthHours: Int!
+  shiftLengthHours: Int
+    @deprecated(
+      reason: "Only accurate for hourly-type rotations. Use shiftLength instead."
+    )
+
+  shiftLength: ISODuration
   count: Int!
 }
 

migrate/migrations/20230911153243-add-monthly-rotation.sql

@@ -0,0 +1,5 @@
+-- +migrate Up notransaction
+ALTER TYPE enum_rotation_type ADD VALUE IF NOT EXISTS 'monthly';
+
+-- +migrate Down
+

migrate/schema.sql

@@ -1,7 +1,7 @@
 -- This file is auto-generated by "make db-schema"; DO NOT EDIT
--- DATA=35c108711cef0a38d78d5872c062fe576844c7f16e309378a051faa813578de0  -
--- DISK=b18bab67b9291c444025e882a3360c022c034d85477cad010781b2ec1b49fe3b  -
--- PSQL=b18bab67b9291c444025e882a3360c022c034d85477cad010781b2ec1b49fe3b  -
+-- DATA=352bdae95107b10d3d72b37649c056c72a8ebf2f4c62116005795107a2acc4e3  -
+-- DISK=9a7f47853bcc8b1aa4f0f916f53609e8523bfd8b9eb44cfee84fbb7286ef3d99  -
+-- PSQL=9a7f47853bcc8b1aa4f0f916f53609e8523bfd8b9eb44cfee84fbb7286ef3d99  -
 --
 -- pgdump-lite database dump
 --
@@ -122,6 +122,7 @@ CREATE TYPE enum_outgoing_messages_type AS ENUM (
 CREATE TYPE enum_rotation_type AS ENUM (
 	'daily',
 	'hourly',
+	'monthly',
 	'weekly'
 );
 

schedule/rotation/rotation.go

@@ -32,10 +32,57 @@ func (r Rotation) shiftClock() timeutil.Clock {
 	case TypeWeekly:
 		return timeutil.NewClock(r.ShiftLength*24*7, 0)
 	default:
+		// monthly is handled separately
 		panic("unexpected rotation type")
 	}
 }
 
+func (r Rotation) monthStartTime(t time.Time, n int) time.Time {
+	if n > 10000 {
+		panic("too many iterations")
+	}
+
+	if t.After(r.Start) || t.Equal(r.Start) { // t is after start of rotation
+		next := r.Start.AddDate(0, r.ShiftLength*n, 0)
+		if next.After(t) {
+			return r.Start.AddDate(0, r.ShiftLength*(n-1), 0)
+		}
+
+		return r.monthStartTime(t, n+1)
+	}
+
+	// t is before start of rotation
+	prev := r.Start.AddDate(0, -r.ShiftLength*n, 0)
+	if prev.Before(t) {
+		return prev
+	}
+
+	return r.monthStartTime(t, n+1)
+}
+
+func (r Rotation) monthEndTime(t time.Time, n int) time.Time {
+	if n > 10000 {
+		panic("too many iterations")
+	}
+
+	if t.After(r.Start) || t.Equal(r.Start) { // t is after start of rotation
+		next := r.Start.AddDate(0, r.ShiftLength*n, 0)
+		if next.After(t) {
+			return next
+		}
+
+		return r.monthEndTime(t, n+1)
+	}
+
+	// t is before start of rotation
+	prev := r.Start.AddDate(0, -r.ShiftLength*n, 0)
+	if prev.Before(t) || prev.Equal(t) {
+		return r.Start.AddDate(0, -r.ShiftLength*(n-1), 0)
+	}
+
+	return r.monthEndTime(t, n+1)
+}
+
 // StartTime calculates the start of the "shift" that started at (or was active) at t.
 // For daily and weekly rotations, start time will be the previous handoff time (from start).
 func (r Rotation) StartTime(t time.Time) time.Time {
@@ -45,6 +92,10 @@ func (r Rotation) StartTime(t time.Time) time.Time {
 	t = t.In(r.Start.Location()).Truncate(time.Minute)
 	r.Start = r.Start.Truncate(time.Minute)
 
+	if r.Type == TypeMonthly {
+		return r.monthStartTime(t, 1)
+	}
+
 	shiftClockLen := r.shiftClock()
 	rem := timeutil.ClockDiff(r.Start, t) % shiftClockLen
 
@@ -65,6 +116,10 @@ func (r Rotation) EndTime(t time.Time) time.Time {
 	t = t.In(r.Start.Location()).Truncate(time.Minute)
 	r.Start = r.Start.Truncate(time.Minute)
 
+	if r.Type == TypeMonthly {
+		return r.monthEndTime(t, 1)
+	}
+
 	shiftClockLen := r.shiftClock()
 	rem := timeutil.ClockDiff(r.Start, t) % shiftClockLen
 
@@ -88,7 +143,7 @@ func (r Rotation) Normalize() (*Rotation, error) {
 	err := validate.Many(
 		validate.IDName("Name", r.Name),
 		validate.Range("ShiftLength", r.ShiftLength, 1, 9000),
-		validate.OneOf("Type", r.Type, TypeWeekly, TypeDaily, TypeHourly),
+		validate.OneOf("Type", r.Type, TypeMonthly, TypeWeekly, TypeDaily, TypeHourly),
 		validate.Text("Description", r.Description, 1, 255),
 	)
 	if err != nil {