Initial commit: NextGen PPR System

- FastAPI backend with JWT authentication
- MySQL database with full schema
- Docker Compose orchestration
- CSV data import for 43,208 airports and 519,999 aircraft
- Complete PPR management API
- Modernized replacement for PHP-based system

backend/app/api/__init__.py

@@ -0,0 +1 @@
+# Empty __init__.py files to make Python packages

backend/app/api/api.py

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+from app.api.endpoints import auth, pprs, public
+
+api_router = APIRouter()
+
+api_router.include_router(auth.router, prefix="/auth", tags=["authentication"])
+api_router.include_router(pprs.router, prefix="/pprs", tags=["pprs"])
+api_router.include_router(public.router, prefix="/public", tags=["public"])

backend/app/api/deps.py

@@ -0,0 +1,47 @@
+from typing import Generator
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from sqlalchemy.orm import Session
+from app.db.session import SessionLocal
+from app.core.security import verify_token
+from app.crud.crud_user import user as crud_user
+
+security = HTTPBearer()
+
+
+def get_db() -> Generator:
+    """Database dependency"""
+    try:
+        db = SessionLocal()
+        yield db
+    finally:
+        db.close()
+
+
+async def get_current_user(
+    db: Session = Depends(get_db),
+    credentials: HTTPAuthorizationCredentials = Depends(security)
+):
+    """Get current authenticated user"""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    username = verify_token(credentials.credentials)
+    if username is None:
+        raise credentials_exception
+    
+    user = crud_user.get_by_username(db, username=username)
+    if user is None:
+        raise credentials_exception
+    
+    return user
+
+
+def get_current_active_user(
+    current_user = Depends(get_current_user),
+):
+    """Get current active user (for future use if we add user status)"""
+    return current_user

backend/app/api/endpoints/__init__.py

@@ -0,0 +1 @@
+# Empty __init__.py files to make Python packages

backend/app/api/endpoints/auth.py

@@ -0,0 +1,41 @@
+from datetime import timedelta
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from app.api.deps import get_db
+from app.core.config import settings
+from app.core.security import create_access_token
+from app.crud.crud_user import user as crud_user
+from app.schemas.ppr import Token
+
+router = APIRouter()
+
+
+@router.post("/login", response_model=Token)
+async def login_for_access_token(
+    db: Session = Depends(get_db),
+    form_data: OAuth2PasswordRequestForm = Depends()
+):
+    """OAuth2 compatible token login, get an access token for future requests"""
+    user = crud_user.authenticate(
+        db, username=form_data.username, password=form_data.password
+    )
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    access_token_expires = timedelta(minutes=settings.access_token_expire_minutes)
+    access_token = create_access_token(
+        subject=user.username, expires_delta=access_token_expires
+    )
+    
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+@router.post("/test-token")
+async def test_token(current_user = Depends(get_db)):
+    """Test access token"""
+    return current_user

backend/app/api/endpoints/pprs.py

@@ -0,0 +1,162 @@
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, status, Request
+from sqlalchemy.orm import Session
+from datetime import date
+from app.api.deps import get_db, get_current_active_user
+from app.crud.crud_ppr import ppr as crud_ppr
+from app.schemas.ppr import PPR, PPRCreate, PPRUpdate, PPRStatus, PPRStatusUpdate
+from app.models.ppr import User
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[PPR])
+async def get_pprs(
+    request: Request,
+    skip: int = 0,
+    limit: int = 100,
+    status: Optional[PPRStatus] = None,
+    date_from: Optional[date] = None,
+    date_to: Optional[date] = None,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Get PPR records with optional filtering"""
+    pprs = crud_ppr.get_multi(
+        db, skip=skip, limit=limit, status=status, 
+        date_from=date_from, date_to=date_to
+    )
+    return pprs
+
+
+@router.post("/", response_model=PPR)
+async def create_ppr(
+    request: Request,
+    ppr_in: PPRCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Create a new PPR record"""
+    ppr = crud_ppr.create(db, obj_in=ppr_in, created_by=current_user.username)
+    
+    # Send real-time update via WebSocket
+    if hasattr(request.app.state, 'connection_manager'):
+        await request.app.state.connection_manager.broadcast({
+            "type": "ppr_created",
+            "data": {
+                "id": ppr.id,
+                "ac_reg": ppr.ac_reg,
+                "status": ppr.status.value
+            }
+        })
+    
+    return ppr
+
+
+@router.get("/{ppr_id}", response_model=PPR)
+async def get_ppr(
+    ppr_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Get a specific PPR record"""
+    ppr = crud_ppr.get(db, ppr_id=ppr_id)
+    if not ppr:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="PPR record not found"
+        )
+    return ppr
+
+
+@router.put("/{ppr_id}", response_model=PPR)
+async def update_ppr(
+    request: Request,
+    ppr_id: int,
+    ppr_in: PPRUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Update a PPR record"""
+    db_ppr = crud_ppr.get(db, ppr_id=ppr_id)
+    if not db_ppr:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="PPR record not found"
+        )
+    
+    ppr = crud_ppr.update(db, db_obj=db_ppr, obj_in=ppr_in)
+    
+    # Send real-time update
+    if hasattr(request.app.state, 'connection_manager'):
+        await request.app.state.connection_manager.broadcast({
+            "type": "ppr_updated",
+            "data": {
+                "id": ppr.id,
+                "ac_reg": ppr.ac_reg,
+                "status": ppr.status.value
+            }
+        })
+    
+    return ppr
+
+
+@router.patch("/{ppr_id}/status", response_model=PPR)
+async def update_ppr_status(
+    request: Request,
+    ppr_id: int,
+    status_update: PPRStatusUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Update PPR status (LANDED, DEPARTED, etc.)"""
+    ppr = crud_ppr.update_status(db, ppr_id=ppr_id, status=status_update.status)
+    if not ppr:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="PPR record not found"
+        )
+    
+    # Log the status change (you might want to create a journal entry here)
+    
+    # Send real-time update
+    if hasattr(request.app.state, 'connection_manager'):
+        await request.app.state.connection_manager.broadcast({
+            "type": "status_update",
+            "data": {
+                "id": ppr.id,
+                "ac_reg": ppr.ac_reg,
+                "status": ppr.status.value,
+                "timestamp": ppr.landed_dt.isoformat() if ppr.landed_dt else None
+            }
+        })
+    
+    return ppr
+
+
+@router.delete("/{ppr_id}", response_model=PPR)
+async def delete_ppr(
+    request: Request,
+    ppr_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Delete (soft delete) a PPR record"""
+    ppr = crud_ppr.delete(db, ppr_id=ppr_id)
+    if not ppr:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="PPR record not found"
+        )
+    
+    # Send real-time update
+    if hasattr(request.app.state, 'connection_manager'):
+        await request.app.state.connection_manager.broadcast({
+            "type": "ppr_deleted",
+            "data": {
+                "id": ppr.id,
+                "ac_reg": ppr.ac_reg
+            }
+        })
+    
+    return ppr

backend/app/api/endpoints/public.py

@@ -0,0 +1,22 @@
+from typing import List
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from app.api.deps import get_db
+from app.crud.crud_ppr import ppr as crud_ppr
+from app.schemas.ppr import PPR
+
+router = APIRouter()
+
+
+@router.get("/arrivals", response_model=List[PPR])
+async def get_public_arrivals(db: Session = Depends(get_db)):
+    """Get today's arrivals for public display"""
+    arrivals = crud_ppr.get_arrivals_today(db)
+    return arrivals
+
+
+@router.get("/departures", response_model=List[PPR])
+async def get_public_departures(db: Session = Depends(get_db)):
+    """Get today's departures for public display"""
+    departures = crud_ppr.get_departures_today(db)
+    return departures