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

backend/app/services/osint_enrichment_service.py

@@ -7,11 +7,15 @@ Designed to run as a weekly background job.  Respects NVD rate limits
 
 import logging
 import time
+from typing import Optional
+from uuid import UUID
 
 import requests
+from sqlalchemy import func
 from sqlalchemy.orm import Session
 
 from app.config import settings
+from app.domain.errors import EntityNotFoundError
 from app.models.osint_item import OsintItem
 from app.models.technique import Technique
 
@@ -189,3 +193,87 @@ def mark_osint_reviewed(db: Session, item_id: str) -> OsintItem | None:
 def get_unreviewed_count(db: Session) -> int:
     """Return the total number of unreviewed OSINT items."""
     return db.query(OsintItem).filter(OsintItem.reviewed == False).count()  # noqa: E712
+
+
+def list_osint_items(
+    db: Session,
+    *,
+    technique_id: Optional[UUID] = None,
+    source_type: Optional[str] = None,
+    reviewed: Optional[bool] = None,
+    offset: int = 0,
+    limit: int = 50,
+) -> dict:
+    """List OSINT items with optional filters and pagination."""
+    query = db.query(OsintItem)
+    if technique_id:
+        query = query.filter(OsintItem.technique_id == technique_id)
+    if source_type:
+        query = query.filter(OsintItem.source_type == source_type)
+    if reviewed is not None:
+        query = query.filter(OsintItem.reviewed == reviewed)
+
+    total = query.count()
+    items = (
+        query.order_by(OsintItem.discovered_at.desc())
+        .offset(offset)
+        .limit(limit)
+        .all()
+    )
+
+    return {
+        "total": total,
+        "items": [
+            {
+                "id": str(item.id),
+                "technique_id": str(item.technique_id),
+                "source_type": item.source_type,
+                "source_url": item.source_url,
+                "title": item.title,
+                "description": item.description,
+                "severity": item.severity,
+                "discovered_at": item.discovered_at.isoformat() if item.discovered_at else None,
+                "reviewed": item.reviewed,
+                "metadata": item.metadata_,
+            }
+            for item in items
+        ],
+    }
+
+
+def get_osint_summary(db: Session) -> dict:
+    """Summary statistics for OSINT items."""
+    total = db.query(func.count(OsintItem.id)).scalar() or 0
+    unreviewed = get_unreviewed_count(db)
+
+    by_severity = dict(
+        db.query(OsintItem.severity, func.count(OsintItem.id))
+        .group_by(OsintItem.severity)
+        .all()
+    )
+
+    by_type = dict(
+        db.query(OsintItem.source_type, func.count(OsintItem.id))
+        .group_by(OsintItem.source_type)
+        .all()
+    )
+
+    techniques_with_items = (
+        db.query(func.count(func.distinct(OsintItem.technique_id))).scalar() or 0
+    )
+
+    return {
+        "total_items": total,
+        "unreviewed": unreviewed,
+        "techniques_with_items": techniques_with_items,
+        "by_severity": by_severity,
+        "by_type": by_type,
+    }
+
+
+def get_technique_or_raise(db: Session, technique_id: UUID) -> Technique:
+    """Get a technique by ID or raise EntityNotFoundError."""
+    technique = db.query(Technique).filter(Technique.id == technique_id).first()
+    if not technique:
+        raise EntityNotFoundError("Technique", str(technique_id))
+    return technique