uploaded backend files

.env

@@ -0,0 +1,11 @@
+# Database configurations
+TRAFFIC_DB_HOST=mysql-19285eb2-tahaelshrif1-7999.h.aivencloud.com
+TRAFFIC_DB_PORT=11520
+MOBILE_DB_HOST=mysql-19285eb2-tahaelshrif1-7999.h.aivencloud.com
+MOBILE_DB_PORT=11520
+RL_DB_HOST=mysql-19285eb2-tahaelshrif1-7999.h.aivencloud.com
+RL_DB_PORT=11520
+
+# Database credentials
+DB_USER=avnadmin
+DB_PASSWORD=AVNS_aT0RGFafs6_34WFegSF

Dockerfile.unknown

@@ -0,0 +1,55 @@
+# syntax=docker/dockerfile:1
+FROM python:3.10-slim AS builder
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create and activate virtual environment
+RUN python -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+# --- Runtime stage ---
+FROM python:3.10-slim
+
+# Platform-agnostic environment setup
+ENV PYTHONUNBUFFERED=1 \
+    PATH="/opt/venv/bin:$PATH" \
+    PORT=8000 \
+    HOST=0.0.0.0
+
+WORKDIR /app
+
+# Copy virtual environment
+COPY --from=builder /opt/venv /opt/venv
+
+# Copy application code (with .dockerignore in place)
+COPY . .
+
+# Create non-root user and permissions
+RUN useradd -m appuser \
+    && chown -R appuser:appuser /app \
+    && mkdir -p /app/tmp \
+    && chown appuser:appuser /app/tmp
+
+USER appuser
+
+# Health check (for platforms that support it)
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:$PORT/health || exit 1
+
+# Universal run command
+CMD ["sh", "-c", "uvicorn main:app --host $HOST --port $PORT"]

__init__.py

@@ -0,0 +1 @@
+# This file makes the 'apis' directory a Python package.

database.py

@@ -0,0 +1,23 @@
+import pymysql
+from pymysql.cursors import DictCursor
+from functools import lru_cache
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class DatabaseConfig:
+    TRAFFIC_MANAGER = {
+        "host": os.getenv("TRAFFIC_DB_HOST"),
+        "port": int(os.getenv("TRAFFIC_DB_PORT")),
+        "user": os.getenv("DB_USER"),
+        "password": os.getenv("DB_PASSWORD"),
+        "db": "trafficManagerFull",
+        "charset": "utf8mb4",
+        "cursorclass": DictCursor
+    }
+    
+
+@lru_cache()
+def get_db_connection(config: dict):
+    return pymysql.connect(**config)

dependencies.py

@@ -0,0 +1,23 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+import jwt
+from models import User
+
+SECRET_KEY = "your_secret_key_here"
+ALGORITHM = "HS256"
+http_bearer = HTTPBearer()
+
+def verify_token(credentials: HTTPAuthorizationCredentials = Depends(http_bearer)) -> dict:
+    token = credentials.credentials
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        # Optionally, check for a custom claim, e.g., 'iss' or 'backend':
+        # if payload.get('backend') != 'my_backend':
+        #     raise HTTPException(status_code=401, detail="Invalid token origin")
+        return payload
+    except jwt.PyJWTError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Could not validate credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )

main.py

@@ -0,0 +1,29 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from routers.traffic_lights import router as traffic_lights_router
+from routers.mobile import router as mobile_router
+from routers.rl_online import router as rl_online_router
+
+app = FastAPI(
+    title="Traffic Management System API",
+    description="API for managing traffic lights, mobile users, and RL online data",
+    version="1.0.0"
+)
+
+# CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(traffic_lights_router)
+app.include_router(mobile_router)
+app.include_router(rl_online_router)
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to Traffic Management System API"}

models.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel
+
+# Traffic Lights Models
+class TrafficSignalBase(BaseModel):
+    lat: float
+    lon: float
+    tl_id_sumo: str
+    tl_id_osm: str
+
+class TrafficSignalCreate(TrafficSignalBase):
+    pass
+
+class TrafficSignal(TrafficSignalBase):
+    class Config:
+        orm_mode = True
+
+# Mobile (Users/Vehicles) Models
+class UserBase(BaseModel):
+    national_id: str
+    name: str
+    phone_number: str
+    email: str
+    type: str
+
+class UserCreate(UserBase):
+    password: str
+
+class User(UserBase):
+    class Config:
+        orm_mode = True
+
+class VehicleBase(BaseModel):
+    national_id: str
+    vehicle: str
+    vehicle_type: str
+
+class VehicleCreate(VehicleBase):
+    password: str
+
+class Vehicle(VehicleBase):
+    class Config:
+        orm_mode = True
+
+class LoginRequest(BaseModel):
+    national_id: str
+    password: str

requirements.txt

@@ -0,0 +1,6 @@
+fastapi>=0.68.0
+uvicorn>=0.15.0
+pymysql>=1.0.2
+python-dotenv>=0.19.0
+bcrypt>=3.2.0
+pyjwt>=2.0.0

routers/mobile.py

@@ -0,0 +1,219 @@
+from fastapi import APIRouter, HTTPException, Depends
+import pymysql
+import bcrypt
+from utils.database import get_db_connection, DatabaseConfig
+from models import User, UserCreate, Vehicle, VehicleCreate, LoginRequest
+import jwt
+from datetime import datetime, timedelta
+from dependencies import verify_token
+
+router = APIRouter(
+    prefix="/mobile",
+    tags=["mobile"]
+)
+
+SECRET_KEY = "your_secret_key_here"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 60
+
+def create_access_token(data: dict, expires_delta: timedelta = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+def hash_password(password: str) -> str:
+    salt = bcrypt.gensalt()
+    hashed_password = bcrypt.hashpw(password.encode('utf-8'), salt)
+    return hashed_password.decode('utf-8')
+
+@router.post("/signup/", response_model=User)
+def create_user(user: UserCreate):
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor() as cursor:
+            cursor.execute("SELECT * FROM users WHERE national_id = %s", (user.national_id,))
+            if cursor.fetchone():
+                raise HTTPException(status_code=400, detail="User already exists")
+            
+            hashed_password = hash_password(user.password)
+            
+            sql = """
+                INSERT INTO users (national_id, name, phone_number, email, password, type)
+                VALUES (%s, %s, %s, %s, %s, %s)
+            """
+            cursor.execute(sql, (
+                user.national_id,
+                user.name,
+                user.phone_number,
+                user.email,
+                hashed_password,
+                user.type
+            ))
+            connection.commit()
+            
+            return {
+                "national_id": user.national_id,
+                "name": user.name,
+                "phone_number": user.phone_number,
+                "email": user.email,
+                "type": user.type
+            }
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.post("/login/")
+def login(login_request: LoginRequest):
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("""
+                SELECT national_id, name, password, type 
+                FROM users 
+                WHERE national_id = %s
+            """, (login_request.national_id,))
+            user = cursor.fetchone()
+            
+            if not user:
+                raise HTTPException(status_code=401, detail="Invalid credentials")
+            
+            if not bcrypt.checkpw(login_request.password.encode('utf-8'), user['password'].encode('utf-8')):
+                raise HTTPException(status_code=401, detail="Invalid credentials")
+            
+            access_token = create_access_token(
+                data={"sub": user['national_id'], "type": user['type']}
+            )
+            
+            return {
+                "access_token": access_token,
+                "token_type": "bearer",
+                "national_id": user['national_id'],
+                "name": user['name'],
+                "type": user['type'],
+                "message": "Login successful"
+            }
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.get("/users/", response_model=list[User], dependencies=[Depends(verify_token)])
+def read_users():
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("SELECT national_id, name, phone_number, email, type FROM users")
+            users = cursor.fetchall()
+            return list(users)
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.get("/users/{national_id}", response_model=User, dependencies=[Depends(verify_token)])
+def read_user(national_id: str):
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("""
+                SELECT national_id, name, phone_number, email, type 
+                FROM users 
+                WHERE national_id = %s
+            """, (national_id,))
+            user = cursor.fetchone()
+            if not user:
+                raise HTTPException(status_code=404, detail="User not found")
+            return user
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.post("/vehicles/", response_model=Vehicle, dependencies=[Depends(verify_token)])
+def create_vehicle(vehicle: VehicleCreate):
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("""
+                SELECT password FROM users 
+                WHERE national_id = %s
+            """, (vehicle.national_id,))
+            user = cursor.fetchone()
+            if not user or not bcrypt.checkpw(vehicle.password.encode('utf-8'), user['password'].encode('utf-8')):
+                raise HTTPException(status_code=401, detail="Invalid credentials")
+            sql = """
+                INSERT INTO vehicles (national_id, vehicle, password, vehicle_type)
+                VALUES (%s, %s, %s, %s)
+            """
+            cursor.execute(sql, (
+                vehicle.national_id,
+                vehicle.vehicle,
+                user['password'],  # Store the hashed password
+                vehicle.vehicle_type
+            ))
+            connection.commit()
+            return {
+                "national_id": vehicle.national_id,
+                "vehicle": vehicle.vehicle,
+                "vehicle_type": vehicle.vehicle_type
+            }
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.get("/vehicles/", response_model=list[Vehicle], dependencies=[Depends(verify_token)])
+def read_vehicles():
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("SELECT national_id, vehicle, vehicle_type FROM vehicles")
+            vehicles = cursor.fetchall()
+            return [
+                {
+                    "national_id": vehicle["national_id"],
+                    "vehicle": vehicle["vehicle"],
+                    "vehicle_type": vehicle["vehicle_type"]
+                }
+                for vehicle in vehicles
+            ]
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.get("/vehicles/{national_id}", response_model=list[Vehicle], dependencies=[Depends(verify_token)])
+def read_user_vehicles(national_id: str):
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("""
+                SELECT national_id, vehicle, vehicle_type 
+                FROM vehicles 
+                WHERE national_id = %s
+            """, (national_id,))
+            vehicles = cursor.fetchall()
+            if not vehicles:
+                raise HTTPException(status_code=404, detail="No vehicles found for this user")
+            return [
+                {
+                    "national_id": vehicle["national_id"],
+                    "vehicle": vehicle["vehicle"],
+                    "vehicle_type": vehicle["vehicle_type"]
+                }
+                for vehicle in vehicles
+            ]
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.get("/users/me-protected", dependencies=[Depends(verify_token)])
+def read_current_user_protected():
+    return {"message": "You are authenticated with a valid backend token."}

routers/rl_online.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter, HTTPException
+import pymysql
+from utils.database import get_db_connection, DatabaseConfig
+
+router = APIRouter(
+    prefix="/rl-online",
+    tags=["rl_online"]
+)
+
+@router.get("/")
+def read_rl_data():
+    # Replace 'RL_ONLINE' with the correct attribute from DatabaseConfig if needed
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)  # <-- Change to your RL DB config
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("SHOW TABLES")
+            tables = cursor.fetchall()
+            return {"tables": tables}
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()

routers/traffic_lights.py

@@ -0,0 +1,104 @@
+from fastapi import APIRouter, HTTPException, Depends
+import pymysql
+from utils.database import get_db_connection, DatabaseConfig
+from models import TrafficSignal, TrafficSignalCreate
+from dependencies import verify_token
+
+router = APIRouter(
+    prefix="/traffic-lights",
+    tags=["traffic_lights"]
+)
+
+@router.post("/", response_model=TrafficSignal, dependencies=[Depends(verify_token)])
+def create_traffic_signal(signal: TrafficSignalCreate):
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor() as cursor:
+            sql = """
+                INSERT INTO traffic_signals (lat, lon, tl_id_sumo, tl_id_osm)
+                VALUES (%s, %s, %s, %s)
+            """
+            cursor.execute(sql, (signal.lat, signal.lon, signal.tl_id_sumo, signal.tl_id_osm))
+            connection.commit()
+            return signal
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+
+@router.get("/", response_model=list[TrafficSignal], dependencies=[Depends(verify_token)])
+def read_traffic_signals():
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("SELECT lat, lon, tl_id_sumo, tl_id_osm FROM traffic_signals")
+            results = cursor.fetchall()
+            return [
+                {"lat": row["lat"], "lon": row["lon"], 
+                 "tl_id_sumo": row["tl_id_sumo"], "tl_id_osm": row["tl_id_osm"]} 
+                for row in results
+            ]
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.get("/{lat}/{lon}", response_model=TrafficSignal, dependencies=[Depends(verify_token)])
+def read_traffic_signal(lat: float, lon: float):
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("SELECT lat, lon, tl_id_sumo, tl_id_osm FROM traffic_signals WHERE lat = %s AND lon = %s", (lat, lon))
+            result = cursor.fetchone()
+            if not result:
+                raise HTTPException(status_code=404, detail="Traffic signal not found")
+            return {
+                "lat": result["lat"], 
+                "lon": result["lon"],
+                "tl_id_sumo": result["tl_id_sumo"], 
+                "tl_id_osm": result["tl_id_osm"]
+            }
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.put("/{lat}/{lon}", response_model=TrafficSignal, dependencies=[Depends(verify_token)])
+def update_traffic_signal(lat: float, lon: float, signal: TrafficSignalCreate):
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor() as cursor:
+            # First check if the record exists
+            cursor.execute("SELECT * FROM traffic_signals WHERE lat = %s AND lon = %s", (lat, lon))
+            if cursor.rowcount == 0:
+                raise HTTPException(status_code=404, detail="Traffic signal not found")
+            
+            # Update all fields
+            sql = """
+                UPDATE traffic_signals 
+                SET lat = %s, lon = %s, tl_id_sumo = %s, tl_id_osm = %s
+                WHERE lat = %s AND lon = %s
+            """
+            cursor.execute(sql, (signal.lat, signal.lon, signal.tl_id_sumo, signal.tl_id_osm, lat, lon))
+            connection.commit()
+            return signal.dict()
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()
+
+@router.delete("/{lat}/{lon}", dependencies=[Depends(verify_token)])
+def delete_traffic_signal(lat: float, lon: float):
+    connection = get_db_connection(DatabaseConfig.TRAFFIC_MANAGER)
+    try:
+        with connection.cursor() as cursor:
+            cursor.execute("DELETE FROM traffic_signals WHERE lat = %s AND lon = %s", (lat, lon))
+            if cursor.rowcount == 0:
+                raise HTTPException(status_code=404, detail="Traffic signal not found")
+            connection.commit()
+            return {"message": "Traffic signal deleted successfully"}
+    except pymysql.Error as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        connection.close()

utils/database.py

@@ -0,0 +1,32 @@
+import os
+import pymysql
+import socket
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class DatabaseConfig:
+    TRAFFIC_MANAGER = {
+        "host": os.getenv("TRAFFIC_DB_HOST"),
+        "port": int(os.getenv("TRAFFIC_DB_PORT")),
+        "user": os.getenv("DB_USER"),
+        "password": os.getenv("DB_PASSWORD"),
+        "database": "trafficManagerFull"
+    }
+
+def get_db_connection(config):
+    if not isinstance(config, dict):
+        raise TypeError("Expected a dictionary for database configuration")
+    try:
+        return pymysql.connect(
+            host=config["host"],
+            port=config["port"],
+            user=config["user"],
+            password=config["password"],
+            database=config["database"]
+        )
+    except socket.gaierror as e:
+        raise ConnectionError(f"Hostname resolution failed for {config['host']}: {e}")
+    except pymysql.err.OperationalError as e:
+        raise ConnectionError(f"Operational error while connecting to the database: {e}")