feat(backend): refactor mono repository
This commit is contained in:
264
backend/repositories/schedule.py
Normal file
264
backend/repositories/schedule.py
Normal file
@@ -0,0 +1,264 @@
|
||||
# myapp/repositories/schedule.py
|
||||
# ------------------------------------------------------------
|
||||
# Persistence layer for the ``Schedule`` model.
|
||||
# ------------------------------------------------------------
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any, List, Optional, Sequence
|
||||
|
||||
from ..db import BaseRepository
|
||||
from ..models import Schedule as ScheduleModel
|
||||
from ..models import ScheduleStatus
|
||||
|
||||
|
||||
class ScheduleRepository(BaseRepository[ScheduleModel]):
|
||||
"""Data‑access object for the ``Schedules`` table."""
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Table‑level constants – change them in one place if the schema evolves.
|
||||
# ------------------------------------------------------------------
|
||||
_TABLE = "Schedules"
|
||||
_PK = "ScheduleId"
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# CRUD helpers
|
||||
# ------------------------------------------------------------------
|
||||
def create(
|
||||
self,
|
||||
*,
|
||||
service_id: int,
|
||||
member_id: int,
|
||||
status: ScheduleStatus = ScheduleStatus.PENDING,
|
||||
reason: Optional[str] = None,
|
||||
scheduled_at: Optional[Any] = None,
|
||||
expires_at: Optional[Any] = None,
|
||||
) -> ScheduleModel:
|
||||
"""
|
||||
Insert a brand‑new schedule row.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
service_id, member_id : int
|
||||
FK references.
|
||||
status : ScheduleStatus
|
||||
Desired initial status (PENDING, DECLINED, …).
|
||||
reason : str | None
|
||||
Stored in ``DeclineReason`` when the status is ``DECLINED``.
|
||||
scheduled_at, expires_at : datetime‑compatible | None
|
||||
``scheduled_at`` defaults to SQLite’s ``CURRENT_TIMESTAMP``.
|
||||
"""
|
||||
schedule = ScheduleModel(
|
||||
ScheduleId=-1, # placeholder – will be replaced
|
||||
ServiceId=service_id,
|
||||
MemberId=member_id,
|
||||
Status=status.value,
|
||||
ScheduledAt=scheduled_at or "CURRENT_TIMESTAMP",
|
||||
AcceptedAt=None,
|
||||
DeclinedAt=None,
|
||||
ExpiresAt=expires_at,
|
||||
DeclineReason=reason if status == ScheduleStatus.DECLINED else None,
|
||||
)
|
||||
return self._insert(self._TABLE, schedule, self._PK)
|
||||
|
||||
def get_by_id(self, schedule_id: int) -> Optional[ScheduleModel]:
|
||||
"""Fetch a schedule by its primary key."""
|
||||
sql = f"SELECT * FROM {self._TABLE} WHERE {self._PK} = ?"
|
||||
row = self.db.fetchone(sql, (schedule_id,))
|
||||
return ScheduleModel.from_row(row) if row else None
|
||||
|
||||
def list_all(self) -> List[ScheduleModel]:
|
||||
"""Return every schedule row."""
|
||||
return self._select_all(self._TABLE, ScheduleModel)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Helper used by the SchedulingService to locate an existing row.
|
||||
# ------------------------------------------------------------------
|
||||
def get_one(self, *, member_id: int, service_id: int) -> Optional[ScheduleModel]:
|
||||
"""
|
||||
Return the *first* schedule (any status) for the supplied
|
||||
``member_id`` / ``service_id`` pair, or ``None`` if none exists.
|
||||
"""
|
||||
sql = f"""
|
||||
SELECT *
|
||||
FROM {self._TABLE}
|
||||
WHERE MemberId = ?
|
||||
AND ServiceId = ?
|
||||
LIMIT 1
|
||||
"""
|
||||
row = self.db.fetchone(sql, (member_id, service_id))
|
||||
return ScheduleModel.from_row(row) if row else None
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Generic status‑change helper (used for “decline” and similar ops).
|
||||
# ------------------------------------------------------------------
|
||||
def update_status(
|
||||
self,
|
||||
*,
|
||||
schedule_id: int,
|
||||
new_status: ScheduleStatus,
|
||||
reason: Optional[str] = None,
|
||||
) -> None:
|
||||
"""
|
||||
Switch a schedule’s status and optionally store a reason.
|
||||
|
||||
If ``new_status`` is ``DECLINED`` the ``DeclineReason`` column is
|
||||
populated; otherwise it is cleared.
|
||||
"""
|
||||
# Build the SET clause dynamically – we only touch the columns we need.
|
||||
set_clause = "Status = ?, DeclinedAt = NULL, DeclineReason = NULL"
|
||||
params: list[Any] = [new_status.value]
|
||||
|
||||
if new_status == ScheduleStatus.DECLINED:
|
||||
set_clause = "Status = ?, DeclinedAt = ?, DeclineReason = ?"
|
||||
params.extend(["CURRENT_TIMESTAMP", reason])
|
||||
|
||||
params.append(schedule_id) # WHERE clause param
|
||||
|
||||
sql = f"""
|
||||
UPDATE {self._TABLE}
|
||||
SET {set_clause}
|
||||
WHERE {self._PK} = ?
|
||||
"""
|
||||
self.db.execute(sql, tuple(params))
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Query helpers used by the scheduling service
|
||||
# ------------------------------------------------------------------
|
||||
def has_any(
|
||||
self,
|
||||
member_id: int,
|
||||
service_id: int,
|
||||
statuses: Sequence[ScheduleStatus],
|
||||
) -> bool:
|
||||
"""True if a schedule exists for the pair with any of the given statuses."""
|
||||
if not statuses:
|
||||
return False
|
||||
|
||||
placeholders = ",".join("?" for _ in statuses)
|
||||
sql = f"""
|
||||
SELECT 1
|
||||
FROM {self._TABLE}
|
||||
WHERE MemberId = ?
|
||||
AND ServiceId = ?
|
||||
AND Status IN ({placeholders})
|
||||
LIMIT 1
|
||||
"""
|
||||
params = (member_id, service_id, *[s.value for s in statuses])
|
||||
row = self.db.fetchone(sql, params)
|
||||
return row is not None
|
||||
|
||||
def is_available(self, member_id: int, service_id: int) -> bool:
|
||||
"""
|
||||
Cool‑down rule: a member is unavailable if they have accepted a
|
||||
schedule for the same service within the last ``COOLDOWN_DAYS``.
|
||||
"""
|
||||
# Latest acceptance timestamp (if any)
|
||||
sql_latest = f"""
|
||||
SELECT MAX(AcceptedAt) AS last_accept
|
||||
FROM {self._TABLE}
|
||||
WHERE MemberId = ?
|
||||
AND ServiceId = ?
|
||||
AND Status = ?
|
||||
"""
|
||||
row = self.db.fetchone(
|
||||
sql_latest,
|
||||
(member_id, service_id, ScheduleStatus.ACCEPTED.value),
|
||||
)
|
||||
last_accept: Optional[str] = row["last_accept"] if row else None
|
||||
|
||||
if not last_accept:
|
||||
return True # never accepted → free to schedule
|
||||
|
||||
COOLDOWN_DAYS = 1
|
||||
sql_cooldown = f"""
|
||||
SELECT 1
|
||||
FROM {self._TABLE}
|
||||
WHERE MemberId = ?
|
||||
AND ServiceId = ?
|
||||
AND Status = ?
|
||||
AND DATE(AcceptedAt) >= DATE('now', '-{COOLDOWN_DAYS} day')
|
||||
LIMIT 1
|
||||
"""
|
||||
row = self.db.fetchone(
|
||||
sql_cooldown,
|
||||
(member_id, service_id, ScheduleStatus.ACCEPTED.value),
|
||||
)
|
||||
return row is None # None → outside the cooldown window
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Status‑transition helpers (accept / decline) – kept for completeness.
|
||||
# ------------------------------------------------------------------
|
||||
def mark_accepted(
|
||||
self,
|
||||
schedule_id: int,
|
||||
accepted_at: Optional[Any] = None,
|
||||
) -> None:
|
||||
sql = f"""
|
||||
UPDATE {self._TABLE}
|
||||
SET Status = ?,
|
||||
AcceptedAt = ?,
|
||||
DeclinedAt = NULL,
|
||||
DeclineReason = NULL
|
||||
WHERE {self._PK} = ?
|
||||
"""
|
||||
ts = accepted_at or "CURRENT_TIMESTAMP"
|
||||
self.db.execute(sql, (ScheduleStatus.ACCEPTED.value, ts, schedule_id))
|
||||
|
||||
def mark_declined(
|
||||
self,
|
||||
schedule_id: int,
|
||||
declined_at: Optional[Any] = None,
|
||||
decline_reason: Optional[str] = None,
|
||||
) -> None:
|
||||
sql = f"""
|
||||
UPDATE {self._TABLE}
|
||||
SET Status = ?,
|
||||
DeclinedAt = ?,
|
||||
DeclineReason = ?
|
||||
WHERE {self._PK} = ?
|
||||
"""
|
||||
ts = declined_at or "CURRENT_TIMESTAMP"
|
||||
self.db.execute(sql, (ScheduleStatus.DECLINED.value, ts, decline_reason, schedule_id))
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Same‑day helper – used by the scheduling service
|
||||
# ------------------------------------------------------------------
|
||||
def has_schedule_on_date(self, member_id: int, service_date: str) -> bool:
|
||||
"""
|
||||
Return ``True`` if *any* schedule (regardless of status) exists for
|
||||
``member_id`` on the calendar day ``service_date`` (format YYYY‑MM‑DD).
|
||||
|
||||
This abstracts the “a member can only be scheduled once per day”
|
||||
rule so the service layer does not need to know the underlying
|
||||
table layout.
|
||||
"""
|
||||
sql = f"""
|
||||
SELECT 1
|
||||
FROM {self._TABLE} AS s
|
||||
JOIN Services AS sv ON s.ServiceId = sv.ServiceId
|
||||
WHERE s.MemberId = ?
|
||||
AND sv.ServiceDate = ?
|
||||
LIMIT 1
|
||||
"""
|
||||
row = self.db.fetchone(sql, (member_id, service_date))
|
||||
return row is not None
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Miscellaneous convenience queries
|
||||
# ------------------------------------------------------------------
|
||||
def get_pending_for_service(self, service_id: int) -> List[ScheduleModel]:
|
||||
"""All PENDING schedules for a given service."""
|
||||
sql = f"""
|
||||
SELECT *
|
||||
FROM {self._TABLE}
|
||||
WHERE ServiceId = ?
|
||||
AND Status = ?
|
||||
"""
|
||||
rows = self.db.fetchall(sql, (service_id, ScheduleStatus.PENDING.value))
|
||||
return [ScheduleModel.from_row(r) for r in rows]
|
||||
|
||||
def delete(self, schedule_id: int) -> None:
|
||||
"""Hard‑delete a schedule row (use with caution)."""
|
||||
sql = f"DELETE FROM {self._TABLE} WHERE {self._PK} = ?"
|
||||
self.db.execute(sql, (schedule_id,))
|
||||
Reference in New Issue
Block a user