feat: move all remaining inline logic from routers to services (Tier 2)

backend/app/services/snapshot_service.py

@@ -14,6 +14,7 @@ from datetime import datetime
 from sqlalchemy import func
 from sqlalchemy.orm import Session
 
+from app.domain.errors import EntityNotFoundError
 from app.models.technique import Technique
 from app.models.coverage_snapshot import CoverageSnapshot, SnapshotTechniqueState
 from app.models.enums import TechniqueStatus
@@ -25,6 +26,101 @@ from app.services.scoring_service import (
 logger = logging.getLogger(__name__)
 
 
+# ---------------------------------------------------------------------------
+# Serialization and queries
+# ---------------------------------------------------------------------------
+
+
+def serialize_snapshot_summary(snap: CoverageSnapshot) -> dict:
+    """Lightweight serialization for list views."""
+    return {
+        "id": str(snap.id),
+        "name": snap.name,
+        "organization_score": snap.organization_score,
+        "total_techniques": snap.total_techniques,
+        "validated_count": snap.validated_count,
+        "partial_count": snap.partial_count,
+        "not_covered_count": snap.not_covered_count,
+        "in_progress_count": snap.in_progress_count,
+        "not_evaluated_count": snap.not_evaluated_count,
+        "created_by": str(snap.created_by) if snap.created_by else None,
+        "created_at": snap.created_at.isoformat() if snap.created_at else None,
+    }
+
+
+def serialize_snapshot_detail(db: Session, snap: CoverageSnapshot) -> dict:
+    """Full serialization including technique states."""
+    base = serialize_snapshot_summary(snap)
+
+    technique_states = (
+        db.query(SnapshotTechniqueState)
+        .filter(SnapshotTechniqueState.snapshot_id == snap.id)
+        .order_by(SnapshotTechniqueState.mitre_id)
+        .all()
+    )
+
+    base["technique_states"] = [
+        {
+            "mitre_id": s.mitre_id,
+            "technique_id": str(s.technique_id),
+            "status": s.status,
+            "score": s.score,
+        }
+        for s in technique_states
+    ]
+    return base
+
+
+def list_snapshots(
+    db: Session,
+    *,
+    offset: int = 0,
+    limit: int = 50,
+) -> dict:
+    """List coverage snapshots ordered by creation date (newest first)."""
+    query = db.query(CoverageSnapshot)
+    total = query.count()
+
+    snapshots = (
+        query
+        .order_by(CoverageSnapshot.created_at.desc())
+        .offset(offset)
+        .limit(limit)
+        .all()
+    )
+
+    return {
+        "total": total,
+        "offset": offset,
+        "limit": limit,
+        "items": [serialize_snapshot_summary(s) for s in snapshots],
+    }
+
+
+def get_snapshot_or_raise(db: Session, snapshot_id: str) -> CoverageSnapshot:
+    """Fetch snapshot by ID or raise EntityNotFoundError."""
+    try:
+        sid = uuid.UUID(snapshot_id)
+    except (ValueError, TypeError):
+        raise EntityNotFoundError("Snapshot", snapshot_id)
+    snapshot = db.query(CoverageSnapshot).filter(CoverageSnapshot.id == sid).first()
+    if snapshot is None:
+        raise EntityNotFoundError("Snapshot", snapshot_id)
+    return snapshot
+
+
+def get_snapshot_detail(db: Session, snapshot_id: str) -> dict:
+    """Get detailed snapshot including per-technique states."""
+    snapshot = get_snapshot_or_raise(db, snapshot_id)
+    return serialize_snapshot_detail(db, snapshot)
+
+
+def delete_snapshot(db: Session, snapshot_id: str) -> None:
+    """Delete a snapshot. Does not commit — caller must commit."""
+    snapshot = get_snapshot_or_raise(db, snapshot_id)
+    db.delete(snapshot)
+
+
 # ---------------------------------------------------------------------------
 # Create snapshot
 # ---------------------------------------------------------------------------
@@ -138,7 +234,7 @@ def compare_snapshots(
     snap_b = db.query(CoverageSnapshot).filter(CoverageSnapshot.id == snapshot_b_id).first()
 
     if not snap_a or not snap_b:
-        return {"error": "One or both snapshots not found"}
+        raise EntityNotFoundError("Snapshot", f"{snapshot_a_id} or {snapshot_b_id}")
 
     # Build lookup dicts: mitre_id -> {status, score}
     states_a = {