Files
crr-shifts/app/scheduling.py
T

165 lines
5.6 KiB
Python

from __future__ import annotations
import calendar
from collections import defaultdict
from datetime import date, timedelta
from sqlalchemy import select
from sqlalchemy.orm import Session, selectinload
from .models import Assignment, MonthlyPattern, RotationMember, Schedule, User
def month_bounds(year: int, month: int) -> tuple[date, date]:
last_day = calendar.monthrange(year, month)[1]
return date(year, month, 1), date(year, month, last_day)
def iter_month_dates(year: int, month: int):
first, last = month_bounds(year, month)
current = first
while current <= last:
yield current
current += timedelta(days=1)
def _rotation_occurrence_index(schedule: Schedule, target: date) -> int:
"""Return zero-based matching-day occurrence index from the schedule anchor."""
if schedule.rotation_anchor_date is None:
raise ValueError("Rotation schedule is missing an anchor date")
anchor = schedule.rotation_anchor_date
weekdays = schedule.weekday_set
step = 1 if target >= anchor else -1
current = anchor
count = 0
if step == 1:
while current < target:
if current.weekday() in weekdays:
count += 1
current += timedelta(days=1)
return count
while current > target:
current -= timedelta(days=1)
if current.weekday() in weekdays:
count -= 1
return count
def rotation_user_for_date(db: Session, schedule: Schedule, target: date) -> User | None:
"""Continue after the last actual assignee in this schedule, with anchor fallback."""
if schedule.schedule_type != "rotation" or target.weekday() not in schedule.weekday_set:
return None
members = db.scalars(
select(RotationMember)
.join(User, RotationMember.user_id == User.id)
.where(RotationMember.schedule_id == schedule.id)
.order_by(RotationMember.position)
.options(selectinload(RotationMember.user))
).all()
active_members = [member for member in members if member.user.is_active]
if not active_members:
return None
previous_user_id = db.scalar(
select(Assignment.user_id)
.where(
Assignment.schedule_id == schedule.id,
Assignment.date < target,
Assignment.user_id.is_not(None),
)
.order_by(Assignment.date.desc())
.limit(1)
)
for idx, member in enumerate(members):
if member.user_id == previous_user_id:
for offset in range(1, len(members) + 1):
next_member = members[(idx + offset) % len(members)]
if next_member.user.is_active:
return next_member.user
# No usable reference yet (or the last assignee left the rotation).
idx = _rotation_occurrence_index(schedule, target) % len(active_members)
return active_members[idx].user
def pattern_user_for_date(db: Session, schedule: Schedule, target: date) -> User | None:
"""The person configured for this calendar day of the month, if any."""
row = db.scalar(
select(MonthlyPattern)
.where(MonthlyPattern.schedule_id == schedule.id, MonthlyPattern.day_of_month == target.day)
.options(selectinload(MonthlyPattern.user))
)
if row is None or row.user is None or not row.user.is_active:
return None
return row.user
def _pattern_users(db: Session, schedule: Schedule) -> dict[int, int]:
rows = db.scalars(
select(MonthlyPattern)
.where(MonthlyPattern.schedule_id == schedule.id)
.options(selectinload(MonthlyPattern.user))
).all()
return {row.day_of_month: row.user.id for row in rows if row.user is not None and row.user.is_active}
def ensure_month_assignments(db: Session, year: int, month: int) -> list[Assignment]:
schedules = db.scalars(select(Schedule).where(Schedule.is_active.is_(True))).all()
first, last = month_bounds(year, month)
existing = db.scalars(
select(Assignment).where(Assignment.date >= first, Assignment.date <= last)
).all()
existing_keys = {(a.schedule_id, a.date) for a in existing}
changed = False
for schedule in schedules:
patterns = _pattern_users(db, schedule) if schedule.schedule_type == "fixed" else {}
for day in iter_month_dates(year, month):
if day.weekday() not in schedule.weekday_set:
continue
key = (schedule.id, day)
if key in existing_keys:
continue
user_id = None
if schedule.schedule_type == "rotation":
user = rotation_user_for_date(db, schedule, day)
user_id = user.id if user else None
else:
user_id = patterns.get(day.day)
db.add(
Assignment(
schedule_id=schedule.id,
date=day,
user_id=user_id,
source="generated",
)
)
# SessionLocal disables autoflush: the next date must see this assignee.
db.flush()
changed = True
if changed:
db.commit()
return list(
db.scalars(
select(Assignment)
.where(Assignment.date >= first, Assignment.date <= last)
.options(selectinload(Assignment.user), selectinload(Assignment.schedule))
.order_by(Assignment.date, Assignment.schedule_id)
).all()
)
def assignments_by_date(assignments: list[Assignment]) -> dict[date, list[Assignment]]:
result: dict[date, list[Assignment]] = defaultdict(list)
for assignment in assignments:
result[assignment.date].append(assignment)
return dict(result)