feat(prospecting): add complete prospecting module for lead discovery and scoring

Migrates scanning pipeline from marketing-.lu-domains app into Orion module.
Supports digital (domain scan) and offline (manual capture) lead channels
with enrichment, scoring, campaign management, and interaction tracking.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app/modules/prospecting/routes/api/admin_enrichment.py

@@ -0,0 +1,177 @@
+# app/modules/prospecting/routes/api/admin_enrichment.py
+"""
+Admin API routes for enrichment/scanning pipeline.
+"""
+
+import logging
+
+from fastapi import APIRouter, Depends, Path, Query
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_current_admin_api
+from app.core.database import get_db
+from app.modules.prospecting.schemas.enrichment import (
+    ContactScrapeResponse,
+    FullEnrichmentResponse,
+    HttpCheckBatchItem,
+    HttpCheckBatchResponse,
+    HttpCheckResult,
+    ScanBatchResponse,
+    ScanSingleResponse,
+    ScoreComputeBatchResponse,
+)
+from app.modules.prospecting.services.enrichment_service import enrichment_service
+from app.modules.prospecting.services.prospect_service import prospect_service
+from app.modules.prospecting.services.scoring_service import scoring_service
+from app.modules.tenancy.schemas.auth import UserContext
+
+router = APIRouter(prefix="/enrichment")
+logger = logging.getLogger(__name__)
+
+
+@router.post("/http-check/{prospect_id}", response_model=HttpCheckResult)
+def http_check_single(
+    prospect_id: int = Path(...),
+    db: Session = Depends(get_db),
+    current_admin: UserContext = Depends(get_current_admin_api),
+):
+    """Run HTTP connectivity check for a single prospect."""
+    prospect = prospect_service.get_by_id(db, prospect_id)
+    result = enrichment_service.check_http(db, prospect)
+    return HttpCheckResult(**result)
+
+
+@router.post("/http-check/batch", response_model=HttpCheckBatchResponse)
+def http_check_batch(
+    limit: int = Query(100, ge=1, le=500),
+    db: Session = Depends(get_db),
+    current_admin: UserContext = Depends(get_current_admin_api),
+):
+    """Run HTTP check for pending prospects."""
+    prospects = prospect_service.get_pending_http_check(db, limit=limit)
+    results = []
+    for prospect in prospects:
+        result = enrichment_service.check_http(db, prospect)
+        results.append(HttpCheckBatchItem(domain=prospect.domain_name, **result))
+    return HttpCheckBatchResponse(processed=len(results), results=results)
+
+
+@router.post("/tech-scan/{prospect_id}", response_model=ScanSingleResponse)
+def tech_scan_single(
+    prospect_id: int = Path(...),
+    db: Session = Depends(get_db),
+    current_admin: UserContext = Depends(get_current_admin_api),
+):
+    """Run technology scan for a single prospect."""
+    prospect = prospect_service.get_by_id(db, prospect_id)
+    profile = enrichment_service.scan_tech_stack(db, prospect)
+    return ScanSingleResponse(domain=prospect.domain_name, profile=profile is not None)
+
+
+@router.post("/tech-scan/batch", response_model=ScanBatchResponse)
+def tech_scan_batch(
+    limit: int = Query(100, ge=1, le=500),
+    db: Session = Depends(get_db),
+    current_admin: UserContext = Depends(get_current_admin_api),
+):
+    """Run tech scan for pending prospects."""
+    prospects = prospect_service.get_pending_tech_scan(db, limit=limit)
+    count = 0
+    for prospect in prospects:
+        result = enrichment_service.scan_tech_stack(db, prospect)
+        if result:
+            count += 1
+    return ScanBatchResponse(processed=len(prospects), successful=count)
+
+
+@router.post("/performance/{prospect_id}", response_model=ScanSingleResponse)
+def performance_scan_single(
+    prospect_id: int = Path(...),
+    db: Session = Depends(get_db),
+    current_admin: UserContext = Depends(get_current_admin_api),
+):
+    """Run PageSpeed audit for a single prospect."""
+    prospect = prospect_service.get_by_id(db, prospect_id)
+    profile = enrichment_service.scan_performance(db, prospect)
+    return ScanSingleResponse(domain=prospect.domain_name, profile=profile is not None)
+
+
+@router.post("/performance/batch", response_model=ScanBatchResponse)
+def performance_scan_batch(
+    limit: int = Query(50, ge=1, le=200),
+    db: Session = Depends(get_db),
+    current_admin: UserContext = Depends(get_current_admin_api),
+):
+    """Run performance scan for pending prospects."""
+    prospects = prospect_service.get_pending_performance_scan(db, limit=limit)
+    count = 0
+    for prospect in prospects:
+        result = enrichment_service.scan_performance(db, prospect)
+        if result:
+            count += 1
+    return ScanBatchResponse(processed=len(prospects), successful=count)
+
+
+@router.post("/contacts/{prospect_id}", response_model=ContactScrapeResponse)
+def scrape_contacts_single(
+    prospect_id: int = Path(...),
+    db: Session = Depends(get_db),
+    current_admin: UserContext = Depends(get_current_admin_api),
+):
+    """Scrape contacts for a single prospect."""
+    prospect = prospect_service.get_by_id(db, prospect_id)
+    contacts = enrichment_service.scrape_contacts(db, prospect)
+    return ContactScrapeResponse(domain=prospect.domain_name, contacts_found=len(contacts))
+
+
+@router.post("/full/{prospect_id}", response_model=FullEnrichmentResponse)
+def full_enrichment(
+    prospect_id: int = Path(...),
+    db: Session = Depends(get_db),
+    current_admin: UserContext = Depends(get_current_admin_api),
+):
+    """Run full enrichment pipeline for a single prospect."""
+    prospect = prospect_service.get_by_id(db, prospect_id)
+
+    # Step 1: HTTP check
+    enrichment_service.check_http(db, prospect)
+
+    # Step 2: Tech scan (if has website)
+    tech_profile = None
+    if prospect.has_website:
+        tech_profile = enrichment_service.scan_tech_stack(db, prospect)
+
+    # Step 3: Performance scan (if has website)
+    perf_profile = None
+    if prospect.has_website:
+        perf_profile = enrichment_service.scan_performance(db, prospect)
+
+    # Step 4: Contact scrape (if has website)
+    contacts = []
+    if prospect.has_website:
+        contacts = enrichment_service.scrape_contacts(db, prospect)
+
+    # Step 5: Compute score
+    db.refresh(prospect)
+    score = scoring_service.compute_score(db, prospect)
+
+    return FullEnrichmentResponse(
+        domain=prospect.domain_name,
+        has_website=prospect.has_website,
+        tech_scanned=tech_profile is not None,
+        perf_scanned=perf_profile is not None,
+        contacts_found=len(contacts),
+        score=score.score,
+        lead_tier=score.lead_tier,
+    )
+
+
+@router.post("/score-compute/batch", response_model=ScoreComputeBatchResponse)
+def compute_scores_batch(
+    limit: int = Query(500, ge=1, le=5000),
+    db: Session = Depends(get_db),
+    current_admin: UserContext = Depends(get_current_admin_api),
+):
+    """Compute or recompute scores for all prospects."""
+    count = scoring_service.compute_all(db, limit=limit)
+    return ScoreComputeBatchResponse(scored=count)