fix: timezone awareness

CK-7vn · CK-7vn · commit 70cd14bc715c · 2026-01-20T15:55:42.000-05:00
diff --git a/backend/src/database/class_events.go b/backend/src/database/class_events.go
@@ -500,7 +500,7 @@ func (db *DB) GetFacilityCalendar(args *models.QueryContext, dtRng *models.DateR
 
 	facilityEvents := make([]models.FacilityProgramClassEvent, 0, 10)
 	for _, event := range events {
-		rRule, err := event.GetRRule()
+		rRule, err := event.GetRRuleWithTimezone(args.Timezone)
 		if err != nil {
 			return nil, err
 		}
@@ -851,7 +851,7 @@ func (db *DB) GetClassEventInstancesWithAttendanceForRecurrence(classId int, qry
 		return nil, newGetRecordsDBError(err, "program_class_events")
 	}
 
-	rRule, err := event.GetRRule()
+	rRule, err := event.GetRRuleWithTimezone(qryCtx.Timezone)
 	if err != nil {
 		logrus.Errorf("event has invalid rule, event: %v", event)
 	}
@@ -1067,7 +1067,7 @@ func (db *DB) GetClassEventDatesForRecurrence(classID int, timezone string, mont
 	}
 
 	loc, _ := time.LoadLocation(timezone)
-	rule, err := event.GetRRule()
+	rule, err := event.GetRRuleWithTimezone(timezone)
 	if err != nil {
 		return nil, err
 	}
diff --git a/backend/src/models/class_event.go b/backend/src/models/class_event.go
@@ -90,7 +90,9 @@ func (e *ProgramClassEvent) GetRRuleWithTimezone(facilityTimezone string) (*rrul
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse event recurrence rule: %w", err)
 	}
-	rruleOptions.Dtstart = rruleOptions.Dtstart.In(time.UTC)
+	// NOTE: We no longer convert Dtstart to UTC here.
+	// For timezone-aware RRULEs (DTSTART;TZID=...), this preserves wall-clock time across DST.
+	// For legacy UTC-based RRULEs (DTSTART:...Z), the DTSTART is already in UTC.
 	if !rruleOptions.Until.IsZero() {
 		loc := rruleOptions.Until.Location()
 		endOfDay := time.Date(
diff --git a/backend/tests/integration/room_conflict_test.go b/backend/tests/integration/room_conflict_test.go
@@ -59,6 +59,18 @@ func TestRoomConflictDetection(t *testing.T) {
 		require.NoError(t, env.DB.Create(otherRoom).Error)
 		testRejectsRoomFromDifferentFacility(t, env, facility, facilityAdmin, program, otherRoom.ID)
 	})
+
+	t.Run("Detects conflicts with timezone-aware RRULEs across DST", func(t *testing.T) {
+		room := &models.Room{FacilityID: facility.ID, Name: "DST Test Room"}
+		require.NoError(t, env.DB.Create(room).Error)
+		testDetectsConflictsWithTimezoneAwareRRules(t, env, facility, facilityAdmin, program, room.ID)
+	})
+
+	t.Run("Backwards compatible with UTC-based RRULEs", func(t *testing.T) {
+		room := &models.Room{FacilityID: facility.ID, Name: "UTC Compat Room"}
+		require.NoError(t, env.DB.Create(room).Error)
+		testBackwardsCompatibleUTCRules(t, env, facility, facilityAdmin, program, room.ID)
+	})
 }
 
 func testDetectsOverlappingBookings(t *testing.T, env *TestEnv, facility *models.Facility, facilityAdmin *models.User, program *models.Program, roomID uint) {
@@ -318,3 +330,122 @@ func testRejectsRoomFromDifferentFacility(t *testing.T, env *TestEnv, facility *
 		Do().
 		ExpectStatus(http.StatusBadRequest)
 }
+
+// testDetectsConflictsWithTimezoneAwareRRules tests that timezone-aware RRULEs
+// correctly detect conflicts across DST transitions. Two classes at "10 AM local time"
+// created in different DST periods should conflict when using DTSTART;TZID= format.
+func testDetectsConflictsWithTimezoneAwareRRules(t *testing.T, env *TestEnv, facility *models.Facility, facilityAdmin *models.User, program *models.Program, roomID uint) {
+	// Use America/New_York timezone for DST testing
+	facility.Timezone = "America/New_York"
+	require.NoError(t, env.DB.Save(facility).Error)
+
+	// Class 1: Created in July (EDT) at 10 AM local time, repeating on Thursdays
+	// Using timezone-aware RRULE format: DTSTART;TZID=America/New_York:20250701T100000
+	classStartDate := time.Date(2025, 7, 1, 0, 0, 0, 0, time.UTC)
+	creditHours := int64(2)
+
+	class1 := models.ProgramClass{
+		ProgramID:      program.ID,
+		FacilityID:     facility.ID,
+		Capacity:       10,
+		Name:           "Summer Class",
+		InstructorName: "Instructor 1",
+		Description:    "Class created in summer at 10 AM",
+		StartDt:        classStartDate,
+		Status:         models.Scheduled,
+		CreditHours:    &creditHours,
+	}
+
+	class1Resp := NewRequest[*models.ProgramClass](env.Client, t, http.MethodPost, fmt.Sprintf("/api/programs/%d/classes", program.ID), class1).
+		WithTestClaims(&handlers.Claims{Role: models.FacilityAdmin, UserID: facilityAdmin.ID, FacilityID: facility.ID}).
+		Do().
+		ExpectStatus(http.StatusCreated)
+
+	createdClass1 := class1Resp.GetData()
+
+	// Timezone-aware RRULE: 10 AM in America/New_York, every Thursday
+	event1Payload := map[string]interface{}{
+		"duration":        "1h",
+		"room_id":         roomID,
+		"recurrence_rule": "DTSTART;TZID=America/New_York:20250703T100000\nRRULE:FREQ=WEEKLY;BYDAY=TH",
+	}
+
+	NewRequest[any](env.Client, t, http.MethodPost, fmt.Sprintf("/api/program-classes/%d/events", createdClass1.ID), event1Payload).
+		WithTestClaims(&handlers.Claims{Role: models.FacilityAdmin, UserID: facilityAdmin.ID, FacilityID: facility.ID}).
+		Do().
+		ExpectStatus(http.StatusCreated)
+
+	// Now try to create Class 2 in December (EST) at 10 AM local time
+	// With timezone-aware RRULEs, this should conflict because both are at 10 AM wall time
+	conflicts, err := env.DB.CheckRRuleConflicts(&models.ConflictCheckRequest{
+		FacilityID:     facility.ID,
+		RoomID:         roomID,
+		RecurrenceRule: "DTSTART;TZID=America/New_York:20251204T100000\nRRULE:FREQ=WEEKLY;BYDAY=TH",
+		Duration:       "1h",
+	})
+	require.NoError(t, err)
+	require.NotEmpty(t, conflicts, "Should detect conflicts when both classes are at 10 AM wall time (timezone-aware RRULEs preserve wall time across DST)")
+	require.Equal(t, "Summer Class", conflicts[0].ClassName, "Conflict should identify the Summer Class")
+
+	// Verify that classes at different wall times don't conflict
+	// 11 AM local time should NOT conflict with 10 AM class
+	noConflicts, err := env.DB.CheckRRuleConflicts(&models.ConflictCheckRequest{
+		FacilityID:     facility.ID,
+		RoomID:         roomID,
+		RecurrenceRule: "DTSTART;TZID=America/New_York:20251204T110000\nRRULE:FREQ=WEEKLY;BYDAY=TH",
+		Duration:       "1h",
+	})
+	require.NoError(t, err)
+	require.Empty(t, noConflicts, "Should NOT detect conflicts when classes are at different wall times (10 AM vs 11 AM)")
+}
+
+// testBackwardsCompatibleUTCRules verifies that old UTC-based RRULEs still work.
+// Note: UTC-based RRULEs will have the DST shift behavior (this is expected for legacy data).
+func testBackwardsCompatibleUTCRules(t *testing.T, env *TestEnv, facility *models.Facility, facilityAdmin *models.User, program *models.Program, roomID uint) {
+	facility.Timezone = "America/New_York"
+	require.NoError(t, env.DB.Save(facility).Error)
+
+	classStartDate := time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC)
+	creditHours := int64(2)
+
+	class1 := models.ProgramClass{
+		ProgramID:      program.ID,
+		FacilityID:     facility.ID,
+		Capacity:       10,
+		Name:           "Legacy UTC Class",
+		InstructorName: "Instructor",
+		Description:    "Class using old UTC-based RRULE format",
+		StartDt:        classStartDate,
+		Status:         models.Scheduled,
+		CreditHours:    &creditHours,
+	}
+
+	class1Resp := NewRequest[*models.ProgramClass](env.Client, t, http.MethodPost, fmt.Sprintf("/api/programs/%d/classes", program.ID), class1).
+		WithTestClaims(&handlers.Claims{Role: models.FacilityAdmin, UserID: facilityAdmin.ID, FacilityID: facility.ID}).
+		Do().
+		ExpectStatus(http.StatusCreated)
+
+	createdClass1 := class1Resp.GetData()
+
+	// Old UTC-based RRULE format: 14:00 UTC = 10:00 AM EDT in August
+	event1Payload := map[string]interface{}{
+		"duration":        "1h",
+		"room_id":         roomID,
+		"recurrence_rule": "DTSTART:20260806T140000Z\nRRULE:FREQ=WEEKLY;BYDAY=TH",
+	}
+
+	NewRequest[any](env.Client, t, http.MethodPost, fmt.Sprintf("/api/program-classes/%d/events", createdClass1.ID), event1Payload).
+		WithTestClaims(&handlers.Claims{Role: models.FacilityAdmin, UserID: facilityAdmin.ID, FacilityID: facility.ID}).
+		Do().
+		ExpectStatus(http.StatusCreated)
+
+	// Another UTC-based RRULE at the same UTC time should conflict
+	conflicts, err := env.DB.CheckRRuleConflicts(&models.ConflictCheckRequest{
+		FacilityID:     facility.ID,
+		RoomID:         roomID,
+		RecurrenceRule: "DTSTART:20260806T140000Z\nRRULE:FREQ=WEEKLY;BYDAY=TH",
+		Duration:       "1h",
+	})
+	require.NoError(t, err)
+	require.NotEmpty(t, conflicts, "UTC-based RRULEs at same UTC time should still conflict (backwards compatibility)")
+}
diff --git a/frontend/src/Components/inputs/RRuleControl.tsx b/frontend/src/Components/inputs/RRuleControl.tsx
@@ -117,13 +117,13 @@ export const RRuleControl = forwardRef<RRuleFormHandle, RRuleControlProp>(
 
                 const duration = formatDuration(startTime, endTime);
                 const rule = new RRule(options);
-                const utcDtstart = zonedDateTime
-                    .toISOString()
-                    .replace(/[-:]/g, '')
-                    .split('.')[0];
+                const localDtstart = `${(startDate as string).replace(/-/g, '')}T${startTime.replace(':', '')}00`;
                 const ruleString = rule
                     .toString()
-                    .replace(/DTSTART[^:]*:[^\n]+/, `DTSTART:${utcDtstart}Z`);
+                    .replace(
+                        /DTSTART[^:]*:[^\n]+/,
+                        `DTSTART;TZID=${user.timezone}:${localDtstart}`
+                    );
                 returnValue = {
                     rule: ruleString,
                     duration: duration
diff --git a/frontend/src/Components/modals/RescheduleClassEventModal.tsx b/frontend/src/Components/modals/RescheduleClassEventModal.tsx
@@ -84,16 +84,9 @@ export const RescheduleClassEventModal = forwardRef(function (
         }
 
         //reschedule logic
-        const timeZoneStartDateTime = fromZonedTime(
-            `${data.date}T${data.start_time}`,
-            user.timezone
-        );
-
-        const rescheduledRule = new RRule({
-            freq: RRule.DAILY,
-            count: 1,
-            dtstart: timeZoneStartDateTime
-        }).toString();
+        const dateStr = (data.date as string).replace(/-/g, '');
+        const timeStr = (data.start_time as string).replace(':', '') + '00';
+        const rescheduledRule = `DTSTART;TZID=${user.timezone}:${dateStr}T${timeStr}\nRRULE:FREQ=DAILY;COUNT=1`;
         const duration = formatDuration(
             data.start_time as string,
             data.end_time as string

Original file line number	Diff line number	Diff line change
`@@ -500,7 +500,7 @@ func (db DB) GetFacilityCalendar(args models.QueryContext, dtRng *models.DateR`
`500`	`500`
`501`	`501`	`facilityEvents := make([]models.FacilityProgramClassEvent, 0, 10)`
`502`	`502`	`for _, event := range events {`
`503`		`- rRule, err := event.GetRRule()`
	`503`	`+ rRule, err := event.GetRRuleWithTimezone(args.Timezone)`
`504`	`504`	`if err != nil {`
`505`	`505`	`return nil, err`
`506`	`506`	`}`
`@@ -851,7 +851,7 @@ func (db *DB) GetClassEventInstancesWithAttendanceForRecurrence(classId int, qry`
`851`	`851`	`return nil, newGetRecordsDBError(err, "program_class_events")`
`852`	`852`	`}`
`853`	`853`
`854`		`- rRule, err := event.GetRRule()`
	`854`	`+ rRule, err := event.GetRRuleWithTimezone(qryCtx.Timezone)`
`855`	`855`	`if err != nil {`
`856`	`856`	`logrus.Errorf("event has invalid rule, event: %v", event)`
`857`	`857`	`}`
`@@ -1067,7 +1067,7 @@ func (db *DB) GetClassEventDatesForRecurrence(classID int, timezone string, mont`
`1067`	`1067`	`}`
`1068`	`1068`
`1069`	`1069`	`loc, _ := time.LoadLocation(timezone)`
`1070`		`- rule, err := event.GetRRule()`
	`1070`	`+ rule, err := event.GetRRuleWithTimezone(timezone)`
`1071`	`1071`	`if err != nil {`
`1072`	`1072`	`return nil, err`
`1073`	`1073`	`}`