fix update following children

Author: firu11

pkg/core/core_events.go

@@ -250,7 +250,6 @@ func (c *Core) updateCurrentChild(updated *Event) (*Event, error) {
 	if !ok || parent == nil || !parent.IsParent() {
 		return nil, fmt.Errorf("no valid parent found")
 	}
-
 	if parent.Repeat == nil {
 		return nil, fmt.Errorf("parent is not a repeating event, WTF")
 	}
@@ -270,83 +269,110 @@ func (c *Core) updateCurrentChild(updated *Event) (*Event, error) {
 	return c.CreateEvent(detachedEvent) // save as new
 }
 
-// Splits the time series into two by stopping the original parent event from repeating further and creating brand new parent with updated properties.
+// updateFollowingChildren splits the time series into two by stopping the original parent event from repeating further and creating brand new parent with updated properties.
 func (c *Core) updateFollowingChildren(old, new *Event) (*Event, error) {
-	parent, ok := c.events[new.ParentId]
+	parent, ok := c.events[old.ParentId]
 	if !ok || parent == nil || !parent.IsParent() {
 		return nil, fmt.Errorf("no valid parent found")
 	}
+	if parent.Repeat == nil {
+		return nil, fmt.Errorf("parent is not a repeating event")
+	}
 
-	// save originals for rollback
+	// keep originals for rollback
 	originalRepeat := *parent.Repeat
-	originalExceptions := append([]uuid.UUID{}, parent.Repeat.Exceptions...) // deep copy
+	originalExceptions := append([]uuid.UUID(nil), parent.Repeat.Exceptions...)
+
+	// find position in the series
+	_, splitIndex := firstOccurrenceAtOrAfter(old.From, parent)
+	if splitIndex == -1 {
+		return nil, fmt.Errorf("could not find occurrence at or after %s", old.From)
+	}
+
+	fromDiff := new.From.Sub(old.From)
+
+	// editing the first occurrence -> update entire series
+	if splitIndex == 0 {
+		return c.updateAllChildren(old, new)
+	}
+
+	// split exceptions before and after the edited occurrence
+	exBefore, exAfter := splitExceptions(originalExceptions, old.From)
+
+	// remove parent before we mutate it
+	if err := c.intervalTree.RemoveEvent(*parent); err != nil {
+		return nil, fmt.Errorf("failed to remove parent from interval tree: %w", err)
+	}
 
-	until := addUnit(old.From, -1, old.Repeat.Frequency) // cap parent at start of change
-	if !until.After(parent.From) {
+	// ------------ cap the original parent ------------
+	previousStart := addUnit(old.From, -originalRepeat.Interval, originalRepeat.Frequency)
+	if !previousStart.After(parent.From) {
+		// only one occurrence left -> turn it into a basic (non-repeating) event
 		parent.Repeat = nil
 	} else {
-		parent.Repeat.Until = until
-		parent.Repeat.Count = 0 // enforce Until logic over Count
+		// keep repeating but stop before the split point
+		capped := originalRepeat
+		capped.Until = previousStart
+		capped.Count = 0
+		capped.Exceptions = exBefore
+		parent.Repeat = &capped
 	}
 
-	// split exceptions
-	exBefore, exAfter := splitExceptions(originalExceptions, new.From)
-	if parent.Repeat != nil {
-		parent.Repeat.Exceptions = exBefore
+	// save the capped parent
+	if err := c.intervalTree.InsertEvent(*parent); err != nil {
+		parent.Repeat = &originalRepeat
+		parent.Repeat.Exceptions = originalExceptions
+		return nil, fmt.Errorf("failed to reinsert capped parent: %w", err)
 	}
 
 	if err := c.saveAndCommitEvent(parent, fmt.Sprintf("Capped parent event %q", parent.Id)); err != nil {
-		return nil, fmt.Errorf("failed to commit parent event: %w", err)
-	}
-
-	// create the new parent for the second half of the time series
-	newEvent := *new             // shallow copy
-	newEvent.Id = uuid.New()     // assign new id
-	newEvent.ParentId = uuid.Nil // not child anymore
-
-	if originalRepeat.Count != 0 && newEvent.Repeat != nil {
-		// shorten the repeat for the second half
-		_, elapsed := firstOccurrenceAtOrAfter(old.From, parent)
-		if elapsed <= 0 {
-			// the split is at the first occurance -> nothing to subtract (basically update all)
-			newEvent.Repeat.Count = originalRepeat.Count
-		} else {
-			remaining := originalRepeat.Count - elapsed
-			if remaining <= 0 {
+		return nil, fmt.Errorf("failed to commit capped parent: %w", err)
+	}
+
+	// ------------ create the new continuing series ------------
+	newEvent := *new
+	newEvent.Id = uuid.New()
+	newEvent.ParentId = uuid.Nil // this is now its own parent
+
+	if newEvent.Repeat != nil {
+		repeat := *newEvent.Repeat
+		repeat.Exceptions = nil
+
+		// adjust count for remaining occurrences
+		if originalRepeat.Count != 0 {
+			remaining := originalRepeat.Count - splitIndex
+			if remaining < 1 {
 				remaining = 1
 			}
-			newEvent.Repeat.Count = remaining
+			repeat.Count = remaining
 		}
-	}
 
-	// transform exceptions
-	fromDiff := newEvent.From.Sub(old.From)
-	if fromDiff != 0 {
-		for _, exc := range exAfter {
-			t := getTimeFromUUID(exc)
-			t = t.Add(fromDiff)
-			newEvent.Repeat.Exceptions = append(newEvent.Repeat.Exceptions, generateCustomUUID(newEvent.Id, t))
-		}
-	}
-	if newEvent.Repeat != nil && newEvent.Repeat.Count != 0 {
-		newEvent.Repeat.Count -= len(exAfter)
-		if newEvent.Repeat.Count < 1 {
-			newEvent.Repeat.Count = 1
+		// shift exceptions to the new parent
+		for _, ex := range exAfter {
+			exTime := getTimeFromUUID(ex).Add(fromDiff)
+			repeat.Exceptions = append(repeat.Exceptions, generateCustomUUID(newEvent.Id, exTime))
 		}
+
+		newEvent.Repeat = &repeat
 	}
 
-	createdEvent, err := c.CreateEvent(newEvent)
+	created, err := c.CreateEvent(newEvent)
 	if err != nil {
-		// rollback the parent cap
+		// rollback: restore original parent
+		_ = c.intervalTree.RemoveEvent(*parent)
 		parent.Repeat = &originalRepeat
 		parent.Repeat.Exceptions = originalExceptions
-		if rbErr := c.saveAndCommitEvent(parent, fmt.Sprintf("Rolled back cap on parent event %q", parent.Id)); rbErr != nil {
-			return nil, fmt.Errorf("failed to create new event: %w; rollback also failed: %v", err, rbErr)
+
+		if rbErr := c.intervalTree.InsertEvent(*parent); rbErr != nil {
+			return nil, fmt.Errorf("failed to create new series: %w; rollback failed too: %v", err, rbErr)
+		}
+		if rbErr := c.saveAndCommitEvent(parent, fmt.Sprintf("rolled back parent %q", parent.Id)); rbErr != nil {
+			return nil, fmt.Errorf("failed to create new series: %w; rollback failed too: %v", err, rbErr)
 		}
-		return nil, fmt.Errorf("failed to create new event: %w", err)
+		return nil, fmt.Errorf("failed to create new continuing series: %w", err)
 	}
 
-	return createdEvent, nil
+	return created, nil
 }
 
 // Updates the entire repeating series by only modifying the parent. That means all generated child events get updated as well.

pkg/core/event.go

@@ -25,7 +25,7 @@ type Event struct {
 	Tag         string      `json:"tag"`       // User-defined category or label.
 	ParentId    uuid.UUID   `json:"parent_id"` // Specific for child events. It is uuid.Nil if the event is basic or parent.
 	Repeat      *Repetition `json:"repeat"`
-	UpdatedAt   time.Time   `json:"updated_at"` // Used for git conflict resolution; latest wins.
+	UpdatedAt   time.Time   `json:"-"` // Used for git conflict resolution; latest wins. Client doesn't need to see this.
 }
 
 // Repetition defines the recurrence rules for a Parent event.