⚡ Bolt: Implement blockchain chaining for field officer visits

backend/cache.py

@@ -175,4 +175,5 @@ def invalidate(self):
 user_upload_cache = ThreadSafeCache(ttl=3600, max_size=1000)  # 1 hour TTL for upload limits
 blockchain_last_hash_cache = ThreadSafeCache(ttl=3600, max_size=1)
 grievance_last_hash_cache = ThreadSafeCache(ttl=3600, max_size=1)
+visit_last_hash_cache = ThreadSafeCache(ttl=3600, max_size=2)
 user_issues_cache = ThreadSafeCache(ttl=300, max_size=50) # 5 minutes TTL

backend/geofencing_service.py

@@ -95,7 +95,7 @@ def generate_visit_hash(visit_data: dict) -> str:
     Generate a tamper-resistant HMAC hash for visit data (blockchain-like integrity).
 
     Uses HMAC-SHA256 with server secret to prevent forgery.
-    Normalizes datetime to ISO format for deterministic hashing.
+    Normalizes datetime to UTC ISO format for deterministic hashing.
 
     Args:
         visit_data: Dictionary containing visit information
@@ -104,21 +104,29 @@ def generate_visit_hash(visit_data: dict) -> str:
         HMAC-SHA256 hash of visit data
     """
     try:
-        # Normalize check_in_time to ISO format string for determinism
+        # Normalize check_in_time to UTC ISO format string for determinism
+        # Ensure microseconds are stripped for consistent comparison across DBs
         check_in_time = visit_data.get('check_in_time')
         if isinstance(check_in_time, datetime):
-            check_in_time_str = check_in_time.isoformat()
+            # Normalize to UTC and strip microseconds for consistency
+            if check_in_time.tzinfo is None:
+                check_in_time = check_in_time.replace(tzinfo=timezone.utc)
+            else:
+                check_in_time = check_in_time.astimezone(timezone.utc)
+
+            check_in_time_str = check_in_time.replace(microsecond=0).strftime('%Y-%m-%dT%H:%M:%S')
         else:
             check_in_time_str = str(check_in_time) if check_in_time else ""
 
-        # Create a deterministic string from visit data
+        # Create a deterministic string from visit data, including previous hash for chaining
         data_string = (
             f"{visit_data.get('issue_id')}"
             f"{visit_data.get('officer_email')}"
             f"{visit_data.get('check_in_latitude')}"
             f"{visit_data.get('check_in_longitude')}"
             f"{check_in_time_str}"
             f"{visit_data.get('visit_notes', '')}"
+            f"{visit_data.get('previous_visit_hash', '')}"
         )
 
         # Generate HMAC-SHA256 hash for tamper-resistance

backend/init_db.py

@@ -187,6 +187,10 @@ def index_exists(table, index_name):
 
             # Indexes for field_officer_visits (run regardless of table creation)
             if inspector.has_table("field_officer_visits"):
+                if not column_exists("field_officer_visits", "previous_visit_hash"):
+                    conn.execute(text("ALTER TABLE field_officer_visits ADD COLUMN previous_visit_hash VARCHAR"))
+                    logger.info("Added previous_visit_hash column to field_officer_visits")
+
                 if not index_exists("field_officer_visits", "ix_field_officer_visits_issue_id"):
                     conn.execute(text("CREATE INDEX IF NOT EXISTS ix_field_officer_visits_issue_id ON field_officer_visits (issue_id)"))
 
@@ -199,6 +203,9 @@ def index_exists(table, index_name):
                 if not index_exists("field_officer_visits", "ix_field_officer_visits_check_in_time"):
                     conn.execute(text("CREATE INDEX IF NOT EXISTS ix_field_officer_visits_check_in_time ON field_officer_visits (check_in_time)"))
 
+                if not index_exists("field_officer_visits", "ix_field_officer_visits_previous_visit_hash"):
+                    conn.execute(text("CREATE INDEX IF NOT EXISTS ix_field_officer_visits_previous_visit_hash ON field_officer_visits (previous_visit_hash)"))
+
             logger.info("Database migration check completed successfully.")
 
     except Exception as e:

backend/models.py

@@ -253,6 +253,7 @@ class FieldOfficerVisit(Base):
 
     # Immutability hash (blockchain-like integrity)
     visit_hash = Column(String, nullable=True)  # Hash of visit data for integrity verification
+    previous_visit_hash = Column(String, nullable=True, index=True) # Linked hash for O(1) verification
 
     # Metadata
     created_at = Column(DateTime, default=lambda: datetime.datetime.now(datetime.timezone.utc))

backend/routers/field_officer.py

@@ -27,9 +27,12 @@
 from backend.geofencing_service import (
     is_within_geofence,
     generate_visit_hash,
+    verify_visit_integrity,
     calculate_visit_metrics,
     get_geofencing_service
 )
+from backend.cache import visit_last_hash_cache
+from backend.schemas import BlockchainVerificationResponse
 
 logger = logging.getLogger(__name__)
 
@@ -93,20 +96,34 @@ def officer_check_in(request: OfficerCheckInRequest, db: Session = Depends(get_d
         )
 
         # Create visit record
-        check_in_time = datetime.now(timezone.utc)
-
+        # Normalize check_in_time: strip microseconds for deterministic hashing across DBs
+        check_in_time = datetime.now(timezone.utc).replace(microsecond=0)
+
+        # Blockchain feature: calculate integrity hash for the visit
+        # Performance Boost: Use thread-safe cache to eliminate DB query for last hash
+        prev_hash = visit_last_hash_cache.get("last_hash")
+        if prev_hash is None:
+            # Cache miss: Fetch only the last hash from DB
+            prev_visit = db.query(FieldOfficerVisit.visit_hash).order_by(FieldOfficerVisit.id.desc()).first()
+            prev_hash = prev_visit[0] if prev_visit and prev_visit[0] else ""
+            visit_last_hash_cache.set(data=prev_hash, key="last_hash")
+
         visit_data = {
             'issue_id': request.issue_id,
             'officer_email': request.officer_email,
             'check_in_latitude': request.check_in_latitude,
             'check_in_longitude': request.check_in_longitude,
-            'check_in_time': check_in_time.isoformat(),
-            'visit_notes': request.visit_notes or ''
+            'check_in_time': check_in_time,
+            'visit_notes': request.visit_notes or '',
+            'previous_visit_hash': prev_hash
         }
 
         # Generate immutable hash
         visit_hash = generate_visit_hash(visit_data)
 
+        # Update cache for next visit
+        visit_last_hash_cache.set(data=visit_hash, key="last_hash")
+
         new_visit = FieldOfficerVisit(
             issue_id=request.issue_id,
             grievance_id=request.grievance_id,
@@ -123,6 +140,7 @@ def officer_check_in(request: OfficerCheckInRequest, db: Session = Depends(get_d
             visit_notes=request.visit_notes,
             status='checked_in',
             visit_hash=visit_hash,
+            previous_visit_hash=prev_hash,
             is_public=True
         )
 
@@ -484,3 +502,54 @@ def verify_visit(
     except Exception as e:
         logger.error(f"Error verifying visit {visit_id}: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail="Verification failed")
+
+
+@router.get("/field-officer/{visit_id}/blockchain-verify", response_model=BlockchainVerificationResponse)
+def verify_visit_blockchain(visit_id: int, db: Session = Depends(get_db)):
+    """
+    Verify the cryptographic integrity of a field officer visit using blockchain-style chaining.
+    Optimized: Uses previous_visit_hash column for O(1) verification.
+    """
+    try:
+        visit = db.query(FieldOfficerVisit).filter(FieldOfficerVisit.id == visit_id).first()
+
+        if not visit:
+            raise HTTPException(status_code=404, detail=f"Visit {visit_id} not found")
+
+        # Determine previous hash (O(1) from stored column)
+        prev_hash = visit.previous_visit_hash or ""
+
+        # Chaining logic: rebuild the dictionary for verification
+        visit_data = {
+            'issue_id': visit.issue_id,
+            'officer_email': visit.officer_email,
+            'check_in_latitude': visit.check_in_latitude,
+            'check_in_longitude': visit.check_in_longitude,
+            'check_in_time': visit.check_in_time,
+            'visit_notes': visit.visit_notes or '',
+            'previous_visit_hash': prev_hash
+        }
+
+        # Use helper for verification
+        is_valid = verify_visit_integrity(visit_data, visit.visit_hash)
+
+        # For the response, we need the computed hash
+        computed_hash = generate_visit_hash(visit_data)
+
+        if is_valid:
+            message = "Integrity verified. This visit record is cryptographically sealed and part of a secure chain."
+        else:
+            message = "Integrity check failed! The visit data does not match its cryptographic seal."
+
+        return BlockchainVerificationResponse(
+            is_valid=is_valid,
+            current_hash=visit.visit_hash,
+            computed_hash=computed_hash,
+            message=message
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error verifying visit blockchain for {visit_id}: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Failed to verify visit integrity")

tests/test_blockchain.py

@@ -29,7 +29,8 @@ def test_blockchain_verification_success(client, db_session):
     issue1 = Issue(
         description="First issue",
         category="Road",
-        integrity_hash=hash1
+        integrity_hash=hash1,
+        previous_integrity_hash=""
     )
     db_session.add(issue1)
     db_session.commit()
@@ -42,7 +43,8 @@ def test_blockchain_verification_success(client, db_session):
     issue2 = Issue(
         description="Second issue",
         category="Garbage",
-        integrity_hash=hash2
+        integrity_hash=hash2,
+        previous_integrity_hash=hash1
     )
     db_session.add(issue2)
     db_session.commit()

tests/test_blockchain_visit.py

@@ -0,0 +1,137 @@
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+from datetime import datetime, timezone
+import hashlib
+
+from backend.main import app
+from backend.database import get_db, Base, engine
+from backend.models import Issue, FieldOfficerVisit
+from backend.cache import visit_last_hash_cache
+
+# Use an isolated SQLite database for blockchain tests
+SQLALCHEMY_DATABASE_URL = "sqlite:///./test_blockchain_visit.db"
+
+@pytest.fixture(scope="module")
+def client():
+    # Setup: Create tables in the test database
+    Base.metadata.create_all(bind=engine)
+    with TestClient(app) as c:
+        yield c
+    # Teardown: Remove the test database file if needed,
+    # but here we just rely on the fact it's a separate file or in-memory
+    Base.metadata.drop_all(bind=engine)
+
+def test_visit_blockchain_chaining(client):
+    # Clear cache for deterministic test
+    visit_last_hash_cache.clear()
+
+    # 1. Create a test issue
+    db = next(get_db())
+    issue = Issue(
+        description="Pothole on Main St",
+        category="Road",
+        latitude=18.5204,
+        longitude=73.8567,
+        status="open"
+    )
+    db.add(issue)
+    db.commit()
+    db.refresh(issue)
+
+    # 2. First check-in (Root of the chain)
+    checkin1 = {
+        "issue_id": issue.id,
+        "officer_email": "officer1@city.gov",
+        "officer_name": "John Doe",
+        "check_in_latitude": 18.5205,
+        "check_in_longitude": 73.8568,
+        "visit_notes": "First visit",
+        "geofence_radius_meters": 100.0
+    }
+    response1 = client.post("/api/field-officer/check-in", json=checkin1)
+    assert response1.status_code == 200
+    data1 = response1.json()
+    visit1_id = data1["id"]
+    visit1_hash = data1.get("visit_hash") # Note: Visit hash is not in FieldOfficerVisitResponse by default in schemas.py?
+
+    # Re-fetch from DB to check visit_hash and previous_visit_hash
+    v1 = db.query(FieldOfficerVisit).filter(FieldOfficerVisit.id == visit1_id).first()
+    assert v1.visit_hash is not None
+    assert v1.previous_visit_hash == ""
+
+    # 3. Second check-in (Chained to first)
+    checkin2 = {
+        "issue_id": issue.id,
+        "officer_email": "officer2@city.gov",
+        "officer_name": "Jane Smith",
+        "check_in_latitude": 18.5204,
+        "check_in_longitude": 73.8567,
+        "visit_notes": "Second visit",
+        "geofence_radius_meters": 100.0
+    }
+    response2 = client.post("/api/field-officer/check-in", json=checkin2)
+    assert response2.status_code == 200
+    data2 = response2.json()
+    visit2_id = data2["id"]
+
+    v2 = db.query(FieldOfficerVisit).filter(FieldOfficerVisit.id == visit2_id).first()
+    assert v2.visit_hash is not None
+    assert v2.previous_visit_hash == v1.visit_hash
+
+    # 4. Verify integrity via API
+    verify_resp1 = client.get(f"/api/field-officer/{visit1_id}/blockchain-verify")
+    assert verify_resp1.status_code == 200
+    assert verify_resp1.json()["is_valid"] is True
+
+    verify_resp2 = client.get(f"/api/field-officer/{visit2_id}/blockchain-verify")
+    assert verify_resp2.status_code == 200
+    assert verify_resp2.json()["is_valid"] is True
+
+    # 5. Simulate tampering
+    v2.visit_notes = "TAMPERED NOTES"
+    db.commit()
+
+    verify_tampered = client.get(f"/api/field-officer/{visit2_id}/blockchain-verify")
+    assert verify_tampered.status_code == 200
+    assert verify_tampered.json()["is_valid"] is False
+    assert "Integrity check failed" in verify_tampered.json()["message"]
+
+def test_cache_miss_recovery(client):
+    # 1. Create a visit
+    db = next(get_db())
+    issue = db.query(Issue).first()
+
+    checkin = {
+        "issue_id": issue.id,
+        "officer_email": "officer3@city.gov",
+        "officer_name": "Officer Cache",
+        "check_in_latitude": 18.5204,
+        "check_in_longitude": 73.8567,
+        "visit_notes": "Cache test",
+        "geofence_radius_meters": 100.0
+    }
+    client.post("/api/field-officer/check-in", json=checkin)
+
+    last_visit = db.query(FieldOfficerVisit).order_by(FieldOfficerVisit.id.desc()).first()
+    last_hash = last_visit.visit_hash
+
+    # 2. Clear cache
+    visit_last_hash_cache.clear()
+
+    # 3. Next check-in should still chain correctly by fetching from DB
+    checkin_next = {
+        "issue_id": issue.id,
+        "officer_email": "officer4@city.gov",
+        "officer_name": "Officer Recovery",
+        "check_in_latitude": 18.5204,
+        "check_in_longitude": 73.8567,
+        "visit_notes": "Recovery test",
+        "geofence_radius_meters": 100.0
+    }
+    resp = client.post("/api/field-officer/check-in", json=checkin_next)
+    assert resp.status_code == 200
+
+    v_next = db.query(FieldOfficerVisit).order_by(FieldOfficerVisit.id.desc()).first()
+    assert v_next.previous_visit_hash == last_hash