ppr-ng/backend/app/crud/crud_arrival.py

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.arrival import Arrival, ArrivalStatus
from app.schemas.arrival import ArrivalCreate, ArrivalUpdate, ArrivalStatusUpdate
from app.models.journal import EntityType
from app.crud.crud_journal import journal
from app.crud.crud_movement import movement as movement_crud
from app.schemas.movement import MovementCreate
from app.models.movement import MovementType


class CRUDArrival:
    def get(self, db: Session, arrival_id: int) -> Optional[Arrival]:
        return db.query(Arrival).filter(Arrival.id == arrival_id).first()

    def get_multi(
        self, 
        db: Session, 
        skip: int = 0, 
        limit: int = 100,
        status: Optional[ArrivalStatus] = None,
        date_from: Optional[date] = None,
        date_to: Optional[date] = None
    ) -> List[Arrival]:
        query = db.query(Arrival)
        
        if status:
            if status == ArrivalStatus.CIRCUIT:
                # Special case: when requesting CIRCUIT status, return all circuit-related statuses
                circuit_statuses = [
                    ArrivalStatus.CIRCUIT,
                    ArrivalStatus.CIRCUIT_DOWNWIND,
                    ArrivalStatus.CIRCUIT_BASE,
                    ArrivalStatus.CIRCUIT_FINAL
                ]
                query = query.filter(Arrival.status.in_(circuit_statuses))
            else:
                query = query.filter(Arrival.status == status)
        
        if date_from:
            query = query.filter(func.date(Arrival.created_dt) >= date_from)
            
        if date_to:
            query = query.filter(func.date(Arrival.created_dt) <= date_to)
        
        return query.order_by(desc(Arrival.created_dt)).offset(skip).limit(limit).all()

    def get_arrivals_today(self, db: Session) -> List[Arrival]:
        """Get today's arrivals (booked in, inbound or landed)"""
        today = date.today()
        return db.query(Arrival).filter(
            and_(
                func.date(Arrival.created_dt) == today,
                or_(
                    Arrival.status == ArrivalStatus.BOOKED_IN,
                    Arrival.status == ArrivalStatus.INBOUND,
                    Arrival.status == ArrivalStatus.LANDED
                )
            )
        ).order_by(Arrival.created_dt).all()

    def create(self, db: Session, obj_in: ArrivalCreate, created_by: str, submitted_via: str = "ADMIN", user_ip: Optional[str] = None) -> Arrival:
        from app.models.arrival import SubmissionSource
        
        # Set initial status based on submission source
        initial_status = ArrivalStatus.BOOKED_IN
        
        if submitted_via == SubmissionSource.ADMIN:
            initial_status = ArrivalStatus.INBOUND
        
        db_obj = Arrival(
            **obj_in.dict(exclude={'submitted_via'}),
            created_by=created_by,
            status=initial_status,
            submitted_via=submitted_via
        )
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        
        # Log creation in journal
        journal.log_change(
            db,
            EntityType.ARRIVAL,
            db_obj.id,
            f"Arrival created: {db_obj.registration}",
            created_by,
            user_ip
        )
        
        return db_obj

    def update(self, db: Session, db_obj: Arrival, obj_in: ArrivalUpdate, user: str = "system", user_ip: Optional[str] = None) -> Arrival:
        from datetime import datetime as dt
        
        update_data = obj_in.dict(exclude_unset=True)
        changes = []
        
        for field, value in update_data.items():
            old_value = getattr(db_obj, field)
            
            # Normalize datetime values for comparison (ignore timezone differences)
            if isinstance(old_value, dt) and isinstance(value, dt):
                # Compare only the date and time, ignoring timezone
                old_normalized = old_value.replace(tzinfo=None) if old_value.tzinfo else old_value
                new_normalized = value.replace(tzinfo=None) if value.tzinfo else value
                if old_normalized == new_normalized:
                    continue  # Skip if datetimes are the same
            
            if old_value != value:
                changes.append(f"{field} changed from '{old_value}' to '{value}'")
                setattr(db_obj, field, value)
        
        if changes:
            db.add(db_obj)
            db.commit()
            db.refresh(db_obj)
            
            # Log changes in journal
            for change in changes:
                journal.log_change(
                    db,
                    EntityType.ARRIVAL,
                    db_obj.id,
                    change,
                    user,
                    user_ip
                )
        
        return db_obj

    def update_status(
        self, 
        db: Session, 
        arrival_id: int, 
        status: ArrivalStatus,
        timestamp: Optional[datetime] = None,
        user: str = "system",
        user_ip: Optional[str] = None
    ) -> Optional[Arrival]:
        db_obj = self.get(db, arrival_id)
        if not db_obj:
            return None
        
        old_status = db_obj.status
        db_obj.status = status
        
        # Set timestamps based on status
        current_time = timestamp if timestamp is not None else datetime.utcnow()
        if status == ArrivalStatus.LANDED:
            db_obj.landed_dt = current_time
        elif status == ArrivalStatus.ARRIVED:
            db_obj.arrived_dt = current_time
        
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        
        # Create movement record if applicable
        if status == ArrivalStatus.LANDED and db_obj.landed_dt:
            movement_data = MovementCreate(
                movement_type=MovementType.LANDING,
                aircraft_registration=db_obj.registration,
                aircraft_type=db_obj.type,
                callsign=db_obj.callsign,
                timestamp=db_obj.landed_dt,
                entity_type="ARRIVAL",
                entity_id=arrival_id,
                from_location=db_obj.in_from,
                created_by=user,
                ip_address=user_ip
            )
            movement_crud.create(db, movement_data)

            # Promote any PENDING departure linked to this arrival to BOOKED_OUT
            from app.models.departure import Departure as DepartureModel, DepartureStatus as DepStatus
            pending_dep = db.query(DepartureModel).filter(
                DepartureModel.arrival_id == arrival_id,
                DepartureModel.status == DepStatus.PENDING
            ).first()
            if pending_dep:
                pending_dep.status = DepStatus.BOOKED_OUT
                db.add(pending_dep)
                db.commit()
                journal.log_change(
                    db,
                    EntityType.ARRIVAL,
                    arrival_id,
                    f"Linked departure #{pending_dep.id} promoted to BOOKED_OUT on landing",
                    user,
                    user_ip
                )
        
        # Log status change in journal
        journal.log_change(
            db,
            EntityType.ARRIVAL,
            arrival_id,
            f"Status changed from {old_status.value} to {status.value}",
            user,
            user_ip
        )
        
        return db_obj

    def cancel(self, db: Session, arrival_id: int, user: str = "system", user_ip: Optional[str] = None) -> Optional[Arrival]:
        db_obj = self.get(db, arrival_id)
        if not db_obj:
            return None
        
        old_status = db_obj.status
        db_obj.status = ArrivalStatus.CANCELLED
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        
        # Log cancellation in journal
        journal.log_change(
            db,
            EntityType.ARRIVAL,
            arrival_id,
            f"Status changed from {old_status.value} to CANCELLED",
            user,
            user_ip
        )
        
        return db_obj


arrival = CRUDArrival()