⚡ Bolt: Serialization caching and blockchain integrity for voice issues

backend/cache.py

@@ -185,3 +185,6 @@ def invalidate(self):
 evidence_audit_last_hash_cache = ThreadSafeCache(ttl=3600, max_size=1)
 closure_last_hash_cache = ThreadSafeCache(ttl=3600, max_size=1)
 user_issues_cache = ThreadSafeCache(ttl=300, max_size=50) # 5 minutes TTL
+grievance_list_cache = ThreadSafeCache(ttl=300, max_size=20)
+escalation_stats_cache = ThreadSafeCache(ttl=300, max_size=10)
+visit_stats_cache = ThreadSafeCache(ttl=300, max_size=10)

backend/grievance_service.py

@@ -15,7 +15,11 @@
 from backend.routing_service import RoutingService
 from backend.sla_config_service import SLAConfigService
 from backend.escalation_engine import EscalationEngine
-from backend.cache import grievance_last_hash_cache
+from backend.cache import (
+    grievance_last_hash_cache,
+    grievance_list_cache,
+    escalation_stats_cache
+)
 
 class GrievanceService:
     """
@@ -130,6 +134,10 @@ def create_grievance(self, grievance_data: Dict[str, Any], db: Session = None) -
             db.commit()
             db.refresh(grievance)
 
+            # Invalidate caches
+            grievance_list_cache.clear()
+            escalation_stats_cache.clear()
+
             # Update cache after successful commit
             grievance_last_hash_cache.set(data=integrity_hash, key="last_hash")
 

backend/main.py

@@ -95,10 +95,10 @@ async def lifespan(app: FastAPI):
     # Startup: Initialize Grievance Service (needed for escalation engine)
     try:
         logger.info("Initializing grievance service...")
-        # Temporarily disabled for local dev
-        # grievance_service = GrievanceService()
-        # app.state.grievance_service = grievance_service
-        logger.info("Grievance service initialization skipped for local dev.")
+        # Re-enabled to avoid redundant re-initialization on every manual escalation
+        grievance_service = GrievanceService()
+        app.state.grievance_service = grievance_service
+        logger.info("Grievance service initialized successfully.")
     except Exception as e:
         logger.error(f"Error initializing grievance service: {e}", exc_info=True)
 

backend/routers/field_officer.py

@@ -4,9 +4,10 @@
 Issue #288: Field Officer Check-In System With Location Verification
 """
 
-from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Form
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Form, Response
 from sqlalchemy.orm import Session
 from sqlalchemy import func, case
+import json
 from typing import List, Optional
 import logging
 import os
@@ -31,7 +32,7 @@
     calculate_visit_metrics,
     get_geofencing_service
 )
-from backend.cache import visit_last_hash_cache
+from backend.cache import visit_last_hash_cache, visit_stats_cache
 from backend.schemas import BlockchainVerificationResponse
 
 logger = logging.getLogger(__name__)
@@ -144,6 +145,9 @@ def officer_check_in(request: OfficerCheckInRequest, db: Session = Depends(get_d
         db.add(new_visit)
         db.commit()
         db.refresh(new_visit)
+
+        # Invalidate stats cache
+        visit_stats_cache.clear()
 
         # Update cache for next visit AFTER successful DB commit
         visit_last_hash_cache.set(data=visit_hash, key="last_hash")
@@ -225,6 +229,9 @@ def officer_check_out(request: OfficerCheckOutRequest, db: Session = Depends(get
 
         db.commit()
         db.refresh(visit)
+
+        # Invalidate stats cache
+        visit_stats_cache.clear()
 
         logger.info(f"Officer checked out from visit {request.visit_id}")
 
@@ -422,10 +429,14 @@ def get_issue_visit_history(
 def get_visit_statistics(db: Session = Depends(get_db)):
     """
     Get aggregate statistics for all field officer visits using optimized SQL queries
-
-    Returns metrics like total visits, verification status, geo-fence compliance, etc.
+    and serialization caching.
     """
     try:
+        # Check cache first
+        cached_json = visit_stats_cache.get("global_visit_stats")
+        if cached_json:
+            return Response(content=cached_json, media_type="application/json")
+
         # Optimized: Use a single aggregate query to fetch multiple statistics in one database roundtrip
         stats = db.query(
             func.count(FieldOfficerVisit.id).label('total'),
@@ -449,14 +460,20 @@ def get_visit_statistics(db: Session = Depends(get_db)):
         else:
             average_distance = 0.0
 
-        return VisitStatsResponse(
-            total_visits=total_visits,
-            verified_visits=verified_visits,
-            within_geofence_count=within_geofence_count,
-            outside_geofence_count=outside_geofence_count,
-            unique_officers=unique_officers,
-            average_distance_from_site=average_distance
-        )
+        data = {
+            "total_visits": total_visits,
+            "verified_visits": verified_visits,
+            "within_geofence_count": within_geofence_count,
+            "outside_geofence_count": outside_geofence_count,
+            "unique_officers": unique_officers,
+            "average_distance_from_site": average_distance
+        }
+
+        # Cache pre-serialized JSON to bypass Pydantic overhead
+        json_data = json.dumps(data)
+        visit_stats_cache.set(json_data, "global_visit_stats")
+
+        return Response(content=json_data, media_type="application/json")
 
     except Exception as e:
         logger.error(f"Error calculating visit statistics: {e}", exc_info=True)
@@ -492,6 +509,9 @@ def verify_visit(
         visit.updated_at = datetime.now(timezone.utc)
 
         db.commit()
+
+        # Invalidate stats cache
+        visit_stats_cache.clear()
 
         logger.info(f"Visit {visit_id} verified by {verifier_email}")
 

backend/routers/grievances.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from fastapi import APIRouter, Depends, HTTPException, Query, Request, Response
 from sqlalchemy.orm import Session, joinedload, selectinload
 from sqlalchemy import func, case
 from typing import List, Optional
@@ -23,6 +23,7 @@
 )
 from backend.grievance_service import GrievanceService
 from backend.closure_service import ClosureService
+from backend.cache import grievance_list_cache, escalation_stats_cache
 
 logger = logging.getLogger(__name__)
 
@@ -38,9 +39,15 @@ def get_grievances(
 ):
     """
     Get list of grievances with escalation history.
-    Optimized: Uses selectinload for audit_logs to avoid Cartesian product and improve O(N) fetching.
+    Optimized: Uses selectinload for audit_logs and serialization caching.
     """
     try:
+        # Check cache first
+        cache_key = f"grievances_{status}_{category}_{limit}_{offset}"
+        cached_json = grievance_list_cache.get(cache_key)
+        if cached_json:
+            return Response(content=cached_json, media_type="application/json")
+
         query = db.query(Grievance).options(
             selectinload(Grievance.audit_logs),
             joinedload(Grievance.jurisdiction)
@@ -57,37 +64,41 @@ def get_grievances(
         result = []
         for grievance in grievances:
             escalation_history = [
-                EscalationAuditResponse(
-                    id=audit.id,
-                    grievance_id=audit.grievance_id,
-                    previous_authority=audit.previous_authority,
-                    new_authority=audit.new_authority,
-                    timestamp=audit.timestamp,
-                    reason=audit.reason.value
-                )
+                {
+                    "id": audit.id,
+                    "grievance_id": audit.grievance_id,
+                    "previous_authority": audit.previous_authority,
+                    "new_authority": audit.new_authority,
+                    "timestamp": audit.timestamp.isoformat() if audit.timestamp else None,
+                    "reason": audit.reason.value
+                }
                 for audit in grievance.audit_logs
             ]
 
-            result.append(GrievanceSummaryResponse(
-                id=grievance.id,
-                unique_id=grievance.unique_id,
-                category=grievance.category,
-                severity=grievance.severity.value,
-                pincode=grievance.pincode,
-                city=grievance.city,
-                district=grievance.district,
-                state=grievance.state,
-                current_jurisdiction_id=grievance.current_jurisdiction_id,
-                assigned_authority=grievance.assigned_authority,
-                sla_deadline=grievance.sla_deadline,
-                status=grievance.status.value,
-                created_at=grievance.created_at,
-                updated_at=grievance.updated_at,
-                resolved_at=grievance.resolved_at,
-                escalation_history=escalation_history
-            ))
-
-        return result
+            result.append({
+                "id": grievance.id,
+                "unique_id": grievance.unique_id,
+                "category": grievance.category,
+                "severity": grievance.severity.value,
+                "pincode": grievance.pincode,
+                "city": grievance.city,
+                "district": grievance.district,
+                "state": grievance.state,
+                "current_jurisdiction_id": grievance.current_jurisdiction_id,
+                "assigned_authority": grievance.assigned_authority,
+                "sla_deadline": grievance.sla_deadline.isoformat() if grievance.sla_deadline else None,
+                "status": grievance.status.value,
+                "created_at": grievance.created_at.isoformat() if grievance.created_at else None,
+                "updated_at": grievance.updated_at.isoformat() if grievance.updated_at else None,
+                "resolved_at": grievance.resolved_at.isoformat() if grievance.resolved_at else None,
+                "escalation_history": escalation_history
+            })
+
+        # Cache pre-serialized JSON to bypass Pydantic overhead
+        json_data = json.dumps(result)
+        grievance_list_cache.set(json_data, cache_key)
+
+        return Response(content=json_data, media_type="application/json")
 
     except Exception as e:
         logger.error(f"Error getting grievances: {e}", exc_info=True)
@@ -149,32 +160,43 @@ def get_grievance(grievance_id: int, db: Session = Depends(get_db)):
 def get_escalation_stats(db: Session = Depends(get_db)):
     """
     Get escalation statistics.
-    Optimized: Uses a single GROUP BY query instead of 4 separate count queries.
+    Optimized: Uses a single multi-metric aggregate query and serialization caching.
     """
     try:
-        # Perform aggregation in a single query for performance
-        status_counts = db.query(
-            Grievance.status,
-            func.count(Grievance.id)
-        ).group_by(Grievance.status).all()
+        # Check cache first
+        cached_json = escalation_stats_cache.get("global_stats")
+        if cached_json:
+            return Response(content=cached_json, media_type="application/json")
 
-        # Process results into a dictionary for easy lookup
-        counts_dict = {status.value if hasattr(status, 'value') else status: count for status, count in status_counts}
+        # Perform aggregation in a single query for maximum performance
+        # Using func.sum(case(...)) is faster than group_by for a fixed set of statuses
+        stats = db.query(
+            func.count(Grievance.id).label('total'),
+            func.sum(case((Grievance.status == 'escalated', 1), else_=0)).label('escalated'),
+            func.sum(case((Grievance.status == 'open', 1), (Grievance.status == 'in_progress', 1), else_=0)).label('active'),
+            func.sum(case((Grievance.status == 'resolved', 1), else_=0)).label('resolved')
+        ).first()
 
-        total_grievances = sum(counts_dict.values())
-        escalated_grievances = counts_dict.get("escalated", 0)
-        active_grievances = counts_dict.get("open", 0) + counts_dict.get("in_progress", 0)
-        resolved_grievances = counts_dict.get("resolved", 0)
+        total_grievances = stats.total or 0
+        escalated_grievances = int(stats.escalated or 0)
+        active_grievances = int(stats.active or 0)
+        resolved_grievances = int(stats.resolved or 0)
 
         escalation_rate = (escalated_grievances / total_grievances * 100) if total_grievances > 0 else 0
 
-        return EscalationStatsResponse(
-            total_grievances=total_grievances,
-            escalated_grievances=escalated_grievances,
-            active_grievances=active_grievances,
-            resolved_grievances=resolved_grievances,
-            escalation_rate=escalation_rate
-        )
+        data = {
+            "total_grievances": total_grievances,
+            "escalated_grievances": escalated_grievances,
+            "active_grievances": active_grievances,
+            "resolved_grievances": resolved_grievances,
+            "escalation_rate": escalation_rate
+        }
+
+        # Cache pre-serialized JSON to bypass Pydantic overhead
+        json_data = json.dumps(data)
+        escalation_stats_cache.set(json_data, "global_stats")
+
+        return Response(content=json_data, media_type="application/json")
 
     except Exception as e:
         logger.error(f"Error getting escalation stats: {e}", exc_info=True)
@@ -276,6 +298,9 @@ def follow_grievance(
         )
         db.add(follower)
         db.commit()
+
+        # Invalidate caches
+        grievance_list_cache.clear()
 
         # Count total followers
         total_followers = db.query(func.count(GrievanceFollower.id)).filter(
@@ -314,6 +339,9 @@ def unfollow_grievance(
 
         db.delete(follower)
         db.commit()
+
+        # Invalidate caches
+        grievance_list_cache.clear()
 
         return {"message": "Successfully unfollowed grievance"}
 
@@ -335,6 +363,9 @@ def request_grievance_closure(
         result = ClosureService.request_closure(grievance_id, db)
 
         if result.get("skip_confirmation"):
+            # Invalidate caches as status might have changed to resolved
+            grievance_list_cache.clear()
+            escalation_stats_cache.clear()
             return RequestClosureResponse(
                 grievance_id=grievance_id,
                 message=result["message"],
@@ -343,6 +374,10 @@ def request_grievance_closure(
                 required_confirmations=0
             )
 
+        # Invalidate caches
+        grievance_list_cache.clear()
+        escalation_stats_cache.clear()
+
         return RequestClosureResponse(
             grievance_id=grievance_id,
             message=result["message"],
@@ -366,6 +401,10 @@ def confirm_grievance_closure(
 ):
     """Confirm or dispute a grievance closure (followers only)"""
     try:
+        # Invalidate caches as status or approval might change
+        grievance_list_cache.clear()
+        escalation_stats_cache.clear()
+
         result = ClosureService.submit_confirmation(
             grievance_id=grievance_id,
             user_email=confirmation.user_email,