diff --git a/luthor/luthor/routers/printer.py b/luthor/luthor/routers/printer.py
deleted file mode 100644
index 92a4bea..0000000
--- a/luthor/luthor/routers/printer.py
+++ /dev/null
@@ -1,131 +0,0 @@
-# import uuid
-#
-# from typing import List
-#
-# import barker.schemas.printer as schemas
-#
-# from fastapi import APIRouter, Depends, HTTPException, Security, status
-# from sqlalchemy.exc import SQLAlchemyError
-# from sqlalchemy.orm import Session
-#
-# from ..core.security import get_current_active_user as get_user
-# from ..db.session import SessionLocal
-# from ..models.master import Printer
-# from ..schemas.user_token import UserToken
-#
-#
-# router = APIRouter()
-#
-#
-# # Dependency
-# def get_db():
-# try:
-# db = SessionLocal()
-# yield db
-# finally:
-# db.close()
-#
-#
-# @router.post("", response_model=schemas.Printer)
-# def save(
-# data: schemas.PrinterIn,
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["printers"]),
-# ) -> schemas.Printer:
-# try:
-# item = Printer(name=data.name, address=data.address, cut_code=data.cut_code)
-# db.add(item)
-# db.commit()
-# return printer_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.Printer)
-# def update(
-# id_: uuid.UUID,
-# data: schemas.PrinterIn,
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["printers"]),
-# ) -> schemas.Printer:
-# try:
-# item: Printer = db.query(Printer).filter(Printer.id == id_).first()
-# item.name = data.name
-# item.address = data.address
-# item.cut_code = data.cut_code
-# db.commit()
-# return printer_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.PrinterBlank)
-# def delete(
-# id_: uuid.UUID,
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["printers"]),
-# ) -> schemas.PrinterBlank:
-# try:
-# item: Printer = db.query(Printer).filter(Printer.id == id_).first()
-# db.delete(item)
-# db.commit()
-# return printer_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.PrinterBlank)
-# def show_blank(
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["printers"]),
-# ) -> schemas.PrinterBlank:
-# return printer_blank()
-#
-#
-# @router.get("/list", response_model=List[schemas.Printer])
-# def show_list(db: Session = Depends(get_db), user: UserToken = Depends(get_user)):
-# return [printer_info(item) for item in db.query(Printer).order_by(Printer.name).all()]
-#
-#
-# @router.get("/{id_}", response_model=schemas.Printer)
-# def show_id(
-# id_: uuid.UUID,
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["printers"]),
-# ) -> schemas.Printer:
-# item: Printer = db.query(Printer).filter(Printer.id == id_).first()
-# return printer_info(item)
-#
-#
-# def printer_info(item: Printer) -> schemas.Printer:
-# return schemas.Printer(
-# id=item.id,
-# name=item.name,
-# address=item.address,
-# cutCode=item.cut_code,
-# )
-#
-#
-# def printer_blank() -> schemas.PrinterBlank:
-# return schemas.PrinterBlank(name="", address="", cutCode="")
diff --git a/luthor/luthor/routers/product.py b/luthor/luthor/routers/product.py
deleted file mode 100644
index 5fe34d6..0000000
--- a/luthor/luthor/routers/product.py
+++ /dev/null
@@ -1,391 +0,0 @@
-# import uuid
-#
-# from datetime import date, timedelta
-# from typing import List
-#
-# import barker.schemas.product as schemas
-#
-# from fastapi import APIRouter, Depends, HTTPException, Security, status
-# from sqlalchemy import and_, or_
-# from sqlalchemy.exc import SQLAlchemyError
-# from sqlalchemy.orm import Session, contains_eager, joinedload
-#
-# from ..core.security import get_current_active_user as get_user
-# from ..db.session import SessionLocal
-# from ..models.master import MenuCategory, Product, ProductVersion, SaleCategory
-# from ..schemas.user_token import UserToken
-# from . import effective_date
-#
-#
-# router = APIRouter()
-#
-#
-# # Dependency
-# def get_db():
-# try:
-# db = SessionLocal()
-# yield db
-# finally:
-# db.close()
-#
-#
-# @router.post("/list", response_model=List[schemas.Product])
-# def sort_order(
-# data: List[schemas.Product],
-# date_: date = Depends(effective_date),
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["products"]),
-# ):
-# try:
-# indexes = {}
-# for item in data:
-# if item.menu_category.id_ in indexes:
-# indexes[item.menu_category.id_] += 1
-# else:
-# indexes[item.menu_category.id_] = 0
-# db.query(ProductVersion).filter(
-# and_(
-# ProductVersion.product_id == item.id_,
-# or_(
-# ProductVersion.valid_from == None, # noqa: E711
-# ProductVersion.valid_from <= date_,
-# ),
-# or_(
-# ProductVersion.valid_till == None, # noqa: E711
-# ProductVersion.valid_till >= date_,
-# ),
-# )
-# ).update({ProductVersion.sort_order: indexes[item.menu_category.id_]})
-# db.commit()
-# return product_list(date_, db)
-# 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.Product)
-# def save(
-# data: schemas.ProductIn,
-# date_: date = Depends(effective_date),
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["products"]),
-# ):
-# try:
-# item = Product()
-# db.add(item)
-# db.flush()
-# product_version = ProductVersion(
-# product_id=item.id,
-# name=data.name,
-# units=data.units,
-# menu_category_id=data.menu_category.id_,
-# sale_category_id=data.sale_category.id_,
-# price=data.price,
-# has_happy_hour=data.has_happy_hour,
-# is_not_available=data.is_not_available,
-# quantity=data.quantity,
-# valid_from=date_,
-# valid_till=None,
-# )
-# db.add(product_version)
-# db.commit()
-# return product_info(product_version)
-# 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.Product)
-# def update(
-# id_: uuid.UUID,
-# data: schemas.ProductIn,
-# date_: date = Depends(effective_date),
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["products"]),
-# ) -> schemas.Product:
-# try:
-# item: ProductVersion = (
-# db.query(ProductVersion)
-# .join(ProductVersion.menu_category)
-# .filter(
-# and_(
-# ProductVersion.product_id == id_,
-# or_(
-# ProductVersion.valid_from == None, # noqa: E711
-# ProductVersion.valid_from <= date_,
-# ),
-# or_(
-# ProductVersion.valid_till == None, # noqa: E711
-# ProductVersion.valid_till >= date_,
-# ),
-# )
-# )
-# .first()
-# )
-# if item.valid_till is not None:
-# # Allow adding a product here splitting the valid from and to, but not implemented right now
-# raise HTTPException(
-# status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-# detail="Product has been invalidated",
-# )
-# if item.valid_from == date_: # Update the product as valid from the the same
-# item.name = data.name
-# item.units = data.units
-# item.menu_category_id = data.menu_category.id_
-# item.sale_category_id = data.sale_category.id_
-# item.price = data.price
-# item.has_happy_hour = data.has_happy_hour
-# item.is_not_available = data.is_not_available
-# item.quantity = data.quantity
-# db.commit()
-# return product_info(item)
-# else: # Create a new version of the product from the new details
-# item.valid_till = date_ - timedelta(days=1)
-# product_version = ProductVersion(
-# product_id=item.product_id,
-# name=data.name,
-# units=data.units,
-# menu_category_id=data.menu_category.id_,
-# sale_category_id=data.sale_category.id_,
-# price=data.price,
-# has_happy_hour=data.has_happy_hour,
-# is_not_available=data.is_not_available,
-# quantity=data.quantity,
-# valid_from=date_,
-# valid_till=None,
-# sort_order=item.sort_order,
-# )
-# db.add(product_version)
-# db.commit()
-# return product_info(product_version)
-#
-# 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_}")
-# def delete(
-# id_: uuid.UUID,
-# date_: date = Depends(effective_date),
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["products"]),
-# ):
-# try:
-# item: ProductVersion = (
-# db.query(ProductVersion)
-# .filter(
-# and_(
-# ProductVersion.product_id == id_,
-# or_(
-# ProductVersion.valid_from == None, # noqa: E711
-# ProductVersion.valid_from <= date_,
-# ),
-# or_(
-# ProductVersion.valid_till == None, # noqa: E711
-# ProductVersion.valid_till >= date_,
-# ),
-# )
-# )
-# .first()
-# )
-# if item is None:
-# raise HTTPException(
-# status_code=status.HTTP_404_NOT_FOUND,
-# detail="Product not found",
-# )
-# elif item.valid_from == date_:
-# db.delete(item)
-# else:
-# item.valid_till = date_ - timedelta(days=1)
-# db.commit()
-# except Exception:
-# db.rollback()
-# raise
-#
-#
-# @router.get("", response_model=schemas.ProductBlank)
-# def show_blank(
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["products"]),
-# ) -> schemas.ProductBlank:
-# return schemas.ProductBlank(
-# name="",
-# units="",
-# price=0,
-# hasHappyHour=False,
-# isNotAvailable=False,
-# isActive=True,
-# sortOrder=0,
-# )
-#
-#
-# @router.get("/list", response_model=List[schemas.Product])
-# def show_list(
-# date_: date = Depends(effective_date), db: Session = Depends(get_db), user: UserToken = Depends(get_user)
-# ) -> List[schemas.Product]:
-# return product_list(date_, db)
-#
-#
-# def product_list(date_: date, db: Session) -> List[schemas.Product]:
-# return [
-# product_info(item)
-# for item in db.query(ProductVersion)
-# .join(ProductVersion.menu_category)
-# .join(ProductVersion.sale_category)
-# .filter(
-# and_(
-# or_(
-# ProductVersion.valid_from == None, # noqa: E711
-# ProductVersion.valid_from <= date_,
-# ),
-# or_(
-# ProductVersion.valid_till == None, # noqa: E711
-# ProductVersion.valid_till >= date_,
-# ),
-# )
-# )
-# .order_by(MenuCategory.sort_order)
-# .order_by(MenuCategory.name)
-# .order_by(ProductVersion.sort_order)
-# .order_by(ProductVersion.name)
-# .options(
-# joinedload(ProductVersion.menu_category, innerjoin=True),
-# joinedload(ProductVersion.sale_category, innerjoin=True),
-# contains_eager(ProductVersion.menu_category),
-# contains_eager(ProductVersion.sale_category),
-# )
-# .all()
-# ]
-#
-#
-# @router.get("/query")
-# async def show_term(
-# mc: uuid.UUID = None,
-# date_: date = Depends(effective_date),
-# db: Session = Depends(get_db),
-# current_user: UserToken = Depends(get_user),
-# ):
-# list_ = []
-# for item in (
-# db.query(ProductVersion)
-# .join(ProductVersion.sale_category)
-# .join(ProductVersion.sale_category, SaleCategory.tax)
-# .filter(
-# and_(
-# ProductVersion.menu_category_id == mc,
-# or_(
-# ProductVersion.valid_from == None, # noqa: E711
-# ProductVersion.valid_from <= date_,
-# ),
-# or_(
-# ProductVersion.valid_till == None, # noqa: E711
-# ProductVersion.valid_till >= date_,
-# ),
-# )
-# )
-# .order_by(ProductVersion.sort_order, ProductVersion.name)
-# .options(
-# joinedload(ProductVersion.sale_category, innerjoin=True),
-# joinedload(ProductVersion.sale_category, SaleCategory.tax, innerjoin=True),
-# contains_eager(ProductVersion.sale_category),
-# contains_eager(ProductVersion.sale_category, SaleCategory.tax),
-# )
-# .all()
-# ):
-# list_.append(query_product_info(item, False))
-# if item.has_happy_hour:
-# list_.append(query_product_info(item, True))
-# return list_
-#
-#
-# @router.get("/{id_}", response_model=schemas.Product)
-# def show_id(
-# id_: uuid.UUID,
-# date_: date = Depends(effective_date),
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["products"]),
-# ) -> schemas.Product:
-# item: ProductVersion = (
-# db.query(ProductVersion)
-# .join(ProductVersion.sale_category)
-# .join(ProductVersion.sale_category, SaleCategory.tax)
-# .filter(
-# and_(
-# ProductVersion.product_id == id_,
-# or_(
-# ProductVersion.valid_from == None, # noqa: E711
-# ProductVersion.valid_from <= date_,
-# ),
-# or_(
-# ProductVersion.valid_till == None, # noqa: E711
-# ProductVersion.valid_till >= date_,
-# ),
-# )
-# )
-# .order_by(ProductVersion.sort_order, ProductVersion.name)
-# .options(
-# joinedload(ProductVersion.sale_category, innerjoin=True),
-# joinedload(ProductVersion.sale_category, SaleCategory.tax, innerjoin=True),
-# contains_eager(ProductVersion.sale_category),
-# contains_eager(ProductVersion.sale_category, SaleCategory.tax),
-# )
-# .first()
-# )
-# return product_info(item)
-#
-#
-# def query_product_info(item: ProductVersion, happy_hour: bool):
-# return {
-# "id": item.product_id,
-# "name": ("H H " if happy_hour else "") + item.full_name,
-# "saleCategory": {
-# "id": item.sale_category_id,
-# "name": item.sale_category.name,
-# },
-# "tax": {
-# "id": item.sale_category.tax_id,
-# "name": item.sale_category.tax.name,
-# "rate": item.sale_category.tax.rate,
-# },
-# "price": item.price,
-# "hasHappyHour": happy_hour,
-# "isNotAvailable": item.is_not_available,
-# "sortOrder": item.sort_order,
-# }
-#
-#
-# def product_info(item: ProductVersion) -> schemas.Product:
-# return schemas.Product(
-# id=item.product_id,
-# name=item.name,
-# units=item.units,
-# menuCategory=schemas.MenuCategoryLink(id=item.menu_category_id, name=item.menu_category.name),
-# saleCategory=schemas.SaleCategoryLink(
-# id=item.sale_category_id,
-# name=item.sale_category.name,
-# ),
-# price=item.price,
-# hasHappyHour=item.has_happy_hour,
-# isNotAvailable=item.is_not_available,
-# isActive=True,
-# sortOrder=item.sort_order,
-# )
diff --git a/luthor/luthor/routers/section.py b/luthor/luthor/routers/section.py
deleted file mode 100644
index de28b67..0000000
--- a/luthor/luthor/routers/section.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import uuid
-
-from typing import List
-
-import luthor.schemas.act as schemas
-
-from fastapi import APIRouter, Depends, HTTPException, Security, status
-from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.orm import Session
-
-from ..core.security import get_current_active_user as get_user
-from ..db.session import SessionLocal
-from ..models.act import Act
-from ..schemas.user_token import UserToken
-
-
-router = APIRouter()
-
-
-# Dependency
-def get_db():
- try:
- db = SessionLocal()
- yield db
- finally:
- db.close()
-
-
-@router.post("", response_model=schemas.Act)
-def save(
- data: schemas.ActIn,
- db: Session = Depends(get_db),
- user: UserToken = Security(get_user, scopes=["acts"]),
-) -> schemas.Act:
- try:
- item = Act(name=data.name)
- db.add(item)
- db.commit()
- return act_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.Act)
-def update(
- id_: uuid.UUID,
- data: schemas.ActIn,
- db: Session = Depends(get_db),
- user: UserToken = Security(get_user, scopes=["acts"]),
-) -> schemas.Act:
- try:
- item: Act = db.query(Act).filter(Act.id == id_).first()
- item.name = data.name
- db.commit()
- return act_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.ActBlank)
-def delete(
- id_: uuid.UUID,
- db: Session = Depends(get_db),
- user: UserToken = Security(get_user, scopes=["acts"]),
-) -> schemas.ActBlank:
- try:
- item: Act = db.query(Act).filter(Act.id == id_).first()
- db.delete(item)
- db.commit()
- return act_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.ActBlank)
-def show_blank(
- db: Session = Depends(get_db),
- user: UserToken = Security(get_user, scopes=["acts"]),
-) -> schemas.ActBlank:
- return act_blank()
-
-
-@router.get("/list", response_model=List[schemas.Act])
-def show_list(db: Session = Depends(get_db), user: UserToken = Depends(get_user)):
- return [act_info(item) for item in db.query(Act).order_by(Act.name).all()]
-
-
-@router.get("/{id_}", response_model=schemas.Act)
-def show_id(
- id_: uuid.UUID,
- db: Session = Depends(get_db),
- user: UserToken = Security(get_user, scopes=["acts"]),
-) -> schemas.Act:
- item: Act = db.query(Act).filter(Act.id == id_).first()
- return act_info(item)
-
-
-def act_info(item: Act) -> schemas.Act:
- return schemas.Act(id=item.id, name=item.name)
-
-
-def act_blank() -> schemas.ActBlank:
- return schemas.ActBlank(name="")
diff --git a/luthor/luthor/routers/table.py b/luthor/luthor/routers/table.py
deleted file mode 100644
index f71515b..0000000
--- a/luthor/luthor/routers/table.py
+++ /dev/null
@@ -1,212 +0,0 @@
-# import uuid
-#
-# 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.security import get_current_active_user as get_user
-# from ..db.session import SessionLocal
-# from ..models.master import FoodTable
-# from ..models.voucher 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.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)
diff --git a/luthor/luthor/routers/tax.py b/luthor/luthor/routers/tax.py
deleted file mode 100644
index f5330b0..0000000
--- a/luthor/luthor/routers/tax.py
+++ /dev/null
@@ -1,178 +0,0 @@
-# import re
-# import uuid
-#
-# from decimal import Decimal
-# from typing import List
-#
-# import barker.schemas.tax as schemas
-#
-# from fastapi import APIRouter, Depends, HTTPException, Security, status
-# from sqlalchemy.exc import SQLAlchemyError
-# from sqlalchemy.orm import Session
-# from sqlalchemy.sql.functions import count
-#
-# from ..core.security import get_current_active_user as get_user
-# from ..db.session import SessionLocal
-# from ..models.master import SaleCategory, Tax
-# from ..models.voucher import Inventory
-# from ..schemas.user_token import UserToken
-#
-#
-# router = APIRouter()
-#
-#
-# # Dependency
-# def get_db():
-# try:
-# db = SessionLocal()
-# yield db
-# finally:
-# db.close()
-#
-#
-# @router.post("", response_model=schemas.Tax)
-# def save(
-# data: schemas.TaxIn,
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["taxes"]),
-# ) -> schemas.Tax:
-# try:
-# item = Tax(name=data.name, rate=round(data.rate, 5))
-# if not name_valid(data.name):
-# raise HTTPException(
-# status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-# detail="The name is not valid",
-# )
-# db.add(item)
-# db.commit()
-# return tax_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.Tax)
-# def update(
-# id_: uuid.UUID,
-# data: schemas.TaxIn,
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["taxes"]),
-# ) -> schemas.Tax:
-# try:
-# item: Tax = db.query(Tax).filter(Tax.id == id_).first()
-# if item.is_fixture:
-# raise HTTPException(
-# status_code=status.HTTP_423_LOCKED,
-# detail=f"{item.name} is a fixture and cannot be edited or deleted.",
-# )
-# if not name_valid(data.name):
-# raise HTTPException(
-# status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-# detail="The name is not valid",
-# )
-# item.name = data.name
-# item.rate = round(data.rate, 5)
-# db.commit()
-# return tax_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.TaxBlank)
-# def delete(
-# id_: uuid.UUID,
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["taxes"]),
-# ) -> schemas.TaxBlank:
-# try:
-# item: Tax = db.query(Tax).filter(Tax.id == id_).first()
-# if item is None:
-# raise HTTPException(
-# status_code=status.HTTP_404_NOT_FOUND,
-# detail="Tax not found",
-# )
-# if item.is_fixture:
-# raise HTTPException(
-# status_code=status.HTTP_423_LOCKED,
-# detail=f"{item.name} is a fixture and cannot be edited or deleted.",
-# )
-# if db.query(count(SaleCategory.tax_id)).filter(SaleCategory.tax_id == item.id).scalar() > 0:
-# raise HTTPException(
-# status_code=status.HTTP_423_LOCKED,
-# detail=f"{item.name} has associated Sale Categories and cannot be deleted",
-# )
-# if db.query(count(Inventory.tax_id)).filter(Inventory.tax_id == item.id).scalar() > 0:
-# raise HTTPException(
-# status_code=status.HTTP_423_LOCKED,
-# detail=f"{item.name} has associated Inventories and cannot be deleted",
-# )
-# db.delete(item)
-# db.commit()
-# return tax_blank()
-# except Exception:
-# db.rollback()
-# raise
-#
-#
-# @router.get("", response_model=schemas.TaxBlank)
-# def show_blank(
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["taxes"]),
-# ) -> schemas.TaxBlank:
-# return tax_blank()
-#
-#
-# @router.get("/list", response_model=List[schemas.Tax])
-# def show_list(db: Session = Depends(get_db), user: UserToken = Depends(get_user)) -> List[schemas.Tax]:
-# return [tax_info(item) for item in db.query(Tax).order_by(Tax.name).all()]
-#
-#
-# @router.get("/{id_}", response_model=schemas.Tax)
-# def show_id(
-# id_: uuid.UUID,
-# db: Session = Depends(get_db),
-# user: UserToken = Security(get_user, scopes=["taxes"]),
-# ) -> schemas.Tax:
-# item: Tax = db.query(Tax).filter(Tax.id == id_).first()
-# return tax_info(item)
-#
-#
-# def tax_info(item: Tax) -> schemas.Tax:
-# return schemas.Tax(
-# id=item.id,
-# name=item.name,
-# rate=item.rate,
-# isFixture=item.is_fixture,
-# )
-#
-#
-# def tax_blank() -> schemas.TaxBlank:
-# return schemas.TaxBlank(name="", rate=0, isFixture=False)
-#
-#
-# def name_valid(name: str) -> bool:
-# items = name.split(";")
-# if len(items) == 1:
-# return True
-# total = 0
-# for i, item in enumerate(it.strip() for it in items):
-# match = re.match(r"(^.*)\s+\((.*?)/(.*?)\)[^(]*$", item)
-# if not match or len(match.groups()) != 3:
-# return False
-# total += round(Decimal(match.group(2)) / Decimal(match.group(3)), 5)
-# if round(total, 2) != 1:
-# return False
-# return True
diff --git a/otis/src/app/cases/case-detail/case-detail.component.html b/otis/src/app/cases/case-detail/case-detail.component.html
index 72d22e6..d83dc29 100644
--- a/otis/src/app/cases/case-detail/case-detail.component.html
+++ b/otis/src/app/cases/case-detail/case-detail.component.html
@@ -21,6 +21,20 @@
formControlName="officeFileNumber"
/>
+