Files
pickling-mes/backend/app/api/equipment.py

113 lines
4.2 KiB
Python
Raw Normal View History

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, func, desc
from typing import Optional
from app.database import get_db
from app.models.equipment import Equipment, EquipmentMaintenance, EquipmentStatus
from app.schemas.equipment import (
EquipmentCreate, EquipmentUpdate, EquipmentOut,
MaintenanceCreate, MaintenanceOut
)
from app.schemas.common import Response, PageResponse
from app.services.auth_service import get_current_user
router = APIRouter()
@router.get("/", response_model=Response[PageResponse[EquipmentOut]])
async def list_equipment(
page: int = 1,
page_size: int = 20,
name: Optional[str] = None,
status: Optional[str] = None,
category: Optional[str] = None,
db: AsyncSession = Depends(get_db),
_ = Depends(get_current_user),
):
query = select(Equipment).order_by(Equipment.code)
if name:
query = query.where(Equipment.name.ilike(f"%{name}%"))
if status:
try:
query = query.where(Equipment.status == EquipmentStatus(status))
except ValueError:
pass
if category:
query = query.where(Equipment.category == category)
total = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
items = [EquipmentOut.model_validate(e) for e in result.scalars()]
return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
@router.post("/", response_model=Response[EquipmentOut])
async def create_equipment(
body: EquipmentCreate,
db: AsyncSession = Depends(get_db),
_ = Depends(get_current_user),
):
existing = await db.execute(select(Equipment).where(Equipment.code == body.code))
if existing.scalar_one_or_none():
raise HTTPException(status_code=400, detail="设备编号已存在")
equip = Equipment(**body.model_dump())
db.add(equip)
await db.flush()
return Response.ok(EquipmentOut.model_validate(equip))
@router.get("/{equip_id}", response_model=Response[EquipmentOut])
async def get_equipment(equip_id: int, db: AsyncSession = Depends(get_db), _ = Depends(get_current_user)):
result = await db.execute(select(Equipment).where(Equipment.id == equip_id))
equip = result.scalar_one_or_none()
if not equip:
raise HTTPException(status_code=404, detail="设备不存在")
return Response.ok(EquipmentOut.model_validate(equip))
@router.put("/{equip_id}", response_model=Response[EquipmentOut])
async def update_equipment(
equip_id: int,
body: EquipmentUpdate,
db: AsyncSession = Depends(get_db),
_ = Depends(get_current_user),
):
result = await db.execute(select(Equipment).where(Equipment.id == equip_id))
equip = result.scalar_one_or_none()
if not equip:
raise HTTPException(status_code=404, detail="设备不存在")
for k, v in body.model_dump(exclude_none=True).items():
setattr(equip, k, v)
await db.flush()
return Response.ok(EquipmentOut.model_validate(equip))
@router.get("/{equip_id}/maintenance", response_model=Response[PageResponse[MaintenanceOut]])
async def list_maintenance(
equip_id: int,
page: int = 1,
page_size: int = 20,
db: AsyncSession = Depends(get_db),
_ = Depends(get_current_user),
):
query = select(EquipmentMaintenance).where(
EquipmentMaintenance.equipment_id == equip_id
).order_by(desc(EquipmentMaintenance.start_time))
total = (await db.execute(select(func.count()).select_from(query.subquery()))).scalar()
result = await db.execute(query.offset((page - 1) * page_size).limit(page_size))
items = [MaintenanceOut.model_validate(m) for m in result.scalars()]
return Response.ok(PageResponse(total=total, page=page, page_size=page_size, items=items))
@router.post("/maintenance", response_model=Response[MaintenanceOut])
async def create_maintenance(
body: MaintenanceCreate,
db: AsyncSession = Depends(get_db),
_ = Depends(get_current_user),
):
record = EquipmentMaintenance(**body.model_dump())
db.add(record)
await db.flush()
return Response.ok(MaintenanceOut.model_validate(record))