__init__.py 3.6 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
  1. import json
  2. from dataclasses import dataclass, field
  3. from datetime import date
  4. from room_cal.store import StoreBacked
  5. from room_cal._utils import EventSource, safe_json_loads, filter_events, services as _services, service_name, source_line
  6. _PREFIX = 'Closed: '
  7. _UNSET = object()
  8. @dataclass
  9. class ClosedData:
  10. services: list[str]
  11. source: dict = field(default_factory=dict)
  12. ClosedList = dict[date, ClosedData]
  13. def _build_title(closed_services: list[str]) -> str:
  14. all_keys = {s.key for s in _services()}
  15. if all_keys <= set(closed_services):
  16. return f"{_PREFIX}All"
  17. names = [service_name(s) for s in sorted(closed_services)]
  18. return f"{_PREFIX}{', '.join(names)}"
  19. def _build_description(closed_services: list[str], source: dict) -> str:
  20. desc = '\n'.join(f"{service_name(s)}: Closed" for s in sorted(closed_services))
  21. if source:
  22. desc += f"\nSource: {source_line(source)}"
  23. return desc
  24. class Closed(StoreBacked, EventSource):
  25. def __init__(self, *, backend=None):
  26. StoreBacked.__init__(self, backend=backend)
  27. EventSource.__init__(self, 'closed')
  28. async def set(self, target_date: date, data: 'ClosedData', *, existing=_UNSET) -> None:
  29. """Create or update a 'Closed' all-day event. Deletes any existing event if data.services is empty.
  30. Pass existing=<EventRecord> to skip the internal lookup when the caller already holds the event.
  31. Pass existing=None to unconditionally create.
  32. """
  33. if existing is _UNSET:
  34. existing = await self._find(target_date)
  35. if not data.services:
  36. if existing:
  37. await self._backend.delete(existing.uid)
  38. return
  39. title = _build_title(data.services)
  40. description = _build_description(data.services, data.source)
  41. x_data = json.dumps({'closed_services': sorted(data.services), 'source': data.source})
  42. if existing:
  43. if title != existing.title or description != existing.description or x_data != existing.x_data:
  44. await self._backend.update(existing.uid, title=title, description=description, x_data=x_data)
  45. else:
  46. await self._create_all_day(target_date, title, description, x_data)
  47. async def get(self, target_date: date) -> 'ClosedData | None':
  48. """Return ClosedData for the date, or None if no closure event exists."""
  49. event = await self._find(target_date)
  50. if event is None:
  51. return None
  52. d = safe_json_loads(event.x_data)
  53. if d is None:
  54. return None
  55. return ClosedData(services=d.get('closed_services', []), source=d.get('source') or {})
  56. async def list(self, start_date: date, end_date: date) -> list:
  57. """Return all 'Closed' all-day events in the date range."""
  58. events = await self._fetch_date_range(start_date, end_date)
  59. return filter_events(events, _PREFIX, all_day=True)
  60. async def get_range(self, start_date: date, end_date: date, *, events: list | None = None) -> 'ClosedList':
  61. """Return {date: ClosedData} for all closed events in range.
  62. Pass events to reuse a pre-fetched list() result and avoid a second backend call.
  63. """
  64. result: ClosedList = {}
  65. for e in (events if events is not None else await self.list(start_date, end_date)):
  66. d = e.start.date()
  67. parsed = safe_json_loads(e.x_data)
  68. if parsed is not None:
  69. result[d] = ClosedData(services=parsed.get('closed_services', []), source=parsed.get('source') or {})
  70. return result
  71. async def delete(self, event) -> None:
  72. await self._backend.delete(event.uid)
  73. async def _find(self, target_date: date):
  74. events = await self._fetch_date_range(target_date, target_date)
  75. matches = filter_events(events, _PREFIX, all_day=True)
  76. return matches[0] if matches else None