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

backend/app/repositories/scheme_groups.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_group import SchemeGroupRecord
+from app.models.scheme_seat import SchemeSeatRecord
 
 
 async def replace_scheme_version_groups(
@@ -14,37 +15,29 @@ async def replace_scheme_version_groups(
     groups: list[dict],
 ) -> None:
     async with AsyncSessionLocal() as session:
-        await session.execute(
-            delete(SchemeGroupRecord).where(
-                SchemeGroupRecord.scheme_version_id == scheme_version_id
-            )
+        existing_result = await session.execute(
+            select(SchemeGroupRecord).where(SchemeGroupRecord.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 groups:
             row = SchemeGroupRecord(
-                group_record_id=uuid4().hex,
+                group_record_id=item["group_record_id"] if "group_record_id" in item and item["group_record_id"] else uuid4().hex,
                 scheme_id=scheme_id,
                 scheme_version_id=scheme_version_id,
                 element_id=item.get("id"),
                 group_id=item.get("group_id"),
-                name=item.get("group_id") or item.get("id") or "unnamed-group",
-                classes_raw=json.dumps(item.get("classes", []), ensure_ascii=False),
+                name=item.get("group_id"),
+                classes_raw=str(item.get("classes")),
             )
             session.add(row)
 
         await session.commit()
 
 
-async def list_scheme_version_groups(scheme_version_id: str) -> list[SchemeGroupRecord]:
-    async with AsyncSessionLocal() as session:
-        result = await session.execute(
-            select(SchemeGroupRecord)
-            .where(SchemeGroupRecord.scheme_version_id == scheme_version_id)
-            .order_by(asc(SchemeGroupRecord.id))
-        )
-        return list(result.scalars().all())
-
-
 async def clone_scheme_version_groups(
     *,
     source_scheme_version_id: str,
@@ -52,23 +45,124 @@ async def clone_scheme_version_groups(
 ) -> None:
     async with AsyncSessionLocal() as session:
         result = await session.execute(
-            select(SchemeGroupRecord).where(
-                SchemeGroupRecord.scheme_version_id == source_scheme_version_id
-            )
+            select(SchemeGroupRecord).where(SchemeGroupRecord.scheme_version_id == source_scheme_version_id)
         )
         rows = list(result.scalars().all())
 
         for row in rows:
-            session.add(
-                SchemeGroupRecord(
-                    group_record_id=uuid4().hex,
-                    scheme_id=row.scheme_id,
-                    scheme_version_id=target_scheme_version_id,
-                    element_id=row.element_id,
-                    group_id=row.group_id,
-                    name=row.name,
-                    classes_raw=row.classes_raw,
-                )
+            cloned = SchemeGroupRecord(
+                group_record_id=uuid4().hex,
+                scheme_id=row.scheme_id,
+                scheme_version_id=target_scheme_version_id,
+                element_id=row.element_id,
+                group_id=row.group_id,
+                name=row.name,
+                classes_raw=row.classes_raw,
             )
+            session.add(cloned)
 
         await session.commit()
+
+
+async def list_scheme_version_groups(scheme_version_id: str) -> list[SchemeGroupRecord]:
+    async with AsyncSessionLocal() as session:
+        result = await session.execute(
+            select(SchemeGroupRecord)
+            .where(SchemeGroupRecord.scheme_version_id == scheme_version_id)
+            .order_by(asc(SchemeGroupRecord.created_at), asc(SchemeGroupRecord.id))
+        )
+        return list(result.scalars().all())
+
+
+async def update_scheme_version_group_by_record_id(
+    *,
+    scheme_version_id: str,
+    group_record_id: str,
+    group_id: str | None,
+    name: str | None,
+) -> tuple[SchemeGroupRecord, str | None]:
+    async with AsyncSessionLocal() as session:
+        result = await session.execute(
+            select(SchemeGroupRecord).where(
+                SchemeGroupRecord.scheme_version_id == scheme_version_id,
+                SchemeGroupRecord.group_record_id == group_record_id,
+            )
+        )
+        row = result.scalar_one_or_none()
+
+        if row is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Group record not found in current draft version",
+            )
+
+        old_group_id = row.group_id
+        row.group_id = group_id
+        row.name = name
+
+        await session.commit()
+        await session.refresh(row)
+        return row, old_group_id
+
+
+async def create_scheme_version_group(
+    *,
+    scheme_id: str,
+    scheme_version_id: str,
+    element_id: str | None,
+    group_id: str,
+    name: str | None,
+    classes_raw: str | None,
+) -> SchemeGroupRecord:
+    async with AsyncSessionLocal() as session:
+        row = SchemeGroupRecord(
+            group_record_id=uuid4().hex,
+            scheme_id=scheme_id,
+            scheme_version_id=scheme_version_id,
+            element_id=element_id,
+            group_id=group_id,
+            name=name,
+            classes_raw=classes_raw,
+        )
+        session.add(row)
+        await session.commit()
+        await session.refresh(row)
+        return row
+
+
+async def delete_scheme_version_group_by_record_id(
+    *,
+    scheme_version_id: str,
+    group_record_id: str,
+) -> None:
+    async with AsyncSessionLocal() as session:
+        group_result = await session.execute(
+            select(SchemeGroupRecord).where(
+                SchemeGroupRecord.scheme_version_id == scheme_version_id,
+                SchemeGroupRecord.group_record_id == group_record_id,
+            )
+        )
+        group = group_result.scalar_one_or_none()
+
+        if group is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Group record not found in current draft version",
+            )
+
+        if group.group_id:
+            seats_result = await session.execute(
+                select(SchemeSeatRecord).where(
+                    SchemeSeatRecord.scheme_version_id == scheme_version_id,
+                    SchemeSeatRecord.group_id == group.group_id,
+                )
+            )
+            seats = list(seats_result.scalars().all())
+            if seats:
+                raise HTTPException(
+                    status_code=status.HTTP_409_CONFLICT,
+                    detail="Cannot delete group while seats still reference it",
+                )
+
+        await session.delete(group)
+        await session.commit()