Merge pull request #101 from nebulabroadcast/97-scheduler-templates

Scheduling: Apply Weekly Plans via Web Interface

Author: martastain

backend/api/scheduler/models.py

@@ -2,49 +2,9 @@
 
 from pydantic import Field
 
+from nebula.helpers.create_new_event import EventData
 from server.models import RequestModel, ResponseModel
 
-Serializable = int | str | float | list[str] | bool | None
-
-
-class EventData(RequestModel):
-    id: int | None = Field(
-        None,
-        title="Event ID",
-        description="Event ID. None for new events.",
-        examples=[320],
-    )
-
-    start: int = Field(
-        ...,
-        title="Start time",
-        examples=[1620000000],
-    )
-
-    id_asset: int | None = Field(
-        None,
-        title="Asset ID",
-        description="ID of the asset to be used as a primary asset for this event.",
-        examples=[123],
-    )
-
-    items: list[dict[str, Serializable]] | None = Field(default_factory=lambda: [])
-
-    meta: dict[str, Serializable] | None = Field(
-        default=None,
-        title="Event metadata",
-        description="Metadata for the event.",
-        examples=[
-            {
-                "title": "My event",
-                "subtitle": "My event subtitle",
-                "genre": "My genre",
-            }
-        ],
-    )
-
-    # TODO: validate meta object against the channel_config fields
-
 
 class SchedulerRequestModel(RequestModel):
     id_channel: int = Field(

backend/api/scheduler/scheduler.py

@@ -1,83 +1,11 @@
 import nebula
+from nebula.helpers.create_new_event import create_new_event
 from nebula.helpers.scheduling import parse_rundown_date
-from nebula.settings.models import PlayoutChannelSettings
 
-from .models import EventData, SchedulerRequestModel, SchedulerResponseModel
+from .models import SchedulerRequestModel, SchedulerResponseModel
 from .utils import delete_events, get_event_at_time, get_events_in_range
 
 
-async def create_new_event(
-    channel: PlayoutChannelSettings,
-    event_data: EventData,
-    user: nebula.User | None = None,
-) -> None:
-    """Create a new event from the given data."""
-
-    username = user.name if user else None
-
-    pool = await nebula.db.pool()
-    async with pool.acquire() as conn, conn.transaction():
-        new_bin = nebula.Bin(connection=conn, username=username)
-        new_event = nebula.Event(connection=conn, username=username)
-
-        await new_bin.save()
-
-        new_event["id_magic"] = new_bin.id
-        new_event["id_channel"] = channel.id
-        new_event["start"] = event_data.start
-
-        asset_meta = {}
-        position = 0
-        if event_data.id_asset:
-            asset = await nebula.Asset.load(
-                event_data.id_asset, connection=conn, username=username
-            )
-
-            new_event["id_asset"] = event_data.id_asset
-
-            new_item = nebula.Item(connection=conn, username=username)
-            new_item["id_asset"] = event_data.id_asset
-            new_item["id_bin"] = new_bin.id
-            new_item["position"] = position
-            new_item["mark_in"] = asset["mark_in"]
-            new_item["mark_out"] = asset["mark_out"]
-
-            await new_item.save()
-            new_bin["duration"] = asset.duration
-            asset_meta = asset.meta
-            position += 1
-
-        if event_data.items:
-            for item_data in event_data.items:
-                if item_data.get("id"):
-                    assert isinstance(item_data["id"], int), "Invalid item ID"
-                    item = await nebula.Item.load(
-                        item_data["id"], connection=conn, username=username
-                    )
-                else:
-                    item = nebula.Item(connection=conn, username=username)
-                item.update(item_data)
-                item["id_bin"] = new_bin.id
-                item["position"] = position
-                await item.save()
-                position += 1
-
-        for field in channel.fields:
-            if (value := asset_meta.get(field.name)) is not None:
-                new_event[field.name] = value
-
-            if event_data.meta is not None:
-                value = event_data.meta.get(field.name)
-                if value is not None:
-                    new_event[field.name] = value
-
-        try:
-            await new_event.save()
-            await new_bin.save()
-        except Exception as e:
-            raise nebula.ConflictException() from e
-
-
 async def scheduler(
     request: SchedulerRequestModel,
     editable: bool = True,

backend/api/scheduling_templates/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["ApplyTemplateRequest", "ListTemplatesRequest"]
+
+from .template_request import ApplyTemplateRequest, ListTemplatesRequest

backend/api/scheduling_templates/models.py

@@ -0,0 +1,50 @@
+from typing import Annotated
+
+from pydantic import BaseModel, Field
+
+from server.models import RequestModel, ResponseModel
+
+
+class TemplateItemModel(BaseModel):
+    name: Annotated[str, Field(..., title="Template name", examples=["my_template"])]
+    title: Annotated[str, Field(..., title="Template title", examples=["My Template"])]
+
+
+class ListTemplatesResponseModel(ResponseModel):
+    templates: Annotated[
+        list[TemplateItemModel],
+        Field(
+            default_factory=lambda: [],
+            title="Templates",
+        ),
+    ]
+
+
+class ApplyTemplateRequestModel(RequestModel):
+    id_channel: Annotated[
+        int,
+        Field(
+            ...,
+            title="Channel ID",
+            examples=[1],
+        ),
+    ]
+    template_name: Annotated[
+        str,
+        Field(..., title="Template name", examples=["my_template"]),
+    ]
+    date: Annotated[
+        str,
+        Field(
+            ...,
+            title="Date",
+            examples=["2022-12-31"],
+        ),
+    ]
+    clear: Annotated[
+        bool,
+        Field(
+            title="Clear events",
+            description="Clear all events before applying the template",
+        ),
+    ] = False

backend/api/scheduling_templates/template_importer.py

@@ -0,0 +1,91 @@
+import datetime
+from typing import Any, Literal
+
+from nebula.helpers.create_new_event import EventData
+
+from .utils import get_week_start
+
+DayKey = Literal[
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday",
+    "default",
+]
+
+DAY_NAMES: list[DayKey] = [
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday",
+]
+
+
+class TemplateImporter:
+    day_start_hour: int
+    day_start_minute: int
+    events: dict[int, EventData]
+    template: dict[DayKey, list[dict[str, Any]]]
+
+    def __init__(
+        self,
+        template: dict[DayKey, list[dict[str, Any]]],
+        day_start_hour: int = 7,
+        day_start_minute: int = 30,
+    ):
+        self.day_start_hour = day_start_hour
+        self.day_start_minute = day_start_minute
+        self.template = template
+        self.events = {}
+
+    @property
+    def day_start_offset(self) -> int:
+        return self.day_start_hour * 3600 + self.day_start_minute * 60
+
+    def build_for_week(self, date: str) -> dict[int, Any]:
+        week_start = get_week_start(date, self.day_start_hour, self.day_start_minute)
+
+        for i in range(7):
+            day_start = week_start + datetime.timedelta(days=i)
+            day_name: DayKey = DAY_NAMES[day_start.weekday()]
+
+            day_start_ts = int(day_start.timestamp())
+            self._apply_day_template("default", day_start_ts)
+
+            if day_name in self.template:
+                self._apply_day_template(day_name, day_start_ts)
+        return self.events
+
+    def _apply_day_template(self, key: DayKey, day_start_ts: int) -> None:
+        day_tpl = self.template.get(key, [])
+
+        for tpl in day_tpl:
+            hour, minute = (int(k) for k in tpl["time"].split(":"))
+            # seconds from midnight
+            toffset = hour * 3600 + minute * 60
+            # if the event is before the day start, it is for the next day
+            if toffset < self.day_start_offset:
+                toffset += 24 * 3600
+            # somehow craft the final event timestamp
+            evt_start = int(day_start_ts + toffset - self.day_start_offset)
+
+            meta = {}
+            for mkey in ["title", "description", "id_asset", "color"]:
+                if tpl.get(mkey):
+                    meta[mkey] = tpl[mkey]
+
+            event_data = EventData(
+                id=None,
+                start=evt_start,
+                items=tpl.get("items", None),
+                meta=meta,
+                id_asset=tpl.get("id_asset", None),
+            )
+
+            self.events[evt_start] = event_data

backend/api/scheduling_templates/template_request.py

@@ -0,0 +1,105 @@
+import nebula
+from nebula.helpers.create_new_event import create_new_event
+from server.dependencies import CurrentUser, RequestInitiator
+from server.request import APIRequest
+
+from .models import (
+    ApplyTemplateRequestModel,
+    ListTemplatesResponseModel,
+    TemplateItemModel,
+)
+from .template_importer import TemplateImporter
+from .utils import list_templates, load_template
+
+
+class ListTemplatesRequest(APIRequest):
+    """Retrieve or update the schedule for a channel
+
+    This endpoint handles chanel macro-scheduling,
+    including the creation, modification, and deletion of playout events.
+
+    Schedule is represented as a list of events, typically for one week.
+    """
+
+    name = "list-scheduling-templates"
+    title = "List scheduling templates"
+    response_model = ListTemplatesResponseModel
+
+    async def handle(
+        self,
+        #        user: CurrentUser,
+        initiator: RequestInitiator,
+    ) -> ListTemplatesResponseModel:
+        template_names = list_templates()
+
+        return ListTemplatesResponseModel(
+            templates=[
+                TemplateItemModel(name=name, title=name.capitalize())
+                for name in template_names
+            ]
+        )
+
+
+class ApplyTemplateRequest(APIRequest):
+    """Apply a template to a channel"""
+
+    name = "apply-scheduling-template"
+    title = "Apply scheduling template"
+
+    async def handle(
+        self,
+        user: CurrentUser,
+        request: ApplyTemplateRequestModel,
+        initiator: RequestInitiator,
+    ) -> None:
+        if not (channel := nebula.settings.get_playout_channel(request.id_channel)):
+            raise nebula.BadRequestException(f"No such channel {request.id_channel}")
+
+        template = load_template(request.template_name)
+        hh, mm = channel.day_start
+
+        importer = TemplateImporter(template.get("schedule", {}), hh, mm)
+        edata = importer.build_for_week(request.date)
+
+        if not edata:
+            nebula.log.warn("No events found in template")
+            return
+
+        first_ts = min(edata.keys())
+        last_ts = max(edata.keys())
+
+        pool = await nebula.db.pool()
+        async with pool.acquire() as conn, conn.transaction():
+            if request.clear:
+                # Clear mode
+                query = """
+                    DELETE FROM events
+                    WHERE start >= $1 AND start <= $2 AND id_channel = $3
+                """
+                await conn.execute(query, first_ts, last_ts, request.id_channel)
+
+            else:
+                # Merge mode
+                query = """
+                    SELECT start FROM events
+                    WHERE start >= $1 AND start <= $2 AND id_channel = $3
+                """
+                existing_times = []
+                async for row in nebula.db.iterate(
+                    query, first_ts, last_ts, request.id_channel
+                ):
+                    existing_times.append(row["start"])
+
+                MINIMUM_GAP_SECONDS = 5 * 60
+                for new_ts in list(edata.keys()):
+                    if any(
+                        abs(new_ts - existing_ts) < MINIMUM_GAP_SECONDS
+                        for existing_ts in existing_times
+                    ):
+                        nebula.log.warn(
+                            f"Skipping event at {new_ts}: too close to existing event"
+                        )
+                        edata.pop(new_ts)
+
+            for _, event_data in edata.items():
+                await create_new_event(channel, event_data, user, conn)