fix scheduling when event is updated

Author: rizqme

internal/handlers/event_handler.go

@@ -175,6 +175,22 @@ func (h *EventHandler) UpdateEvent(c *gin.Context) {
 		return
 	}
 
+	// Remove all scheduled occurrences for this event from Redis
+	err = h.repo.RemoveEventOccurrencesFromRedis(c, event.ID)
+	if err != nil {
+		// Log but do not fail the request
+		zap.L().Warn("Failed to remove old scheduled occurrences from Redis", zap.String("event_id", event.ID.String()), zap.Error(err))
+	}
+
+	// Re-expand the event to schedule new occurrences
+	go func() {
+		if event.Schedule == nil {
+			_ = h.expander.ExpandNonRecurringEvent(context.Background(), event)
+		} else {
+			_ = h.expander.ExpandRecurringEvent(context.Background(), event)
+		}
+	}()
+
 	c.JSON(http.StatusOK, event)
 }
 

internal/integration/event_redis_cleanup_test.go

@@ -3,6 +3,7 @@ package integration
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"testing"
 	"time"
 
@@ -62,16 +63,19 @@ func TestEventRepository_RedisCleanupOnDelete(t *testing.T) {
 	for _, occ := range occurrences {
 		data, err := json.Marshal(occ)
 		require.NoError(t, err)
+		key := "schedule:" + event.ID.String() + ":" + fmt.Sprintf("%d", occ.ScheduledAt.Unix())
 		score := float64(occ.ScheduledAt.UnixMilli())
-		_, err = redisClient.ZAdd(ctx, "schedule:events", redis.Z{
+		_, err = redisClient.ZAdd(ctx, "schedules", redis.Z{
 			Score:  score,
-			Member: string(data),
+			Member: key,
 		}).Result()
 		require.NoError(t, err)
+		_, err = redisClient.HSet(ctx, "schedule:data", key, data).Result()
+		require.NoError(t, err)
 	}
 
 	// Ensure occurrences are in Redis
-	results, err := redisClient.ZRange(ctx, "schedule:events", 0, -1).Result()
+	results, err := redisClient.ZRange(ctx, "schedules", 0, -1).Result()
 	require.NoError(t, err)
 	assert.NotEmpty(t, results)
 
@@ -80,11 +84,16 @@ func TestEventRepository_RedisCleanupOnDelete(t *testing.T) {
 	require.NoError(t, err)
 
 	// Ensure occurrences for this event are removed from Redis
-	results, err = redisClient.ZRange(ctx, "schedule:events", 0, -1).Result()
+	results, err = redisClient.ZRange(ctx, "schedules", 0, -1).Result()
 	require.NoError(t, err)
 	for _, res := range results {
+		// Fetch from hash instead of decoding directly
+		data, err := redisClient.HGet(ctx, "schedule:data", res).Result()
+		if err != nil {
+			continue // skip if not found
+		}
 		var occ models.Occurrence
-		err := json.Unmarshal([]byte(res), &occ)
+		err = json.Unmarshal([]byte(data), &occ)
 		if err == nil {
 			assert.NotEqual(t, event.ID, occ.EventID, "Occurrence for deleted event should be removed from Redis")
 		}

internal/repository/event_repository.go

@@ -164,27 +164,36 @@ func (r *EventRepository) Delete(ctx context.Context, id uuid.UUID) error {
 	}
 
 	// Remove all scheduled occurrences for this event from Redis
-	err = r.removeEventOccurrencesFromRedis(ctx, id)
+	err = r.RemoveEventOccurrencesFromRedis(ctx, id)
 	if err != nil {
 		r.logger.Warn("Failed to remove event occurrences from Redis", zap.String("event_id", id.String()), zap.Error(err))
 	}
 
 	return nil
 }
 
-// removeEventOccurrencesFromRedis removes all scheduled occurrences for an event from Redis
-func (r *EventRepository) removeEventOccurrencesFromRedis(ctx context.Context, eventID uuid.UUID) error {
-	results, err := r.redis.ZRange(ctx, "schedule:events", 0, -1).Result()
+// RemoveEventOccurrencesFromRedis removes all scheduled occurrences for an event from Redis
+func (r *EventRepository) RemoveEventOccurrencesFromRedis(ctx context.Context, eventID uuid.UUID) error {
+	results, err := r.redis.ZRange(ctx, "schedules", 0, -1).Result()
 	if err != nil {
 		return err
 	}
-	for _, res := range results {
-		var occ models.Occurrence
-		if err := json.Unmarshal([]byte(res), &occ); err != nil {
+	for _, key := range results {
+		// Fetch the schedule data from the hash
+		data, err := r.redis.HGet(ctx, "schedule:data", key).Result()
+		if err != nil {
+			continue // skip if not found or error
+		}
+		var sched struct {
+			EventID uuid.UUID `json:"event_id"`
+		}
+		if err := json.Unmarshal([]byte(data), &sched); err != nil {
 			continue // skip invalid
 		}
-		if occ.EventID == eventID {
-			r.redis.ZRem(ctx, "schedule:events", res)
+		if sched.EventID == eventID {
+			// Remove from both sorted set and hash
+			r.redis.ZRem(ctx, "schedules", key)
+			r.redis.HDel(ctx, "schedule:data", key)
 		}
 	}
 	return nil

internal/scheduler/expander_test.go

@@ -241,4 +241,90 @@ func TestEventExpander(t *testing.T) {
 		}
 		assert.Equal(t, expectedMondays, scheduledMondays)
 	})
+
+	t.Run("update_event_cleans_and_reexpands", func(t *testing.T) {
+		cleanup()
+		fixedNow := time.Date(2024, 6, 1, 10, 0, 0, 0, time.UTC) // Saturday
+		lookAheadDuration := 14 * 24 * time.Hour                 // 2 weeks
+		gracePeriod := 2 * time.Minute
+		expansionInterval := 5 * time.Minute
+
+		oldNow := TimeNow
+		TimeNow = func() time.Time { return fixedNow }
+		defer func() { TimeNow = oldNow }()
+
+		eventStart := fixedNow.AddDate(0, 0, -7) // 1 week ago
+		scheduleConfig := &models.ScheduleConfig{
+			Frequency: "weekly",
+			Interval:  1,
+			ByDay:     []string{"MO"}, // Every Monday
+		}
+		event := &models.Event{
+			ID:          uuid.New(),
+			Name:        "Weekly Event",
+			Description: "Weekly event for update test",
+			StartTime:   eventStart,
+			Webhook:     "http://example.com",
+			Schedule:    scheduleConfig,
+			Status:      models.EventStatusActive,
+			Metadata:    []byte(`{"key": "value"}`),
+			Tags:        pq.StringArray{"test"},
+			CreatedAt:   eventStart,
+		}
+		err := eventRepo.Create(ctx, event)
+		require.NoError(t, err)
+
+		expander := NewExpander(scheduler, eventRepo, occurrenceRepo, lookAheadDuration, expansionInterval, gracePeriod, logger)
+		err = expander.ExpandEvents(ctx)
+		require.NoError(t, err)
+
+		// Check that Monday is scheduled
+		results, err := redisClient.ZRange(ctx, ScheduleKey, 0, -1).Result()
+		require.NoError(t, err)
+		var scheduledDays []time.Weekday
+		for _, key := range results {
+			data, err := redisClient.HGet(ctx, "schedule:data", key).Result()
+			require.NoError(t, err)
+			var sched models.Schedule
+			err = json.Unmarshal([]byte(data), &sched)
+			require.NoError(t, err)
+			if sched.EventID == event.ID {
+				scheduledDays = append(scheduledDays, sched.ScheduledAt.Weekday())
+			}
+		}
+		assert.Contains(t, scheduledDays, time.Monday)
+		assert.NotContains(t, scheduledDays, time.Wednesday)
+
+		// Update event to schedule on Wednesday instead
+		event.Schedule = &models.ScheduleConfig{
+			Frequency: "weekly",
+			Interval:  1,
+			ByDay:     []string{"WE"}, // Every Wednesday
+		}
+		err = eventRepo.Update(ctx, event)
+		require.NoError(t, err)
+		// Remove old occurrences
+		err = eventRepo.RemoveEventOccurrencesFromRedis(ctx, event.ID)
+		require.NoError(t, err)
+		// Re-expand
+		err = expander.ExpandEvents(ctx)
+		require.NoError(t, err)
+
+		// Check that only Wednesday is scheduled
+		results, err = redisClient.ZRange(ctx, ScheduleKey, 0, -1).Result()
+		require.NoError(t, err)
+		scheduledDays = scheduledDays[:0]
+		for _, key := range results {
+			data, err := redisClient.HGet(ctx, "schedule:data", key).Result()
+			require.NoError(t, err)
+			var sched models.Schedule
+			err = json.Unmarshal([]byte(data), &sched)
+			require.NoError(t, err)
+			if sched.EventID == event.ID {
+				scheduledDays = append(scheduledDays, sched.ScheduledAt.Weekday())
+			}
+		}
+		assert.Contains(t, scheduledDays, time.Wednesday)
+		assert.NotContains(t, scheduledDays, time.Monday)
+	})
 }