| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495 |
- import json
- from dataclasses import dataclass, field
- from datetime import date
- from room_cal.store import StoreBacked
- from room_cal._utils import EventSource, safe_json_loads, filter_events, services as _services, service_name, source_line
- _PREFIX = 'Closed: '
- _UNSET = object()
- @dataclass
- class ClosedData:
- services: list[str]
- source: dict = field(default_factory=dict)
- ClosedList = dict[date, ClosedData]
- def _build_title(closed_services: list[str]) -> str:
- all_keys = {s.key for s in _services()}
- if all_keys <= set(closed_services):
- return f"{_PREFIX}All"
- names = [service_name(s) for s in sorted(closed_services)]
- return f"{_PREFIX}{', '.join(names)}"
- def _build_description(closed_services: list[str], source: dict) -> str:
- desc = '\n'.join(f"{service_name(s)}: Closed" for s in sorted(closed_services))
- if source:
- desc += f"\nSource: {source_line(source)}"
- return desc
- class Closed(StoreBacked, EventSource):
- def __init__(self, *, backend=None):
- StoreBacked.__init__(self, backend=backend)
- EventSource.__init__(self, 'closed')
- async def set(self, target_date: date, data: 'ClosedData', *, existing=_UNSET) -> None:
- """Create or update a 'Closed' all-day event. Deletes any existing event if data.services is empty.
- Pass existing=<EventRecord> to skip the internal lookup when the caller already holds the event.
- Pass existing=None to unconditionally create.
- """
- if existing is _UNSET:
- existing = await self._find(target_date)
- if not data.services:
- if existing:
- await self._backend.delete(existing.uid)
- return
- title = _build_title(data.services)
- description = _build_description(data.services, data.source)
- x_data = json.dumps({'closed_services': sorted(data.services), 'source': data.source})
- if existing:
- if title != existing.title or description != existing.description or x_data != existing.x_data:
- await self._backend.update(existing.uid, title=title, description=description, x_data=x_data)
- else:
- await self._create_all_day(target_date, title, description, x_data)
- async def get(self, target_date: date) -> 'ClosedData | None':
- """Return ClosedData for the date, or None if no closure event exists."""
- event = await self._find(target_date)
- if event is None:
- return None
- d = safe_json_loads(event.x_data)
- if d is None:
- return None
- return ClosedData(services=d.get('closed_services', []), source=d.get('source') or {})
- async def list(self, start_date: date, end_date: date) -> list:
- """Return all 'Closed' all-day events in the date range."""
- events = await self._fetch_date_range(start_date, end_date)
- return filter_events(events, _PREFIX, all_day=True)
- async def get_range(self, start_date: date, end_date: date, *, events: list | None = None) -> 'ClosedList':
- """Return {date: ClosedData} for all closed events in range.
- Pass events to reuse a pre-fetched list() result and avoid a second backend call.
- """
- result: ClosedList = {}
- for e in (events if events is not None else await self.list(start_date, end_date)):
- d = e.start.date()
- parsed = safe_json_loads(e.x_data)
- if parsed is not None:
- result[d] = ClosedData(services=parsed.get('closed_services', []), source=parsed.get('source') or {})
- return result
- async def delete(self, event) -> None:
- await self._backend.delete(event.uid)
- async def _find(self, target_date: date):
- events = await self._fetch_date_range(target_date, target_date)
- matches = filter_events(events, _PREFIX, all_day=True)
- return matches[0] if matches else None
|