sdf

services/emergency_service/main.py

@@ -1,25 +1,56 @@
 import asyncio
 from datetime import datetime, timedelta
-from typing import List
+from typing import List, Optional
+import math
 
 import httpx
-from fastapi import BackgroundTasks, Depends, FastAPI, HTTPException, status
+from fastapi import BackgroundTasks, Depends, FastAPI, HTTPException, Query, status
 from fastapi.middleware.cors import CORSMiddleware
-from sqlalchemy import func, select, update
+from sqlalchemy import func, select, update, desc, and_, or_
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from services.emergency_service.models import EmergencyAlert, EmergencyResponse
+from services.emergency_service.models import EmergencyAlert, EmergencyResponse, EmergencyReport, SafetyCheck
 from services.emergency_service.schemas import (
+    AlertStatus,
+    AlertType,
     EmergencyAlertCreate,
     EmergencyAlertResponse,
+    EmergencyAlertUpdate,
     EmergencyResponseCreate,
     EmergencyResponseResponse,
-    EmergencyStats,
+    EmergencyStatistics,
+    EmergencyReportCreate,
+    EmergencyReportResponse,
+    NearbyAlertResponse,
+    SafetyCheckCreate,
+    SafetyCheckResponse,
 )
-from services.user_service.models import User
+# Упрощенная модель User для Emergency Service 
+from sqlalchemy import Column, Integer, String, Boolean
+from shared.database import BaseModel
+
+class User(BaseModel):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+    is_active = Column(Boolean, default=True)
+
 from shared.auth import get_current_user_from_token
 from shared.config import settings
-from shared.database import get_db
+from shared.database import AsyncSessionLocal
+
+# Database dependency
+async def get_db():
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
 
 app = FastAPI(title="Emergency Service", version="1.0.0")
 
@@ -48,6 +79,21 @@ async def get_current_user(
     return user
 
 
+def calculate_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """Calculate distance between two points in kilometers using Haversine formula."""
+    # Convert latitude and longitude from degrees to radians
+    lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])
+    
+    # Haversine formula
+    dlat = lat2 - lat1
+    dlon = lon2 - lon1
+    a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
+    c = 2 * math.asin(math.sqrt(a))
+    
+    # Radius of earth in kilometers
+    r = 6371
+    return c * r
+
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""
@@ -176,7 +222,7 @@ async def respond_to_alert(
     existing_response = await db.execute(
         select(EmergencyResponse).filter(
             EmergencyResponse.alert_id == alert_id,
-            EmergencyResponse.user_id == current_user.id
+            EmergencyResponse.responder_id == current_user.id
         )
     )
     if existing_response.scalars().first():
@@ -188,7 +234,7 @@ async def respond_to_alert(
     # Create response
     db_response = EmergencyResponse(
         alert_id=alert_id,
-        user_id=current_user.id,
+        responder_id=current_user.id,
         response_type=response_data.response_type,
         message=response_data.message,
         eta_minutes=response_data.eta_minutes,
@@ -206,7 +252,12 @@ async def respond_to_alert(
     await db.commit()
     await db.refresh(db_response)
 
-    return EmergencyResponseResponse.model_validate(db_response)
+    # Create response with responder info
+    response_dict = db_response.__dict__.copy()
+    response_dict['responder_name'] = current_user.username
+    response_dict['responder_phone'] = getattr(current_user, 'phone_number', None)
+
+    return EmergencyResponseResponse.model_validate(response_dict)
 
 
 @app.put("/api/v1/alert/{alert_id}/resolve")
@@ -297,7 +348,7 @@ async def get_emergency_reports(
     return [EmergencyAlertResponse.model_validate(alert) for alert in alerts]
 
 
-@app.get("/api/v1/stats", response_model=EmergencyStats)
+@app.get("/api/v1/stats", response_model=EmergencyStatistics)
 async def get_emergency_stats(
     current_user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db)
@@ -320,15 +371,203 @@ async def get_emergency_stats(
     total_responders_result = await db.execute(select(func.count(EmergencyResponse.id)))
     total_responders = total_responders_result.scalar() or 0
 
-    return EmergencyStats(
+    return EmergencyStatistics(
         total_alerts=total_alerts,
         active_alerts=active_alerts,
         resolved_alerts=resolved_alerts,
-        avg_response_time_minutes=None,  # TODO: Calculate this
+        avg_response_time_minutes=0,  # TODO: Calculate this
         total_responders=total_responders,
     )
 
 
+@app.get("/api/v1/alerts/nearby", response_model=List[NearbyAlertResponse])
+async def get_nearby_alerts(
+    latitude: float = Query(..., ge=-90, le=90),
+    longitude: float = Query(..., ge=-180, le=180),
+    radius_km: float = Query(default=10.0, ge=0.1, le=100),
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Get nearby emergency alerts within specified radius"""
+    # For now, return all active alerts (in production, add distance filtering)
+    result = await db.execute(
+        select(EmergencyAlert)
+        .filter(EmergencyAlert.is_resolved == False)
+        .order_by(EmergencyAlert.created_at.desc())
+        .limit(20)
+    )
+    alerts = result.scalars().all()
+    
+    nearby_alerts = []
+    for alert in alerts:
+        distance = calculate_distance(latitude, longitude, alert.latitude, alert.longitude)
+        if distance <= radius_km:
+            nearby_alerts.append(NearbyAlertResponse(
+                id=alert.id,
+                alert_type=alert.alert_type,
+                latitude=alert.latitude,
+                longitude=alert.longitude,
+                address=alert.address,
+                distance_km=round(distance, 2),
+                created_at=alert.created_at,
+                responded_users_count=alert.responded_users_count or 0
+            ))
+    
+    return sorted(nearby_alerts, key=lambda x: x.distance_km)
+
+
+@app.post("/api/v1/report", response_model=EmergencyReportResponse)
+async def create_emergency_report(
+    report_data: EmergencyReportCreate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Create emergency report"""
+    db_report = EmergencyReport(
+        user_id=current_user.id if not report_data.is_anonymous else None,
+        latitude=report_data.latitude,
+        longitude=report_data.longitude,
+        address=report_data.address,
+        report_type=report_data.report_type,
+        description=report_data.description,
+        is_anonymous=report_data.is_anonymous,
+        severity=report_data.severity
+    )
+    
+    db.add(db_report)
+    await db.commit()
+    await db.refresh(db_report)
+    
+    return EmergencyReportResponse.model_validate(db_report)
+
+
+@app.get("/api/v1/reports", response_model=List[EmergencyReportResponse])
+async def get_emergency_reports(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Get emergency reports"""
+    result = await db.execute(
+        select(EmergencyReport)
+        .order_by(EmergencyReport.created_at.desc())
+        .limit(50)
+    )
+    reports = result.scalars().all()
+    
+    return [EmergencyReportResponse.model_validate(report) for report in reports]
+
+
+@app.post("/api/v1/safety-check", response_model=SafetyCheckResponse)
+async def create_safety_check(
+    check_data: SafetyCheckCreate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Create safety check-in"""
+    db_check = SafetyCheck(
+        user_id=current_user.id,
+        message=check_data.message,
+        location_latitude=check_data.location_latitude,
+        location_longitude=check_data.location_longitude
+    )
+    
+    db.add(db_check)
+    await db.commit()
+    await db.refresh(db_check)
+    
+    return SafetyCheckResponse.model_validate(db_check)
+
+
+@app.get("/api/v1/safety-checks", response_model=List[SafetyCheckResponse])
+async def get_safety_checks(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Get user's safety check-ins"""
+    result = await db.execute(
+        select(SafetyCheck)
+        .filter(SafetyCheck.user_id == current_user.id)
+        .order_by(SafetyCheck.created_at.desc())
+        .limit(50)
+    )
+    checks = result.scalars().all()
+    
+    return [SafetyCheckResponse.model_validate(check) for check in checks]
+
+
+@app.put("/api/v1/alert/{alert_id}", response_model=EmergencyAlertResponse)
+async def update_emergency_alert(
+    alert_id: int,
+    update_data: EmergencyAlertUpdate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Update emergency alert"""
+    result = await db.execute(select(EmergencyAlert).filter(EmergencyAlert.id == alert_id))
+    alert = result.scalars().first()
+    
+    if not alert:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Alert not found"
+        )
+
+    # Only alert creator can update
+    if alert.user_id != current_user.id:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only alert creator can update the alert"
+        )
+
+    # Update fields
+    update_dict = {}
+    if update_data.is_resolved is not None:
+        update_dict['is_resolved'] = update_data.is_resolved
+        if update_data.is_resolved:
+            update_dict['resolved_at'] = datetime.utcnow()
+            update_dict['resolved_by'] = current_user.id
+    
+    if update_data.message is not None:
+        update_dict['message'] = update_data.message
+
+    if update_dict:
+        await db.execute(
+            update(EmergencyAlert)
+            .where(EmergencyAlert.id == alert_id)
+            .values(**update_dict)
+        )
+        await db.commit()
+        await db.refresh(alert)
+
+    return EmergencyAlertResponse.model_validate(alert)
+
+
+@app.get("/api/v1/alert/{alert_id}/responses", response_model=List[EmergencyResponseResponse])
+async def get_alert_responses(
+    alert_id: int,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Get responses for specific alert"""
+    # Check if alert exists
+    result = await db.execute(select(EmergencyAlert).filter(EmergencyAlert.id == alert_id))
+    alert = result.scalars().first()
+    
+    if not alert:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Alert not found"
+        )
+
+    # Get responses
+    responses_result = await db.execute(
+        select(EmergencyResponse)
+        .filter(EmergencyResponse.alert_id == alert_id)
+        .order_by(EmergencyResponse.created_at.desc())
+    )
+    responses = responses_result.scalars().all()
+    
+    return [EmergencyResponseResponse.model_validate(response) for response in responses]
+
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8002)