initial-db-setup: Setup database connection and configuration

Backend/.env.example

@@ -0,0 +1,7 @@
+DATABASE_URL=
+SUPABASE_URL=
+SUPABASE_KEY=
+SUPABASE_JWT_SECRET=
+SUPABASE_BUCKET=
+GEMINI_API_KEY=
+FRONTEND_URL=

Backend/core/config.py

@@ -0,0 +1,83 @@
+from functools import lru_cache
+from pathlib import Path
+from typing import Optional
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import field_validator
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore"
+    )
+    
+    database_url: str
+    
+    supabase_url: str
+    supabase_key: str
+    supabase_jwt_secret: str
+    supabase_bucket: str = "city-issues"
+    
+    supabase_s3_endpoint: Optional[str] = None
+    supabase_s3_region: str = "ap-southeast-1"
+    supabase_s3_access_key: Optional[str] = None
+    supabase_s3_secret_key: Optional[str] = None
+    
+    model_path: Path = Path("Backend/agents/vision/model.pt")
+    model_confidence_threshold: float = 0.25
+    model_input_size: int = 512
+    
+    local_temp_dir: Path = Path("static/temp")
+    
+    sla_critical_hours: int = 4
+    sla_high_hours: int = 12
+    sla_medium_hours: int = 48
+    sla_low_hours: int = 168
+    
+    api_host: str = "0.0.0.0"
+    api_port: int = 8000
+    api_workers: int = 4
+    
+    max_upload_size_mb: int = 10
+    allowed_extensions: set[str] = {"jpg", "jpeg", "png", "webp"}
+    
+    duplicate_radius_meters: float = 50.0
+    
+    debug: bool = False
+    
+    resend_api_key: Optional[str] = None
+    google_client_id: Optional[str] = None
+    gemini_api_key: Optional[str] = None
+    google_client_secret: Optional[str] = None
+    project_id: Optional[str] = None
+    sender_email: str = "noreply@urbanlens.city"
+    admin_email: str = "admin@urbanlens.city"
+
+    frontend_url: Optional[str] = None
+    
+    cors_origins: list[str] = []
+    jwt_algorithm: str = "HS256"
+    jwt_expire_hours: int = 24
+    
+    @field_validator("database_url")
+    @classmethod
+    def validate_database_url(cls, v: str) -> str:
+        if not v.startswith("postgresql"):
+            raise ValueError("DATABASE_URL must be a PostgreSQL connection string")
+        return v
+    
+    @field_validator("supabase_jwt_secret")
+    @classmethod
+    def validate_jwt_secret(cls, v: str) -> str:
+        if len(v) < 32:
+            raise ValueError("SUPABASE_JWT_SECRET must be at least 32 characters")
+        return v
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()
+
+
+settings = get_settings()

Backend/core/schemas.py

@@ -0,0 +1,169 @@
+from datetime import datetime
+from enum import IntEnum, StrEnum
+from typing import Optional
+from uuid import UUID, uuid4
+from pydantic import BaseModel, Field, field_validator
+
+
+class IssueState(StrEnum):
+    REPORTED = "reported"
+    PENDING_CONFIRMATION = "pending_confirmation"
+    VALIDATED = "validated"
+    ASSIGNED = "assigned"
+    IN_PROGRESS = "in_progress"
+    PENDING_VERIFICATION = "pending_verification"
+    RESOLVED = "resolved"
+    VERIFIED = "verified"
+    CLOSED = "closed"
+    ESCALATED = "escalated"
+    REJECTED = "rejected"
+
+
+class PriorityLevel(IntEnum):
+    CRITICAL = 1
+    HIGH = 2
+    MEDIUM = 3
+    LOW = 4
+
+
+class IssueCategory(StrEnum):
+    DAMAGED_ROAD = "Damaged Road Issues"
+    POTHOLE = "Pothole Issues"
+    ILLEGAL_PARKING = "Illegal Parking Issues"
+    BROKEN_SIGN = "Broken Road Sign Issues"
+    FALLEN_TREE = "Fallen Trees"
+    GARBAGE = "Littering/Garbage on Public Places"
+    VANDALISM = "Vandalism Issues"
+    DEAD_ANIMAL = "Dead Animal Pollution"
+    DAMAGED_CONCRETE = "Damaged Concrete Structures"
+    DAMAGED_ELECTRIC = "Damaged Electric Wires and Poles"
+
+
+CLASS_ID_TO_CATEGORY = {
+    0: IssueCategory.DAMAGED_ROAD,
+    1: IssueCategory.POTHOLE,
+    2: IssueCategory.ILLEGAL_PARKING,
+    3: IssueCategory.BROKEN_SIGN,
+    4: IssueCategory.FALLEN_TREE,
+    5: IssueCategory.GARBAGE,
+    6: IssueCategory.VANDALISM,
+    7: IssueCategory.DEAD_ANIMAL,
+    8: IssueCategory.DAMAGED_CONCRETE,
+    9: IssueCategory.DAMAGED_ELECTRIC,
+}
+
+
+class Coordinates(BaseModel):
+    latitude: float = Field(..., ge=-90, le=90)
+    longitude: float = Field(..., ge=-180, le=180)
+    accuracy_meters: Optional[float] = Field(None, ge=0)
+
+
+class DeviceMetadata(BaseModel):
+    platform: str = Field(..., max_length=50)
+    device_model: Optional[str] = Field(None, max_length=100)
+    os_version: Optional[str] = Field(None, max_length=50)
+    app_version: Optional[str] = Field(None, max_length=20)
+
+
+class IssuePacket(BaseModel):
+    description: Optional[str] = Field(None, max_length=2000)
+    coordinates: Coordinates
+    device_metadata: DeviceMetadata
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    
+    @field_validator("description")
+    @classmethod
+    def clean_description(cls, v: Optional[str]) -> Optional[str]:
+        if v:
+            return v.strip()
+        return v
+
+
+class DetectionBox(BaseModel):
+    class_id: int
+    class_name: str
+    confidence: float = Field(..., ge=0, le=1)
+    bbox: tuple[float, float, float, float]
+
+
+class ClassificationResult(BaseModel):
+    issue_id: UUID
+    detections: list[DetectionBox]
+    primary_category: Optional[IssueCategory] = None
+    primary_confidence: float = 0.0
+    annotated_urls: list[str] = []
+    inference_time_ms: float
+    model_version: str = "1.0"
+    
+    def model_post_init(self, __context) -> None:
+        if self.detections and not self.primary_category:
+            best = max(self.detections, key=lambda d: d.confidence)
+            self.primary_category = CLASS_ID_TO_CATEGORY.get(best.class_id)
+            self.primary_confidence = best.confidence
+
+
+class IssueCreate(BaseModel):
+    description: Optional[str] = Field(None, max_length=2000)
+    latitude: float = Field(..., ge=-90, le=90)
+    longitude: float = Field(..., ge=-180, le=180)
+    accuracy_meters: Optional[float] = Field(None, ge=0)
+    platform: str = Field(..., max_length=50)
+    device_model: Optional[str] = Field(None, max_length=100)
+
+    @field_validator("description")
+    @classmethod
+    def clean_description(cls, v: Optional[str]) -> Optional[str]:
+        if v is None:
+            return None
+        cleaned = v.strip()
+        return cleaned or None
+
+
+class AgentOutput(BaseModel):
+    agent: str
+    decision: str
+    reasoning: Optional[str] = None
+    duration_ms: Optional[float] = None
+
+
+class IssueResponse(BaseModel):
+    id: UUID
+    description: Optional[str]
+    latitude: float
+    longitude: float
+    state: IssueState
+    priority: Optional[PriorityLevel]
+    priority_reason: Optional[str] = None
+    category: Optional[str]
+    confidence: Optional[float]
+    detections_count: Optional[int] = None
+    image_urls: list[str]
+    annotated_urls: list[str] = []
+    proof_image_url: Optional[str] = None
+    validation_source: Optional[str] = None
+    is_duplicate: bool = False
+    parent_issue_id: Optional[UUID] = None
+    nearby_count: Optional[int] = None
+    city: Optional[str] = None
+    locality: Optional[str] = None
+    full_address: Optional[str] = None
+    geo_status: Optional[str] = None
+    department: Optional[str] = None
+    assigned_member: Optional[str] = None
+    sla_hours: Optional[int] = None
+    sla_deadline: Optional[datetime] = None
+    agent_flow: list[AgentOutput] = []
+    created_at: datetime
+    updated_at: datetime
+    
+    class Config:
+        from_attributes = True
+
+
+class IssueListResponse(BaseModel):
+    items: list[IssueResponse]
+    total: int
+    page: int
+    page_size: int
+

Backend/database/connection.py

@@ -0,0 +1,57 @@
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.pool import NullPool
+
+from Backend.core.config import settings
+
+database_url = settings.database_url.replace("postgresql://", "postgresql+asyncpg://")
+
+engine = create_async_engine(
+    database_url,
+    poolclass=NullPool,
+    echo=False,
+    connect_args={
+        "statement_cache_size": 0,
+        "prepared_statement_cache_size": 0,
+    },
+)
+
+async_session_factory = async_sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autocommit=False,
+    autoflush=False,
+)
+
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_factory() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+
+
+@asynccontextmanager
+async def get_db_context() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_factory() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+
+
+async def init_db() -> None:
+    from Backend.database.models import Base
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def close_db() -> None:
+    await engine.dispose()