barker/barker/barker/routers/table.py

import uuid

from datetime import timedelta
from typing import List, Union

import barker.schemas.table as schemas

from fastapi import APIRouter, Depends, HTTPException, Security, status
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session

from ..core.config import settings
from ..core.security import get_current_active_user as get_user
from ..db.session import SessionLocal
from ..models.food_table import FoodTable
from ..models.overview import Overview
from ..schemas.user_token import UserToken


router = APIRouter()


# Dependency
def get_db():
    try:
        db = SessionLocal()
        yield db
    finally:
        db.close()


@router.post("/list", response_model=List[schemas.Table])
def sort_order(
    data: List[schemas.Table],
    db: Session = Depends(get_db),
    user: UserToken = Security(get_user, scopes=["sections"]),
) -> List[schemas.Table]:
    try:
        for index, item in enumerate(data):
            db.query(FoodTable).filter(FoodTable.id == item.id_).update({FoodTable.sort_order: index})
        db.commit()
        return [
            {
                "id": item.id,
                "name": item.name,
                "seats": item.seats,
                "section": {"id": item.section_id, "name": item.section.name},
                "isActive": item.is_active,
                "sortOrder": item.sort_order,
            }
            for item in db.query(FoodTable).order_by(FoodTable.sort_order).all()
        ]
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=str(e),
        )
    except Exception:
        db.rollback()
        raise


@router.post("", response_model=schemas.Table)
def save(
    data: schemas.TableIn,
    db: Session = Depends(get_db),
    user: UserToken = Security(get_user, scopes=["sections"]),
) -> schemas.Table:
    try:
        item = FoodTable(
            name=data.name,
            seats=data.seats,
            section_id=data.section.id_,
            is_active=data.is_active,
        )
        db.add(item)
        db.commit()
        return food_table_info(item)
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=str(e),
        )
    except Exception:
        db.rollback()
        raise


@router.put("/{id_}", response_model=schemas.Table)
def update(
    id_: uuid.UUID,
    data: schemas.TableIn,
    db: Session = Depends(get_db),
    user: UserToken = Security(get_user, scopes=["sections"]),
) -> schemas.Table:
    try:
        item: FoodTable = db.query(FoodTable).filter(FoodTable.id == id_).first()
        item.name = data.name
        item.seats = data.seats
        item.section_id = data.section.id_
        item.is_active = data.is_active
        db.commit()
        return food_table_info(item)
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=str(e),
        )
    except Exception:
        db.rollback()
        raise


@router.delete("/{id_}", response_model=schemas.TableBlank)
def delete(
    id_: uuid.UUID,
    db: Session = Depends(get_db),
    user: UserToken = Security(get_user, scopes=["sections"]),
) -> schemas.TableBlank:
    try:
        item: FoodTable = db.query(FoodTable).filter(FoodTable.id == id_).first()
        db.delete(item)
        db.commit()
        return food_table_blank()
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=str(e),
        )
    except Exception:
        db.rollback()
        raise


@router.get("", response_model=schemas.TableBlank)
def show_blank(
    db: Session = Depends(get_db),
    user: UserToken = Security(get_user, scopes=["sections"]),
) -> schemas.TableBlank:
    return food_table_blank()


@router.get("/list", response_model=List[schemas.Table])
def show_list(db: Session = Depends(get_db), user: UserToken = Depends(get_user)):
    return [food_table_info(item) for item in db.query(FoodTable).order_by(FoodTable.sort_order).all()]


@router.get("/running")
def show_running(db: Session = Depends(get_db), user: UserToken = Depends(get_user)):
    list_ = db.query(FoodTable).filter(FoodTable.is_active == True).order_by(FoodTable.sort_order).all()  # noqa: E712

    food_tables = []
    for item in list_:
        ft = {
            "id": item.id,
            "name": item.name,
            "seats": item.seats,
            "section": {"id": item.section_id, "name": item.section.name},
            "isActive": item.is_active,
            "sortOrder": item.sort_order,
        }
        if item.status is not None:
            ft["status"] = item.status.status
            ft["voucherId"] = item.status.voucher_id
            ft["pax"] = item.status.voucher.pax
            ft["date"] = (item.status.voucher.date + timedelta(minutes=settings.TIMEZONE_OFFSET_MINUTES)).strftime(
                "%d-%b-%Y %H:%M"
            )
            ft["amount"] = item.status.voucher.amount
            if item.status.guest is not None:
                ft["guest"] = item.status.guest.customer.name
        food_tables.append(ft)
    return food_tables


@router.get("/from-voucher/{id_}", response_model=Union[schemas.Table, schemas.TableBlank])
def show_voucher(
    id_: uuid.UUID,
    db: Session = Depends(get_db),
    user: UserToken = Security(get_user),
) -> Union[schemas.Table, schemas.TableBlank]:
    overview: Overview = db.query(Overview).filter(Overview.voucher_id == id_).first()
    if overview is not None:
        return food_table_info(overview.food_table)
    return food_table_blank()


@router.get("/{id_}", response_model=schemas.Table)
def show_id(
    id_: uuid.UUID,
    db: Session = Depends(get_db),
    user: UserToken = Security(get_user, scopes=["sections"]),
) -> schemas.Table:
    item: FoodTable = db.query(FoodTable).filter(FoodTable.id == id_).first()
    return food_table_info(item)


def food_table_info(item: FoodTable) -> schemas.Table:
    return schemas.Table(
        id=item.id,
        name=item.name,
        seats=item.seats,
        section=schemas.SectionLink(id=item.section_id, name=item.section.name),
        isActive=item.is_active,
        status="" if item.status is None else item.status.status,
        sortOrder=item.sort_order,
        voucherId=None if item.status is None else item.status.voucher_id,
    )


def food_table_blank() -> schemas.TableBlank:
    return schemas.TableBlank(name="", seats=0, isActive=True, sortOrder=0)