809 lines
28 KiB
Python
809 lines
28 KiB
Python
from fastapi import APIRouter, Depends, Query, Request
|
|
|
|
from app.core.config import settings
|
|
from app.repositories.audit import create_audit_event
|
|
from app.repositories.scheme_groups import (
|
|
create_scheme_version_group,
|
|
delete_scheme_version_group_by_record_id,
|
|
get_scheme_version_group_by_record_id,
|
|
list_scheme_version_groups,
|
|
update_scheme_version_group_by_record_id,
|
|
)
|
|
from app.repositories.scheme_seats import (
|
|
bulk_update_scheme_version_seats_by_record_id,
|
|
cascade_update_seat_group_reference,
|
|
cascade_update_seat_sector_reference,
|
|
get_scheme_version_seat_by_record_id,
|
|
list_scheme_version_seats,
|
|
update_scheme_version_seat_by_record_id,
|
|
)
|
|
from app.repositories.scheme_sectors import (
|
|
create_scheme_version_sector,
|
|
delete_scheme_version_sector_by_record_id,
|
|
get_scheme_version_sector_by_record_id,
|
|
list_scheme_version_sectors,
|
|
update_scheme_version_sector_by_record_id,
|
|
)
|
|
from app.repositories.scheme_versions import get_current_scheme_version
|
|
from app.repositories.schemes import get_scheme_record_by_scheme_id
|
|
from app.schemas.editor import (
|
|
BulkSeatPatchRequest,
|
|
BulkSeatPatchResponse,
|
|
BulkSeatPatchResultItem,
|
|
CreateGroupRequest,
|
|
CreateGroupResponse,
|
|
CreateSectorRequest,
|
|
CreateSectorResponse,
|
|
DeleteEntityResponse,
|
|
DraftGroupItem,
|
|
DraftSeatItem,
|
|
DraftSectorItem,
|
|
DraftStructureResponse,
|
|
DraftSummaryResponse,
|
|
EditorContextResponse,
|
|
GroupPatchRequest,
|
|
GroupPatchResponse,
|
|
RepairReferencesResponse,
|
|
SeatPatchRequest,
|
|
SeatPatchResponse,
|
|
SectorPatchRequest,
|
|
SectorPatchResponse,
|
|
StructureDiffEntityItem,
|
|
StructureDiffResponse,
|
|
)
|
|
from app.security.auth import require_api_key
|
|
from app.services.draft_guard import get_current_draft_context
|
|
from app.services.editor_validation import (
|
|
validate_bulk_seat_patch_references,
|
|
validate_bulk_seat_patch_uniqueness,
|
|
validate_group_patch_uniqueness,
|
|
validate_sector_patch_uniqueness,
|
|
validate_single_seat_patch_references,
|
|
validate_single_seat_patch_uniqueness,
|
|
)
|
|
from app.services.publish_readiness import build_publish_readiness
|
|
from app.services.scheme_validation import build_scheme_validation_report
|
|
from app.services.structure_diff import build_structure_diff
|
|
from app.services.structure_sync import repair_structure_references
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
def _seat_item(row) -> DraftSeatItem:
|
|
return DraftSeatItem(
|
|
seat_record_id=row.seat_record_id,
|
|
scheme_id=row.scheme_id,
|
|
scheme_version_id=row.scheme_version_id,
|
|
element_id=row.element_id,
|
|
seat_id=row.seat_id,
|
|
sector_id=row.sector_id,
|
|
group_id=row.group_id,
|
|
row_label=row.row_label,
|
|
seat_number=row.seat_number,
|
|
tag=row.tag,
|
|
classes_raw=row.classes_raw,
|
|
x=row.x,
|
|
y=row.y,
|
|
cx=row.cx,
|
|
cy=row.cy,
|
|
width=row.width,
|
|
height=row.height,
|
|
created_at=row.created_at.isoformat(),
|
|
)
|
|
|
|
|
|
def _sector_item(row) -> DraftSectorItem:
|
|
return DraftSectorItem(
|
|
sector_record_id=row.sector_record_id,
|
|
scheme_id=row.scheme_id,
|
|
scheme_version_id=row.scheme_version_id,
|
|
element_id=row.element_id,
|
|
sector_id=row.sector_id,
|
|
name=row.name,
|
|
classes_raw=row.classes_raw,
|
|
created_at=row.created_at.isoformat(),
|
|
)
|
|
|
|
|
|
def _group_item(row) -> DraftGroupItem:
|
|
return DraftGroupItem(
|
|
group_record_id=row.group_record_id,
|
|
scheme_id=row.scheme_id,
|
|
scheme_version_id=row.scheme_version_id,
|
|
element_id=row.element_id,
|
|
group_id=row.group_id,
|
|
name=row.name,
|
|
classes_raw=row.classes_raw,
|
|
created_at=row.created_at.isoformat(),
|
|
)
|
|
|
|
|
|
@router.get(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/editor/context", response_model=EditorContextResponse)
|
|
async def get_editor_context(
|
|
scheme_id: str,
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme = await get_scheme_record_by_scheme_id(scheme_id)
|
|
version = await get_current_scheme_version(
|
|
scheme_id=scheme.scheme_id,
|
|
current_version_number=scheme.current_version_number,
|
|
)
|
|
|
|
current_is_draft = scheme.status == "draft" and version.status == "draft"
|
|
|
|
return EditorContextResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
current_scheme_version_id=version.scheme_version_id,
|
|
current_version_number=version.version_number,
|
|
scheme_status=scheme.status,
|
|
scheme_version_status=version.status,
|
|
editor_available=True,
|
|
current_is_draft=current_is_draft,
|
|
create_draft_available=not current_is_draft,
|
|
recommended_action="use_current_draft" if current_is_draft else "create_draft",
|
|
)
|
|
|
|
|
|
@router.get(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/summary", response_model=DraftSummaryResponse)
|
|
async def get_draft_summary(
|
|
scheme_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
seats = await list_scheme_version_seats(version.scheme_version_id)
|
|
sectors = await list_scheme_version_sectors(version.scheme_version_id)
|
|
groups = await list_scheme_version_groups(version.scheme_version_id)
|
|
|
|
validation = await build_scheme_validation_report(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
)
|
|
structure_diff = await build_structure_diff(
|
|
scheme_id=scheme.scheme_id,
|
|
draft_scheme_version_id=version.scheme_version_id,
|
|
)
|
|
readiness = await build_publish_readiness(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
status=version.status,
|
|
)
|
|
|
|
return DraftSummaryResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
status=version.status,
|
|
total_seats=len(seats),
|
|
total_sectors=len(sectors),
|
|
total_groups=len(groups),
|
|
validation_summary=validation["summary"],
|
|
structure_diff_summary=structure_diff["summary"],
|
|
publish_readiness=readiness["readiness"],
|
|
)
|
|
|
|
|
|
@router.get(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/structure", response_model=DraftStructureResponse)
|
|
async def get_draft_structure(
|
|
scheme_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
seats = await list_scheme_version_seats(version.scheme_version_id)
|
|
sectors = await list_scheme_version_sectors(version.scheme_version_id)
|
|
groups = await list_scheme_version_groups(version.scheme_version_id)
|
|
|
|
return DraftStructureResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
status=version.status,
|
|
seats=[_seat_item(row) for row in seats],
|
|
sectors=[_sector_item(row) for row in sectors],
|
|
groups=[_group_item(row) for row in groups],
|
|
total_seats=len(seats),
|
|
total_sectors=len(sectors),
|
|
total_groups=len(groups),
|
|
)
|
|
|
|
|
|
@router.get(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/validation")
|
|
async def get_draft_validation(
|
|
scheme_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
report = await build_scheme_validation_report(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
)
|
|
return {
|
|
"scheme_id": scheme.scheme_id,
|
|
"scheme_version_id": version.scheme_version_id,
|
|
"status": version.status,
|
|
"report": report,
|
|
}
|
|
|
|
|
|
@router.get(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/compare-preview", response_model=StructureDiffResponse)
|
|
async def get_draft_compare_preview(
|
|
scheme_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
diff = await build_structure_diff(
|
|
scheme_id=scheme.scheme_id,
|
|
draft_scheme_version_id=version.scheme_version_id,
|
|
)
|
|
return StructureDiffResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
draft_scheme_version_id=version.scheme_version_id,
|
|
baseline_scheme_version_id=diff["baseline_scheme_version_id"],
|
|
summary=diff["summary"],
|
|
sectors=[StructureDiffEntityItem(**item) for item in diff["sectors"]],
|
|
groups=[StructureDiffEntityItem(**item) for item in diff["groups"]],
|
|
seats=[StructureDiffEntityItem(**item) for item in diff["seats"]],
|
|
)
|
|
|
|
|
|
@router.get(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/seats/records/{{seat_record_id}}", response_model=DraftSeatItem)
|
|
async def get_draft_seat_by_record_id(
|
|
scheme_id: str,
|
|
seat_record_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
_scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
row = await get_scheme_version_seat_by_record_id(
|
|
scheme_version_id=version.scheme_version_id,
|
|
seat_record_id=seat_record_id,
|
|
)
|
|
return _seat_item(row)
|
|
|
|
|
|
@router.get(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/sectors/records/{{sector_record_id}}", response_model=DraftSectorItem)
|
|
async def get_draft_sector_by_record_id(
|
|
scheme_id: str,
|
|
sector_record_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
_scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
row = await get_scheme_version_sector_by_record_id(
|
|
scheme_version_id=version.scheme_version_id,
|
|
sector_record_id=sector_record_id,
|
|
)
|
|
return _sector_item(row)
|
|
|
|
|
|
@router.get(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/groups/records/{{group_record_id}}", response_model=DraftGroupItem)
|
|
async def get_draft_group_by_record_id(
|
|
scheme_id: str,
|
|
group_record_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
_scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
row = await get_scheme_version_group_by_record_id(
|
|
scheme_version_id=version.scheme_version_id,
|
|
group_record_id=group_record_id,
|
|
)
|
|
return _group_item(row)
|
|
|
|
|
|
@router.post(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/sectors", response_model=CreateSectorResponse)
|
|
async def create_draft_sector(
|
|
scheme_id: str,
|
|
payload: CreateSectorRequest,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
await validate_sector_patch_uniqueness(
|
|
scheme_version_id=version.scheme_version_id,
|
|
sector_record_id="__create__",
|
|
new_sector_id=payload.sector_id,
|
|
)
|
|
|
|
existing = await list_scheme_version_sectors(version.scheme_version_id)
|
|
for row in existing:
|
|
if payload.element_id and row.element_id == payload.element_id:
|
|
from fastapi import HTTPException, status
|
|
raise HTTPException(
|
|
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
|
detail={
|
|
"code": "duplicate_sector_element_id",
|
|
"message": "Sector element binding already exists in current draft version",
|
|
"element_id": payload.element_id,
|
|
"conflict_sector_record_id": row.sector_record_id,
|
|
},
|
|
)
|
|
|
|
row = await create_scheme_version_sector(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
element_id=payload.element_id,
|
|
sector_id=payload.sector_id,
|
|
name=payload.name,
|
|
classes_raw=payload.classes_raw,
|
|
)
|
|
|
|
await create_audit_event(
|
|
scheme_id=scheme.scheme_id,
|
|
event_type="draft.sector.created",
|
|
object_type="sector",
|
|
object_ref=row.sector_record_id,
|
|
details={
|
|
"scheme_version_id": version.scheme_version_id,
|
|
"sector_id": row.sector_id,
|
|
"name": row.name,
|
|
},
|
|
)
|
|
|
|
return CreateSectorResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
sector_record_id=row.sector_record_id,
|
|
element_id=row.element_id,
|
|
sector_id=row.sector_id,
|
|
name=row.name,
|
|
)
|
|
|
|
|
|
@router.post(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/groups", response_model=CreateGroupResponse)
|
|
async def create_draft_group(
|
|
scheme_id: str,
|
|
payload: CreateGroupRequest,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
await validate_group_patch_uniqueness(
|
|
scheme_version_id=version.scheme_version_id,
|
|
group_record_id="__create__",
|
|
new_group_id=payload.group_id,
|
|
)
|
|
|
|
existing = await list_scheme_version_groups(version.scheme_version_id)
|
|
for row in existing:
|
|
if payload.element_id and row.element_id == payload.element_id:
|
|
from fastapi import HTTPException, status
|
|
raise HTTPException(
|
|
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
|
detail={
|
|
"code": "duplicate_group_element_id",
|
|
"message": "Group element binding already exists in current draft version",
|
|
"element_id": payload.element_id,
|
|
"conflict_group_record_id": row.group_record_id,
|
|
},
|
|
)
|
|
|
|
row = await create_scheme_version_group(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
element_id=payload.element_id,
|
|
group_id=payload.group_id,
|
|
name=payload.name,
|
|
classes_raw=payload.classes_raw,
|
|
)
|
|
|
|
await create_audit_event(
|
|
scheme_id=scheme.scheme_id,
|
|
event_type="draft.group.created",
|
|
object_type="group",
|
|
object_ref=row.group_record_id,
|
|
details={
|
|
"scheme_version_id": version.scheme_version_id,
|
|
"group_id": row.group_id,
|
|
"name": row.name,
|
|
},
|
|
)
|
|
|
|
return CreateGroupResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
group_record_id=row.group_record_id,
|
|
element_id=row.element_id,
|
|
group_id=row.group_id,
|
|
name=row.name,
|
|
)
|
|
|
|
|
|
@router.delete(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/sectors/records/{{sector_record_id}}", response_model=DeleteEntityResponse)
|
|
async def delete_draft_sector(
|
|
scheme_id: str,
|
|
sector_record_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
await delete_scheme_version_sector_by_record_id(
|
|
scheme_version_id=version.scheme_version_id,
|
|
sector_record_id=sector_record_id,
|
|
)
|
|
|
|
await create_audit_event(
|
|
scheme_id=scheme.scheme_id,
|
|
event_type="draft.sector.deleted",
|
|
object_type="sector",
|
|
object_ref=sector_record_id,
|
|
details={"scheme_version_id": version.scheme_version_id},
|
|
)
|
|
|
|
return DeleteEntityResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
deleted=True,
|
|
record_id=sector_record_id,
|
|
)
|
|
|
|
|
|
@router.delete(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/groups/records/{{group_record_id}}", response_model=DeleteEntityResponse)
|
|
async def delete_draft_group(
|
|
scheme_id: str,
|
|
group_record_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
await delete_scheme_version_group_by_record_id(
|
|
scheme_version_id=version.scheme_version_id,
|
|
group_record_id=group_record_id,
|
|
)
|
|
|
|
await create_audit_event(
|
|
scheme_id=scheme.scheme_id,
|
|
event_type="draft.group.deleted",
|
|
object_type="group",
|
|
object_ref=group_record_id,
|
|
details={"scheme_version_id": version.scheme_version_id},
|
|
)
|
|
|
|
return DeleteEntityResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
deleted=True,
|
|
record_id=group_record_id,
|
|
)
|
|
|
|
|
|
@router.patch(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/seats/records/{{seat_record_id}}", response_model=SeatPatchResponse)
|
|
async def patch_draft_seat(
|
|
request: Request,
|
|
scheme_id: str,
|
|
seat_record_id: str,
|
|
payload: SeatPatchRequest,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
await validate_single_seat_patch_uniqueness(
|
|
scheme_version_id=version.scheme_version_id,
|
|
seat_record_id=seat_record_id,
|
|
new_seat_id=payload.seat_id,
|
|
)
|
|
await validate_single_seat_patch_references(
|
|
scheme_version_id=version.scheme_version_id,
|
|
sector_id=payload.sector_id,
|
|
group_id=payload.group_id,
|
|
)
|
|
|
|
raw_json = await request.json()
|
|
update_data = {k: v for k, v in payload.model_dump(exclude_unset=True).items() if k in raw_json}
|
|
for field in ("seat_id", "sector_id", "group_id"):
|
|
if field in update_data and (update_data[field] is None or update_data[field] == ""):
|
|
from app.services.api_errors import raise_unprocessable
|
|
raise_unprocessable(
|
|
code="business_identifier_nullification_forbidden",
|
|
message=f"{field} cannot be nullified or explicitly cleared",
|
|
)
|
|
|
|
row = await update_scheme_version_seat_by_record_id(
|
|
scheme_version_id=version.scheme_version_id,
|
|
seat_record_id=seat_record_id,
|
|
**update_data,
|
|
)
|
|
|
|
await create_audit_event(
|
|
scheme_id=scheme.scheme_id,
|
|
event_type="draft.seat.updated",
|
|
object_type="seat",
|
|
object_ref=seat_record_id,
|
|
details={
|
|
"scheme_version_id": version.scheme_version_id,
|
|
"seat_id": payload.seat_id,
|
|
"sector_id": payload.sector_id,
|
|
"group_id": payload.group_id,
|
|
"row_label": payload.row_label,
|
|
"seat_number": payload.seat_number,
|
|
},
|
|
)
|
|
|
|
return SeatPatchResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
element_id=row.element_id,
|
|
seat_id=row.seat_id,
|
|
sector_id=row.sector_id,
|
|
group_id=row.group_id,
|
|
row_label=row.row_label,
|
|
seat_number=row.seat_number,
|
|
)
|
|
|
|
|
|
@router.post(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/seats/bulk", response_model=BulkSeatPatchResponse)
|
|
async def bulk_patch_draft_seats(
|
|
request: Request,
|
|
scheme_id: str,
|
|
payload: BulkSeatPatchRequest,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
raw_json = await request.json()
|
|
items = []
|
|
for i, item in enumerate(payload.items):
|
|
item_raw = raw_json.get("items", [])[i] if "items" in raw_json else {}
|
|
items.append({k: item.model_dump(exclude_unset=True).get(k) for k in item_raw})
|
|
|
|
for item in items:
|
|
for field in ("seat_id", "sector_id", "group_id"):
|
|
if field in item and (item[field] is None or item[field] == ""):
|
|
from app.services.api_errors import raise_unprocessable
|
|
raise_unprocessable(
|
|
code="business_identifier_nullification_forbidden",
|
|
message=f"{field} cannot be nullified or explicitly cleared",
|
|
)
|
|
await validate_bulk_seat_patch_uniqueness(
|
|
scheme_version_id=version.scheme_version_id,
|
|
items=items,
|
|
)
|
|
await validate_bulk_seat_patch_references(
|
|
scheme_version_id=version.scheme_version_id,
|
|
items=items,
|
|
)
|
|
|
|
rows = await bulk_update_scheme_version_seats_by_record_id(
|
|
scheme_version_id=version.scheme_version_id,
|
|
items=items,
|
|
)
|
|
|
|
await create_audit_event(
|
|
scheme_id=scheme.scheme_id,
|
|
event_type="draft.seats.bulk_updated",
|
|
object_type="seat_bulk",
|
|
object_ref=version.scheme_version_id,
|
|
details={
|
|
"scheme_version_id": version.scheme_version_id,
|
|
"updated_count": len(rows),
|
|
},
|
|
)
|
|
|
|
return BulkSeatPatchResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
updated_count=len(rows),
|
|
items=[
|
|
BulkSeatPatchResultItem(
|
|
seat_record_id=payload.items[idx].seat_record_id,
|
|
updated_seat_id=row.seat_id,
|
|
sector_id=row.sector_id,
|
|
group_id=row.group_id,
|
|
row_label=row.row_label,
|
|
seat_number=row.seat_number,
|
|
)
|
|
for idx, row in enumerate(rows)
|
|
],
|
|
)
|
|
|
|
|
|
@router.patch(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/sectors/records/{{sector_record_id}}", response_model=SectorPatchResponse)
|
|
async def patch_draft_sector(
|
|
request: Request,
|
|
scheme_id: str,
|
|
sector_record_id: str,
|
|
payload: SectorPatchRequest,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
await validate_sector_patch_uniqueness(
|
|
scheme_version_id=version.scheme_version_id,
|
|
sector_record_id=sector_record_id,
|
|
new_sector_id=payload.sector_id,
|
|
)
|
|
|
|
raw_json = await request.json()
|
|
update_data = {k: v for k, v in payload.model_dump(exclude_unset=True).items() if k in raw_json}
|
|
for field in ("sector_id",):
|
|
if field in update_data and (update_data[field] is None or update_data[field] == ""):
|
|
from app.services.api_errors import raise_unprocessable
|
|
raise_unprocessable(
|
|
code="business_identifier_nullification_forbidden",
|
|
message=f"{field} cannot be nullified or explicitly cleared",
|
|
)
|
|
|
|
row, old_sector_id = await update_scheme_version_sector_by_record_id(
|
|
scheme_version_id=version.scheme_version_id,
|
|
sector_record_id=sector_record_id,
|
|
**update_data,
|
|
)
|
|
cascaded_count = 0
|
|
if "sector_id" in update_data and update_data["sector_id"] and update_data["sector_id"] != old_sector_id:
|
|
cascaded_count = await cascade_update_seat_sector_reference(
|
|
scheme_version_id=version.scheme_version_id,
|
|
old_sector_id=old_sector_id,
|
|
new_sector_id=update_data["sector_id"],
|
|
)
|
|
|
|
await create_audit_event(
|
|
scheme_id=scheme.scheme_id,
|
|
event_type="draft.sector.updated",
|
|
object_type="sector",
|
|
object_ref=sector_record_id,
|
|
details={
|
|
"scheme_version_id": version.scheme_version_id,
|
|
"old_sector_id": old_sector_id,
|
|
"new_sector_id": payload.sector_id,
|
|
"name": payload.name,
|
|
"cascaded_seats_count": cascaded_count,
|
|
},
|
|
)
|
|
|
|
return SectorPatchResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
element_id=row.element_id,
|
|
sector_id=row.sector_id,
|
|
name=row.name,
|
|
)
|
|
|
|
|
|
@router.patch(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/groups/records/{{group_record_id}}", response_model=GroupPatchResponse)
|
|
async def patch_draft_group(
|
|
request: Request,
|
|
scheme_id: str,
|
|
group_record_id: str,
|
|
payload: GroupPatchRequest,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
await validate_group_patch_uniqueness(
|
|
scheme_version_id=version.scheme_version_id,
|
|
group_record_id=group_record_id,
|
|
new_group_id=payload.group_id,
|
|
)
|
|
|
|
raw_json = await request.json()
|
|
update_data = {k: v for k, v in payload.model_dump(exclude_unset=True).items() if k in raw_json}
|
|
for field in ("group_id",):
|
|
if field in update_data and (update_data[field] is None or update_data[field] == ""):
|
|
from app.services.api_errors import raise_unprocessable
|
|
raise_unprocessable(
|
|
code="business_identifier_nullification_forbidden",
|
|
message=f"{field} cannot be nullified or explicitly cleared",
|
|
)
|
|
|
|
row, old_group_id = await update_scheme_version_group_by_record_id(
|
|
scheme_version_id=version.scheme_version_id,
|
|
group_record_id=group_record_id,
|
|
**update_data,
|
|
)
|
|
cascaded_count = 0
|
|
if "group_id" in update_data and update_data["group_id"] and update_data["group_id"] != old_group_id:
|
|
cascaded_count = await cascade_update_seat_group_reference(
|
|
scheme_version_id=version.scheme_version_id,
|
|
old_group_id=old_group_id,
|
|
new_group_id=update_data["group_id"],
|
|
)
|
|
|
|
await create_audit_event(
|
|
scheme_id=scheme.scheme_id,
|
|
event_type="draft.group.updated",
|
|
object_type="group",
|
|
object_ref=group_record_id,
|
|
details={
|
|
"scheme_version_id": version.scheme_version_id,
|
|
"old_group_id": old_group_id,
|
|
"new_group_id": payload.group_id,
|
|
"name": payload.name,
|
|
"cascaded_seats_count": cascaded_count,
|
|
},
|
|
)
|
|
|
|
return GroupPatchResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
element_id=row.element_id,
|
|
group_id=row.group_id,
|
|
name=row.name,
|
|
)
|
|
|
|
|
|
@router.post(f"{settings.api_v1_prefix}/schemes/{{scheme_id}}/draft/repair-references", response_model=RepairReferencesResponse)
|
|
async def repair_draft_references(
|
|
scheme_id: str,
|
|
expected_scheme_version_id: str | None = Query(default=None),
|
|
role: str = Depends(require_api_key),
|
|
):
|
|
scheme, version = await get_current_draft_context(
|
|
scheme_id,
|
|
expected_scheme_version_id=expected_scheme_version_id,
|
|
)
|
|
|
|
result = await repair_structure_references(
|
|
scheme_version_id=version.scheme_version_id,
|
|
)
|
|
|
|
await create_audit_event(
|
|
scheme_id=scheme.scheme_id,
|
|
event_type="draft.references.repaired",
|
|
object_type="draft_structure",
|
|
object_ref=version.scheme_version_id,
|
|
details=result,
|
|
)
|
|
|
|
return RepairReferencesResponse(
|
|
scheme_id=scheme.scheme_id,
|
|
scheme_version_id=version.scheme_version_id,
|
|
repaired_sector_refs_count=result.get("repaired_sector_refs_count", 0),
|
|
repaired_group_refs_count=result.get("repaired_group_refs_count", 0),
|
|
details=result,
|
|
)
|