Implement display artifacts, pricing integrity, draft base and publish preview bundle

backend/app/repositories/scheme_sectors.py

@@ -1,10 +1,11 @@
-import json
 from uuid import uuid4
 
-from sqlalchemy import asc, delete, select
+from fastapi import HTTPException, status
+from sqlalchemy import asc, select
 
 from app.db.session import AsyncSessionLocal
 from app.models.scheme_sector import SchemeSectorRecord
+from app.models.scheme_seat import SchemeSeatRecord
 
 
 async def replace_scheme_version_sectors(
@@ -14,37 +15,29 @@ async def replace_scheme_version_sectors(
     sectors: list[dict],
 ) -> None:
     async with AsyncSessionLocal() as session:
-        await session.execute(
-            delete(SchemeSectorRecord).where(
-                SchemeSectorRecord.scheme_version_id == scheme_version_id
-            )
+        existing_result = await session.execute(
+            select(SchemeSectorRecord).where(SchemeSectorRecord.scheme_version_id == scheme_version_id)
         )
+        existing_rows = list(existing_result.scalars().all())
+
+        for row in existing_rows:
+            await session.delete(row)
 
         for item in sectors:
             row = SchemeSectorRecord(
-                sector_record_id=uuid4().hex,
+                sector_record_id=item["sector_record_id"] if "sector_record_id" in item and item["sector_record_id"] else uuid4().hex,
                 scheme_id=scheme_id,
                 scheme_version_id=scheme_version_id,
                 element_id=item.get("id"),
                 sector_id=item.get("sector_id"),
-                name=item.get("sector_id") or item.get("id") or "unnamed-sector",
-                classes_raw=json.dumps(item.get("classes", []), ensure_ascii=False),
+                name=item.get("sector_id"),
+                classes_raw=str(item.get("classes")),
             )
             session.add(row)
 
         await session.commit()
 
 
-async def list_scheme_version_sectors(scheme_version_id: str) -> list[SchemeSectorRecord]:
-    async with AsyncSessionLocal() as session:
-        result = await session.execute(
-            select(SchemeSectorRecord)
-            .where(SchemeSectorRecord.scheme_version_id == scheme_version_id)
-            .order_by(asc(SchemeSectorRecord.id))
-        )
-        return list(result.scalars().all())
-
-
 async def clone_scheme_version_sectors(
     *,
     source_scheme_version_id: str,
@@ -52,23 +45,124 @@ async def clone_scheme_version_sectors(
 ) -> None:
     async with AsyncSessionLocal() as session:
         result = await session.execute(
-            select(SchemeSectorRecord).where(
-                SchemeSectorRecord.scheme_version_id == source_scheme_version_id
-            )
+            select(SchemeSectorRecord).where(SchemeSectorRecord.scheme_version_id == source_scheme_version_id)
         )
         rows = list(result.scalars().all())
 
         for row in rows:
-            session.add(
-                SchemeSectorRecord(
-                    sector_record_id=uuid4().hex,
-                    scheme_id=row.scheme_id,
-                    scheme_version_id=target_scheme_version_id,
-                    element_id=row.element_id,
-                    sector_id=row.sector_id,
-                    name=row.name,
-                    classes_raw=row.classes_raw,
-                )
+            cloned = SchemeSectorRecord(
+                sector_record_id=uuid4().hex,
+                scheme_id=row.scheme_id,
+                scheme_version_id=target_scheme_version_id,
+                element_id=row.element_id,
+                sector_id=row.sector_id,
+                name=row.name,
+                classes_raw=row.classes_raw,
             )
+            session.add(cloned)
 
         await session.commit()
+
+
+async def list_scheme_version_sectors(scheme_version_id: str) -> list[SchemeSectorRecord]:
+    async with AsyncSessionLocal() as session:
+        result = await session.execute(
+            select(SchemeSectorRecord)
+            .where(SchemeSectorRecord.scheme_version_id == scheme_version_id)
+            .order_by(asc(SchemeSectorRecord.created_at), asc(SchemeSectorRecord.id))
+        )
+        return list(result.scalars().all())
+
+
+async def update_scheme_version_sector_by_record_id(
+    *,
+    scheme_version_id: str,
+    sector_record_id: str,
+    sector_id: str | None,
+    name: str | None,
+) -> tuple[SchemeSectorRecord, str | None]:
+    async with AsyncSessionLocal() as session:
+        result = await session.execute(
+            select(SchemeSectorRecord).where(
+                SchemeSectorRecord.scheme_version_id == scheme_version_id,
+                SchemeSectorRecord.sector_record_id == sector_record_id,
+            )
+        )
+        row = result.scalar_one_or_none()
+
+        if row is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Sector record not found in current draft version",
+            )
+
+        old_sector_id = row.sector_id
+        row.sector_id = sector_id
+        row.name = name
+
+        await session.commit()
+        await session.refresh(row)
+        return row, old_sector_id
+
+
+async def create_scheme_version_sector(
+    *,
+    scheme_id: str,
+    scheme_version_id: str,
+    element_id: str | None,
+    sector_id: str,
+    name: str | None,
+    classes_raw: str | None,
+) -> SchemeSectorRecord:
+    async with AsyncSessionLocal() as session:
+        row = SchemeSectorRecord(
+            sector_record_id=uuid4().hex,
+            scheme_id=scheme_id,
+            scheme_version_id=scheme_version_id,
+            element_id=element_id,
+            sector_id=sector_id,
+            name=name,
+            classes_raw=classes_raw,
+        )
+        session.add(row)
+        await session.commit()
+        await session.refresh(row)
+        return row
+
+
+async def delete_scheme_version_sector_by_record_id(
+    *,
+    scheme_version_id: str,
+    sector_record_id: str,
+) -> None:
+    async with AsyncSessionLocal() as session:
+        sector_result = await session.execute(
+            select(SchemeSectorRecord).where(
+                SchemeSectorRecord.scheme_version_id == scheme_version_id,
+                SchemeSectorRecord.sector_record_id == sector_record_id,
+            )
+        )
+        sector = sector_result.scalar_one_or_none()
+
+        if sector is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Sector record not found in current draft version",
+            )
+
+        if sector.sector_id:
+            seats_result = await session.execute(
+                select(SchemeSeatRecord).where(
+                    SchemeSeatRecord.scheme_version_id == scheme_version_id,
+                    SchemeSeatRecord.sector_id == sector.sector_id,
+                )
+            )
+            seats = list(seats_result.scalars().all())
+            if seats:
+                raise HTTPException(
+                    status_code=status.HTTP_409_CONFLICT,
+                    detail="Cannot delete sector while seats still reference it",
+                )
+
+        await session.delete(sector)
+        await session.commit()