deploy: initial backend API to Tataaicoltd/api

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Copy backend only (no admin frontend)
+COPY backend/ ./backend/
+
+# Install dependencies
+RUN pip install --no-cache-dir -r backend/requirements.txt
+
+EXPOSE 7860
+
+# Run from backend dir so relative imports resolve correctly
+WORKDIR /app/backend
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

backend/config.py

@@ -0,0 +1,18 @@
+import os
+from pydantic_settings import BaseSettings
+from supabase import create_client, Client
+
+
+class Settings(BaseSettings):
+    supabase_url: str
+    supabase_key: str
+    admin_api_key: str
+
+    class Config:
+        env_file = "../.env"
+
+
+settings = Settings()
+
+# Initialize Supabase client
+supabase: Client = create_client(settings.supabase_url, settings.supabase_key)

backend/main.py

@@ -0,0 +1,505 @@
+import sys
+import os
+
+# Add backend directory to path to import modules
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from fastapi import FastAPI, HTTPException, Query, Body
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse
+from typing import Optional, List
+import logging
+
+from config import supabase, settings
+from models import (
+    Category, CategoryCreate, CategoryUpdate,
+    Intent, IntentCreate, IntentUpdate, IntentWithCategory,
+    City, CityCreate, CityUpdate,
+    District, DistrictCreate, DistrictUpdate,
+    Street, StreetCreate, StreetUpdate,
+    Position, PositionCreate, PositionUpdate,
+)
+from services.category_service import CategoryService
+from services.intent_service import IntentService
+from services.maps_service import MapsService
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create FastAPI app
+app = FastAPI(
+    title="Admin Dashboard API",
+    description="CRUD API for managing categories and intents",
+    version="1.0.0"
+)
+
+# API Key authentication middleware
+class APIKeyMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        path = request.url.path
+        if path.startswith('/api/') and path != '/api/auth/verify':
+            api_key = request.headers.get('X-API-Key', '')
+            if api_key != settings.admin_api_key:
+                return JSONResponse({"detail": "Unauthorized"}, status_code=401)
+        return await call_next(request)
+
+app.add_middleware(APIKeyMiddleware)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Auth verify endpoint (no key required)
+@app.post("/api/auth/verify")
+async def verify_api_key(body: dict = Body(...)):
+    key = body.get("key", "")
+    return {"valid": key == settings.admin_api_key}
+
+
+# Map images listing
+@app.get("/api/map-images")
+async def get_map_images():
+    images_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'admin', 'images')
+    try:
+        files = [f for f in os.listdir(images_dir) if f.lower().endswith(('.jpg', '.jpeg', '.png', '.webp'))]
+        files.sort(key=lambda x: int(x.rsplit('.', 1)[0].split('_')[-1]) if x.rsplit('.', 1)[0].split('_')[-1].isdigit() else 0)
+        return {"images": [f"images/{f}" for f in files]}
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Images directory not found")
+
+
+# Health check
+@app.get("/api/health")
+async def health_check():
+    """Health check endpoint"""
+    try:
+        # Test Supabase connection by fetching one record
+        result = supabase.table("Categories").select("id").limit(1).execute()
+        return {"status": "ok", "database": "connected"}
+    except Exception as e:
+        logger.error(f"Health check failed: {str(e)}")
+        raise HTTPException(status_code=500, detail="Database connection failed")
+
+
+# ==================== CATEGORIES ENDPOINTS ====================
+
+@app.get("/api/categories", response_model=List[Category])
+async def list_categories(search: Optional[str] = Query(None)):
+    """Get all categories with optional search"""
+    try:
+        categories = await CategoryService.get_all_categories(search)
+        return categories
+    except Exception as e:
+        logger.error(f"Error fetching categories: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/categories/{category_id}", response_model=Category)
+async def get_category(category_id: int):
+    """Get a single category by id"""
+    try:
+        category = await CategoryService.get_category_by_id(category_id)
+        if not category:
+            raise HTTPException(status_code=404, detail="Category not found")
+        return category
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching category: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/categories", response_model=Category)
+async def create_category(category: CategoryCreate):
+    """Create a new category"""
+    try:
+        new_category = await CategoryService.create_category(category)
+        return new_category
+    except Exception as e:
+        logger.error(f"Error creating category: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/api/categories/{category_id}", response_model=Category)
+async def update_category(category_id: int, category: CategoryUpdate):
+    """Update an existing category"""
+    try:
+        updated = await CategoryService.update_category(category_id, category)
+        return updated
+    except Exception as e:
+        logger.error(f"Error updating category: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/api/categories/{category_id}")
+async def delete_category(category_id: int):
+    """Delete a category"""
+    try:
+        await CategoryService.delete_category(category_id)
+        return {"message": "Category deleted successfully"}
+    except Exception as e:
+        logger.error(f"Error deleting category: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== INTENTS ENDPOINTS ====================
+
+@app.get("/api/intents", response_model=List[IntentWithCategory])
+async def list_intents(
+    search: Optional[str] = Query(None),
+    category_id: Optional[int] = Query(None),
+    priority: Optional[str] = Query(None)
+):
+    """Get all intents with optional filters"""
+    try:
+        intents = await IntentService.get_all_intents(search, category_id, priority)
+        return intents
+    except Exception as e:
+        logger.error(f"Error fetching intents: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/intents/{intent_id}", response_model=IntentWithCategory)
+async def get_intent(intent_id: int):
+    """Get a single intent by ID"""
+    try:
+        intent = await IntentService.get_intent_by_id(intent_id)
+        if not intent:
+            raise HTTPException(status_code=404, detail="Intent not found")
+        return intent
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching intent: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/categories/{category_id}/intents", response_model=List[IntentWithCategory])
+async def get_intents_by_category(category_id: int):
+    """Get all intents for a specific category"""
+    try:
+        intents = await IntentService.get_intents_by_category(category_id)
+        return intents
+    except Exception as e:
+        logger.error(f"Error fetching intents for category: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/intents", response_model=IntentWithCategory)
+async def create_intent(intent: IntentCreate):
+    """Create a new intent"""
+    try:
+        new_intent = await IntentService.create_intent(intent)
+        return new_intent
+    except Exception as e:
+        logger.error(f"Error creating intent: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/api/intents/{intent_id}", response_model=IntentWithCategory)
+async def update_intent(intent_id: int, intent: IntentUpdate):
+    """Update an existing intent"""
+    try:
+        updated = await IntentService.update_intent(intent_id, intent)
+        return updated
+    except Exception as e:
+        logger.error(f"Error updating intent: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/api/intents/{intent_id}")
+async def delete_intent(intent_id: int):
+    """Delete an intent"""
+    try:
+        await IntentService.delete_intent(intent_id)
+        return {"message": "Intent deleted successfully"}
+    except Exception as e:
+        logger.error(f"Error deleting intent: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== MAPS ENDPOINTS ====================
+
+@app.get("/api/cities", response_model=List[City])
+async def list_cities():
+    """Get all cities"""
+    try:
+        return await MapsService.get_all_cities()
+    except Exception as e:
+        logger.error(f"Error fetching cities: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/cities", response_model=City)
+async def create_city(city: CityCreate):
+    """Create a new city"""
+    try:
+        return await MapsService.create_city(city)
+    except Exception as e:
+        logger.error(f"Error creating city: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/cities/{city_id}", response_model=City)
+async def get_city(city_id: int):
+    try:
+        city = await MapsService.get_city_by_id(city_id)
+        if not city:
+            raise HTTPException(status_code=404, detail="City not found")
+        return city
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/api/cities/{city_id}", response_model=City)
+async def update_city(city_id: int, city: CityUpdate):
+    try:
+        return await MapsService.update_city(city_id, city)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/api/cities/{city_id}")
+async def delete_city(city_id: int):
+    try:
+        await MapsService.delete_city(city_id)
+        return {"message": "City deleted"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/districts", response_model=List[District])
+async def list_districts(city_id: Optional[int] = Query(None)):
+    """Get districts, optionally filtered by city_id"""
+    try:
+        return await MapsService.get_districts(city_id)
+    except Exception as e:
+        logger.error(f"Error fetching districts: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/districts", response_model=District)
+async def create_district(district: DistrictCreate):
+    """Create a new district"""
+    try:
+        return await MapsService.create_district(district)
+    except Exception as e:
+        logger.error(f"Error creating district: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/districts/{district_id}", response_model=District)
+async def get_district(district_id: int):
+    try:
+        district = await MapsService.get_district_by_id(district_id)
+        if not district:
+            raise HTTPException(status_code=404, detail="District not found")
+        return district
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/api/districts/{district_id}", response_model=District)
+async def update_district(district_id: int, district: DistrictUpdate):
+    try:
+        return await MapsService.update_district(district_id, district)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/api/districts/{district_id}")
+async def delete_district(district_id: int):
+    try:
+        await MapsService.delete_district(district_id)
+        return {"message": "District deleted"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/streets", response_model=List[Street])
+async def list_streets(
+    district_id: Optional[int] = Query(None),
+    city_id: Optional[int] = Query(None)
+):
+    """Get streets, optionally filtered by district_id or city_id"""
+    try:
+        return await MapsService.get_streets(district_id, city_id)
+    except Exception as e:
+        logger.error(f"Error fetching streets: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/streets/search")
+async def search_streets(payload: dict = Body(...)):
+    """Search streets by text.
+    Payload: { text: str, district_id?: int, city_id?: int, limit?: int }
+    Returns list of matches with score.
+    """
+    try:
+        text = payload.get('text')
+        if not text:
+            raise HTTPException(status_code=422, detail='text is required')
+        district_id = payload.get('district_id')
+        city_id = payload.get('city_id')
+        limit = int(payload.get('limit') or 10)
+        results = await MapsService.search_streets_by_text(text, district_id=district_id, city_id=city_id, limit=limit)
+        return { 'results': results }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error searching streets: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/streets", response_model=Street)
+async def create_street(street: StreetCreate):
+    """Create a new street"""
+    try:
+        return await MapsService.create_street(street)
+    except Exception as e:
+        logger.error(f"Error creating street: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/streets/{street_id}", response_model=Street)
+async def get_street(street_id: int):
+    try:
+        street = await MapsService.get_street_by_id(street_id)
+        if not street:
+            raise HTTPException(status_code=404, detail="Street not found")
+        return street
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/api/streets/{street_id}", response_model=Street)
+async def update_street(street_id: int, street: StreetUpdate):
+    try:
+        return await MapsService.update_street(street_id, street)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/api/streets/{street_id}")
+async def delete_street(street_id: int):
+    try:
+        await MapsService.delete_street(street_id)
+        return {"message": "Street deleted"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== POSITIONS ENDPOINTS ====================
+
+@app.get("/api/positions", response_model=List[Position])
+async def list_positions(street_id: Optional[int] = Query(None)):
+    try:
+        return await MapsService.get_positions(street_id)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/positions/{position_id}", response_model=Position)
+async def get_position(position_id: int):
+    try:
+        pos = await MapsService.get_position_by_id(position_id)
+        if not pos:
+            raise HTTPException(status_code=404, detail="Position not found")
+        return pos
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/positions", response_model=Position)
+async def create_position(position: PositionCreate):
+    try:
+        return await MapsService.create_position(position)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/positions/bulk")
+async def create_positions_bulk(payload: List[dict] = Body(...)):
+    """Accepts a flat array of unique positions and upserts them.
+    Expected payload: [{lat, lon, streets: [street_id, ...], pos_id?}, ...]
+    pos_id present → UPDATE; absent → INSERT.
+    """
+    try:
+        created = await MapsService.create_positions_bulk(payload)
+        return {"created": created}
+    except Exception as e:
+        logger.error(f"Error creating positions bulk: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/api/positions/{position_id}", response_model=Position)
+async def update_position(position_id: int, position: PositionUpdate):
+    try:
+        return await MapsService.update_position(position_id, position)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/api/positions/{position_id}")
+async def delete_position(position_id: int):
+    try:
+        await MapsService.delete_position(position_id)
+        return {"message": "Position deleted"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/api/positions/{position_id}/cascade")
+async def delete_position_cascade(position_id: int):
+    try:
+        await MapsService.delete_position_cascade(position_id)
+        return {"message": "Position deleted and Streets updated"}
+    except Exception as e:
+        logger.error(f"Error deleting position cascade: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/search")
+async def search_nearest(payload: dict = Body(...)):
+    """Find the nearest DB position for each query point.
+    Expected: {points: [{lat, lon}, ...]}  (1 or 2 points)
+    Returns:  {data, label, warning, message}
+    """
+    try:
+        points = payload.get("points") or []
+        if not points:
+            raise HTTPException(status_code=422, detail="points array is required")
+        return await MapsService.search_nearest(points)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error searching nearest: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# Serve admin static files (must be mounted last, after all API routes)
+_admin_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'admin')
+if os.path.isdir(_admin_dir):
+    app.mount("/", StaticFiles(directory=_admin_dir, html=True), name="admin")
+
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=4000, log_level="info")

backend/models.py

@@ -0,0 +1,167 @@
+from pydantic import BaseModel
+from typing import Optional, List, Union
+
+
+class CategoryBase(BaseModel):
+    label: str
+
+
+class Category(CategoryBase):
+    id: Optional[int] = None
+    embedding: Optional[str] = None
+    created_at: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+
+class CategoryCreate(CategoryBase):
+    pass
+
+
+class CategoryUpdate(BaseModel):
+    label: Optional[str] = None
+    embedding: Optional[str] = None
+
+
+class IntentBase(BaseModel):
+    name: str
+    priority: Union[int, str]
+    category_id: int
+
+
+class Intent(IntentBase):
+    id: Optional[int] = None
+    embedding: Optional[str] = None
+    created_at: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+
+class IntentCreate(IntentBase):
+    pass
+
+
+class IntentUpdate(BaseModel):
+    name: Optional[str] = None
+    priority: Optional[Union[int, str]] = None
+    category_id: Optional[int] = None
+    embedding: Optional[str] = None
+
+
+class IntentWithCategory(Intent):
+    category_label: Optional[str] = None
+
+
+# ==================== MAPS MODELS ====================
+
+class City(BaseModel):
+    id: Optional[int] = None
+    name: Optional[str] = None
+    created_at: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+
+class CityCreate(BaseModel):
+    name: str
+
+
+class District(BaseModel):
+    id: Optional[int] = None
+    name: Optional[str] = None
+    lname: Optional[str] = None
+    city: Optional[int] = None
+    created_at: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+
+class DistrictCreate(BaseModel):
+    name: str
+    lname: Optional[str] = None
+    city: int
+
+
+class Street(BaseModel):
+    id: Optional[int] = None
+    name: Optional[str] = None
+    type: Optional[str] = None
+    district_id: Optional[int] = None
+    city_id: Optional[int] = None
+    positions: Optional[list] = None
+    created_at: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+
+class StreetCreate(BaseModel):
+    name: str
+    type: Optional[str] = None
+    district_id: int
+    city_id: int
+
+
+class CityUpdate(BaseModel):
+    name: Optional[str] = None
+
+
+class DistrictUpdate(BaseModel):
+    name: Optional[str] = None
+    lname: Optional[str] = None
+    city: Optional[int] = None
+
+
+class StreetUpdate(BaseModel):
+    name: Optional[str] = None
+    type: Optional[str] = None
+    district_id: Optional[int] = None
+    city_id: Optional[int] = None
+
+
+# ==================== POSITIONS MODEL ====================
+
+class Position(BaseModel):
+    id: Optional[int] = None
+    street_id: Optional[int] = None
+    x: Optional[float] = None
+    y: Optional[float] = None
+    streets: Optional[list] = None
+    ban: Optional[list] = None
+    speed: Optional[dict] = None
+    park: Optional[bool] = None
+    lane: Optional[int] = None
+    tool: Optional[int] = None
+    flooding: Optional[bool] = None
+    created_at: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+
+class PositionCreate(BaseModel):
+    street_id: int
+    x: float
+    y: float
+    ban: Optional[list] = None
+    speed: Optional[dict] = None
+    park: Optional[bool] = None
+    lane: Optional[int] = None
+    tool: Optional[int] = None
+    flooding: Optional[bool] = None
+
+
+class PositionUpdate(BaseModel):
+    street_id: Optional[int] = None
+    x: Optional[float] = None
+    y: Optional[float] = None
+    ban: Optional[list] = None
+    speed: Optional[dict] = None
+    park: Optional[bool] = None
+    lane: Optional[int] = None
+    tool: Optional[int] = None
+    flooding: Optional[bool] = None

backend/requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-dotenv==1.0.0
+supabase==2.9.1
+pydantic==2.5.0
+pydantic-settings==2.1.0
+httpx==0.27.2

backend/services/__init__.py

@@ -0,0 +1 @@
+# Services init

backend/services/category_service.py

@@ -0,0 +1,62 @@
+from config import supabase
+from models import Category, CategoryCreate, CategoryUpdate
+from typing import List, Optional
+
+
+class CategoryService:
+    @staticmethod
+    async def get_all_categories(search: Optional[str] = None) -> List[Category]:
+        """Get all categories, optionally filtered by search term"""
+        try:
+            query = supabase.table("Categories").select("*")
+
+            if search:
+                query = query.ilike("label", f"%{search}%")
+
+            result = query.execute()
+            return [Category(**item) for item in result.data]
+        except Exception as e:
+            raise Exception(f"Failed to fetch categories: {str(e)}")
+
+    @staticmethod
+    async def get_category_by_id(category_id: int) -> Optional[Category]:
+        """Get a single category by id"""
+        try:
+            result = supabase.table("Categories").select("*").eq("id", category_id).execute()
+            if result.data:
+                return Category(**result.data[0])
+            return None
+        except Exception as e:
+            raise Exception(f"Failed to fetch category: {str(e)}")
+
+    @staticmethod
+    async def create_category(category: CategoryCreate) -> Category:
+        """Create a new category"""
+        try:
+            result = supabase.table("Categories").insert(category.dict()).execute()
+            if result.data:
+                return Category(**result.data[0])
+            raise Exception("Failed to create category")
+        except Exception as e:
+            raise Exception(f"Failed to create category: {str(e)}")
+
+    @staticmethod
+    async def update_category(category_id: int, category: CategoryUpdate) -> Category:
+        """Update an existing category"""
+        try:
+            update_data = category.dict(exclude_unset=True)
+            result = supabase.table("Categories").update(update_data).eq("id", category_id).execute()
+            if result.data:
+                return Category(**result.data[0])
+            raise Exception("Category not found")
+        except Exception as e:
+            raise Exception(f"Failed to update category: {str(e)}")
+
+    @staticmethod
+    async def delete_category(category_id: int) -> bool:
+        """Delete a category"""
+        try:
+            result = supabase.table("Categories").delete().eq("id", category_id).execute()
+            return True
+        except Exception as e:
+            raise Exception(f"Failed to delete category: {str(e)}")

backend/services/intent_service.py

@@ -0,0 +1,121 @@
+from config import supabase
+from models import Intent, IntentCreate, IntentUpdate, IntentWithCategory
+from typing import List, Optional
+
+
+class IntentService:
+    @staticmethod
+    async def get_all_intents(
+        search: Optional[str] = None,
+        category_id: Optional[int] = None,
+        priority: Optional[str] = None
+    ) -> List[IntentWithCategory]:
+        """Get all intents with optional filters"""
+        try:
+            query = supabase.table("Intents").select("*, Categories(label)")
+
+            if search:
+                query = query.ilike("name", f"%{search}%")
+
+            if category_id:
+                query = query.eq("category_id", category_id)
+
+            if priority:
+                query = query.eq("priority", priority)
+
+            result = query.execute()
+            intents = []
+            for item in result.data:
+                # Flatten nested category data
+                if "Categories" in item and item["Categories"]:
+                    item["category_label"] = item["Categories"].get("label")
+                else:
+                    item["category_label"] = None
+                
+                # Remove nested Categories key before creating model
+                item.pop("Categories", None)
+                
+                intent = IntentWithCategory(**item)
+                intents.append(intent)
+            return intents
+        except Exception as e:
+            raise Exception(f"Failed to fetch intents: {str(e)}")
+
+    @staticmethod
+    async def get_intent_by_id(intent_id: int) -> Optional[IntentWithCategory]:
+        """Get a single intent by ID"""
+        try:
+            result = supabase.table("Intents").select("*, Categories(label)").eq("id", intent_id).execute()
+            if result.data:
+                item = result.data[0]
+                
+                # Flatten nested category data
+                if "Categories" in item and item["Categories"]:
+                    item["category_label"] = item["Categories"].get("label")
+                else:
+                    item["category_label"] = None
+                
+                # Remove nested Categories key before creating model
+                item.pop("Categories", None)
+                
+                intent = IntentWithCategory(**item)
+                return intent
+            return None
+        except Exception as e:
+            raise Exception(f"Failed to fetch intent: {str(e)}")
+
+    @staticmethod
+    async def get_intents_by_category(category_id: int) -> List[IntentWithCategory]:
+        """Get all intents for a specific category"""
+        try:
+            result = supabase.table("Intents").select("*, Categories(label)").eq("category_id", category_id).execute()
+            intents = []
+            for item in result.data:
+                # Flatten nested category data
+                if "Categories" in item and item["Categories"]:
+                    item["category_label"] = item["Categories"].get("label")
+                else:
+                    item["category_label"] = None
+                
+                # Remove nested Categories key before creating model
+                item.pop("Categories", None)
+                
+                intent = IntentWithCategory(**item)
+                intents.append(intent)
+            return intents
+        except Exception as e:
+            raise Exception(f"Failed to fetch intents for category: {str(e)}")
+
+    @staticmethod
+    async def create_intent(intent: IntentCreate) -> IntentWithCategory:
+        """Create a new intent"""
+        try:
+            result = supabase.table("Intents").insert(intent.dict()).execute()
+            if result.data:
+                item = result.data[0]
+                return IntentWithCategory(**item)
+            raise Exception("Failed to create intent")
+        except Exception as e:
+            raise Exception(f"Failed to create intent: {str(e)}")
+
+    @staticmethod
+    async def update_intent(intent_id: int, intent: IntentUpdate) -> IntentWithCategory:
+        """Update an existing intent"""
+        try:
+            update_data = intent.dict(exclude_unset=True)
+            result = supabase.table("Intents").update(update_data).eq("id", intent_id).execute()
+            if result.data:
+                item = result.data[0]
+                return IntentWithCategory(**item)
+            raise Exception("Intent not found")
+        except Exception as e:
+            raise Exception(f"Failed to update intent: {str(e)}")
+
+    @staticmethod
+    async def delete_intent(intent_id: int) -> bool:
+        """Delete an intent"""
+        try:
+            result = supabase.table("Intents").delete().eq("id", intent_id).execute()
+            return True
+        except Exception as e:
+            raise Exception(f"Failed to delete intent: {str(e)}")

backend/services/maps_service.py

@@ -0,0 +1,758 @@
+from config import supabase
+from models import (
+    City, CityCreate, CityUpdate,
+    District, DistrictCreate, DistrictUpdate,
+    Street, StreetCreate, StreetUpdate,
+    Position, PositionCreate, PositionUpdate,
+)
+from typing import List, Optional
+import unicodedata
+
+
+def _next_id(table: str, id_col: str = "id") -> int:
+    """Get max(id) + 1 from a table to avoid identity sequence conflicts."""
+    result = supabase.table(table).select(id_col).order(id_col, desc=True).limit(1).execute()
+    max_id = result.data[0][id_col] if result.data else 0
+    return max_id + 1
+
+
+class MapsService:
+    @staticmethod
+    def _db_pos_to_model(item: dict) -> dict:
+        if not item:
+            return {}
+        return {
+            'id': item.get('id'),
+            'x': item.get('long'),
+            'y': item.get('lat'),
+            'ban': item.get('ban'),
+            'speed': item.get('speed'),
+            'park': item.get('park'),
+            'lane': item.get('lane'),
+            'tool': item.get('tool'),
+            'flooding': item.get('flooding'),
+            'streets': item.get('streets'),
+            'created_at': item.get('created_at')
+        }
+    @staticmethod
+    async def get_all_cities() -> List[City]:
+        try:
+            result = supabase.table("Cities").select("id, name").order("name").execute()
+            return [City(**item) for item in result.data]
+        except Exception as e:
+            raise Exception(f"Failed to fetch cities: {str(e)}")
+
+    @staticmethod
+    async def create_city(data: CityCreate) -> City:
+        try:
+            next_id = _next_id("Cities")
+            result = supabase.table("Cities").insert({"id": next_id, "name": data.name}).execute()
+            return City(**result.data[0])
+        except Exception as e:
+            raise Exception(f"Failed to create city: {str(e)}")
+
+    @staticmethod
+    async def get_city_by_id(city_id: int) -> Optional[City]:
+        try:
+            result = supabase.table("Cities").select("id, name").eq("id", city_id).execute()
+            return City(**result.data[0]) if result.data else None
+        except Exception as e:
+            raise Exception(f"Failed to fetch city: {str(e)}")
+
+    @staticmethod
+    async def update_city(city_id: int, data: CityUpdate) -> City:
+        try:
+            payload = {k: v for k, v in data.model_dump().items() if v is not None}
+            result = supabase.table("Cities").update(payload).eq("id", city_id).execute()
+            return City(**result.data[0])
+        except Exception as e:
+            raise Exception(f"Failed to update city: {str(e)}")
+
+    @staticmethod
+    async def delete_city(city_id: int) -> bool:
+        try:
+            supabase.table("Cities").delete().eq("id", city_id).execute()
+            return True
+        except Exception as e:
+            raise Exception(f"Failed to delete city: {str(e)}")
+
+    @staticmethod
+    async def get_districts(city_id: Optional[int] = None) -> List[District]:
+        try:
+            query = supabase.table("Districts").select("id, name, lname, city").order("name")
+            if city_id is not None:
+                query = query.eq("city", city_id)
+            result = query.execute()
+            return [District(**item) for item in result.data]
+        except Exception as e:
+            raise Exception(f"Failed to fetch districts: {str(e)}")
+
+    @staticmethod
+    async def create_district(data: DistrictCreate) -> District:
+        try:
+            next_id = _next_id("Districts")
+            payload = {"id": next_id, "name": data.name, "city": data.city}
+            if data.lname:
+                payload["lname"] = data.lname
+            result = supabase.table("Districts").insert(payload).execute()
+            return District(**result.data[0])
+        except Exception as e:
+            raise Exception(f"Failed to create district: {str(e)}")
+
+    @staticmethod
+    async def get_district_by_id(district_id: int) -> Optional[District]:
+        try:
+            result = supabase.table("Districts").select("id, name, lname, city").eq("id", district_id).execute()
+            return District(**result.data[0]) if result.data else None
+        except Exception as e:
+            raise Exception(f"Failed to fetch district: {str(e)}")
+
+    @staticmethod
+    async def update_district(district_id: int, data: DistrictUpdate) -> District:
+        try:
+            payload = {k: v for k, v in data.model_dump().items() if v is not None}
+            result = supabase.table("Districts").update(payload).eq("id", district_id).execute()
+            return District(**result.data[0])
+        except Exception as e:
+            raise Exception(f"Failed to update district: {str(e)}")
+
+    @staticmethod
+    async def delete_district(district_id: int) -> bool:
+        try:
+            supabase.table("Districts").delete().eq("id", district_id).execute()
+            return True
+        except Exception as e:
+            raise Exception(f"Failed to delete district: {str(e)}")
+
+    @staticmethod
+    async def get_streets(district_id: Optional[int] = None, city_id: Optional[int] = None) -> List[Street]:
+        try:
+            query = supabase.table("Streets").select("id, name, type, district_id, city_id").order("name")
+            if district_id is not None:
+                query = query.eq("district_id", district_id)
+            elif city_id is not None:
+                query = query.eq("city_id", city_id)
+            result = query.execute()
+            return [Street(**item) for item in result.data]
+        except Exception as e:
+            raise Exception(f"Failed to fetch streets: {str(e)}")
+
+    @staticmethod
+    async def create_street(data: StreetCreate) -> Street:
+        try:
+            # Normalize helper (remove diacritics, lower, collapse whitespace)
+            import re
+
+            def _normalize(s: str) -> str:
+                if not s:
+                    return ''
+                s = str(s).strip().lower()
+                # NFKD to decompose accents, then remove combining marks
+                s = unicodedata.normalize('NFKD', s)
+                s = ''.join(ch for ch in s if not unicodedata.combining(ch))
+                # remove punctuation, keep letters/numbers and spaces
+                s = re.sub(r'[^0-9a-z\s]', ' ', s)
+                s = ' '.join(s.split())
+                return s
+
+            def _levenshtein(a: str, b: str) -> int:
+                # simple iterative DP
+                if a == b:
+                    return 0
+                if len(a) == 0:
+                    return len(b)
+                if len(b) == 0:
+                    return len(a)
+                prev = list(range(len(b) + 1))
+                for i, ca in enumerate(a, start=1):
+                    curr = [i]
+                    for j, cb in enumerate(b, start=1):
+                        insert_cost = curr[j-1] + 1
+                        delete_cost = prev[j] + 1
+                        replace_cost = prev[j-1] + (0 if ca == cb else 1)
+                        curr.append(min(insert_cost, delete_cost, replace_cost))
+                    prev = curr
+                return prev[-1]
+
+            name_norm = _normalize(data.name)
+            city_id = data.city_id
+            district_id = data.district_id
+
+            # Fetch candidate existing streets in same district or city
+            query = supabase.table("Streets").select("id, name, district_id, city_id").order("name")
+            if district_id is not None:
+                query = query.eq("district_id", district_id)
+            elif city_id is not None:
+                query = query.eq("city_id", city_id)
+            existing_res = query.execute()
+            existing_list = existing_res.data or []
+            for item in existing_list:
+                existing_name = item.get('name') or ''
+                en_norm = _normalize(existing_name)
+                # exact or containment
+                if en_norm == name_norm or (name_norm and en_norm and (name_norm in en_norm or en_norm in name_norm)):
+                    raise Exception(f"Similar street exists: {existing_name} (id={item.get('id')})")
+                # small edit distance -> likely duplicate; threshold scales with length
+                max_dist = max(2, int(max(len(en_norm), len(name_norm)) * 0.2))
+                dist = _levenshtein(en_norm, name_norm)
+                # debug log
+                try:
+                    import logging
+                    logging.getLogger(__name__).info(f"create_street: compare '{name_norm}' vs '{en_norm}' -> dist={dist} threshold={max_dist}")
+                except Exception:
+                    pass
+                if dist <= max_dist:
+                    raise Exception(f"Similar street exists: {existing_name} (id={item.get('id')})")
+
+            # Also perform a global fuzzy search to catch similar names in other districts/cities
+            try:
+                global_results = await MapsService.search_streets_by_text(data.name, district_id=None, city_id=None, limit=10)
+                # Accept if any match has a low score (<= 0.15)
+                for r in (global_results or []):
+                    if float(r.get('score', 1.0)) <= 0.15:
+                        raise Exception(f"Similar street exists elsewhere: {r.get('name')} (id={r.get('id')})")
+            except Exception as e:
+                # If search_streets_by_text raised an exception because of DB, re-raise as generic
+                if str(e).startswith('Failed to create street'):
+                    raise
+                # If we raised above due to similarity, pass it up
+                if 'Similar street exists' in str(e) or 'Similar street exists elsewhere' in str(e):
+                    raise
+                # otherwise ignore search errors and proceed with insert
+                pass
+
+            # No similar found -> proceed to insert
+            next_id = _next_id("Streets")
+            payload = {"id": next_id, "name": data.name, "district_id": data.district_id, "city_id": data.city_id}
+            if data.type:
+                payload["type"] = data.type
+            result = supabase.table("Streets").insert(payload).execute()
+            return Street(**result.data[0])
+        except Exception as e:
+            raise Exception(f"Failed to create street: {str(e)}")
+
+    @staticmethod
+    async def get_street_by_id(street_id: int) -> Optional[Street]:
+        try:
+            result = supabase.table("Streets").select("id, name, type, district_id, city_id").eq("id", street_id).execute()
+            return Street(**result.data[0]) if result.data else None
+        except Exception as e:
+            raise Exception(f"Failed to fetch street: {str(e)}")
+
+    @staticmethod
+    async def update_street(street_id: int, data: StreetUpdate) -> Street:
+        try:
+            payload = {k: v for k, v in data.model_dump().items() if v is not None}
+            result = supabase.table("Streets").update(payload).eq("id", street_id).execute()
+            return Street(**result.data[0])
+        except Exception as e:
+            raise Exception(f"Failed to update street: {str(e)}")
+
+    @staticmethod
+    async def delete_street(street_id: int) -> bool:
+        try:
+            supabase.table("Streets").delete().eq("id", street_id).execute()
+            return True
+        except Exception as e:
+            raise Exception(f"Failed to delete street: {str(e)}")
+
+    @staticmethod
+    async def search_streets_by_text(text: str, district_id: Optional[int] = None, city_id: Optional[int] = None, limit: int = 10) -> list:
+        """Search streets by text with normalization and fuzzy matching.
+        Returns list of dicts: {id, name, type, district_id, city_id, score}
+        Lower score == better match.
+        """
+        try:
+            if not text or not str(text).strip():
+                return []
+            import re
+            def _normalize(s: str) -> str:
+                s = str(s or '').strip().lower()
+                s = unicodedata.normalize('NFKD', s)
+                s = ''.join(ch for ch in s if not unicodedata.combining(ch))
+                s = re.sub(r'[^0-9a-z\s]', ' ', s)
+                s = ' '.join(s.split())
+                return s
+
+            def _lev(a: str, b: str) -> int:
+                if a == b:
+                    return 0
+                if len(a) == 0:
+                    return len(b)
+                if len(b) == 0:
+                    return len(a)
+                prev = list(range(len(b) + 1))
+                for i, ca in enumerate(a, start=1):
+                    curr = [i]
+                    for j, cb in enumerate(b, start=1):
+                        insert_cost = curr[j-1] + 1
+                        delete_cost = prev[j] + 1
+                        replace_cost = prev[j-1] + (0 if ca == cb else 1)
+                        curr.append(min(insert_cost, delete_cost, replace_cost))
+                    prev = curr
+                return prev[-1]
+
+            q = _normalize(text)
+            # Fetch candidate streets filtered by district or city
+            query = supabase.table("Streets").select("id, name, type, district_id, city_id").order("name")
+            if district_id is not None:
+                query = query.eq("district_id", district_id)
+            elif city_id is not None:
+                query = query.eq("city_id", city_id)
+            res = query.execute()
+            candidates = res.data or []
+
+            scored = []
+            for item in candidates:
+                name = item.get('name') or ''
+                norm = _normalize(name)
+                score = None
+                if norm == q:
+                    score = 0.0
+                elif q in norm or norm in q:
+                    score = 0.1
+                else:
+                    dist = _lev(q, norm)
+                    max_len = max(len(q), len(norm), 1)
+                    # normalized distance
+                    score = dist / max_len
+                scored.append({
+                    'id': item.get('id'),
+                    'name': name,
+                    'type': item.get('type'),
+                    'district_id': item.get('district_id'),
+                    'city_id': item.get('city_id'),
+                    'score': round(float(score), 3)
+                })
+
+            # sort by score asc, then by name
+            scored.sort(key=lambda x: (x['score'], x['name']))
+            return scored[:limit]
+        except Exception as e:
+            raise Exception(f"Failed to search streets: {str(e)}")
+
+    # ==================== POSITIONS ====================
+
+    @staticmethod
+    async def get_positions(street_id: Optional[int] = None) -> List[Position]:
+        try:
+            if street_id is not None:
+                # Filter directly on Positions.streets JSON array
+                result = supabase.table("Positions").select("*").contains("streets", [street_id]).order("id").execute()
+            else:
+                result = supabase.table("Positions").select("*").order("id").execute()
+            return [Position(**MapsService._db_pos_to_model(item)) for item in (result.data or [])]
+        except Exception as e:
+            raise Exception(f"Failed to fetch positions: {str(e)}")
+
+    @staticmethod
+    async def get_position_by_id(position_id: int) -> Optional[Position]:
+        try:
+            result = supabase.table("Positions").select("*").eq("id", position_id).execute()
+            if result.data:
+                return Position(**MapsService._db_pos_to_model(result.data[0]))
+            return None
+        except Exception as e:
+            raise Exception(f"Failed to fetch position: {str(e)}")
+
+    @staticmethod
+    async def create_position(data: PositionCreate) -> Position:
+        try:
+            next_id = _next_id("Positions")
+            # Map internal x/y to DB columns long/lat
+            payload = {"id": next_id, "long": data.x, "lat": data.y}
+            # include streets JSON if provided on model
+            if getattr(data, 'street_id', None):
+                payload['streets'] = [data.street_id]
+            for field in ("ban", "speed", "park", "lane", "tool", "flooding"):
+                val = getattr(data, field)
+                if val is not None:
+                    payload[field] = val
+            result = supabase.table("Positions").insert(payload).execute()
+            if not result.data:
+                raise Exception("Failed to insert position")
+            pos = result.data[0]
+            # append to Streets.positions JSON column if street_id provided
+            if getattr(data, 'street_id', None):
+                try:
+                    street_row = supabase.table("Streets").select("positions").eq("id", data.street_id).limit(1).execute()
+                    existing = []
+                    if street_row.data and 'positions' in street_row.data[0] and street_row.data[0]['positions']:
+                        existing = list(street_row.data[0]['positions'])
+                    existing.append(pos['id'])
+                    supabase.table("Streets").update({"positions": existing}).eq("id", data.street_id).execute()
+                except Exception:
+                    pass
+            return Position(**MapsService._db_pos_to_model(pos))
+        except Exception as e:
+            raise Exception(f"Failed to create position: {str(e)}")
+
+    @staticmethod
+    async def update_position(position_id: int, data: PositionUpdate) -> Position:
+        try:
+            payload = {k: v for k, v in data.model_dump().items() if v is not None}
+            result = supabase.table("Positions").update(payload).eq("id", position_id).execute()
+            return Position(**result.data[0])
+        except Exception as e:
+            raise Exception(f"Failed to update position: {str(e)}")
+
+    @staticmethod
+    async def delete_position(position_id: int) -> bool:
+        try:
+            supabase.table("Positions").delete().eq("id", position_id).execute()
+            return True
+        except Exception as e:
+            raise Exception(f"Failed to delete position: {str(e)}")
+
+    @staticmethod
+    async def create_positions_bulk(positions_payload: list) -> list:
+        """positions_payload: [{lat, lon, streets: [street_id, ...], pos_id?}, ...]
+        Each item is ONE unique position carrying its complete streets array.
+        pos_id present → UPDATE existing Positions row and sync Streets.positions arrays.
+        pos_id absent  → INSERT new row, then add its id to all relevant Streets.positions arrays.
+        Returns list of affected position records.
+        """
+        created = []
+        try:
+            for pt in positions_payload:
+                lat     = float(pt.get('lat'))
+                lon     = float(pt.get('lon'))
+                streets = [int(s) for s in (pt.get('streets') or [])]
+                pos_id  = pt.get('pos_id')
+
+                if pos_id:
+                    # ── UPDATE existing position ──────────────────────────────────
+                    pos_id = int(pos_id)
+                    # Fetch old streets so we can diff
+                    existing_pos = supabase.table("Positions").select("streets").eq("id", pos_id).limit(1).execute()
+                    old_streets = list((existing_pos.data[0].get('streets') or []) if existing_pos.data else [])
+
+                    result = supabase.table("Positions").update({"long": lon, "lat": lat, "streets": streets}).eq("id", pos_id).execute()
+                    if result.data:
+                        created.append(result.data[0])
+
+                    # Remove pos_id from Streets that are no longer associated
+                    for sid in old_streets:
+                        if sid not in streets:
+                            try:
+                                sr = supabase.table("Streets").select("positions").eq("id", sid).limit(1).execute()
+                                if sr.data:
+                                    existing = [i for i in (sr.data[0].get('positions') or []) if i != pos_id]
+                                    supabase.table("Streets").update({"positions": existing}).eq("id", sid).execute()
+                            except Exception:
+                                pass
+                    # Add pos_id to Streets newly associated
+                    for sid in streets:
+                        if sid not in old_streets:
+                            try:
+                                sr = supabase.table("Streets").select("positions").eq("id", sid).limit(1).execute()
+                                if sr.data:
+                                    existing = list(sr.data[0].get('positions') or [])
+                                    if pos_id not in existing:
+                                        existing.append(pos_id)
+                                        supabase.table("Streets").update({"positions": existing}).eq("id", sid).execute()
+                            except Exception:
+                                pass
+                else:
+                    # ── INSERT new position ───────────────────────────────────────
+                    next_id = _next_id("Positions")
+                    payload = {"id": next_id, "long": lon, "lat": lat, "streets": streets}
+                    result = supabase.table("Positions").insert(payload).execute()
+                    if not result.data:
+                        raise Exception("Failed to insert position")
+                    pos = result.data[0]
+                    created.append(pos)
+                    # Append new position id to every associated Street.positions array
+                    for sid in streets:
+                        try:
+                            sr = supabase.table("Streets").select("positions").eq("id", sid).limit(1).execute()
+                            if sr.data:
+                                existing = list(sr.data[0].get('positions') or [])
+                                if pos['id'] not in existing:
+                                    existing.append(pos['id'])
+                                    supabase.table("Streets").update({"positions": existing}).eq("id", sid).execute()
+                        except Exception:
+                            pass
+
+            return created
+        except Exception as e:
+            raise Exception(f"Failed to create/update positions bulk: {str(e)}")
+
+    @staticmethod
+    async def search_nearest(points: list) -> dict:
+        """
+        1 query point  → return nearest DB position.
+        2 query points → find nearest DB node to each, then run Dijkstra on the
+                         street-adjacency graph to return the shortest path array.
+        Graph: positions are nodes; two positions are adjacent iff they share ≥1 street.
+        Edge weight = Haversine distance (metres).
+        Returns `tts` field: natural Vietnamese navigation text with street names,
+        turn directions, and congestion warnings (speed.normal < 20 km/h).
+        """
+        import math
+        import heapq
+
+        def haversine_m(lat1, lon1, lat2, lon2):
+            R = 6_371_000
+            phi1, phi2 = math.radians(lat1), math.radians(lat2)
+            dphi = math.radians(lat2 - lat1)
+            dlam = math.radians(lon2 - lon1)
+            a = math.sin(dphi / 2) ** 2 + math.cos(phi1) * math.cos(phi2) * math.sin(dlam / 2) ** 2
+            return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+
+        def bearing_deg(lat1, lon1, lat2, lon2):
+            phi1 = math.radians(lat1)
+            phi2 = math.radians(lat2)
+            dl   = math.radians(lon2 - lon1)
+            x = math.sin(dl) * math.cos(phi2)
+            y = math.cos(phi1) * math.sin(phi2) - math.sin(phi1) * math.cos(phi2) * math.cos(dl)
+            return (math.degrees(math.atan2(x, y)) + 360) % 360
+
+        def turn_vi(b_in, b_out):
+            diff = (b_out - b_in + 360) % 360
+            if diff <= 30 or diff >= 330:
+                return "đi thẳng"
+            elif diff < 150:
+                return "rẽ phải"
+            elif diff < 210:
+                return "quay đầu"
+            else:
+                return "rẽ trái"
+
+        def is_congested(pos_row):
+            speed = pos_row.get("speed")
+            if isinstance(speed, dict):
+                normal = speed.get("normal")
+                try:
+                    return normal is not None and float(normal) < 20
+                except (ValueError, TypeError):
+                    pass
+            return False
+
+        def build_tts(path_pts, pos_by_id_map, s_map, total_m):
+            if not path_pts:
+                return ""
+            if len(path_pts) == 1:
+                snames = path_pts[0]["street_names"]
+                loc = snames[0] if snames else "vị trí không xác định"
+                return f"Vị trí gần nhất nằm trên {loc}."
+
+            # Street shared between each consecutive pair of path nodes
+            segment_streets = []
+            for i in range(len(path_pts) - 1):
+                shared = set(path_pts[i]["streets"]) & set(path_pts[i + 1]["streets"])
+                segment_streets.append(list(shared)[0] if shared else None)
+
+            instructions = []
+            current_sid = segment_streets[0]
+            start_name = s_map.get(current_sid, "đường không xác định")
+            instructions.append(f"Xuất phát từ {start_name}")
+
+            for i in range(1, len(path_pts)):
+                pt      = path_pts[i]
+                pos_row = pos_by_id_map.get(pt["id"], {})
+
+                # Congestion warning
+                if is_congested(pos_row):
+                    loc = " - ".join(pt["street_names"]) if pt["street_names"] else "điểm này"
+                    instructions.append(f"Lưu ý kẹt xe tại {loc}")
+
+                # Detect street change at this node
+                new_sid = segment_streets[i] if i < len(segment_streets) else None
+                if new_sid is not None and new_sid != current_sid:
+                    # Bearings: incoming (i-1 → i) and outgoing (i → i+1)
+                    p_prev = path_pts[i - 1]
+                    p_curr = pt
+                    p_next = path_pts[i + 1]   # always valid: i < len(segment_streets) ensures i+1 exists
+                    b_in  = bearing_deg(float(p_prev["lat"]), float(p_prev["lon"]),
+                                        float(p_curr["lat"]), float(p_curr["lon"]))
+                    b_out = bearing_deg(float(p_curr["lat"]), float(p_curr["lon"]),
+                                        float(p_next["lat"]), float(p_next["lon"]))
+                    turn     = turn_vi(b_in, b_out)
+                    new_name = s_map.get(new_sid, "đường không xác định")
+                    inter    = " - ".join(pt["street_names"]) if len(pt["street_names"]) > 1 else ""
+                    if inter:
+                        instructions.append(f"Tại ngã tư {inter}, {turn} vào {new_name}")
+                    else:
+                        instructions.append(f"{turn.capitalize()} vào {new_name}")
+                    current_sid = new_sid
+
+            dist_text = (
+                f"khoảng {total_m} mét" if total_m < 1000
+                else f"khoảng {round(total_m / 1000, 1)} kilômét"
+            )
+            instructions.append(f"Đã đến nơi. Tổng quãng đường {dist_text}")
+            return ". ".join(instructions) + "."
+
+        try:
+            result = supabase.table("Positions").select("*").execute()
+            all_positions = result.data or []
+            if not all_positions:
+                return {"data": [], "label": "Không có điểm nào trong CSDL", "tts": "", "warning": "", "message": ""}
+
+            streets_result = supabase.table("Streets").select("id, name").execute()
+            street_map = {s["id"]: s["name"] for s in (streets_result.data or [])}
+
+            pos_by_id = {}
+            for p in all_positions:
+                if p.get("lat") is not None and p.get("long") is not None:
+                    pos_by_id[p["id"]] = p
+
+            def find_nearest_id(qlat, qlon):
+                best_id, best_d = None, float("inf")
+                for pid, pos in pos_by_id.items():
+                    d = haversine_m(qlat, qlon, float(pos["lat"]), float(pos["long"]))
+                    if d < best_d:
+                        best_d, best_id = d, pid
+                return best_id, best_d
+
+            def make_result_point(pos):
+                street_ids = pos.get("streets") or []
+                return {
+                    "id": pos["id"],
+                    "lat": pos["lat"],
+                    "lon": pos["long"],
+                    "streets": street_ids,
+                    "street_names": [street_map.get(sid, str(sid)) for sid in street_ids],
+                }
+
+            def dist_label(m):
+                return f"~{m}m" if m < 1000 else f"~{round(m / 1000, 1)}km"
+
+            # ── Single-point mode: return nearest ────────────────────────────
+            if len(points) < 2:
+                qlat, qlon = float(points[0]["lat"]), float(points[0]["lon"])
+                nid, dist_m = find_nearest_id(qlat, qlon)
+                if nid is None:
+                    return {"data": [], "label": "Không tìm thấy", "tts": "", "warning": "", "message": ""}
+                pt    = make_result_point(pos_by_id[nid])
+                sname = pt["street_names"][0] if pt["street_names"] else "vị trí không xác định"
+                return {
+                    "data": [pt],
+                    "label": f"Điểm gần nhất: {sname} ({dist_label(round(dist_m))})",
+                    "tts": f"Vị trí gần nhất nằm trên {sname}, cách bạn khoảng {round(dist_m)} mét.",
+                    "warning": "",
+                    "message": f"Khoảng cách: ~{round(dist_m)}m",
+                }
+
+            # ── Two-point mode: shortest path via Dijkstra ───────────────────
+            q1, q2 = points[0], points[1]
+            start_id, d_start = find_nearest_id(float(q1["lat"]), float(q1["lon"]))
+            end_id,   d_end   = find_nearest_id(float(q2["lat"]), float(q2["lon"]))
+
+            if start_id is None or end_id is None:
+                return {"data": [], "label": "Không tìm thấy", "tts": "", "warning": "Không có điểm nào gần query", "message": ""}
+
+            if start_id == end_id:
+                pt    = make_result_point(pos_by_id[start_id])
+                sname = pt["street_names"][0] if pt["street_names"] else "vị trí này"
+                return {
+                    "data": [pt],
+                    "label": f"Điểm xuất phát và đích trùng nhau tại {sname}",
+                    "tts": f"Điểm xuất phát và điểm đích đều nằm tại {sname}.",
+                    "warning": "",
+                    "message": "",
+                }
+
+            # Build adjacency: positions adjacent if they share a street
+            street_to_pids: dict = {}
+            for pid, pos in pos_by_id.items():
+                for sid in (pos.get("streets") or []):
+                    street_to_pids.setdefault(sid, set()).add(pid)
+
+            adjacency: dict = {pid: {} for pid in pos_by_id}
+            for sid, pids in street_to_pids.items():
+                pid_list = list(pids)
+                for i, pid1 in enumerate(pid_list):
+                    p1 = pos_by_id[pid1]
+                    for pid2 in pid_list[i + 1:]:
+                        p2 = pos_by_id[pid2]
+                        d = haversine_m(float(p1["lat"]), float(p1["long"]),
+                                        float(p2["lat"]), float(p2["long"]))
+                        if pid2 not in adjacency[pid1] or adjacency[pid1][pid2] > d:
+                            adjacency[pid1][pid2] = d
+                            adjacency[pid2][pid1] = d
+
+            # Dijkstra
+            dist  = {pid: float("inf") for pid in pos_by_id}
+            prev  = {pid: None         for pid in pos_by_id}
+            dist[start_id] = 0
+            heap = [(0.0, start_id)]
+
+            while heap:
+                d, u = heapq.heappop(heap)
+                if d > dist[u]:
+                    continue
+                if u == end_id:
+                    break
+                for v, w in adjacency[u].items():
+                    nd = dist[u] + w
+                    if nd < dist[v]:
+                        dist[v] = nd
+                        prev[v] = u
+                        heapq.heappush(heap, (nd, v))
+
+            if dist[end_id] == float("inf"):
+                return {
+                    "data": [],
+                    "label": "Không tìm được đường",
+                    "tts": "Không tìm được đường đi giữa hai điểm này.",
+                    "warning": "Hai điểm không có đường nối trong đồ thị",
+                    "message": "",
+                }
+
+            # Reconstruct path
+            path_ids = []
+            cur = end_id
+            while cur is not None:
+                path_ids.append(cur)
+                cur = prev[cur]
+            path_ids.reverse()
+
+            total_m = round(dist[end_id])
+            data    = [make_result_point(pos_by_id[pid]) for pid in path_ids]
+
+            start_name = data[0]["street_names"][0]  if data[0]["street_names"]  else "?"
+            end_name   = data[-1]["street_names"][0] if data[-1]["street_names"] else "?"
+            label = f"Từ {start_name} đến {end_name}, {dist_label(total_m)}"
+            tts   = build_tts(data, pos_by_id, street_map, total_m)
+
+            return {
+                "data": data,
+                "label": label,
+                "tts": tts,
+                "tts_url": "",
+                "warning": "",
+                "message": f"Tổng: {dist_label(total_m)}  |  Snap start: ~{round(d_start)}m  |  Snap end: ~{round(d_end)}m",
+            }
+
+        except Exception as e:
+            raise Exception(f"Search nearest failed: {str(e)}")
+
+    @staticmethod
+    async def delete_position_cascade(position_id: int) -> bool:
+        """Delete a position and remove its id from any Streets.positions arrays listed in position.streets"""
+        try:
+            # fetch position to know related streets
+            pos = None
+            result = supabase.table("Positions").select("*").eq("id", position_id).limit(1).execute()
+            if result.data:
+                pos = result.data[0]
+            # remove this position from Streets.positions JSON arrays if present
+            if pos and 'streets' in pos and pos['streets']:
+                for sid in pos['streets']:
+                    try:
+                        street_row = supabase.table("Streets").select("positions").eq("id", sid).limit(1).execute()
+                        if street_row.data:
+                            existing = list(street_row.data[0].get('positions') or [])
+                            if position_id in existing:
+                                existing = [i for i in existing if i != position_id]
+                                supabase.table("Streets").update({"positions": existing}).eq("id", sid).execute()
+                    except Exception:
+                        pass
+            # delete the position
+            supabase.table("Positions").delete().eq("id", position_id).execute()
+
+            return True
+        except Exception as e:
+            raise Exception(f"Failed to delete position cascade: {str(e)}")

backend/table1.sql

@@ -0,0 +1,58 @@
+-- WARNING: This schema is for context only and is not meant to be run.
+-- Table order and constraints may not be valid for execution.
+
+
+CREATE TABLE public.Cities (
+  id smallint GENERATED ALWAYS AS IDENTITY NOT NULL,
+  name character varying,
+  created_at timestamp with time zone NOT NULL DEFAULT now(),
+  CONSTRAINT Cities_pkey PRIMARY KEY (id)
+);
+CREATE TABLE public.Districts (
+  id integer GENERATED ALWAYS AS IDENTITY NOT NULL,
+  name character varying,
+  lname character varying,
+  city smallint,
+  created_at timestamp with time zone NOT NULL DEFAULT now(),
+  CONSTRAINT Districts_pkey PRIMARY KEY (id),
+  CONSTRAINT Districts_city_fkey FOREIGN KEY (city) REFERENCES public.Cities(id)
+);
+
+CREATE TABLE public.Positions (
+  id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
+  long real,
+  lat real,
+  type character varying,
+  speed json,
+  light smallint,
+  created_at timestamp with time zone NOT NULL DEFAULT now(),
+  CONSTRAINT Positions_pkey PRIMARY KEY (id)
+);
+CREATE TABLE public.StreetPosition (
+  id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
+  pos_id bigint,
+  street_id bigint,
+  created_at timestamp with time zone NOT NULL DEFAULT now(),
+  CONSTRAINT StreetPosition_pkey PRIMARY KEY (id)
+);
+CREATE TABLE public.Streets (
+  id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
+  name character varying,
+  type character varying,
+  district_id integer,
+  city_id smallint,
+  ban_id smallint,
+  parking_id smallint,
+  length smallint,
+  direction smallint,
+  speed smallint,
+  lane_1 character varying,
+  lane_2 character varying,
+  lane_n smallint,
+  toll smallint,
+  flooding smallint,
+  created_at timestamp with time zone NOT NULL DEFAULT now(),
+  CONSTRAINT Streets_pkey PRIMARY KEY (id),
+  CONSTRAINT Streets_city_id_fkey FOREIGN KEY (city_id) REFERENCES public.Cities(id),
+  CONSTRAINT Streets_district_id_fkey FOREIGN KEY (district_id) REFERENCES public.Districts(id)
+);