jacobh2/F-r-ldraledigplannerare
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Complete NextSteps roadmap: planning engine UI, calendar cluster, flexible wishes

Browse Source 
Works through every numbered item in NextSteps260913.md section 3, plus the
three known verification issues in section 4.1.

Surface what the backend already computed:
- 3.1 render surplus_advice in PlanResults, mirroring the shortfall remedies
- 3.2 surface VacationBalance.is_assumed so assumed statutory years are visible
- 3.3 age-4 expiry given the proposed plan, via a new Age4Projection reusing
  the existing _age4_projections arithmetic (Dashboard stat verified, not rebuilt)

Calendar cluster (one pass over the holiday data):
- new GET /api/calendar/days exposing roda dagar, klamdagar and day overrides,
  paginated four years at a time
- 3.4 shade roda dagar/klamdagar, with R/K badges so colour is not the only signal
- 3.6 click-to-override behind an explicit mode toggle, leaving drag multi-select intact
- 3.7 click month/year to advance
- 3.8 per-year red-days list in Settings, statutory days plus overrides

i18n:
- 3.5 five backend-generated Swedish surfaces converted to message_key + data,
  following the tips_service pattern; old string fields replaced, not kept

Flexible wishes (3.9):
- PLANNING_ENGINE_SPEC section 10: window_mode, candidate search, cost function,
  deterministic tie-break, two-pass ordering, test matrix rows 15-24
- backend: entity, migration 006, _FULL_SCHEMA sync, repository, allocator
- frontend: season-preset toggle in WishEditor, unplaced outcome rendering

Fixes (4.1):
- pin typecheck to the local tsc rather than npx resolving a newer TypeScript
- ignore generated coverage/ and dist/ in the ESLint flat config
- fix the flaky usePlanApply test properly, with waitFor rather than a retry

Tests: backend 361 -> 404, frontend 540 -> 704. Coverage 89.47% -> 96.52% lines.

Not yet verified in a browser.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RXMhc9nT6sNz1SL4j8dznL
This commit is contained in:
Jacob Hagstedt
2026-09-14 02:33:03 +02:00
parent 3ca1418d94
commit 76b1e712b9
218 changed files with 29867 additions and 6085 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/app/routers/auth.py
+7 -3
View File
@@ -5,7 +5,12 @@ from pydantic import BaseModel
from starlette.requests import Request
from app.config import settings
from app.dependencies import AuthServiceDep, ChildRepositoryDep, CurrentUserDep, PersonalDataRepositoryDep
from app.dependencies import (
AuthServiceDep,
ChildRepositoryDep,
CurrentUserDep,
PersonalDataRepositoryDep,
)
from app.rate_limit import limiter
from app.models.auth import LoginRequest, RegisterRequest, TokenResponse, UserMeResponse
from app.utils.errors import AuthError, ConflictError, UnauthorizedError
@@ -113,8 +118,7 @@ async def get_context(
workspace_id=str(pd.workspace_id),
parent_name=pd.name,
children=[
_ChildContext(id=str(c.id), name=c.name, birth_date=str(c.birth_date))
for c in children
_ChildContext(id=str(c.id), name=c.name, birth_date=str(c.birth_date)) for c in children
],
)
backend/app/routers/break_periods.py
-83
View File
@@ -1,83 +0,0 @@
"""HTTP routes for break periods.
Routers stay thin: validate via Pydantic, call the service, map domain errors to HTTP.
"""
from uuid import UUID
from fastapi import APIRouter, HTTPException, status
from app.dependencies import BreakPeriodServiceDep
from app.models.break_period import (
BreakPeriodCreate,
BreakPeriodResponse,
BreakPeriodUpdate,
)
from app.utils.errors import NotFoundError, ValidationError
router = APIRouter(prefix="/api/break-periods", tags=["break-periods"])
@router.post("", response_model=BreakPeriodResponse, status_code=status.HTTP_201_CREATED)
async def create_break_period(
payload: BreakPeriodCreate, service: BreakPeriodServiceDep
) -> BreakPeriodResponse:
try:
entity = await service.create(
workspace_id=payload.workspace_id,
name=payload.name,
start_date=payload.start_date,
end_date=payload.end_date,
target_weeks=payload.target_weeks,
)
except ValidationError as exc:
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, str(exc)) from exc
return BreakPeriodResponse.from_entity(entity)
@router.get("/{break_period_id}", response_model=BreakPeriodResponse)
async def get_break_period(
break_period_id: UUID, service: BreakPeriodServiceDep
) -> BreakPeriodResponse:
try:
entity = await service.get(break_period_id)
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
return BreakPeriodResponse.from_entity(entity)
@router.get("/workspace/{workspace_id}", response_model=list[BreakPeriodResponse])
async def list_break_periods(
workspace_id: UUID, service: BreakPeriodServiceDep
) -> list[BreakPeriodResponse]:
entities = await service.list_for_workspace(workspace_id)
return [BreakPeriodResponse.from_entity(e) for e in entities]
@router.put("/{break_period_id}", response_model=BreakPeriodResponse)
async def update_break_period(
break_period_id: UUID,
payload: BreakPeriodUpdate,
service: BreakPeriodServiceDep,
) -> BreakPeriodResponse:
try:
entity = await service.update(
break_period_id=break_period_id,
name=payload.name,
start_date=payload.start_date,
end_date=payload.end_date,
target_weeks=payload.target_weeks,
)
except ValidationError as exc:
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, str(exc)) from exc
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
return BreakPeriodResponse.from_entity(entity)
@router.delete("/{break_period_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_break_period(break_period_id: UUID, service: BreakPeriodServiceDep) -> None:
try:
await service.delete(break_period_id)
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
backend/app/routers/calendar.py
+34
View File
@@ -0,0 +1,34 @@
"""HTTP routes for the Swedish calendar (röda dagar / klämdagar).
Routers stay thin: validate via Pydantic/query params, call the service, map
domain errors to HTTP. Serves both §3.4 (Kalender shading) and §3.8 (Settings
red-days list) from one endpoint — see `app.services.calendar_service`.
"""
from uuid import UUID
from fastapi import APIRouter, HTTPException, Query, status
from app.dependencies import CalendarServiceDep, CurrentUserDep
from app.models.calendar import CalendarDaysResponse
from app.services.calendar_service import MAX_WINDOW_YEARS
from app.utils.errors import ValidationError
router = APIRouter(prefix="/api/calendar", tags=["calendar"])
@router.get("/days", response_model=CalendarDaysResponse)
async def get_calendar_days(
workspace_id: UUID,
start_year: int,
service: CalendarServiceDep,
_current_user: CurrentUserDep,
years: int = Query(default=MAX_WINDOW_YEARS, ge=1, le=MAX_WINDOW_YEARS),
) -> CalendarDaysResponse:
try:
window = await service.get_calendar_window(
workspace_id=workspace_id, start_year=start_year, years=years
)
except ValidationError as exc:
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, str(exc)) from exc
return CalendarDaysResponse.from_domain(window)
backend/app/routers/day_overrides.py
+58
View File
@@ -0,0 +1,58 @@
"""HTTP routes for day overrides.
Routers stay thin: validate via Pydantic, call the service, map domain
errors to HTTP.
"""
from uuid import UUID
from fastapi import APIRouter, HTTPException, status
from app.dependencies import DayOverrideServiceDep
from app.models.day_override import DayOverrideCreate, DayOverrideResponse
from app.utils.errors import NotFoundError, ValidationError
router = APIRouter(prefix="/api/day-overrides", tags=["day-overrides"])
@router.post("", response_model=DayOverrideResponse, status_code=status.HTTP_201_CREATED)
async def upsert_day_override(
payload: DayOverrideCreate, service: DayOverrideServiceDep
) -> DayOverrideResponse:
try:
entity = await service.upsert(
workspace_id=payload.workspace_id,
day=payload.date,
is_working_day=payload.is_working_day,
note=payload.note,
)
except ValidationError as exc:
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, str(exc)) from exc
return DayOverrideResponse.from_entity(entity)
@router.get("/{day_override_id}", response_model=DayOverrideResponse)
async def get_day_override(
day_override_id: UUID, service: DayOverrideServiceDep
) -> DayOverrideResponse:
try:
entity = await service.get(day_override_id)
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
return DayOverrideResponse.from_entity(entity)
@router.get("/workspace/{workspace_id}", response_model=list[DayOverrideResponse])
async def list_day_overrides(
workspace_id: UUID, service: DayOverrideServiceDep
) -> list[DayOverrideResponse]:
entities = await service.list_for_workspace(workspace_id)
return [DayOverrideResponse.from_entity(e) for e in entities]
@router.delete("/{day_override_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_day_override(day_override_id: UUID, service: DayOverrideServiceDep) -> None:
try:
await service.delete(day_override_id)
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
backend/app/routers/leave_wishes.py
+106
View File
@@ -0,0 +1,106 @@
"""HTTP routes for leave wishes.
Routers stay thin: validate via Pydantic, call the service, map domain errors
to HTTP. Business logic (recurrence/parent_mode/goal_override validation,
month-day range checks) lives in LeaveWishService. See PLANNING_ENGINE_SPEC.md §4.
"""
from uuid import UUID
from fastapi import APIRouter, HTTPException, status
from app.dependencies import LeaveWishServiceDep
from app.models.leave_wish import (
LeaveWishCreate,
LeaveWishResponse,
LeaveWishUpdate,
)
from app.utils.errors import NotFoundError, ValidationError
router = APIRouter(prefix="/api/leave-wishes", tags=["leave-wishes"])
@router.post("", response_model=LeaveWishResponse, status_code=status.HTTP_201_CREATED)
async def create_leave_wish(
payload: LeaveWishCreate, service: LeaveWishServiceDep
) -> LeaveWishResponse:
try:
entity = await service.create(
workspace_id=payload.workspace_id,
child_id=payload.child_id,
name=payload.name,
window_start_month=payload.window_start_month,
window_start_day=payload.window_start_day,
window_end_month=payload.window_end_month,
window_end_day=payload.window_end_day,
target_weeks=payload.target_weeks,
recurrence=payload.recurrence,
first_year=payload.first_year,
last_year=payload.last_year,
priority=payload.priority,
parent_mode=payload.parent_mode,
parent_personal_data_uuid=payload.parent_personal_data_uuid,
goal_override=payload.goal_override,
window_mode=payload.window_mode,
)
except ValidationError as exc:
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, str(exc)) from exc
return LeaveWishResponse.from_entity(entity)
@router.get("/{workspace_id}", response_model=list[LeaveWishResponse])
async def list_leave_wishes(
workspace_id: UUID, service: LeaveWishServiceDep
) -> list[LeaveWishResponse]:
"""List all leave wishes for a workspace. Matches PLANNING_ENGINE_SPEC.md §4
(`GET /api/leave-wishes/{workspace_id}` — list-by-workspace, not get-by-id)."""
entities = await service.list_for_workspace(workspace_id)
return [LeaveWishResponse.from_entity(e) for e in entities]
@router.put("/{leave_wish_id}", response_model=LeaveWishResponse)
async def update_leave_wish(
leave_wish_id: UUID,
payload: LeaveWishUpdate,
service: LeaveWishServiceDep,
) -> LeaveWishResponse:
fields_set = payload.model_fields_set
try:
entity = await service.update(
leave_wish_id=leave_wish_id,
child_id=payload.child_id,
name=payload.name,
window_start_month=payload.window_start_month,
window_start_day=payload.window_start_day,
window_end_month=payload.window_end_month,
window_end_day=payload.window_end_day,
target_weeks=payload.target_weeks,
recurrence=payload.recurrence,
first_year=payload.first_year,
last_year=payload.last_year,
priority=payload.priority,
parent_mode=payload.parent_mode,
parent_personal_data_uuid=payload.parent_personal_data_uuid,
goal_override=payload.goal_override,
window_mode=payload.window_mode,
_clear_child_id="child_id" in fields_set and payload.child_id is None,
_clear_last_year="last_year" in fields_set and payload.last_year is None,
_clear_parent_personal_data_uuid=(
"parent_personal_data_uuid" in fields_set
and payload.parent_personal_data_uuid is None
),
_clear_goal_override=("goal_override" in fields_set and payload.goal_override is None),
)
except ValidationError as exc:
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, str(exc)) from exc
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
return LeaveWishResponse.from_entity(entity)
@router.delete("/{leave_wish_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_leave_wish(leave_wish_id: UUID, service: LeaveWishServiceDep) -> None:
try:
await service.delete(leave_wish_id)
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
backend/app/routers/plan.py
+55
View File
@@ -0,0 +1,55 @@
"""HTTP routes for the planning engine.
Routers stay thin: validate via Pydantic, call the service, map domain errors
to HTTP. All allocation logic lives in `app.services.allocation_service`, and
all bulk-apply logic (idempotency, collisions, `replace`, validation) lives in
`app.services.planning_service.PlanningService.apply_proposed_days`. See
PLANNING_ENGINE_SPEC.md §4.
"""
from fastapi import APIRouter, HTTPException, status
from app.dependencies import PlanningEngineServiceDep, PlanningServiceDep
from app.models.plan import (
PlanApplyRequest,
PlanApplyResponse,
PlanProposalResponse,
PlanProposeRequest,
)
from app.utils.errors import NotFoundError
router = APIRouter(prefix="/api/plan", tags=["plan"])
@router.post("/propose", response_model=PlanProposalResponse)
async def propose_plan(
payload: PlanProposeRequest, service: PlanningEngineServiceDep
) -> PlanProposalResponse:
"""Compute a plan proposal. Read-only — persists nothing, safe to spam."""
try:
proposal = await service.propose(payload.workspace_id)
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
return PlanProposalResponse.from_domain(proposal)
@router.post("/apply", response_model=PlanApplyResponse)
async def apply_plan(payload: PlanApplyRequest, service: PlanningServiceDep) -> PlanApplyResponse:
"""Accept a (possibly user-edited) set of proposed days as real plan.
Always returns 200 with `accepted: false` and a `rejections`/`collisions`
breakdown when the batch is refused — refusal (a collision without
`replace`, an invalid day type, a balance/eligibility violation) is an
expected, structured outcome for the UI to render, not an HTTP error.
A genuinely missing workspace/child (404) is the one case still raised
as an HTTP error, since that's not something the batch report can explain.
"""
try:
result = await service.apply_proposed_days(
workspace_id=payload.workspace_id,
days=[item.to_domain() for item in payload.days],
replace=payload.replace,
)
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
return PlanApplyResponse.from_domain(result)
backend/app/routers/settings.py
+22 -99
View File
@@ -1,32 +1,29 @@
"""HTTP routes for settings and tips.
Covers:
- Break periods (CRUD) — uses models/break_period.py
- Children (CRUD) — uses models/child.py
- Tips endpoint
Leave wishes (formerly "break periods") moved to their own router,
app/routers/leave_wishes.py, at /api/leave-wishes — see PLANNING_ENGINE_SPEC.md §4.
"""
from datetime import datetime
from uuid import UUID, uuid4
from uuid import UUID
from fastapi import APIRouter, HTTPException, status
from app.dependencies import (
BreakPeriodRepositoryDep,
ChildRepositoryDep,
ChildServiceDep,
CurrentUserDep,
LeaveWishRepositoryDep,
ParentalLeaveRepositoryDep,
PersonalDataRepositoryDep,
PersonalDataServiceDep,
PlannedLeaveRepositoryDep,
VacationDaysRepositoryDep,
WorkspaceRepositoryDep,
)
from app.entities.break_period import BreakPeriod
from app.models.break_period import (
BreakPeriodCreate,
BreakPeriodResponse,
BreakPeriodUpdate,
)
from app.models.child import ChildCreate, ChildResponse, ChildUpdate
from app.models.personal_data import PersonalDataResponse, PersonalDataUpdate
from app.services.tips_service import TipsService
@@ -50,11 +47,13 @@ async def get_tips(
child_repo: ChildRepositoryDep,
pd_repo: PersonalDataRepositoryDep,
vacation_repo: VacationDaysRepositoryDep,
break_repo: BreakPeriodRepositoryDep,
leave_wish_repo: LeaveWishRepositoryDep,
ws_repo: WorkspaceRepositoryDep,
_current_user: CurrentUserDep,
) -> list[dict]:
service = TipsService(leave_repo, planned_repo, child_repo, pd_repo, vacation_repo, break_repo, ws_repo)
service = TipsService(
leave_repo, planned_repo, child_repo, pd_repo, vacation_repo, leave_wish_repo, ws_repo
)
tips = await service.get_tips(workspace_id)
return [
{"id": t.id, "severity": t.severity, "message_key": t.message_key, "data": t.data}
@@ -85,6 +84,7 @@ async def create_child(
name=payload.name,
birth_date=payload.birth_date,
preschool_start_date=payload.preschool_start_date,
preschool_planning_days_per_year=payload.preschool_planning_days_per_year,
)
return _child_to_response(child)
except ValidationError as exc:
@@ -131,6 +131,7 @@ async def update_child(
name=payload.name,
birth_date=payload.birth_date,
preschool_start_date=payload.preschool_start_date,
preschool_planning_days_per_year=payload.preschool_planning_days_per_year,
)
return _child_to_response(child)
except ValidationError as exc:
@@ -155,96 +156,18 @@ async def delete_child(
async def update_parent_settings(
personal_data_uuid: UUID,
payload: PersonalDataUpdate,
repo: PersonalDataRepositoryDep,
service: PersonalDataServiceDep,
_current_user: CurrentUserDep,
) -> PersonalDataResponse:
try:
entity = await repo.get_by_id(personal_data_uuid)
if entity is None:
raise HTTPException(
status.HTTP_404_NOT_FOUND, f"PersonalData {personal_data_uuid} not found"
)
# Apply partial updates
if payload.salary_type is not None:
entity.salary_type = payload.salary_type
if payload.employment_status is not None:
entity.employment_status = payload.employment_status
updated = await repo.update(personal_data_uuid, entity)
updated = await service.update(
personal_data_uuid,
salary_type=payload.salary_type,
employment_status=payload.employment_status,
min_vacation_days_per_year=payload.min_vacation_days_per_year,
)
return PersonalDataResponse.from_entity(updated)
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
# ---------------------------------------------------------------------------
# Break periods
# ---------------------------------------------------------------------------
break_router = APIRouter(prefix="/api/break-periods", tags=["break-periods"])
def _to_response(bp: BreakPeriod) -> BreakPeriodResponse:
return BreakPeriodResponse.from_entity(bp)
@break_router.get("/{workspace_id}", response_model=list[BreakPeriodResponse])
async def list_break_periods(
workspace_id: UUID,
repo: BreakPeriodRepositoryDep,
_current_user: CurrentUserDep,
) -> list[BreakPeriodResponse]:
periods = await repo.get_by_workspace(workspace_id)
return [_to_response(bp) for bp in periods]
@break_router.post("", response_model=BreakPeriodResponse, status_code=status.HTTP_201_CREATED)
async def create_break_period(
payload: BreakPeriodCreate,
repo: BreakPeriodRepositoryDep,
_current_user: CurrentUserDep,
) -> BreakPeriodResponse:
bp = BreakPeriod(
id=uuid4(),
workspace_id=payload.workspace_id,
name=payload.name,
start_date=payload.start_date,
end_date=payload.end_date,
target_weeks=payload.target_weeks,
created_at=datetime.now(),
updated_at=datetime.now(),
)
created = await repo.create(bp)
return _to_response(created)
@break_router.put("/{break_period_id}", response_model=BreakPeriodResponse)
async def update_break_period(
break_period_id: UUID,
payload: BreakPeriodUpdate,
repo: BreakPeriodRepositoryDep,
_current_user: CurrentUserDep,
) -> BreakPeriodResponse:
existing = await repo.get_by_id(break_period_id)
if existing is None:
raise HTTPException(status.HTTP_404_NOT_FOUND, f"BreakPeriod {break_period_id} not found")
# BreakPeriodUpdate in models/break_period.py has all fields required (not Optional).
# Apply all fields unconditionally.
existing.name = payload.name
existing.start_date = payload.start_date
existing.end_date = payload.end_date
existing.target_weeks = payload.target_weeks
updated = await repo.update(break_period_id, existing)
return _to_response(updated)
@break_router.delete("/{break_period_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_break_period(
break_period_id: UUID,
repo: BreakPeriodRepositoryDep,
_current_user: CurrentUserDep,
) -> None:
try:
await repo.delete(break_period_id)
except ValidationError as exc:
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, str(exc)) from exc
except NotFoundError as exc:
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
backend/app/routers/workspace.py
+3 -1
View File
@@ -51,7 +51,9 @@ async def update_workspace(
_current_user: CurrentUserDep,
) -> WorkspaceResponse:
try:
ws = await service.update_workspace(workspace_id, payload.name, payload.planning_goal)
ws = await service.update_workspace(
workspace_id, payload.name, payload.planning_goal, payload.planning_mode
)
except (NotFoundError, ValidationError) as exc:
code = (
status.HTTP_404_NOT_FOUND