Validator complete

app/routers/incidents.py

@@ -1,12 +1,16 @@
 from datetime import datetime
 from typing import List
 
-from fastapi import APIRouter, Depends, File, Form, HTTPException, status, UploadFile
+from fastapi import APIRouter, Depends, File, Form, HTTPException, status, UploadFile, Body
+from pydantic import BaseModel
 from bson import ObjectId
 
 from ..dependencies import get_current_user
 from ..schemas import IncidentResponse, IncidentList
-from ..services.incidents import save_incident_document, store_image, get_user_incidents, get_all_incidents
+from ..services.incidents import (
+    save_incident_document, store_image, get_user_incidents, 
+    get_all_incidents, update_incident_status
+)
 from ..services.nlp import classify_incident, get_model_info
 from ..database import is_database_available
 
@@ -122,6 +126,54 @@ async def list_incidents(current_user=Depends(get_current_user)):
             detail=f"Failed to list incidents: {str(e)}"
         )
 
+@router.post("/update-status/{incident_id}")
+async def update_status(
+    incident_id: str,
+    status: str = Body(..., embed=True),
+    current_user=Depends(get_current_user),
+):
+    """Update the status of an incident (validated, rejected, investigating)"""
+    if not is_database_available():
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Database service is currently unavailable. Please try again later."
+        )
+    
+    # Check if the user is a validator or higher role
+    if current_user.get("role") not in ["validator", "researcher", "policy_maker"]:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only validators can update incident status"
+        )
+    
+    # Validate the status value
+    if status not in ["validated", "rejected", "investigating"]:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid status. Must be one of: validated, rejected, investigating"
+        )
+    
+    try:
+        success = await update_incident_status(
+            incident_id=incident_id,
+            status=status,
+            validator_id=current_user["id"]
+        )
+        
+        if success:
+            return {"message": f"Incident status updated to {status}"}
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Incident not found or could not be updated"
+            )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to update incident status: {str(e)}"
+        )
+
+
 @router.post("/test-classify")
 async def test_classification(
     description: str = Form(...),

app/schemas.py

@@ -47,6 +47,9 @@ class IncidentInDB(BaseModel):
     created_at: datetime
     reporter_id: Optional[str]
     image_path: Optional[str]
+    status: Optional[str] = None
+    validated_by: Optional[str] = None
+    validated_at: Optional[datetime] = None
 
 
 class IncidentResponse(BaseModel):

app/services/incidents.py

@@ -6,12 +6,11 @@ import cloudinary
 import cloudinary.uploader
 import tempfile
 import os
-
+from datetime import datetime
 from ..database import get_collection
 from ..config import get_settings
 
 logger = logging.getLogger(__name__)
-
 INCIDENTS_COLLECTION = "incidents"
 
 
@@ -36,6 +35,41 @@ async def get_all_incidents() -> list:
     return await cursor.to_list(length=None)
 
 
+async def update_incident_status(incident_id: str, status: str, validator_id: str) -> bool:
+    """
+    Update the status of an incident
+    
+    Args:
+        incident_id: The ID of the incident to update
+        status: The new status (validated, rejected, investigating)
+        validator_id: The ID of the validator who updated the status
+    
+    Returns:
+        True if the update was successful, False otherwise
+    """
+    try:
+        collection = get_collection(INCIDENTS_COLLECTION)
+        
+        # Convert string ID to ObjectId
+        from bson import ObjectId
+        object_id = ObjectId(incident_id)
+        
+        # Update the incident with the new status and validator information
+        result = await collection.update_one(
+            {"_id": object_id},
+            {"$set": {
+                "status": status,
+                "validated_by": validator_id,
+                "validated_at": datetime.utcnow()
+            }}
+        )
+        
+        return result.modified_count > 0
+    except Exception as e:
+        logger.error(f"Failed to update incident status: {e}")
+        return False
+
+
 async def store_image(upload_file) -> Optional[str]:
     """
     Store an uploaded image using Cloudinary only.

generate_test_incidents.py

@@ -0,0 +1,145 @@
+import os
+import requests
+import json
+from pathlib import Path
+import random
+import time
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# API endpoint
+API_BASE_URL = os.getenv("API_BASE_URL", "http://localhost:8000/api")
+
+# Test user credentials
+EMAIL = "test@example.com"
+PASSWORD = "password123"  # Change to your test user password
+TOKEN = None
+
+# Sample incidents data
+SAMPLE_INCIDENTS = [
+    {
+        "name": "Large plastic debris near coastal area",
+        "description": "Found a significant amount of plastic waste including bottles, bags, and packaging materials washing up on the northern section of the beach. Appears to have accumulated over several days.",
+        "latitude": 34.0522,
+        "longitude": -118.2437,
+        "image_filename": None,  # No image for this one
+    },
+    {
+        "name": "Oil spill from fishing vessel",
+        "description": "Observed a small to medium oil slick extending approximately 100m from a commercial fishing vessel. The oil appears to be engine oil with rainbow sheen visible on the water surface.",
+        "latitude": 37.7749,
+        "longitude": -122.4194,
+        "image_filename": "test_files/cloudinary_test_7574.jpg",
+    },
+    {
+        "name": "Chemical discharge near industrial area",
+        "description": "Unusual discoloration and strong chemical odor in the water near the industrial park outflow. Several dead fish observed floating nearby. Possible unauthorized chemical discharge.",
+        "latitude": 40.7128,
+        "longitude": -74.0060,
+        "image_filename": None,
+    },
+    {
+        "name": "Fishing nets and gear debris",
+        "description": "Large tangled mass of abandoned fishing nets, lines, and traps washed up on the shoreline. Poses danger to marine life and should be removed immediately.",
+        "latitude": 32.7157,
+        "longitude": -117.1611,
+        "image_filename": None,
+    },
+    {
+        "name": "Microplastic concentration",
+        "description": "High concentration of microplastic particles observed in the sand along the shoreline. The plastic particles are small, multicolored, and appear to be widespread across the beach.",
+        "latitude": 21.3069,
+        "longitude": -157.8583,
+        "image_filename": None,
+    },
+]
+
+def login():
+    """Login and get authentication token"""
+    try:
+        response = requests.post(
+            f"{API_BASE_URL}/auth/login",
+            json={"email": EMAIL, "password": PASSWORD},
+        )
+        response.raise_for_status()
+        return response.json()["access_token"]
+    except requests.RequestException as e:
+        print(f"Login failed: {str(e)}")
+        if hasattr(response, 'text'):
+            print(f"Response: {response.text}")
+        return None
+
+def create_incident(incident_data, token):
+    """Create a test incident"""
+    try:
+        # Create form data
+        form_data = {
+            "name": incident_data["name"],
+            "description": incident_data["description"],
+            "latitude": str(incident_data["latitude"]),
+            "longitude": str(incident_data["longitude"]),
+        }
+        
+        files = {}
+        
+        # Add image if available
+        if incident_data["image_filename"] and os.path.exists(incident_data["image_filename"]):
+            files = {
+                "image": (
+                    os.path.basename(incident_data["image_filename"]),
+                    open(incident_data["image_filename"], "rb"),
+                    "image/jpeg"
+                )
+            }
+        
+        # Send request
+        response = requests.post(
+            f"{API_BASE_URL}/incidents/classify",
+            data=form_data,
+            files=files,
+            headers={"Authorization": f"Bearer {token}"}
+        )
+        response.raise_for_status()
+        
+        # Close the file if it was opened
+        if "image" in files:
+            files["image"][1].close()
+            
+        return response.json()
+    except requests.RequestException as e:
+        print(f"Failed to create incident: {str(e)}")
+        if hasattr(response, 'text'):
+            print(f"Response: {response.text}")
+        return None
+
+def generate_test_incidents():
+    """Generate several test incidents"""
+    # Login to get token
+    token = login()
+    if not token:
+        print("Authentication failed, cannot create test incidents")
+        return False
+    
+    print(f"Successfully logged in as {EMAIL}")
+    
+    # Create each sample incident
+    for i, incident in enumerate(SAMPLE_INCIDENTS, 1):
+        print(f"Creating incident {i}/{len(SAMPLE_INCIDENTS)}: {incident['name']}")
+        result = create_incident(incident, token)
+        
+        if result:
+            print(f"✅ Created incident: {result.get('incident_id')} - {result.get('incident_class')} (Severity: {result.get('severity')})")
+        else:
+            print("❌ Failed to create incident")
+            
+        # Add a delay to prevent rate limiting
+        time.sleep(1)
+    
+    print("\nAll test incidents created successfully!")
+    return True
+
+if __name__ == "__main__":
+    print("=== Marine Guard Test Incident Generator ===")
+    generate_test_incidents()