api/ovdashboard_api/core/caldav.py

@@ -47,13 +47,13 @@ class CalDAV:
         _logger.debug("calendars")
         return [str(cal.name) for cal in cls.principal.calendars()]
 
-    @classmethod
     @AsyncTTL(
         time_to_live=SETTINGS.caldav.cache_ttl,
         maxsize=SETTINGS.caldav.cache_size,
         skip_args=1,
     )
     @asyncify
+    @classmethod
     def get_calendar(cls, calendar_name: str) -> Calendar:
         """
         Get a calendar by name using the CalDAV principal object.
@@ -62,12 +62,6 @@ class CalDAV:
         return cls.principal.calendar(calendar_name)
 
     @classmethod
-    @AsyncTTL(
-        time_to_live=SETTINGS.caldav.cache_ttl,
-        maxsize=SETTINGS.caldav.cache_size,
-        skip_args=1,
-    )
-    @asyncify
     def get_events(cls, calendar_name: str, cfg: Config) -> list[CalEvent]:
         """
         Get a sorted list of events by CalDAV calendar name.

api/ovdashboard_api/routers/v1/__init__.py

@@ -6,7 +6,8 @@ This file: Main API router definition.
 
 from fastapi import APIRouter
 
-from . import aggregate, calendar, file, image, misc, text, ticker
+# from . import aggregate, calendar, file, image, misc, text, ticker
+from . import calendar, file, image, misc, text, ticker
 
 router = APIRouter(prefix="/api/v1")
 
@@ -18,6 +19,6 @@ router.include_router(image.router)
 router.include_router(file.router)
 
 router.include_router(calendar.router)
-router.include_router(aggregate.router)
+# router.include_router(aggregate.router)
 
 __all__ = ["router"]

api/ovdashboard_api/routers/v1/_common.py

@@ -11,7 +11,7 @@ from fastapi import Depends, HTTPException, params, status
 from webdav3.exceptions import RemoteResourceNotFound
 
 from ...core.caldav import CalDAV
-from ...core.config import Config, get_config
+from ...core.config import get_config
 from ...core.webdav import WebDAV
 
 _logger = getLogger(__name__)
@@ -171,17 +171,14 @@ async def list_calendar_names() -> list[str]:
 LM_CALENDARS = ListManager.from_lister_fn(list_calendar_names)
 
 
-async def list_aggregate_names(
+# async def list_aggregate_names(
-    cfg: Config = Depends(get_config),
+#     cfg: Config = Depends(get_config),
-) -> list[str]:
+# ) -> list[str]:
-    """
+#     """
-    List aggregate calendar names
+#     List aggregate calendar names
-    """
+#     """
 
-    if isinstance(cfg, params.Depends):
+#     return list(cfg.calendar.aggregates.keys())
-        cfg = await get_config()
-
-    return list(cfg.calendar.aggregates.keys())
 
 
-LM_AGGREGATES = ListManager.from_lister_fn(list_aggregate_names)
+# LM_AGGREGATES = ListManager.from_lister_fn(list_aggregate_names)

api/ovdashboard_api/routers/v1/aggregate.py

@@ -13,51 +13,53 @@ from fastapi import APIRouter, Depends
 
 from ...core.caldav import CalDAV
 from ...core.calevent import CalEvent
-from ...core.config import Config, get_config
+from ...core.config import Config
-from ._common import LM_AGGREGATES, LM_CALENDARS
+from ._common import AggregateNameLister, PrefixFinder, PrefixUnique
+from .calendar import calendar_unique
 
 _logger = getLogger(__name__)
 
 router = APIRouter(prefix="/aggregate", tags=["calendar"])
 
+aggregate_lister = AggregateNameLister()
+aggregate_finder = PrefixFinder(aggregate_lister)
+aggregate_unique = PrefixUnique(aggregate_finder)
+
 
 @router.on_event("startup")
 async def start_router() -> None:
     _logger.debug(f"{router.prefix} router starting.")
 
 
-@router.get(
+@router.get("/list", response_model=list[str])
-    "/list",
-    responses=LM_AGGREGATES.lister.responses,
-)
 async def list_aggregate_calendars(
-    names: Iterator[str] = Depends(LM_AGGREGATES.lister.func),
+    names: Iterator[str] = Depends(aggregate_lister),
 ) -> list[str]:
     return list(names)
 
 
-@router.get(
+@router.get("/find/{prefix}", response_model=list[str])
-    "/find/{prefix}",
-    responses=LM_AGGREGATES.filter.responses,
-)
 async def find_aggregate_calendars(
-    names: Iterator[str] = Depends(LM_AGGREGATES.filter.func),
+    names: Iterator[str] = Depends(aggregate_finder),
 ) -> list[str]:
     return list(names)
 
 
-@router.get(
+@router.get("/get/{prefix}", response_model=list[CalEvent])
-    "/get/{prefix}",
-    responses=LM_AGGREGATES.getter.responses,
-)
 async def get_aggregate_calendar(
-    cfg: Config = Depends(get_config),
+    name: str = Depends(aggregate_unique),
-    name: str = Depends(LM_AGGREGATES.getter.func),
 ) -> list[CalEvent]:
-    events: list[CalEvent] = []
+    cfg = await Config.get()
+    aggregate = cfg.calendar.aggregates[name]
 
-    for cal_prefix in cfg.calendar.aggregates[name]:
+    calendars = (
-        cal_name = await LM_CALENDARS.getter.func(cal_prefix)
+        DavCalendar(await calendar_unique(cal_prefix)) for cal_prefix in aggregate
-        events.extend(await CalDAV.get_events(cal_name, cfg))
+    )
 
-    return sorted(events)
+    return sorted(
+        [
+            event
+            async for calendar in calendars  # type: ignore
+            for event in (await calendar.events)
+        ]
+    )

api/ovdashboard_api/routers/v1/calendar.py

@@ -52,7 +52,7 @@ async def get_calendar(
     name: str = Depends(LM_CALENDARS.getter.func),
     cfg: Config = Depends(get_config),
 ) -> list[CalEvent]:
-    return await CalDAV.get_events(name, cfg)
+    return CalDAV.get_events(name, cfg)
 
 
 @router.get("/config")