feat(events): reliable holiday skipping for recurrences + UI badge; clean logs

Backend: generate EventException on create/update when skip_holidays or recurrence changes; emit RecurrenceException (EXDATE) with exact occurrence start time (UTC)
API: return master events with RecurrenceRule + RecurrenceException
Frontend: map RecurrenceException → recurrenceException; ensure SkipHolidays instances never render on holidays; place TentTree icon (black) next to main event icon via template
Docs: update README and Copilot instructions for recurrence/holiday behavior
Cleanup: remove dataSource and debug console logs

server/routes/events.py

@@ -1,8 +1,10 @@
 from flask import Blueprint, request, jsonify
 from server.database import Session
-from models.models import Event, EventMedia, MediaType
-from datetime import datetime, timezone
+from models.models import Event, EventMedia, MediaType, EventException
+from datetime import datetime, timezone, timedelta
 from sqlalchemy import and_
+from dateutil.rrule import rrulestr
+from dateutil.tz import UTC
 import sys
 sys.path.append('/workspace')
 
@@ -28,6 +30,8 @@ def get_events():
     group_id = request.args.get("group_id")
     show_inactive = request.args.get(
         "show_inactive", "0") == "1"  # Checkbox-Logik
+    # Always let Syncfusion handle recurrence; do not expand on backend
+    expand = False
 
     now = datetime.now(timezone.utc)
     events_query = session.query(Event)
@@ -47,18 +51,48 @@ def get_events():
         if end_dt and end_dt < now and e.is_active:
             e.is_active = False
             session.commit()
-        if show_inactive or e.is_active:
-            result.append({
-                "Id": str(e.id),
-                "GroupId": e.group_id,
-                "Subject": e.title,
-                "StartTime": e.start.isoformat() if e.start else None,
-                "EndTime": e.end.isoformat() if e.end else None,
-                "IsAllDay": False,
-                "MediaId": e.event_media_id,
-                "Type": e.event_type.value if e.event_type else None,  # <-- Enum zu String!
-                "Icon": get_icon_for_type(e.event_type.value if e.event_type else None),
-            })
+        if not (show_inactive or e.is_active):
+            continue
+
+        # Gather exception dates for this event (for recurrenceException/EXDATE)
+        exception_dates = session.query(EventException).filter(
+            EventException.event_id == e.id,
+            EventException.is_skipped == True
+        ).all()
+        # Syncfusion expects recurrenceException as comma-separated ISO strings (yyyy-MM-ddTHH:mm:ssZ)
+        # IMPORTANT: The time must match the event's occurrence start time. Use the event's start time-of-day.
+        recurrence_exception = None
+        if exception_dates:
+            # Use event start time in UTC as baseline
+            base_start = e.start.astimezone(UTC) if e.start.tzinfo else e.start.replace(tzinfo=UTC)
+            tokens = []
+            for d in exception_dates:
+                exd = d.exception_date  # date
+                occ_dt = datetime(
+                    exd.year, exd.month, exd.day,
+                    base_start.hour, base_start.minute, base_start.second,
+                    tzinfo=UTC
+                )
+                tokens.append(occ_dt.strftime('%Y-%m-%dT%H:%M:%SZ'))
+            recurrence_exception = ','.join(tokens)
+
+        base_payload = {
+            "Id": str(e.id),
+            "GroupId": e.group_id,
+            "Subject": e.title,
+            "StartTime": e.start.isoformat() if e.start else None,
+            "EndTime": e.end.isoformat() if e.end else None,
+            "IsAllDay": False,
+            "MediaId": e.event_media_id,
+            "Type": e.event_type.value if e.event_type else None,  # <-- Enum zu String!
+            "Icon": get_icon_for_type(e.event_type.value if e.event_type else None),
+            # Recurrence metadata
+            "RecurrenceRule": e.recurrence_rule,
+            "RecurrenceEnd": e.recurrence_end.isoformat() if e.recurrence_end else None,
+            "RecurrenceException": recurrence_exception,
+            "SkipHolidays": bool(getattr(e, 'skip_holidays', False)),
+        }
+        result.append(base_payload)
     session.close()
     return jsonify(result)
 
@@ -125,6 +159,9 @@ def create_event():
     if end.tzinfo is None:
         end = end.astimezone(timezone.utc)
 
+    # Determine skip_holidays from either camelCase or snake_case
+    skip_holidays_val = bool(data.get("skipHolidays")) or bool(data.get("skip_holidays"))
+
     # Event anlegen
     event = Event(
         group_id=data["group_id"],
@@ -134,12 +171,51 @@ def create_event():
         end=end,
         event_type=event_type,
         is_active=True,
-        event_media_id=event_media_id,
-        slideshow_interval=slideshow_interval,
-        created_by=created_by  # <--- HIER hinzugefügt
+    event_media_id=event_media_id,
+    slideshow_interval=slideshow_interval,
+    created_by=created_by,
+    # Recurrence
+    recurrence_rule=data.get("recurrence_rule"),
+    skip_holidays=skip_holidays_val,
+    recurrence_end=(datetime.fromisoformat(data["recurrence_end"]) if data.get("recurrence_end") else None),
     )
     session.add(event)
     session.commit()
+
+    # --- Holiday exception creation (backend) ---
+    def regenerate_event_exceptions(ev: Event):
+        from models.models import SchoolHoliday, EventException
+        from dateutil.rrule import rrulestr
+        from dateutil.tz import UTC
+        # Clear existing exceptions for this event
+        session.query(EventException).filter_by(event_id=ev.id).delete()
+        session.commit()
+        if not (ev.skip_holidays and ev.recurrence_rule):
+            return
+        # Get holidays
+        holidays = session.query(SchoolHoliday).all()
+        dtstart = ev.start.astimezone(UTC)
+        r = rrulestr(ev.recurrence_rule, dtstart=dtstart)
+        window_start = dtstart
+        window_end = ev.recurrence_end.astimezone(UTC) if ev.recurrence_end else dtstart.replace(year=dtstart.year + 1)
+        # Build set of all holiday dates (inclusive)
+        holiday_dates = set()
+        for h in holidays:
+            hs = h.start_date
+            he = h.end_date
+            d = hs
+            while d <= he:
+                holiday_dates.add(d)
+                d = d + timedelta(days=1)
+        # Create exceptions for occurrences on holiday dates
+        for occ_start in r.between(window_start, window_end, inc=True):
+            occ_date = occ_start.date()
+            if occ_date in holiday_dates:
+                session.add(EventException(event_id=ev.id, exception_date=occ_date, is_skipped=True))
+        session.commit()
+
+    regenerate_event_exceptions(event)
+
     return jsonify({"success": True, "event_id": event.id})
 
 
@@ -160,10 +236,63 @@ def update_event(event_id):
         data["end"]) if "end" in data else event.end
     event.event_type = data.get("event_type", event.event_type)
     event.event_media_id = data.get("event_media_id", event.event_media_id)
-    event.slideshow_interval = data.get(
-        "slideshow_interval", event.slideshow_interval)
+    event.slideshow_interval = data.get("slideshow_interval", event.slideshow_interval)
     event.created_by = data.get("created_by", event.created_by)
+    # Track previous values to decide on exception regeneration
+    prev_rule = event.recurrence_rule
+    prev_end = event.recurrence_end
+    prev_skip = bool(getattr(event, 'skip_holidays', False))
+
+    # Recurrence updates
+    if "recurrence_rule" in data:
+        event.recurrence_rule = data.get("recurrence_rule")
+    if "recurrence_end" in data:
+        rec_end_val = data.get("recurrence_end")
+        event.recurrence_end = datetime.fromisoformat(rec_end_val) if rec_end_val else None
+    # Skip holidays can be updated independently
+    if "skipHolidays" in data or "skip_holidays" in data:
+        event.skip_holidays = bool(data.get("skipHolidays") or data.get("skip_holidays"))
+
     session.commit()
+
+    # Regenerate exceptions if any relevant field changed
+    need_regen = (
+        prev_rule != event.recurrence_rule or
+        prev_end != event.recurrence_end or
+        prev_skip != bool(getattr(event, 'skip_holidays', False))
+    )
+    if need_regen:
+        # Re-use helper from create route
+        def regenerate_event_exceptions(ev: Event):
+            from models.models import SchoolHoliday, EventException
+            from dateutil.rrule import rrulestr
+            from dateutil.tz import UTC
+            # Clear existing exceptions
+            session.query(EventException).filter_by(event_id=ev.id).delete()
+            session.commit()
+            if not (ev.skip_holidays and ev.recurrence_rule):
+                return
+            holidays = session.query(SchoolHoliday).all()
+            dtstart = ev.start.astimezone(UTC)
+            r = rrulestr(ev.recurrence_rule, dtstart=dtstart)
+            window_start = dtstart
+            window_end = ev.recurrence_end.astimezone(UTC) if ev.recurrence_end else dtstart.replace(year=dtstart.year + 1)
+            holiday_dates = set()
+            for h in holidays:
+                hs = h.start_date
+                he = h.end_date
+                d = hs
+                while d <= he:
+                    holiday_dates.add(d)
+                    d = d + timedelta(days=1)
+            for occ_start in r.between(window_start, window_end, inc=True):
+                occ_date = occ_start.date()
+                if occ_date in holiday_dates:
+                    session.add(EventException(event_id=ev.id, exception_date=occ_date, is_skipped=True))
+            session.commit()
+
+        regenerate_event_exceptions(event)
+
     event_id_return = event.id  # <-- ID vor session.close() speichern!
     session.close()
     return jsonify({"success": True, "event_id": event_id_return})