local tests

services/emergency_service/main.py

@@ -1,10 +1,11 @@
 import asyncio
 from datetime import datetime, timedelta
+from typing import List
 
 import httpx
 from fastapi import BackgroundTasks, Depends, FastAPI, HTTPException, status
 from fastapi.middleware.cors import CORSMiddleware
-from sqlalchemy import func, select
+from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from services.emergency_service.models import EmergencyAlert, EmergencyResponse
@@ -18,7 +19,7 @@ from services.emergency_service.schemas import (
 from services.user_service.models import User
 from shared.auth import get_current_user_from_token
 from shared.config import settings
-from shared.database import AsyncSessionLocal, get_db
+from shared.database import get_db
 
 app = FastAPI(title="Emergency Service", version="1.0.0")
 
@@ -55,7 +56,7 @@ async def health_check():
 
 async def get_nearby_users(
     latitude: float, longitude: float, radius_km: float = 1.0
-) -> list:
+) -> List[dict]:
     """Get users within radius using Location Service"""
     async with httpx.AsyncClient() as client:
         try:
@@ -75,7 +76,7 @@ async def get_nearby_users(
             return []
 
 
-async def send_emergency_notifications(alert_id: int, nearby_users: list):
+async def send_emergency_notifications(alert_id: int, nearby_users: List[dict]):
     """Send push notifications to nearby users"""
     async with httpx.AsyncClient() as client:
         try:
@@ -98,15 +99,14 @@ async def create_emergency_alert(
     current_user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db),
 ):
-    """Create new emergency alert and notify nearby users"""
-
+    """Create new emergency alert"""
     # Create alert
     db_alert = EmergencyAlert(
         user_id=current_user.id,
         latitude=alert_data.latitude,
         longitude=alert_data.longitude,
         address=alert_data.address,
-        alert_type=alert_data.alert_type.value,
+        alert_type=alert_data.alert_type,
         message=alert_data.message,
     )
 
@@ -114,34 +114,45 @@ async def create_emergency_alert(
     await db.commit()
     await db.refresh(db_alert)
 
-    # Get nearby users and send notifications in background
+    # Process alert in background
     background_tasks.add_task(
-        process_emergency_alert, db_alert.id, alert_data.latitude, alert_data.longitude
+        process_emergency_alert_in_background,
+        int(db_alert.id),  # Convert to int explicitly
+        alert_data.latitude, 
+        alert_data.longitude
     )
 
     return EmergencyAlertResponse.model_validate(db_alert)
 
 
-async def process_emergency_alert(alert_id: int, latitude: float, longitude: float):
-    """Process emergency alert - get nearby users and send notifications"""
-    # Get nearby users
-    nearby_users = await get_nearby_users(
-        latitude, longitude, settings.MAX_EMERGENCY_RADIUS_KM
-    )
+async def process_emergency_alert_in_background(alert_id: int, latitude: float, longitude: float):
+    """Process emergency alert - notify nearby users"""
+    try:
+        # Get nearby users
+        nearby_users = await get_nearby_users(latitude, longitude)
 
-    # Update alert with notified users count
-    async with AsyncSessionLocal() as db:
-        result = await db.execute(
-            select(EmergencyAlert).filter(EmergencyAlert.id == alert_id)
-        )
-        alert = result.scalars().first()
-        if alert:
-            alert.notified_users_count = len(nearby_users)
-            await db.commit()
+        if nearby_users:
+            # Create new database session for background task
+            from shared.database import AsyncSessionLocal
+            async with AsyncSessionLocal() as db:
+                try:
+                    # Update alert with notification count
+                    await db.execute(
+                        update(EmergencyAlert)
+                        .where(EmergencyAlert.id == alert_id)
+                        .values(notified_users_count=len(nearby_users))
+                    )
+                    await db.commit()
 
-    # Send notifications
-    if nearby_users:
-        await send_emergency_notifications(alert_id, nearby_users)
+                    # Send notifications
+                    await send_emergency_notifications(alert_id, nearby_users)
+
+                except Exception as e:
+                    print(f"Error processing emergency alert: {e}")
+                    await db.rollback()
+
+    except Exception as e:
+        print(f"Error in process_emergency_alert_in_background: {e}")
 
 
 @app.post("/api/v1/alert/{alert_id}/respond", response_model=EmergencyResponseResponse)
@@ -152,44 +163,46 @@ async def respond_to_alert(
     db: AsyncSession = Depends(get_db),
 ):
     """Respond to emergency alert"""
-
     # Check if alert exists
-    result = await db.execute(
-        select(EmergencyAlert).filter(EmergencyAlert.id == alert_id)
-    )
+    result = await db.execute(select(EmergencyAlert).filter(EmergencyAlert.id == alert_id))
     alert = result.scalars().first()
+    
     if not alert:
-        raise HTTPException(status_code=404, detail="Alert not found")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Alert not found"
+        )
 
-    if alert.is_resolved:
-        raise HTTPException(status_code=400, detail="Alert already resolved")
-
-    # Check if user already responded
+    # Check if already responded
     existing_response = await db.execute(
         select(EmergencyResponse).filter(
             EmergencyResponse.alert_id == alert_id,
-            EmergencyResponse.responder_id == current_user.id,
+            EmergencyResponse.user_id == current_user.id
         )
     )
     if existing_response.scalars().first():
         raise HTTPException(
-            status_code=400, detail="You already responded to this alert"
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="You have already responded to this alert"
         )
 
     # Create response
     db_response = EmergencyResponse(
         alert_id=alert_id,
-        responder_id=current_user.id,
-        response_type=response_data.response_type.value,
+        user_id=current_user.id,
+        response_type=response_data.response_type,
         message=response_data.message,
         eta_minutes=response_data.eta_minutes,
     )
 
     db.add(db_response)
-
+    
     # Update responded users count
-    alert.responded_users_count += 1
-
+    await db.execute(
+        update(EmergencyAlert)
+        .where(EmergencyAlert.id == alert_id)
+        .values(responded_users_count=EmergencyAlert.responded_users_count + 1)
+    )
+    
     await db.commit()
     await db.refresh(db_response)
 
@@ -202,116 +215,110 @@ async def resolve_alert(
     current_user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db),
 ):
-    """Mark alert as resolved (only by alert creator)"""
-
-    result = await db.execute(
-        select(EmergencyAlert).filter(EmergencyAlert.id == alert_id)
-    )
+    """Resolve emergency alert"""
+    result = await db.execute(select(EmergencyAlert).filter(EmergencyAlert.id == alert_id))
     alert = result.scalars().first()
-
+    
     if not alert:
-        raise HTTPException(status_code=404, detail="Alert not found")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Alert not found"
+        )
 
+    # Only alert creator can resolve
     if alert.user_id != current_user.id:
-        raise HTTPException(status_code=403, detail="Only alert creator can resolve it")
-
-    if alert.is_resolved:
-        raise HTTPException(status_code=400, detail="Alert already resolved")
-
-    alert.is_resolved = True
-    alert.resolved_at = datetime.utcnow()
-    alert.resolved_by = current_user.id
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only alert creator can resolve the alert"
+        )
 
+    # Update alert
+    await db.execute(
+        update(EmergencyAlert)
+        .where(EmergencyAlert.id == alert_id)
+        .values(
+            is_resolved=True,
+            resolved_at=datetime.utcnow(),
+            resolved_by=current_user.id
+        )
+    )
     await db.commit()
 
     return {"message": "Alert resolved successfully"}
 
 
-@app.get("/api/v1/alerts/my", response_model=list[EmergencyAlertResponse])
+@app.get("/api/v1/alerts/my", response_model=List[EmergencyAlertResponse])
 async def get_my_alerts(
     current_user: User = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db),
-    limit: int = 50,
+    db: AsyncSession = Depends(get_db)
 ):
     """Get current user's emergency alerts"""
-
     result = await db.execute(
         select(EmergencyAlert)
         .filter(EmergencyAlert.user_id == current_user.id)
         .order_by(EmergencyAlert.created_at.desc())
-        .limit(limit)
     )
     alerts = result.scalars().all()
-
+    
     return [EmergencyAlertResponse.model_validate(alert) for alert in alerts]
 
 
-@app.get("/api/v1/alerts/active", response_model=list[EmergencyAlertResponse])
+@app.get("/api/v1/alerts/active", response_model=List[EmergencyAlertResponse])
 async def get_active_alerts(
     current_user: User = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db),
-    limit: int = 20,
+    db: AsyncSession = Depends(get_db)
 ):
-    """Get active alerts in user's area (last 2 hours)"""
-
-    # Get user's current location first
-    async with httpx.AsyncClient() as client:
-        try:
-            response = await client.get(
-                f"http://localhost:8003/api/v1/user-location/{current_user.id}",
-                timeout=5.0,
-            )
-            if response.status_code != 200:
-                raise HTTPException(
-                    status_code=400, detail="User location not available"
-                )
-            location_data = response.json()
-        except Exception:
-            raise HTTPException(status_code=400, detail="Location service unavailable")
-
-    # Get alerts from last 2 hours
-    two_hours_ago = datetime.utcnow() - timedelta(hours=2)
-
+    """Get active emergency alerts"""
     result = await db.execute(
         select(EmergencyAlert)
-        .filter(
-            EmergencyAlert.is_resolved == False,
-            EmergencyAlert.created_at >= two_hours_ago,
-        )
+        .filter(EmergencyAlert.is_resolved == False)
         .order_by(EmergencyAlert.created_at.desc())
-        .limit(limit)
+        .limit(50)
     )
     alerts = result.scalars().all()
+    
+    return [EmergencyAlertResponse.model_validate(alert) for alert in alerts]
 
+
+@app.get("/api/v1/emergency/reports", response_model=List[EmergencyAlertResponse])
+async def get_emergency_reports(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Get emergency reports/alerts for admin users or general statistics"""
+    # For now, return all active alerts (in production, add admin check)
+    result = await db.execute(
+        select(EmergencyAlert)
+        .filter(EmergencyAlert.is_resolved == False)
+        .order_by(EmergencyAlert.created_at.desc())
+        .limit(50)
+    )
+    alerts = result.scalars().all()
+    
     return [EmergencyAlertResponse.model_validate(alert) for alert in alerts]
 
 
 @app.get("/api/v1/stats", response_model=EmergencyStats)
 async def get_emergency_stats(
-    current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
 ):
-    """Get emergency service statistics"""
-
-    # Get total alerts
-    total_result = await db.execute(select(func.count(EmergencyAlert.id)))
-    total_alerts = total_result.scalar()
-
-    # Get active alerts
-    active_result = await db.execute(
-        select(func.count(EmergencyAlert.id)).filter(
-            EmergencyAlert.is_resolved == False
-        )
+    """Get emergency statistics"""
+    # Get total alerts count
+    total_alerts_result = await db.execute(select(func.count(EmergencyAlert.id)))
+    total_alerts = total_alerts_result.scalar() or 0
+    
+    # Get active alerts count  
+    active_alerts_result = await db.execute(
+        select(func.count(EmergencyAlert.id)).filter(EmergencyAlert.is_resolved == False)
     )
-    active_alerts = active_result.scalar()
-
-    # Get resolved alerts
+    active_alerts = active_alerts_result.scalar() or 0
+    
+    # Calculate resolved alerts
     resolved_alerts = total_alerts - active_alerts
-
-    # Get total responders
-    responders_result = await db.execute(
-        select(func.count(func.distinct(EmergencyResponse.responder_id)))
-    )
-    total_responders = responders_result.scalar()
+    
+    # Get total responders count
+    total_responders_result = await db.execute(select(func.count(EmergencyResponse.id)))
+    total_responders = total_responders_result.scalar() or 0
 
     return EmergencyStats(
         total_alerts=total_alerts,
@@ -322,13 +329,6 @@ async def get_emergency_stats(
     )
 
 
-@app.get("/api/v1/health")
-async def health_check():
-    """Health check endpoint"""
-    return {"status": "healthy", "service": "emergency-service"}
-
-
 if __name__ == "__main__":
     import uvicorn
-
-    uvicorn.run(app, host="0.0.0.0", port=8002)
+    uvicorn.run(app, host="0.0.0.0", port=8002)