fix: removed notes

Author: corypride

backend/src/database/class_events.go

@@ -236,8 +236,6 @@ func (db *DB) CreateOverrideEvents(ctx *models.QueryContext, overrideEvents []*m
 	return nil
 }
 
-
-// calculateClassBoundariesWithContext computes boundaries with context for restore scenarios.
 func (db *DB) calculateClassBoundariesWithContext(trans *gorm.DB, classID uint, isRestore bool) (time.Time, time.Time, error) {
 	var events []models.ProgramClassEvent
 	if err := trans.Preload("Overrides").Where("class_id = ?", classID).Find(&events).Error; err != nil {
@@ -262,24 +260,18 @@ func (db *DB) calculateClassBoundariesWithContext(trans *gorm.DB, classID uint,
 			continue
 		}
 
-		// For boundary calculation, use different logic based on context
 		startBoundary := rRule.OrigOptions.Dtstart
 		endBoundary := time.Now().UTC().AddDate(MaxYearsForInfiniteRRule, 0, 0)
 
 		if isRestore {
-			// During restore, calculate boundaries based on the original RRULE pattern
-			// without considering the current extended UNTIL date
 			var originalEndBoundary time.Time
 			if !rRule.OrigOptions.Until.IsZero() {
-				// Use the original RRULE UNTIL if it exists, but limit it to reasonable range
 				originalEndBoundary = rRule.OrigOptions.Until
 			} else {
-				// If no UNTIL, use a reasonable window based on start date
-				originalEndBoundary = rRule.OrigOptions.Dtstart.AddDate(0, 3, 0) // 3 months from start
+				originalEndBoundary = rRule.OrigOptions.Dtstart.AddDate(0, 3, 0)
 			}
 			endBoundary = originalEndBoundary.AddDate(0, ClassEndDateBufferMonths, 0)
 		} else {
-			// During normal operations, use current RRULE UNTIL or class end date
 			if !rRule.OrigOptions.Until.IsZero() {
 				endBoundary = rRule.OrigOptions.Until.AddDate(0, ClassEndDateBufferMonths, 0)
 			} else if class.EndDt != nil {
@@ -334,13 +326,6 @@ func (db *DB) calculateClassBoundariesWithContext(trans *gorm.DB, classID uint,
 	return computedStart, computedEnd, nil
 }
 
-// calculateOriginalEndDate calculates what the end date should be based on the base RRULE pattern
-// without considering any overrides or current extended UNTIL dates.
-//
-// This function dynamically determines the actual last occurrence of the class by:
-// 1. Using the RRULE pattern to calculate occurrences within the original date range
-// 2. Finding the last actual occurrence (not just the UNTIL parameter)
-// 3. Returning the real last class date
 func (db *DB) calculateOriginalEndDate(trans *gorm.DB, classID uint) (time.Time, error) {
 	var events []models.ProgramClassEvent
 	if err := trans.Where("class_id = ?", classID).Find(&events).Error; err != nil {
@@ -356,22 +341,16 @@ func (db *DB) calculateOriginalEndDate(trans *gorm.DB, classID uint) (time.Time,
 		return time.Time{}, newGetRecordsDBError(err, "program_classes")
 	}
 
-	// Determine the original date range (before any rescheduling extensions)
-	originalEndRange := class.StartDt.AddDate(0, 3, 0) // Default: 3 months from start
+	originalEndRange := class.StartDt.AddDate(0, 3, 0)
 	if class.EndDt != nil {
-		// If current end_dt suggests this was extended, use a reasonable original range
-		// Check if current end date is significantly beyond what it would normally be
 		monthsDiff := int(class.EndDt.Sub(class.StartDt).Hours() / (24 * 30))
 		if monthsDiff > 3 {
-			// Likely extended, use 3 months from start as original range
 			originalEndRange = class.StartDt.AddDate(0, 3, 0)
 		} else {
-			// Use current end date as it seems reasonable
 			originalEndRange = *class.EndDt
 		}
 	}
 
-	// Calculate the actual last occurrence within the original date range
 	var lastOccurrence time.Time
 	for _, event := range events {
 		rRule, err := event.GetRRule()
@@ -380,7 +359,6 @@ func (db *DB) calculateOriginalEndDate(trans *gorm.DB, classID uint) (time.Time,
 			continue
 		}
 
-		// Get all occurrences within the original date range
 		occurrences := rRule.Between(class.StartDt, originalEndRange, true)
 		if len(occurrences) > 0 {
 			eventLastOccurrence := occurrences[len(occurrences)-1]
@@ -394,11 +372,9 @@ func (db *DB) calculateOriginalEndDate(trans *gorm.DB, classID uint) (time.Time,
 		return lastOccurrence, nil
 	}
 
-	// Fallback: if no occurrences found, use the original end range
 	return originalEndRange.Truncate(24 * time.Hour), nil
 }
 
-// updateClassDateBoundaries updates only the class start_dt and end_dt fields.
 func (db *DB) updateClassDateBoundaries(trans *gorm.DB, classID uint, newStart, newEnd time.Time) error {
 	updates := make(map[string]interface{})
 
@@ -407,7 +383,6 @@ func (db *DB) updateClassDateBoundaries(trans *gorm.DB, classID uint, newStart,
 		return newGetRecordsDBError(err, "program_classes")
 	}
 
-	// Truncate times to start of day since StartDt and EndDt are date-only fields
 	truncatedStart := newStart.Truncate(24 * time.Hour)
 	truncatedEnd := newEnd.Truncate(24 * time.Hour)
 
@@ -428,8 +403,6 @@ func (db *DB) updateClassDateBoundaries(trans *gorm.DB, classID uint, newStart,
 	return nil
 }
 
-// updateRRuleUntilDates updates the UNTIL parameter for all event RRULEs in a class.
-// This should be called separately from class boundary updates to avoid circular dependencies.
 func (db *DB) updateRRuleUntilDates(trans *gorm.DB, classID uint, newUntil time.Time) error {
 	var events []models.ProgramClassEvent
 	if err := trans.Where("class_id = ?", classID).Find(&events).Error; err != nil {
@@ -443,7 +416,6 @@ func (db *DB) updateRRuleUntilDates(trans *gorm.DB, classID uint, newUntil time.
 			continue
 		}
 
-		// Update UNTIL parameter - add it if it doesn't exist, or update if it does
 		newOptions := rRule.OrigOptions
 		newOptions.Until = newUntil
 
@@ -460,24 +432,17 @@ func (db *DB) updateRRuleUntilDates(trans *gorm.DB, classID uint, newUntil time.
 	return nil
 }
 
-// syncClassDateBoundaries synchronizes class date boundaries with actual event occurrences.
-// This refactored version separates calculation from updates to avoid circular dependencies.
 func (db *DB) syncClassDateBoundaries(trans *gorm.DB, classID uint) error {
 	return db.syncClassDateBoundariesWithContext(trans, classID, false)
 }
 
-// syncClassDateBoundariesWithContext synchronizes class date boundaries with context.
-// isRestore indicates whether this is being called during an override restore operation.
 func (db *DB) syncClassDateBoundariesWithContext(trans *gorm.DB, classID uint, isRestore bool) error {
-	// Step 1: Get current class state for comparison
 	var class models.ProgramClass
 	if err := trans.First(&class, "id = ?", classID).Error; err != nil {
 		return newGetRecordsDBError(err, "program_classes")
 	}
 
-	// Step 2: For restore scenarios, calculate the correct end date based on base pattern
 	if isRestore {
-		// Calculate what the end date should be based on the original RRULE pattern
 		originalEndDate, err := db.calculateOriginalEndDate(trans, classID)
 		if err != nil {
 			return err
@@ -489,23 +454,19 @@ func (db *DB) syncClassDateBoundariesWithContext(trans *gorm.DB, classID uint, i
 		}
 	}
 
-	// Step 3: Calculate the correct boundaries
 	computedStart, computedEnd, err := db.calculateClassBoundariesWithContext(trans, classID, isRestore)
 	if err != nil {
 		return err
 	}
 
-	// If no dates found, nothing to sync
 	if computedStart.IsZero() || computedEnd.IsZero() {
 		return nil
 	}
 
-	// Step 4: Update class dates only
 	if err := db.updateClassDateBoundaries(trans, classID, computedStart, computedEnd); err != nil {
 		return err
 	}
 
-	// Step 5: Update RRULE UNTIL dates separately (only if not restore, since we already did it)
 	if !isRestore {
 		if err := db.updateRRuleUntilDates(trans, classID, computedEnd); err != nil {
 			return err