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/__init__.py

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

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

backend/app/core/__init__.py

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

backend/app/core/config.py

@@ -0,0 +1,43 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+
+class Settings(BaseSettings):
+    # Database settings
+    db_host: str = "db"  # Docker service name
+    db_user: str = "ppr_user"
+    db_password: str = "ppr_password123"
+    db_name: str = "ppr_nextgen"
+    db_port: int = 3306
+    
+    # Security settings
+    secret_key: str = "your-secret-key-change-this-in-production"
+    algorithm: str = "HS256"
+    access_token_expire_minutes: int = 30
+    
+    # Mail settings
+    mail_host: str = "send.one.com"
+    mail_port: int = 465
+    mail_username: str = "noreply@swansea-airport.wales"
+    mail_password: str = "SASAGoForward2155"
+    mail_from: str = "noreply@swansea-airport.wales"
+    mail_from_name: str = "Swansea Airport"
+    
+    # Application settings
+    api_v1_str: str = "/api/v1"
+    project_name: str = "Airfield PPR API"
+    base_url: str = "https://pprdev.swansea-airport.wales"
+    
+    # Redis settings (for future use)
+    redis_url: Optional[str] = None
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+
+    @property
+    def database_url(self) -> str:
+        return f"mysql+pymysql://{self.db_user}:{self.db_password}@{self.db_host}:{self.db_port}/{self.db_name}"
+
+
+settings = Settings()

backend/app/core/security.py

@@ -0,0 +1,47 @@
+from datetime import datetime, timedelta
+from typing import Optional, Union
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from fastapi import HTTPException, status
+from app.core.config import settings
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def create_access_token(
+    subject: Union[str, int], expires_delta: Optional[timedelta] = None
+) -> str:
+    """Create a new access token"""
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(
+            minutes=settings.access_token_expire_minutes
+        )
+    
+    to_encode = {"exp": expire, "sub": str(subject)}
+    encoded_jwt = jwt.encode(to_encode, settings.secret_key, algorithm=settings.algorithm)
+    return encoded_jwt
+
+
+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:
+    """Generate password hash"""
+    return pwd_context.hash(password)
+
+
+def verify_token(token: str) -> Optional[str]:
+    """Verify JWT token and return username"""
+    try:
+        payload = jwt.decode(
+            token, settings.secret_key, algorithms=[settings.algorithm]
+        )
+        username: str = payload.get("sub")
+        if username is None:
+            return None
+        return username
+    except JWTError:
+        return None

backend/app/crud/__init__.py

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

backend/app/crud/crud_ppr.py

@@ -0,0 +1,120 @@
+from typing import List, Optional
+from sqlalchemy.orm import Session
+from sqlalchemy import and_, or_, func, desc
+from datetime import date, datetime
+from app.models.ppr import PPRRecord, PPRStatus
+from app.schemas.ppr import PPRCreate, PPRUpdate
+
+
+class CRUDPPR:
+    def get(self, db: Session, ppr_id: int) -> Optional[PPRRecord]:
+        return db.query(PPRRecord).filter(PPRRecord.id == ppr_id).first()
+
+    def get_multi(
+        self, 
+        db: Session, 
+        skip: int = 0, 
+        limit: int = 100,
+        status: Optional[PPRStatus] = None,
+        date_from: Optional[date] = None,
+        date_to: Optional[date] = None
+    ) -> List[PPRRecord]:
+        query = db.query(PPRRecord)
+        
+        if status:
+            query = query.filter(PPRRecord.status == status)
+        
+        if date_from:
+            query = query.filter(
+                or_(
+                    func.date(PPRRecord.eta) >= date_from,
+                    func.date(PPRRecord.etd) >= date_from
+                )
+            )
+            
+        if date_to:
+            query = query.filter(
+                or_(
+                    func.date(PPRRecord.eta) <= date_to,
+                    func.date(PPRRecord.etd) <= date_to
+                )
+            )
+        
+        return query.order_by(desc(PPRRecord.submitted_dt)).offset(skip).limit(limit).all()
+
+    def get_arrivals_today(self, db: Session) -> List[PPRRecord]:
+        """Get today's arrivals"""
+        today = date.today()
+        return db.query(PPRRecord).filter(
+            and_(
+                func.date(PPRRecord.eta) == today,
+                PPRRecord.status == PPRStatus.NEW
+            )
+        ).order_by(PPRRecord.eta).all()
+
+    def get_departures_today(self, db: Session) -> List[PPRRecord]:
+        """Get today's departures"""
+        today = date.today()
+        return db.query(PPRRecord).filter(
+            and_(
+                func.date(PPRRecord.etd) == today,
+                PPRRecord.status == PPRStatus.LANDED
+            )
+        ).order_by(PPRRecord.etd).all()
+
+    def create(self, db: Session, obj_in: PPRCreate, created_by: str) -> PPRRecord:
+        db_obj = PPRRecord(
+            **obj_in.dict(),
+            created_by=created_by,
+            status=PPRStatus.NEW
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
+
+    def update(self, db: Session, db_obj: PPRRecord, obj_in: PPRUpdate) -> PPRRecord:
+        update_data = obj_in.dict(exclude_unset=True)
+        for field, value in update_data.items():
+            setattr(db_obj, field, value)
+        
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
+
+    def update_status(
+        self, 
+        db: Session, 
+        ppr_id: int, 
+        status: PPRStatus
+    ) -> Optional[PPRRecord]:
+        db_obj = self.get(db, ppr_id)
+        if not db_obj:
+            return None
+        
+        db_obj.status = status
+        
+        # Set timestamps based on status
+        if status == PPRStatus.LANDED:
+            db_obj.landed_dt = datetime.utcnow()
+        elif status == PPRStatus.DEPARTED:
+            db_obj.departed_dt = datetime.utcnow()
+        
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
+
+    def delete(self, db: Session, ppr_id: int) -> Optional[PPRRecord]:
+        db_obj = self.get(db, ppr_id)
+        if db_obj:
+            # Soft delete by setting status
+            db_obj.status = PPRStatus.DELETED
+            db.add(db_obj)
+            db.commit()
+            db.refresh(db_obj)
+        return db_obj
+
+
+ppr = CRUDPPR()

backend/app/crud/crud_user.py

@@ -0,0 +1,39 @@
+from typing import Optional
+from sqlalchemy.orm import Session
+from app.models.ppr import User
+from app.schemas.ppr import UserCreate
+from app.core.security import get_password_hash, verify_password
+
+
+class CRUDUser:
+    def get(self, db: Session, user_id: int) -> Optional[User]:
+        return db.query(User).filter(User.id == user_id).first()
+
+    def get_by_username(self, db: Session, username: str) -> Optional[User]:
+        return db.query(User).filter(User.username == username).first()
+
+    def create(self, db: Session, obj_in: UserCreate) -> User:
+        hashed_password = get_password_hash(obj_in.password)
+        db_obj = User(
+            username=obj_in.username,
+            password=hashed_password
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
+
+    def authenticate(self, db: Session, username: str, password: str) -> Optional[User]:
+        user = self.get_by_username(db, username=username)
+        if not user:
+            return None
+        if not verify_password(password, user.password):
+            return None
+        return user
+
+    def is_active(self, user: User) -> bool:
+        # For future use if we add user status
+        return True
+
+
+user = CRUDUser()

backend/app/db/__init__.py

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

backend/app/db/session.py

@@ -0,0 +1,15 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from app.core.config import settings
+
+engine = create_engine(
+    settings.database_url,
+    pool_pre_ping=True,
+    pool_recycle=300,
+    echo=False,  # Set to True for SQL debugging
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()

backend/app/main.py

@@ -0,0 +1,78 @@
+from fastapi import FastAPI, Depends, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List
+import json
+from app.core.config import settings
+from app.api.api import api_router
+
+app = FastAPI(
+    title=settings.project_name,
+    openapi_url=f"{settings.api_v1_str}/openapi.json",
+    description="Prior Permission Required (PPR) system API for aircraft operations management",
+    version="2.0.0"
+)
+
+# Set up CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure this properly for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# WebSocket connection manager for real-time updates
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: List[WebSocket] = []
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        self.active_connections.append(websocket)
+
+    def disconnect(self, websocket: WebSocket):
+        self.active_connections.remove(websocket)
+
+    async def send_personal_message(self, message: str, websocket: WebSocket):
+        await websocket.send_text(message)
+
+    async def broadcast(self, message: dict):
+        message_str = json.dumps(message)
+        for connection in self.active_connections:
+            try:
+                await connection.send_text(message_str)
+            except:
+                # Connection is dead, remove it
+                self.active_connections.remove(connection)
+
+manager = ConnectionManager()
+
+@app.websocket("/ws/tower-updates")
+async def websocket_endpoint(websocket: WebSocket):
+    await manager.connect(websocket)
+    try:
+        while True:
+            # Keep connection alive
+            data = await websocket.receive_text()
+            # Echo back for heartbeat
+            await websocket.send_text(f"Heartbeat: {data}")
+    except WebSocketDisconnect:
+        manager.disconnect(websocket)
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Airfield PPR API", 
+        "version": "2.0.0",
+        "docs": "/docs"
+    }
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "timestamp": "2024-01-01T00:00:00Z"}
+
+# Include API router
+app.include_router(api_router, prefix=settings.api_v1_str)
+
+# Make connection manager available to the app
+app.state.connection_manager = manager

backend/app/models/__init__.py

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

backend/app/models/ppr.py

@@ -0,0 +1,88 @@
+from sqlalchemy import Column, Integer, String, DateTime, Text, Enum as SQLEnum, BigInteger
+from sqlalchemy.sql import func
+from enum import Enum
+from app.db.session import Base
+
+
+class PPRStatus(str, Enum):
+    NEW = "NEW"
+    CONFIRMED = "CONFIRMED"
+    CANCELED = "CANCELED"
+    LANDED = "LANDED"
+    DELETED = "DELETED"
+    DEPARTED = "DEPARTED"
+
+
+class PPRRecord(Base):
+    __tablename__ = "submitted"
+    
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+    status = Column(SQLEnum(PPRStatus), nullable=False, default=PPRStatus.NEW)
+    ac_reg = Column(String(16), nullable=False)
+    ac_type = Column(String(32), nullable=False)
+    ac_call = Column(String(16), nullable=True)
+    captain = Column(String(64), nullable=False)
+    fuel = Column(String(16), nullable=True)
+    in_from = Column(String(64), nullable=False)
+    eta = Column(DateTime, nullable=False)
+    pob_in = Column(Integer, nullable=False)
+    out_to = Column(String(64), nullable=True)
+    etd = Column(DateTime, nullable=True)
+    pob_out = Column(Integer, nullable=True)
+    email = Column(String(128), nullable=True)
+    phone = Column(String(16), nullable=True)
+    notes = Column(String(2000), nullable=True)
+    landed_dt = Column(DateTime, nullable=True)
+    departed_dt = Column(DateTime, nullable=True)
+    created_by = Column(String(16), nullable=True)
+    submitted_dt = Column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class User(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    username = Column(String(50), nullable=False, unique=True, index=True)
+    password = Column(String(255), nullable=False)
+
+
+class Journal(Base):
+    __tablename__ = "journal"
+    
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+    ppr_id = Column(Integer, nullable=False, index=True)
+    entry = Column(Text, nullable=False)
+    user = Column(Text, nullable=False)
+    ip = Column(Text, nullable=False)
+    entry_dt = Column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class Airport(Base):
+    __tablename__ = "airports"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    icao = Column(String(4), nullable=False, unique=True, index=True)
+    iata = Column(String(3), nullable=True, index=True)
+    name = Column(String(255), nullable=False)
+    country = Column(String(100), nullable=False)
+    city = Column(String(100), nullable=True)
+    timezone = Column(String(50), nullable=True)
+    latitude = Column(Text, nullable=True)
+    longitude = Column(Text, nullable=True)
+    elevation = Column(Integer, nullable=True)
+    created_at = Column(DateTime, nullable=False, server_default=func.current_timestamp())
+
+
+class Aircraft(Base):
+    __tablename__ = "aircraft"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    icao24 = Column(String(6), nullable=True)
+    registration = Column(String(25), nullable=True, index=True)
+    manufacturer_icao = Column(String(50), nullable=True)
+    type_code = Column(String(30), nullable=True)
+    manufacturer_name = Column(String(255), nullable=True)
+    model = Column(String(255), nullable=True)
+    clean_reg = Column(String(25), nullable=True, index=True)
+    created_at = Column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = Column(DateTime, nullable=False, server_default=func.current_timestamp())

backend/app/schemas/__init__.py

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

backend/app/schemas/ppr.py

@@ -0,0 +1,176 @@
+from pydantic import BaseModel, EmailStr, validator
+from datetime import datetime
+from typing import Optional
+from enum import Enum
+
+
+class PPRStatus(str, Enum):
+    NEW = "NEW"
+    CONFIRMED = "CONFIRMED"
+    CANCELED = "CANCELED"
+    LANDED = "LANDED"
+    DELETED = "DELETED"
+    DEPARTED = "DEPARTED"
+
+
+class PPRBase(BaseModel):
+    ac_reg: str
+    ac_type: str
+    ac_call: Optional[str] = None
+    captain: str
+    fuel: Optional[str] = None
+    in_from: str
+    eta: datetime
+    pob_in: int
+    out_to: Optional[str] = None
+    etd: Optional[datetime] = None
+    pob_out: Optional[int] = None
+    email: Optional[EmailStr] = None
+    phone: Optional[str] = None
+    notes: Optional[str] = None
+
+    @validator('ac_reg')
+    def validate_registration(cls, v):
+        if not v or len(v.strip()) == 0:
+            raise ValueError('Aircraft registration is required')
+        return v.strip().upper()
+
+    @validator('pob_in')
+    def validate_pob_in(cls, v):
+        if v is not None and v < 0:
+            raise ValueError('POB inbound must be non-negative')
+        return v
+
+    @validator('pob_out')
+    def validate_pob_out(cls, v):
+        if v is not None and v < 0:
+            raise ValueError('POB outbound must be non-negative')
+        return v
+
+
+class PPRCreate(PPRBase):
+    pass
+
+
+class PPRUpdate(BaseModel):
+    ac_reg: Optional[str] = None
+    ac_type: Optional[str] = None
+    ac_call: Optional[str] = None
+    captain: Optional[str] = None
+    fuel: Optional[str] = None
+    in_from: Optional[str] = None
+    eta: Optional[datetime] = None
+    pob_in: Optional[int] = None
+    out_to: Optional[str] = None
+    etd: Optional[datetime] = None
+    pob_out: Optional[int] = None
+    email: Optional[EmailStr] = None
+    phone: Optional[str] = None
+    notes: Optional[str] = None
+
+
+class PPRStatusUpdate(BaseModel):
+    status: PPRStatus
+
+
+class PPRInDBBase(PPRBase):
+    id: int
+    status: PPRStatus
+    landed_dt: Optional[datetime] = None
+    departed_dt: Optional[datetime] = None
+    created_by: Optional[str] = None
+    submitted_dt: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class PPR(PPRInDBBase):
+    pass
+
+
+class PPRInDB(PPRInDBBase):
+    pass
+
+
+# User schemas
+class UserBase(BaseModel):
+    username: str
+
+
+class UserCreate(UserBase):
+    password: str
+
+
+class UserInDBBase(UserBase):
+    id: int
+
+    class Config:
+        from_attributes = True
+
+
+class User(UserInDBBase):
+    pass
+
+
+class UserInDB(UserInDBBase):
+    password: str
+
+
+# Authentication schemas
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+
+class TokenData(BaseModel):
+    username: Optional[str] = None
+
+
+# Journal schemas
+class JournalBase(BaseModel):
+    ppr_id: int
+    entry: str
+    user: str
+    ip: str
+
+
+class JournalCreate(JournalBase):
+    pass
+
+
+class Journal(JournalBase):
+    id: int
+    entry_dt: datetime
+
+    class Config:
+        from_attributes = True
+
+
+# Airport schemas
+class AirportBase(BaseModel):
+    icao: str
+    iata: Optional[str] = None
+    name: str
+    country: str
+
+
+class Airport(AirportBase):
+    class Config:
+        from_attributes = True
+
+
+# Aircraft schemas
+class AircraftBase(BaseModel):
+    icao24: Optional[str] = None
+    registration: Optional[str] = None
+    manufacturericao: Optional[str] = None
+    typecode: Optional[str] = None
+    manufacturername: Optional[str] = None
+    model: Optional[str] = None
+    clean_reg: Optional[str] = None
+
+
+class Aircraft(AircraftBase):
+    class Config:
+        from_attributes = True