216 lines
8.6 KiB
Python
216 lines
8.6 KiB
Python
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
from fastapi import APIRouter, Depends, Query, Response
|
|
from sqlalchemy import func, select
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.api.dependencies import current_user
|
|
from app.db.session import get_session
|
|
from app.models.contact import Contact
|
|
from app.models.customer import Customer
|
|
from app.models.device import Device
|
|
from app.models.equipment import Equipment
|
|
from app.models.location import Location
|
|
from app.models.validation import Validation
|
|
from app.schemas.common import PaginatedResponse
|
|
from app.schemas.domain import (
|
|
ContactCreate,
|
|
ContactRead,
|
|
ContactUpdate,
|
|
CustomerCreate,
|
|
CustomerRead,
|
|
CustomerUpdate,
|
|
DeviceCreate,
|
|
DeviceRead,
|
|
DeviceUpdate,
|
|
EquipmentCreate,
|
|
EquipmentRead,
|
|
EquipmentUpdate,
|
|
LocationCreate,
|
|
LocationRead,
|
|
LocationUpdate,
|
|
ValidationCreate,
|
|
ValidationRead,
|
|
ValidationUpdate,
|
|
)
|
|
from app.services.domain_service import CrudService, DomainServices
|
|
|
|
router = APIRouter(tags=["domain"], dependencies=[Depends(current_user)])
|
|
|
|
|
|
@router.get("/dashboard")
|
|
def dashboard(session: Session = Depends(get_session)) -> dict[str, int]:
|
|
return {
|
|
"customers": session.scalar(select(func.count()).select_from(Customer)) or 0,
|
|
"locations": session.scalar(select(func.count()).select_from(Location)) or 0,
|
|
"contacts": session.scalar(select(func.count()).select_from(Contact)) or 0,
|
|
"devices": session.scalar(select(func.count()).select_from(Device)) or 0,
|
|
"equipment": session.scalar(select(func.count()).select_from(Equipment)) or 0,
|
|
"validations": session.scalar(select(func.count()).select_from(Validation)) or 0,
|
|
}
|
|
|
|
|
|
def paging(
|
|
page: int = Query(default=1, ge=1),
|
|
page_size: int = Query(default=20, ge=1, le=100),
|
|
search: str | None = Query(default=None, max_length=120),
|
|
) -> dict[str, Any]:
|
|
return {"page": page, "page_size": page_size, "search": search}
|
|
|
|
|
|
def commit_create(session: Session, service: CrudService, payload):
|
|
item = service.create(payload.model_dump())
|
|
session.commit()
|
|
session.refresh(item)
|
|
return item
|
|
|
|
|
|
def commit_update(session: Session, service: CrudService, item_id: str, payload):
|
|
item = service.update(item_id, payload.model_dump())
|
|
session.commit()
|
|
session.refresh(item)
|
|
return item
|
|
|
|
|
|
def commit_delete(session: Session, service: CrudService, item_id: str) -> Response:
|
|
service.delete(item_id)
|
|
session.commit()
|
|
return Response(status_code=204)
|
|
|
|
|
|
@router.get("/customers", response_model=PaginatedResponse[CustomerRead])
|
|
def list_customers(params: dict = Depends(paging), session: Session = Depends(get_session)):
|
|
return DomainServices(session).customers.list(**params)
|
|
|
|
|
|
@router.post("/customers", response_model=CustomerRead, status_code=201)
|
|
def create_customer(payload: CustomerCreate, session: Session = Depends(get_session)):
|
|
return commit_create(session, DomainServices(session).customers, payload)
|
|
|
|
|
|
@router.put("/customers/{item_id}", response_model=CustomerRead)
|
|
def update_customer(item_id: str, payload: CustomerUpdate, session: Session = Depends(get_session)):
|
|
return commit_update(session, DomainServices(session).customers, item_id, payload)
|
|
|
|
|
|
@router.delete("/customers/{item_id}", status_code=204)
|
|
def delete_customer(item_id: str, session: Session = Depends(get_session)):
|
|
return commit_delete(session, DomainServices(session).customers, item_id)
|
|
|
|
|
|
@router.get("/locations", response_model=PaginatedResponse[LocationRead])
|
|
def list_locations(params: dict = Depends(paging), session: Session = Depends(get_session)):
|
|
return DomainServices(session).locations.list(**params)
|
|
|
|
|
|
@router.post("/locations", response_model=LocationRead, status_code=201)
|
|
def create_location(payload: LocationCreate, session: Session = Depends(get_session)):
|
|
return commit_create(session, DomainServices(session).locations, payload)
|
|
|
|
|
|
@router.put("/locations/{item_id}", response_model=LocationRead)
|
|
def update_location(item_id: str, payload: LocationUpdate, session: Session = Depends(get_session)):
|
|
return commit_update(session, DomainServices(session).locations, item_id, payload)
|
|
|
|
|
|
@router.delete("/locations/{item_id}", status_code=204)
|
|
def delete_location(item_id: str, session: Session = Depends(get_session)):
|
|
return commit_delete(session, DomainServices(session).locations, item_id)
|
|
|
|
|
|
@router.get("/contacts", response_model=PaginatedResponse[ContactRead])
|
|
def list_contacts(params: dict = Depends(paging), session: Session = Depends(get_session)):
|
|
return DomainServices(session).contacts.list(**params)
|
|
|
|
|
|
@router.post("/contacts", response_model=ContactRead, status_code=201)
|
|
def create_contact(payload: ContactCreate, session: Session = Depends(get_session)):
|
|
return commit_create(session, DomainServices(session).contacts, payload)
|
|
|
|
|
|
@router.put("/contacts/{item_id}", response_model=ContactRead)
|
|
def update_contact(item_id: str, payload: ContactUpdate, session: Session = Depends(get_session)):
|
|
return commit_update(session, DomainServices(session).contacts, item_id, payload)
|
|
|
|
|
|
@router.delete("/contacts/{item_id}", status_code=204)
|
|
def delete_contact(item_id: str, session: Session = Depends(get_session)):
|
|
return commit_delete(session, DomainServices(session).contacts, item_id)
|
|
|
|
|
|
@router.get("/devices", response_model=PaginatedResponse[DeviceRead])
|
|
def list_devices(params: dict = Depends(paging), session: Session = Depends(get_session)):
|
|
return DomainServices(session).devices.list(**params)
|
|
|
|
|
|
@router.post("/devices", response_model=DeviceRead, status_code=201)
|
|
def create_device(payload: DeviceCreate, session: Session = Depends(get_session)):
|
|
return commit_create(session, DomainServices(session).devices, payload)
|
|
|
|
|
|
@router.put("/devices/{item_id}", response_model=DeviceRead)
|
|
def update_device(item_id: str, payload: DeviceUpdate, session: Session = Depends(get_session)):
|
|
return commit_update(session, DomainServices(session).devices, item_id, payload)
|
|
|
|
|
|
@router.delete("/devices/{item_id}", status_code=204)
|
|
def delete_device(item_id: str, session: Session = Depends(get_session)):
|
|
return commit_delete(session, DomainServices(session).devices, item_id)
|
|
|
|
|
|
@router.get("/equipment", response_model=PaginatedResponse[EquipmentRead])
|
|
def list_equipment(params: dict = Depends(paging), session: Session = Depends(get_session)):
|
|
return DomainServices(session).equipment.list(**params)
|
|
|
|
|
|
@router.post("/equipment", response_model=EquipmentRead, status_code=201)
|
|
def create_equipment(payload: EquipmentCreate, session: Session = Depends(get_session)):
|
|
return commit_create(session, DomainServices(session).equipment, payload)
|
|
|
|
|
|
@router.put("/equipment/{item_id}", response_model=EquipmentRead)
|
|
def update_equipment(item_id: str, payload: EquipmentUpdate, session: Session = Depends(get_session)):
|
|
return commit_update(session, DomainServices(session).equipment, item_id, payload)
|
|
|
|
|
|
@router.delete("/equipment/{item_id}", status_code=204)
|
|
def delete_equipment(item_id: str, session: Session = Depends(get_session)):
|
|
return commit_delete(session, DomainServices(session).equipment, item_id)
|
|
|
|
|
|
@router.get("/validations", response_model=PaginatedResponse[ValidationRead])
|
|
def list_validations(params: dict = Depends(paging), session: Session = Depends(get_session)):
|
|
return DomainServices(session).validations.list(**params)
|
|
|
|
|
|
@router.get("/validations/next-report-number")
|
|
def next_report_number(session: Session = Depends(get_session)) -> dict[str, str]:
|
|
count = session.scalar(select(func.count()).select_from(Validation)) or 0
|
|
return {"report_number": f"VAL-{count + 1:05d}"}
|
|
|
|
|
|
@router.get("/validations/{item_id}", response_model=ValidationRead)
|
|
def get_validation(item_id: str, session: Session = Depends(get_session)):
|
|
item = DomainServices(session).validations.repository.get(item_id)
|
|
if item is None:
|
|
from fastapi import HTTPException
|
|
|
|
raise HTTPException(status_code=404, detail="Resource not found")
|
|
return item
|
|
|
|
|
|
@router.post("/validations", response_model=ValidationRead, status_code=201)
|
|
def create_validation(payload: ValidationCreate, session: Session = Depends(get_session)):
|
|
return commit_create(session, DomainServices(session).validations, payload)
|
|
|
|
|
|
@router.put("/validations/{item_id}", response_model=ValidationRead)
|
|
def update_validation(item_id: str, payload: ValidationUpdate, session: Session = Depends(get_session)):
|
|
return commit_update(session, DomainServices(session).validations, item_id, payload)
|
|
|
|
|
|
@router.delete("/validations/{item_id}", status_code=204)
|
|
def delete_validation(item_id: str, session: Session = Depends(get_session)):
|
|
return commit_delete(session, DomainServices(session).validations, item_id)
|