251 lines
8.2 KiB
Python
251 lines
8.2 KiB
Python
"""HTTP routes for settings and tips.
|
|
|
|
Covers:
|
|
- Break periods (CRUD) — uses models/break_period.py
|
|
- Tips endpoint
|
|
"""
|
|
|
|
from datetime import datetime
|
|
from uuid import UUID, uuid4
|
|
|
|
from fastapi import APIRouter, HTTPException, status
|
|
|
|
from app.dependencies import (
|
|
BreakPeriodRepositoryDep,
|
|
ChildRepositoryDep,
|
|
ChildServiceDep,
|
|
CurrentUserDep,
|
|
ParentalLeaveRepositoryDep,
|
|
PersonalDataRepositoryDep,
|
|
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
|
|
from app.utils.errors import NotFoundError, ValidationError
|
|
|
|
router = APIRouter(tags=["settings"])
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tips
|
|
# ---------------------------------------------------------------------------
|
|
|
|
tips_router = APIRouter(prefix="/api/tips", tags=["tips"])
|
|
|
|
|
|
@tips_router.get("/{workspace_id}", response_model=list[dict])
|
|
async def get_tips(
|
|
workspace_id: UUID,
|
|
leave_repo: ParentalLeaveRepositoryDep,
|
|
planned_repo: PlannedLeaveRepositoryDep,
|
|
child_repo: ChildRepositoryDep,
|
|
pd_repo: PersonalDataRepositoryDep,
|
|
vacation_repo: VacationDaysRepositoryDep,
|
|
break_repo: BreakPeriodRepositoryDep,
|
|
ws_repo: WorkspaceRepositoryDep,
|
|
_current_user: CurrentUserDep,
|
|
) -> list[dict]:
|
|
service = TipsService(leave_repo, planned_repo, child_repo, pd_repo, vacation_repo, break_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}
|
|
for t in tips
|
|
]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Children
|
|
# ---------------------------------------------------------------------------
|
|
|
|
child_router = APIRouter(prefix="/api/children", tags=["children"])
|
|
|
|
|
|
def _child_to_response(child) -> ChildResponse:
|
|
return ChildResponse.from_entity(child)
|
|
|
|
|
|
@child_router.post("", response_model=ChildResponse, status_code=status.HTTP_201_CREATED)
|
|
async def create_child(
|
|
payload: ChildCreate,
|
|
service: ChildServiceDep,
|
|
_current_user: CurrentUserDep,
|
|
) -> ChildResponse:
|
|
try:
|
|
child = await service.create(
|
|
workspace_id=payload.workspace_id,
|
|
name=payload.name,
|
|
birth_date=payload.birth_date,
|
|
preschool_start_date=payload.preschool_start_date,
|
|
)
|
|
return _child_to_response(child)
|
|
except ValidationError as exc:
|
|
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, str(exc)) from exc
|
|
|
|
|
|
@child_router.get("/{child_id}", response_model=ChildResponse)
|
|
async def get_child(
|
|
child_id: UUID,
|
|
service: ChildServiceDep,
|
|
_current_user: CurrentUserDep,
|
|
) -> ChildResponse:
|
|
try:
|
|
child = await service.get(child_id)
|
|
return _child_to_response(child)
|
|
except NotFoundError as exc:
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
|
|
|
|
|
|
@child_router.get("/workspace/{workspace_id}", response_model=list[ChildResponse])
|
|
async def list_children(
|
|
workspace_id: UUID,
|
|
service: ChildServiceDep,
|
|
_current_user: CurrentUserDep,
|
|
) -> list[ChildResponse]:
|
|
children = await service.list_by_workspace(workspace_id)
|
|
return [_child_to_response(c) for c in children]
|
|
|
|
|
|
# Settings endpoint for updating child
|
|
settings_child_router = APIRouter(prefix="/api/settings", tags=["settings"])
|
|
|
|
|
|
@settings_child_router.put("/child/{child_id}", response_model=ChildResponse)
|
|
async def update_child(
|
|
child_id: UUID,
|
|
payload: ChildUpdate,
|
|
service: ChildServiceDep,
|
|
_current_user: CurrentUserDep,
|
|
) -> ChildResponse:
|
|
try:
|
|
child = await service.update(
|
|
child_id=child_id,
|
|
name=payload.name,
|
|
birth_date=payload.birth_date,
|
|
preschool_start_date=payload.preschool_start_date,
|
|
)
|
|
return _child_to_response(child)
|
|
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
|
|
|
|
|
|
@settings_child_router.delete("/{child_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def delete_child(
|
|
child_id: UUID,
|
|
service: ChildServiceDep,
|
|
_current_user: CurrentUserDep,
|
|
) -> None:
|
|
try:
|
|
await service.delete(child_id)
|
|
except NotFoundError as exc:
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
|
|
|
|
|
|
@settings_child_router.put("/parent/{personal_data_uuid}", response_model=PersonalDataResponse)
|
|
async def update_parent_settings(
|
|
personal_data_uuid: UUID,
|
|
payload: PersonalDataUpdate,
|
|
repo: PersonalDataRepositoryDep,
|
|
_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)
|
|
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 NotFoundError as exc:
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc
|