tanshu
/
barker
1
0
Fork 0
Code Issues 1 Pull Requests Releases 4 Activity

Ported: 

Customer
  Device
  Role
  Settings
This commit is contained in:
Amritanshu Agrawal 2020-09-22 07:59:14 +05:30
parent 7b6c09cea3
commit cabdd505e0
17 changed files with 419 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
barker/routers/customer.py
View File

@ -1,86 +1,116 @@
import uuid
from typing import Optional
import transaction
from pyramid.view import view_config
from fastapi import APIRouter, HTTPException, status, Depends, Security
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session
from barker.models import Customer
from ..schemas.auth import UserToken
import barker.schemas.master as schemas
from ..core.security import get_current_active_user as get_user
from ..db.session import SessionLocal
from ..models.master import Customer
router = APIRouter()
@view_config(
request_method="PUT", route_name="v1_customers_new", renderer="json", permission="Customers", trans=True,
)
def save(request):
json = request.json_body
item = Customer(json["company"], json["name"], json["phone"], json["address"], json["important"])
request.dbsession.add(item)
transaction.commit()
item = request.dbsession.query(Customer).filter(Customer.id == item.id).first()
return customer_info(item)
# Dependency
def get_db():
try:
db = SessionLocal()
yield db
finally:
db.close()
@view_config(
request_method="POST", route_name="v1_customers_id", renderer="json", permission="Customers", trans=True,
)
def update(request):
json = request.json_body
item = request.dbsession.query(Customer).filter(Customer.id == uuid.UUID(request.matchdict["id"])).first()
item.company = json["company"]
item.name = json["name"]
item.phone = json["phone"]
item.address = json["address"]
item.is_important = json["important"]
transaction.commit()
item = request.dbsession.query(Customer).filter(Customer.id == item.id).first()
return customer_info(item)
@view_config(
request_method="DELETE", route_name="v1_customers_id", renderer="json", permission="Customers", trans=True,
)
def delete(request):
item = request.dbsession.query(Customer).filter(Customer.id == uuid.UUID(request.matchdict["id"])).first()
request.dbsession.delete(item)
transaction.commit()
return {}
@view_config(
request_method="GET", route_name="v1_customers_id", renderer="json", permission="Authenticated",
)
def show_id(request):
id_ = uuid.UUID(request.matchdict["id"])
item = request.dbsession.query(Customer).filter(Customer.id == id_).first()
return customer_info(item)
@view_config(
request_method="GET", route_name="v1_customers_list", renderer="json", permission="Authenticated",
)
def show_list(request):
list_ = request.dbsession.query(Customer).order_by(Customer.name).all()
customers = []
for item in list_:
customers.append(
{
"id": item.id,
"company": item.company,
"name": item.name,
"address": item.address,
"important": item.is_important,
"phone": item.phone,
"remarks": "",
}
@router.post("", response_model=schemas.Customer)
def save(
data: schemas.CustomerIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["customers"]),
):
try:
item = Customer(company=data.company, name=data.name, phone=data.phone, address=data.address)
db.add(item)
db.commit()
return customer_info(item)
except SQLAlchemyError as e:
db.rollback()
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
)
return customers
except Exception:
db.rollback()
raise
def customer_info(item):
@router.put("/{id_}", response_model=schemas.Customer)
def update(
id_: uuid.UUID,
data: schemas.CustomerIn,
db: Session = Depends(get_db),
user: UserToken = Security(get_user, scopes=["customers"]),
):
try:
item: Customer = db.query(Customer).filter(Customer.id == id_).first()
item.company = data.company
item.name = data.name
item.phone = data.phone
item.address = data.address
db.commit()
return customer_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_}")
def delete(
id_: uuid.UUID, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["customers"]),
):
try:
item: Customer = db.query(Customer).filter(Customer.id == id_).first()
if item is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND, detail="Sale Category not found",
)
db.delete(item)
db.commit()
except Exception:
db.rollback()
raise
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["customers"]),
):
return customer_info(None)
@router.get("/list")
def show_list(db: Session = Depends(get_db), user: UserToken = Depends(get_user)):
return [customer_info(item) for item in db.query(Customer).order_by(Customer.name).all()]
@router.get("/{id_}")
def show_id(
id_: uuid.UUID, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["customers"]),
):
item: Customer = db.query(Customer).filter(Customer.id == id_).first()
return customer_info(item)
def customer_info(item: Optional[Customer]):
if item is None:
return {"name": "", "company": "", "address": "", "phone": ""}
return {
"id": item.id,
"company": item.company,
"name": item.name,
"address": item.address,
"important": item.is_important,
"phone": item.phone,
"remarks": "",
}

157
barker/routers/device.py
View File

@ -1,87 +1,112 @@
import uuid
import transaction
from pyramid.response import Response
from pyramid.view import view_config
from typing import Optional
from barker.models import Device
from barker.models.validation_exception import ValidationError
from fastapi import APIRouter, HTTPException, status, Depends, Security
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session
from ..schemas.auth import UserToken
import barker.schemas.master as schemas
from ..core.security import get_current_active_user as get_user
from ..db.session import SessionLocal
from ..models.master import Device
router = APIRouter()
@view_config(
request_method="POST", route_name="v1_devices_new", renderer="json", permission="Devices", trans=True,
)
def save(request):
json = request.json_body
name = json.get("name", "").strip()
if name == "":
raise ValidationError("Name cannot be blank")
section = json.get("section", None)
if section is None:
raise ValidationError("please choose a section")
section_id = uuid.UUID(section["id"])
item = Device(name, section_id)
request.dbsession.add(item)
transaction.commit()
return device_info(item.id, request.dbsession)
# Dependency
def get_db():
try:
db = SessionLocal()
yield db
finally:
db.close()
@view_config(
request_method="PUT", route_name="v1_devices_id", renderer="json", permission="Devices", trans=True,
)
def update(request):
json = request.json_body
item = request.dbsession.query(Device).filter(Device.id == uuid.UUID(request.matchdict["id"])).first()
if item.is_fixture:
raise ValidationError("{0} is a fixture and cannot be edited or deleted.".format(item.full_name))
item.name = json["name"].strip()
item.section_id = uuid.UUID(json["section"]["id"])
transaction.commit()
return device_info(item.id, request.dbsession)
@router.post("", response_model=schemas.Device)
def save(
data: schemas.DeviceIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["devices"]),
):
try:
item = Device(name=data.name, section_id=data.section.id_)
db.add(item)
db.commit()
return device_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
@view_config(
request_method="DELETE", route_name="v1_devices_id", renderer="json", permission="Devices", trans=True,
)
def delete(request):
item = request.dbsession.query(Device).filter(Device.id == uuid.UUID(request.matchdict["id"])).first()
if item is None:
response = Response("Device not Found")
response.status_int = 500
return response
else:
response = Response("Device deletion not implemented")
response.status_int = 500
return response
@router.put("/{id_}", response_model=schemas.Device)
def update(
id_: uuid.UUID,
data: schemas.DeviceIn,
db: Session = Depends(get_db),
user: UserToken = Security(get_user, scopes=["devices"]),
):
try:
item: Device = db.query(Device).filter(Device.id == id_).first()
item.name = data.name
item.section_id = data.section.id_
db.commit()
return device_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
@view_config(
request_method="GET", route_name="v1_devices_new", renderer="json", permission="Authenticated",
)
def show_blank(request):
return device_info(None, request.dbsession)
@router.delete("/{id_}")
def delete(
id_: uuid.UUID, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["devices"]),
):
try:
item: Device = db.query(Device).filter(Device.id == id_).first()
db.delete(item)
db.commit()
return device_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
@view_config(
request_method="GET", route_name="v1_devices_id", renderer="json", permission="Authenticated",
)
def show_id(request):
return device_info(uuid.UUID(request.matchdict["id"]), request.dbsession)
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["devices"]),
):
return device_info(None)
@view_config(
request_method="GET", route_name="v1_devices_list", renderer="json", permission="Authenticated",
)
def show_list(request):
return [
device_info(item, request.dbsession) for item in request.dbsession.query(Device).order_by(Device.name).all()
]
@router.get("/list")
def show_list(db: Session = Depends(get_db), user: UserToken = Depends(get_user)):
return [device_info(item) for item in db.query(Device).order_by(Device.name).all()]
def device_info(item, dbsession):
@router.get("/{id_}")
def show_id(
id_: uuid.UUID, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["devices"]),
):
item: Device = db.query(Device).filter(Device.id == id_).first()
return device_info(item)
def device_info(item: Optional[Device]):
if item is None:
return {"name": "", "section": {}}
if type(item) is uuid.UUID:
item = dbsession.query(Device).filter(Device.id == item).first()
return {
"id": item.id,
"name": item.name,

4
barker/routers/menu_category.py
View File

@ -23,7 +23,7 @@ def get_db():
db.close()
@router.post("/", response_model=schemas.MenuCategory)
@router.post("", response_model=schemas.MenuCategory)
def save(
data: schemas.MenuCategoryIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["products"]),
):
@ -93,7 +93,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["products"]),
):

4
barker/routers/modifier.py
View File

@ -23,7 +23,7 @@ def get_db():
db.close()
@router.post("/", response_model=schemas.Modifier)
@router.post("", response_model=schemas.Modifier)
def save(
data: schemas.ModifierIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["modifiers"]),
):
@ -93,7 +93,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["modifiers"]),
):

4
barker/routers/modifier_category.py
View File

@ -24,7 +24,7 @@ def get_db():
db.close()
@router.post("/", response_model=schemas.ModifierCategory)
@router.post("", response_model=schemas.ModifierCategory)
def save(
data: schemas.ModifierCategoryIn,
db: Session = Depends(get_db),
@ -91,7 +91,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["modifiers"]),
):

4
barker/routers/printer.py
View File

@ -23,7 +23,7 @@ def get_db():
db.close()
@router.post("/", response_model=schemas.Printer)
@router.post("", response_model=schemas.Printer)
def save(
data: schemas.PrinterIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["printers"]),
):
@ -85,7 +85,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=[""]),
):

4
barker/routers/product.py
View File

@ -58,7 +58,7 @@ def sort_order(
raise
@router.post("/", response_model=schemas.Product)
@router.post("", response_model=schemas.Product)
def save(
data: schemas.ProductIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["products"]),
):
@ -136,7 +136,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["products"]),
):

196
barker/routers/role.py
View File

@ -1,100 +1,144 @@
import uuid
from typing import List, Optional
import transaction
from pyramid.response import Response
from pyramid.view import view_config
from fastapi import APIRouter, HTTPException, status, Depends, Security
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session
from barker.models import Permission, Role
from ..schemas.auth import UserToken
from ..core.security import get_current_active_user as get_user
from ..db.session import SessionLocal
from ..models.auth import Role, Permission
import barker.schemas.auth as schemas
router = APIRouter()
@view_config(
request_method="POST", route_name="v1_roles_new", renderer="json", permission="Users", trans=True,
)
def save(request):
item = Role(request.json_body["name"])
request.dbsession.add(item)
add_permissions(item, request.json_body["permissions"], request.dbsession)
transaction.commit()
return role_info(item.id, request.dbsession)
# Dependency
def get_db():
try:
db = SessionLocal()
yield db
finally:
db.close()
@view_config(
request_method="PUT", route_name="v1_roles_id", renderer="json", permission="Users", trans=True,
)
def update(request):
id_ = request.matchdict["id"]
item = request.dbsession.query(Role).filter(Role.id == uuid.UUID(id_)).one()
item.name = request.json_body["name"]
add_permissions(item, request.json_body["permissions"], request.dbsession)
transaction.commit()
return role_info(item.id, request.dbsession)
@router.post("", response_model=schemas.Role)
def save(
data: schemas.RoleIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["users"]),
):
try:
item = Role(data.name)
db.add(item)
add_permissions(item, data.permissions, db)
db.commit()
return role_info(item, 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
def add_permissions(role, permissions, dbsession):
@router.put("/{id_}", response_model=schemas.Role)
def update(
id_: uuid.UUID,
data: schemas.RoleIn,
db: Session = Depends(get_db),
user: UserToken = Security(get_user, scopes=["users"]),
):
try:
item: Role = db.query(Role).filter(Role.id == id_).first()
item.name = data.name
add_permissions(item, data.permissions, db)
db.commit()
return role_info(item, 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
def add_permissions(role: Role, permissions: List[schemas.PermissionItem], db):
for permission in permissions:
id_ = uuid.UUID(permission["id"])
rp = [p for p in role.permissions if p.id == id_]
rp = None if len(rp) == 0 else rp[0]
if permission["enabled"] and rp is None:
permission_object = dbsession.query(Permission).filter(Permission.id == id_).one()
role.permissions.append(permission_object)
elif not permission["enabled"] and rp:
role.permissions.remove(rp)
gp = [p for p in role.permissions if p.id == permission.id_]
gp = None if len(gp) == 0 else gp[0]
if permission.enabled and gp is None:
role.permissions.append(db.query(Permission).filter(Permission.id == permission.id_).one())
elif not permission.enabled and gp:
role.permissions.remove(gp)
@view_config(
request_method="DELETE", route_name="v1_roles_id", renderer="json", permission="Users", trans=True,
)
def delete(request):
id_ = request.matchdict["id"]
if id_ is None:
response = Response("Role is Null")
response.status_int = 500
return response
else:
response = Response("Role deletion not implemented")
response.status_int = 500
return response
@router.delete("/{id_}")
def delete(
id_: uuid.UUID, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["users"]),
):
try:
item: Role = db.query(Role).filter(Role.id == id_).first()
if item is None:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Role not found",
)
else:
raise HTTPException(
status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Role deletion not implemented",
)
except Exception:
db.rollback()
raise
@view_config(
request_method="GET", route_name="v1_roles_id", renderer="json", permission="Authenticated",
)
def show_id(request):
id_ = uuid.UUID(request.matchdict["id"])
return role_info(id_, request.dbsession)
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["users"]),
):
return role_info(None, db)
@view_config(
request_method="GET", route_name="v1_roles_new", renderer="json", permission="Authenticated",
)
def show_blank(request):
return role_info(None, request.dbsession)
@view_config(
request_method="GET", route_name="v1_roles_list", renderer="json", permission="Authenticated",
)
def show_list(request):
list_ = request.dbsession.query(Role).order_by(Role.name).all()
@router.get("/list", response_model=List[schemas.RoleList])
async def show_list(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["users"]),
):
return [
{"id": item.id, "name": item.name, "permissions": sorted(p.name for p in item.permissions),} for item in list_
{
"id": item.id,
"name": item.name,
"permissions": [p.name for p in sorted(item.permissions, key=lambda p: p.name)],
}
for item in db.query(Role).order_by(Role.name).all()
]
def role_info(item, dbsession):
permissions = dbsession.query(Permission).order_by(Permission.name).all()
@router.get("/{id_}", response_model=schemas.Role)
def show_id(
id_: uuid.UUID, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["users"]),
):
item: Role = db.query(Role).filter(Role.id == id_).first()
return role_info(item, db)
def role_info(item: Optional[Role], db):
if item is None:
return {
"name": "",
"permissions": [{"id": p.id, "name": p.name, "enabled": False} for p in permissions],
"permissions": [
{"id": p.id, "name": p.name, "enabled": False}
for p in db.query(Permission).order_by(Permission.name).all()
],
}
else:
return {
"id": item.id,
"name": item.name,
"permissions": [
{"id": p.id, "name": p.name, "enabled": True if p in item.permissions else False,}
for p in db.query(Permission).order_by(Permission.name).all()
],
}
if type(item) is uuid.UUID:
item = dbsession.query(Role).filter(Role.id == item).first()
return {
"id": item.id,
"name": item.name,
"permissions": [
{"id": p.id, "name": p.name, "enabled": True if p in item.permissions else False,} for p in permissions
],
}

4
barker/routers/sale_category.py
View File

@ -23,7 +23,7 @@ def get_db():
db.close()
@router.post("/", response_model=schemas.SaleCategory)
@router.post("", response_model=schemas.SaleCategory)
def save(
data: schemas.SaleCategoryIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["products"]),
):
@ -84,7 +84,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["products"]),
):

4
barker/routers/section.py
View File

@ -23,7 +23,7 @@ def get_db():
db.close()
@router.post("/", response_model=schemas.Section)
@router.post("", response_model=schemas.Section)
def save(
data: schemas.SectionIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["sections"]),
):
@ -83,7 +83,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["sections"]),
):

2
barker/routers/section_printer.py
View File

@ -94,7 +94,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["section-printers"]),
):

36
barker/routers/setting.py
View File

@ -1,12 +1,30 @@
from pyramid.view import view_config
import uuid
from barker.models import DbSetting
from fastapi import APIRouter, Depends, Security
from sqlalchemy.orm import Session
from ..schemas.auth import UserToken
from ..core.security import get_current_active_user as get_user
from ..db.session import SessionLocal
from ..models.master import DbSetting
router = APIRouter()
@view_config(
request_method="GET", route_name="v1_settings_id", renderer="json", permission="Authenticated",
)
def show_id(request):
name = request.matchdict["id"]
item = request.dbsession.query(DbSetting).filter(DbSetting.name == name).first()
return {"SettingID": item.id, "Name": item.name, "Details": item.data}
# Dependency
def get_db():
try:
db = SessionLocal()
yield db
finally:
db.close()
@router.get("/{id_}")
def get(
id_: uuid.UUID,
db: Session = Depends(get_db),
user: UserToken = Security(get_user),
):
data = db.query(DbSetting).filter(DbSetting.name == id_).first()
return {"id": data.id, "name": data.name, "details": data.data}

4
barker/routers/table.py
View File

@ -56,7 +56,7 @@ def sort_order(
raise
@router.post("/", response_model=schemas.Table)
@router.post("", response_model=schemas.Table)
def save(
data: schemas.TableIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["tables"]),
):
@ -119,7 +119,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["tables"]),
):

4
barker/routers/tax.py
View File

@ -23,7 +23,7 @@ def get_db():
db.close()
@router.post("/", response_model=schemas.Tax)
@router.post("", response_model=schemas.Tax)
def save(
data: schemas.TaxIn, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["taxes"]),
):
@ -92,7 +92,7 @@ def delete(
raise
@router.get("/")
@router.get("")
def show_blank(
db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["taxes"]),
):

29
barker/schemas/customer.py Normal file
View File

@ -0,0 +1,29 @@
import uuid
from typing import Optional, List
from decimal import Decimal
from pydantic import BaseModel, Field
from barker.schemas import to_camel
from barker.schemas.product import ProductLink
class CustomerIn(BaseModel):
name: str = Field(..., min_length=1)
company: str
phone: str = Field(..., min_length=1)
address: str
class Config:
fields = {"id_": "id"}
anystr_strip_whitespace = True
alias_generator = to_camel
class Customer(CustomerIn):
id_: uuid.UUID
class Config:
fields = {"id_": "id"}
anystr_strip_whitespace = True
alias_generator = to_camel

32
barker/schemas/device.py Normal file
View File

@ -0,0 +1,32 @@
import uuid
from typing import Optional
from pydantic import BaseModel, Field
from barker.schemas import to_camel
from barker.schemas.section import SectionLink
class DeviceIn(BaseModel):
name: str = Field(..., min_length=1)
section: SectionLink
class Config:
anystr_strip_whitespace = True
alias_generator = to_camel
class Device(DeviceIn):
id_: uuid.UUID
class Config:
alias_generator = to_camel
class DeviceLink(BaseModel):
id_: uuid.UUID = Field(...)
name: Optional[str]
class Config:
fields = {"id_": "id"}
alias_generator = to_camel

2
barker/schemas/master.py
View File

@ -8,12 +8,14 @@ from pydantic import BaseModel, Field, validator
from barker.schemas import to_camel
from barker.schemas.tax import TaxLink, TaxIn, Tax # noqa: F401
from barker.schemas.sale_category import SaleCategoryLink, SaleCategoryIn, SaleCategory # noqa: F401
from barker.schemas.customer import CustomerIn, Customer # noqa: F401
from barker.schemas.menu_category import MenuCategoryLink, MenuCategoryIn, MenuCategory # noqa: F401
from barker.schemas.product import ProductLink, ProductIn, Product # noqa: F401
from barker.schemas.modifier_category import ModifierCategoryLink, ModifierCategoryIn, ModifierCategory # noqa: F401
from barker.schemas.modifier import ModifierLink, ModifierIn, Modifier # noqa: F401
from barker.schemas.printer import PrinterLink, PrinterIn, Printer # noqa: F401
from barker.schemas.section import SectionLink, SectionIn, Section # noqa: F401
from barker.schemas.device import DeviceLink, DeviceIn, Device # noqa: F401
from barker.schemas.section_printer import SectionPrinter # noqa: F401
from barker.schemas.table import TableLink, TableIn, Table # noqa: F401