feat: Remove deprecated API components and Docker configurations

Author: Kevin

api/auth.py

@@ -1,83 +0,0 @@
-"""Authentication and authorization utilities"""
-
-import os
-from datetime import datetime, timedelta
-from typing import Optional
-
-import jwt
-from fastapi import Depends, HTTPException, status
-from fastapi.security import HTTPBearer
-from passlib.context import CryptContext
-from sqlalchemy.orm import Session
-
-from api.database import get_db
-from api.models import User
-
-# Security configuration
-SECRET_KEY = os.getenv("SECRET_KEY", "dev-secret-change-in-production")
-ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
-
-security = HTTPBearer()
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-
-def verify_password(plain_password: str, hashed_password: str) -> bool:
-    """Verify a password against its hash"""
-    return pwd_context.verify(plain_password, hashed_password)
-
-
-def get_password_hash(password: str) -> str:
-    """Hash a password"""
-    return pwd_context.hash(password)
-
-
-def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
-    """Create access token"""
-    to_encode = data.copy()
-    if expires_delta:
-        expire = datetime.utcnow() + expires_delta
-    else:
-        expire = datetime.utcnow() + timedelta(minutes=15)
-
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return encoded_jwt
-
-
-def verify_token(token: str = Depends(security), db: Session = Depends(get_db)):
-    """Verify JWT token and return user"""
-    try:
-        payload = jwt.decode(token.credentials, SECRET_KEY, algorithms=[ALGORITHM])
-        username: str = payload.get("sub")
-        if username is None:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Could not validate credentials"
-            )
-    except jwt.PyJWTError:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Could not validate credentials"
-        )
-
-    user = db.query(User).filter(User.username == username).first()
-    if user is None:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="User not found"
-        )
-
-    return user
-
-
-def require_instructor(current_user: User = Depends(verify_token)):
-    """Require instructor role"""
-    if not current_user.is_instructor:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Instructor access required"
-        )
-    return current_user
-        )
-    return current_user

api/database.py

@@ -1,43 +0,0 @@
-"""Database configuration and session management"""
-
-import os
-
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-from sqlalchemy.pool import StaticPool
-
-# Database URL from environment
-DATABASE_URL = os.getenv(
-    "DATABASE_URL",
-    "postgresql://fllsim:fllsimpass@localhost:5432/fllsim"
-)
-
-# Create engine
-if DATABASE_URL.startswith("sqlite"):
-    engine = create_engine(
-        DATABASE_URL,
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool
-    )
-else:
-    engine = create_engine(DATABASE_URL, pool_pre_ping=True)
-
-# Session factory
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-# Base class for models
-Base = declarative_base()
-
-async def init_db():
-    """Initialize database tables"""
-    Base.metadata.create_all(bind=engine)
-
-def get_db():
-    """Get database session"""
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-        db.close()

api/main.py

@@ -1,146 +0,0 @@
-"""
-FLL-Sim Educational Platform API
-FastAPI-based REST API for the FLL-Sim educational platform
-"""
-
-import logging
-import os
-import sys
-from contextlib import asynccontextmanager
-from pathlib import Path
-
-from fastapi import Depends, FastAPI, HTTPException, status
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.gzip import GZipMiddleware
-from fastapi.responses import JSONResponse
-from fastapi.security import HTTPBearer
-
-# Add project src to path for imports
-project_root = Path(__file__).parent.parent
-sys.path.insert(0, str(project_root / "src"))
-
-from api.auth import verify_token
-from api.database import get_db, init_db
-from api.models import User
-from api.routers import analytics, auth, missions, simulations, students
-from fll_sim.education.educational_platform import EducationalPlatform
-from fll_sim.utils.logger import FLLLogger
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = FLLLogger('FLLSimAPI')
-
-# Security
-security = HTTPBearer()
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Application lifespan events"""
-    # Startup
-    logger.info("Starting FLL-Sim API...")
-    await init_db()
-    logger.info("Database initialized")
-
-    # Initialize educational platform
-    app.state.edu_platform = EducationalPlatform()
-    logger.info("Educational platform initialized")
-
-    yield
-
-    # Shutdown
-    logger.info("Shutting down FLL-Sim API...")
-
-# Create FastAPI application
-app = FastAPI(
-    title="FLL-Sim Educational Platform API",
-    description="REST API for the FLL-Sim educational robotics platform",
-    version="1.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    lifespan=lifespan
-)
-
-# Add middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=os.getenv("CORS_ORIGINS", "http://localhost:3000").split(","),
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-
-# Include routers
-app.include_router(auth.router, prefix="/api/v1/auth", tags=["Authentication"])
-app.include_router(students.router, prefix="/api/v1/students", tags=["Students"])
-app.include_router(missions.router, prefix="/api/v1/missions", tags=["Missions"])
-app.include_router(simulations.router, prefix="/api/v1/simulations", tags=["Simulations"])
-app.include_router(analytics.router, prefix="/api/v1/analytics", tags=["Analytics"])
-
-@app.get("/")
-async def root():
-    """Root endpoint"""
-    return {
-        "message": "FLL-Sim Educational Platform API",
-        "version": "1.0.0",
-        "docs": "/docs"
-    }
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    try:
-        # Check database connection
-        db = next(get_db())
-        db.execute("SELECT 1")
-
-        return {
-            "status": "healthy",
-            "database": "connected",
-            "version": "1.0.0"
-        }
-    except Exception as e:
-        logger.error(f"Health check failed: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Service unhealthy"
-        )
-
-@app.get("/api/v1/platform/status")
-async def platform_status(current_user: User = Depends(verify_token)):
-    """Get educational platform status"""
-    try:
-        edu_platform = app.state.edu_platform
-
-        return {
-            "platform_active": True,
-            "active_sessions": len(edu_platform.active_sessions),
-            "available_missions": len(edu_platform.mission_builder.missions),
-            "system_status": "operational"
-        }
-    except Exception as e:
-        logger.error(f"Platform status error: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to get platform status"
-        )
-
-@app.exception_handler(Exception)
-async def global_exception_handler(request, exc):
-    """Global exception handler"""
-    logger.error(f"Unhandled exception: {exc}")
-    return JSONResponse(
-        status_code=500,
-        content={"detail": "Internal server error"}
-    )
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(
-        "main:app",
-        host="0.0.0.0",
-        port=8000,
-        reload=True,
-        log_level="info"
-    )
-    )

api/models.py

@@ -1,85 +0,0 @@
-"""Database models for FLL-Sim API"""
-
-from sqlalchemy import (Boolean, Column, DateTime, ForeignKey, Integer, String,
-                        Text)
-from sqlalchemy.orm import relationship
-from sqlalchemy.sql import func
-
-from api.database import Base
-
-
-class User(Base):
-    """User model"""
-    __tablename__ = "users"
-
-    id = Column(Integer, primary_key=True, index=True)
-    username = Column(String(50), unique=True, index=True, nullable=False)
-    email = Column(String(100), unique=True, index=True, nullable=False)
-    hashed_password = Column(String(255), nullable=False)
-    full_name = Column(String(100))
-    is_active = Column(Boolean, default=True)
-    is_student = Column(Boolean, default=True)
-    is_instructor = Column(Boolean, default=False)
-    grade_level = Column(String(20))
-    class_section = Column(String(50))
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-
-    # Relationships
-    simulation_results = relationship("SimulationResult", back_populates="user")
-    progress_records = relationship("ProgressRecord", back_populates="user")
-
-
-class Mission(Base):
-    """Mission model"""
-    __tablename__ = "missions"
-
-    id = Column(Integer, primary_key=True, index=True)
-    name = Column(String(100), nullable=False)
-    description = Column(Text)
-    difficulty_level = Column(Integer, default=1)
-    season = Column(String(50))
-    objectives = Column(Text)  # JSON string
-    scoring_criteria = Column(Text)  # JSON string
-    is_active = Column(Boolean, default=True)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-
-    # Relationships
-    simulation_results = relationship("SimulationResult", back_populates="mission")
-
-
-class SimulationResult(Base):
-    """Simulation result model"""
-    __tablename__ = "simulation_results"
-
-    id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
-    mission_id = Column(Integer, ForeignKey("missions.id"))
-    score = Column(Integer, default=0)
-    completion_time = Column(Integer)  # seconds
-    success = Column(Boolean, default=False)
-    program_code = Column(Text)
-    error_log = Column(Text)
-    robot_path = Column(Text)  # JSON string
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-
-    # Relationships
-    user = relationship("User", back_populates="simulation_results")
-    mission = relationship("Mission", back_populates="simulation_results")
-
-
-class ProgressRecord(Base):
-    """Student progress tracking"""
-    __tablename__ = "progress_records"
-
-    id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
-    activity_type = Column(String(50))  # tutorial, mission, visual_programming
-    activity_id = Column(String(100))
-    status = Column(String(20))  # started, completed, failed
-    progress_data = Column(Text)  # JSON string
-    notes = Column(Text)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-
-    # Relationships
-    user = relationship("User", back_populates="progress_records")
-    user = relationship("User", back_populates="progress_records")