jacobh2
782415122d
The calendar mixed two kinds of truth in one table. `planned_leave_day` was simultaneously the allocator's output cache, the user's override store (`is_pinned`, plus ad-hoc rows with no `wish_id`), and the resource ledger that analytics and the age-4 maths read. The planner therefore had to ask "am I allowed to touch this row?" on every sync, and got it wrong at the edges. Every user assertion is now one `day_assertion` row — a concrete `day_type` replaces a pinned day, a row with no `wish_id` replaces an ad-hoc day, and `day_type='none'` replaces `planned_day_exclusion`. `planned_leave_day` becomes purely derived with a single writer, and `PlanningService.pinned_keys()` is the single answer to "is this day pinned", used by the allocator's loader, by `sync_plan` and by the read router alike. On top of that, every calendar band is now a real event: an ad-hoc band opens the same full editor as a wish-backed one and saving it promotes it to a `LeaveWish`, so it can be named, repeated yearly, assigned to either or both parents, and handed to the planner. "Planering" is a `moveable` toggle plus a from/to month bound plus a separate lock/unlock action on the days themselves, replacing a three-rung ladder whose "planner decides" rung set a search window equal to the drawn dates and so could never move anything. Bugs found and fixed along the way: - The plan erased its own history. Fixed windows clip to today, so an elapsed auto-placed day fell into `stale_keys` and was deleted on the next sync — and a background sync runs on every workspace load. Past rows are now frozen and counted as spent. - Migration 010's downgrade silently destroyed every pinned day and exclusion (`is_pinned` returned as DEFAULT 0, the exclusion table came back empty, exit 0, no warning). It now reconstructs both from `day_assertion`, and 009 itemises what it cannot recover before dropping the table. - Deleting a period left its assertions behind, locking those dates forever with no UI path to clear them. Wish deletion now clears them by `wish_id`. - `DayAssertionService` and `LeaveWishService` committed multi-statement writes without a transaction; a crash mid-write diverged the tables or half-deleted a series. Both now run in a unit of work. - A sibling year's shortfall was never surfaced: the toast only inspected the edited occurrence's outcome, so a fully unfunded later year rendered as an empty band with no warning. - A flexible window whose bound had entirely elapsed was dropped from the proposal with no outcome at all. It now reports as `unplaced`. - Unlocking a period deleted its days instead of returning them to the planner. - The e2e global setup posted to a route deleted in this change, which would have failed the whole suite before its first test. Gates: backend 938 tests / 91% coverage, frontend 1351 / 97.4 | 92.2 | 94.37 | 97.4. Migrations 009 and 010 audited against a hand-built realistic database: the upgrade reconciles exactly and a constraint violation fails safe, leaving the schema at 008. Not complete. Step 4's toggle, month picker and lock/unlock action are verified by browser walk and unit tests, but the partial-lock readout was not exercised. `ideas.md` §7 adds a full plan for the vacation-forfeiture defect (the planner detects expiring days and then does nothing about them) — not implemented here. Remaining smaller items are listed in the session's restructure notes. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01T4wjgbVL4HAC5Rdaw75VbV
78 lines
2.9 KiB
Python
78 lines
2.9 KiB
Python
"""HTTP routes for planned leave days (calendar planning) — READ ONLY.
|
|
|
|
Restructure step 3b: `planned_leave_day` is purely derived output now. The
|
|
write endpoints that used to live here (`POST`/`PUT`/`DELETE`) are gone —
|
|
every write goes through `POST /api/plan/sync(-with-wish)` (the allocator)
|
|
or `POST`/`DELETE /api/day-assertions` (a hand-pin, an ad-hoc day, or an
|
|
exclusion). Routers stay thin: validate via Pydantic, call the service, map
|
|
domain errors to HTTP.
|
|
"""
|
|
|
|
from uuid import UUID
|
|
|
|
from fastapi import APIRouter, HTTPException, Query, status
|
|
|
|
from app.dependencies import PlanningServiceDep, WorkspaceIdDep, WorkspaceScopeDep
|
|
from app.entities.planned_leave import PlannedLeaveDay
|
|
from app.models.planned_leave import PlannedLeaveDayResponse
|
|
from app.services.planning_service import PlanningService
|
|
from app.utils.errors import NotFoundError
|
|
|
|
router = APIRouter(prefix="/api/planned-days", tags=["planned-days"])
|
|
|
|
|
|
async def _to_responses(
|
|
service: PlanningService, days: list[PlannedLeaveDay]
|
|
) -> list[PlannedLeaveDayResponse]:
|
|
"""Annotate a batch of rows with the live `is_pinned` signal in one shot
|
|
|
|
(one `pinned_keys` read per workspace, not one per row) — see
|
|
`PlanningService.pinned_keys`.
|
|
"""
|
|
workspace_ids = {d.workspace_id for d in days}
|
|
pinned: set[tuple[UUID, UUID, object]] = set()
|
|
for ws_id in workspace_ids:
|
|
pinned |= await service.pinned_keys(ws_id)
|
|
return [
|
|
PlannedLeaveDayResponse.from_entity(
|
|
d, is_pinned=(d.parent_personal_data_uuid, d.child_id, d.date) in pinned
|
|
)
|
|
for d in days
|
|
]
|
|
|
|
|
|
@router.get("", response_model=list[PlannedLeaveDayResponse])
|
|
async def list_planned_days(
|
|
service: PlanningServiceDep,
|
|
scope: WorkspaceScopeDep,
|
|
child_id: UUID = Query(...),
|
|
) -> list[PlannedLeaveDayResponse]:
|
|
await scope.check_child(child_id)
|
|
days = await service.list_by_child(child_id)
|
|
return await _to_responses(service, days)
|
|
|
|
|
|
@router.get("/{planned_leave_day_id}", response_model=PlannedLeaveDayResponse)
|
|
async def get_planned_day(
|
|
planned_leave_day_id: UUID,
|
|
service: PlanningServiceDep,
|
|
scope: WorkspaceScopeDep,
|
|
) -> PlannedLeaveDayResponse:
|
|
try:
|
|
day = await service.get(planned_leave_day_id, workspace_id=scope.workspace_id)
|
|
except NotFoundError as exc:
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
|
|
is_pinned = (day.parent_personal_data_uuid, day.child_id, day.date) in (
|
|
await service.pinned_keys(day.workspace_id)
|
|
)
|
|
return PlannedLeaveDayResponse.from_entity(day, is_pinned=is_pinned)
|
|
|
|
|
|
@router.get("/workspace/{workspace_id}", response_model=list[PlannedLeaveDayResponse])
|
|
async def list_planned_days_by_workspace(
|
|
workspace_id: WorkspaceIdDep,
|
|
service: PlanningServiceDep,
|
|
) -> list[PlannedLeaveDayResponse]:
|
|
days = await service.list_by_workspace(workspace_id)
|
|
return await _to_responses(service, days)
|