72256f4fe9
Neuer Endpoint GET /items liefert alle Einzelstuecke ueber alle Produkte, angereichert mit Produkt-, Kategorie-, Lagerort- und Shop-Angaben (Beziehungen vorgeladen). ItemOut bekommt category_id/category_name. ProductOut bekommt image_version (Epoch der letzten Bildaenderung, None ohne Bild) - identisch zum ETag der Bild-Route, damit Clients Bilder cachen und nur bei Aenderung neu laden. Grundlage fuer die neue Einzelstueck-Liste (Web+iOS) und den iOS-Bild-Cache. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
349 lines
11 KiB
Python
349 lines
11 KiB
Python
"""Einzelstücke (Items) eines Gegenstands: anlegen, ändern, entfernen, per UID finden.
|
||
|
||
Ein Item ist ein physisches Exemplar mit eigener UID/QR und eigenen Angaben
|
||
(Lagerort, Kaufdatum, Garantie, Bezugsquelle, Notiz). Nur sinnvoll für
|
||
Gegenstands-Produkte mit ``Product.individual``.
|
||
"""
|
||
|
||
import re
|
||
|
||
from fastapi import APIRouter, Depends, File, HTTPException, UploadFile, status
|
||
from fastapi.responses import Response
|
||
from sqlalchemy.orm import Session, joinedload
|
||
|
||
from ..database import get_db
|
||
from ..deps import get_current_user, require_admin
|
||
from ..models import (
|
||
Item,
|
||
ItemDocument,
|
||
Location,
|
||
Movement,
|
||
MovementType,
|
||
Product,
|
||
Shop,
|
||
User,
|
||
)
|
||
from ..schemas import (
|
||
DocumentSuggestions,
|
||
ItemCreate,
|
||
ItemDocumentUploadOut,
|
||
ItemOut,
|
||
ItemRemove,
|
||
ItemUpdate,
|
||
)
|
||
from ..services.items import generate_uid, item_to_out
|
||
from ..services.warranty import (
|
||
extract_pdf_text,
|
||
guess_acquired_on,
|
||
guess_price_candidates,
|
||
guess_price_cents,
|
||
guess_shop,
|
||
guess_warranty_until,
|
||
)
|
||
|
||
router = APIRouter(tags=["items"])
|
||
|
||
# Belege sind meist kleine PDFs; die Grenze schuetzt vor Ausreissern und passt
|
||
# zur nginx-Grenze (client_max_body_size 12m).
|
||
DOC_MAX_BYTES = 10 * 1024 * 1024
|
||
|
||
|
||
def _product_or_404(db: Session, product_id: int) -> Product:
|
||
product = db.get(Product, product_id)
|
||
if product is None:
|
||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Produkt nicht gefunden")
|
||
return product
|
||
|
||
|
||
def _item_or_404(db: Session, item_id: int) -> Item:
|
||
item = db.get(Item, item_id)
|
||
if item is None:
|
||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Einzelstück nicht gefunden")
|
||
return item
|
||
|
||
|
||
def _check_refs(db: Session, shop_id: int | None, location_id: str | None) -> None:
|
||
if shop_id is not None and db.get(Shop, shop_id) is None:
|
||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Shop nicht gefunden")
|
||
if location_id is not None and db.get(Location, location_id) is None:
|
||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Lagerort nicht gefunden")
|
||
|
||
|
||
@router.get("/products/{product_id}/items", response_model=list[ItemOut])
|
||
def list_items(
|
||
product_id: int,
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(get_current_user),
|
||
) -> list[ItemOut]:
|
||
_product_or_404(db, product_id)
|
||
rows = db.query(Item).filter(Item.product_id == product_id).order_by(Item.id).all()
|
||
return [item_to_out(i) for i in rows]
|
||
|
||
|
||
@router.post(
|
||
"/products/{product_id}/items", response_model=list[ItemOut],
|
||
status_code=status.HTTP_201_CREATED,
|
||
)
|
||
def create_items(
|
||
product_id: int,
|
||
payload: ItemCreate,
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(require_admin),
|
||
) -> list[ItemOut]:
|
||
"""Ein oder mehrere (count) Einzelstücke mit gemeinsamen Startwerten anlegen."""
|
||
product = _product_or_404(db, product_id)
|
||
_check_refs(db, payload.shop_id, payload.location_id)
|
||
created: list[Item] = []
|
||
for _ in range(payload.count):
|
||
item = Item(
|
||
uid=generate_uid(db),
|
||
product_id=product.id,
|
||
location_id=payload.location_id,
|
||
shop_id=payload.shop_id,
|
||
acquired_on=payload.acquired_on,
|
||
warranty_until=payload.warranty_until,
|
||
note=payload.note,
|
||
price_cents=payload.price_cents,
|
||
currency=payload.currency,
|
||
)
|
||
db.add(item)
|
||
db.flush()
|
||
created.append(item)
|
||
db.commit()
|
||
for item in created:
|
||
db.refresh(item)
|
||
return [item_to_out(i) for i in created]
|
||
|
||
|
||
@router.get("/items", response_model=list[ItemOut])
|
||
def list_all_items(
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(get_current_user),
|
||
) -> list[ItemOut]:
|
||
"""Alle Einzelstücke über alle Produkte – Grundlage der Einzelstück-Liste.
|
||
|
||
Angereichert mit Produkt-, Kategorie-, Lagerort- und Shop-Angaben; die
|
||
Beziehungen werden vorgeladen, damit die Liste nicht in N+1-Abfragen zerfällt.
|
||
"""
|
||
rows = (
|
||
db.query(Item)
|
||
.options(
|
||
joinedload(Item.product).joinedload(Product.category),
|
||
joinedload(Item.location),
|
||
joinedload(Item.shop),
|
||
joinedload(Item.documents),
|
||
)
|
||
.order_by(Item.id)
|
||
.all()
|
||
)
|
||
return [item_to_out(i) for i in rows]
|
||
|
||
|
||
@router.get("/items/by-uid/{uid}", response_model=ItemOut)
|
||
def item_by_uid(
|
||
uid: str,
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(get_current_user),
|
||
) -> ItemOut:
|
||
"""QR-Auflösung: UID → Einzelstück (mit Produktangaben)."""
|
||
item = db.query(Item).filter(Item.uid == uid.strip().upper()).first()
|
||
if item is None:
|
||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Kein Einzelstück mit dieser UID")
|
||
return item_to_out(item)
|
||
|
||
|
||
@router.get("/items/{item_id}", response_model=ItemOut)
|
||
def get_item(
|
||
item_id: int,
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(get_current_user),
|
||
) -> ItemOut:
|
||
return item_to_out(_item_or_404(db, item_id))
|
||
|
||
|
||
@router.patch("/items/{item_id}", response_model=ItemOut)
|
||
def update_item(
|
||
item_id: int,
|
||
payload: ItemUpdate,
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(require_admin),
|
||
) -> ItemOut:
|
||
item = _item_or_404(db, item_id)
|
||
data = payload.model_dump(exclude_unset=True)
|
||
_check_refs(db, data.get("shop_id"), data.get("location_id"))
|
||
for field, value in data.items():
|
||
setattr(item, field, value)
|
||
db.commit()
|
||
db.refresh(item)
|
||
return item_to_out(item)
|
||
|
||
|
||
@router.post("/items/{item_id}/remove", status_code=status.HTTP_204_NO_CONTENT)
|
||
def remove_item(
|
||
item_id: int,
|
||
payload: ItemRemove,
|
||
db: Session = Depends(get_db),
|
||
user: User = Depends(require_admin),
|
||
) -> None:
|
||
"""Einzelstück mit Grund entfernen – als Bewegung protokolliert (Statistik je Modell)."""
|
||
item = _item_or_404(db, item_id)
|
||
db.add(
|
||
Movement(
|
||
product_id=item.product_id,
|
||
lot_id=None,
|
||
user_id=user.id,
|
||
type=MovementType.out,
|
||
quantity=1,
|
||
unit_used="Stück",
|
||
note=(payload.note or f"Einzelstück {item.uid}"),
|
||
location_id=item.location_id,
|
||
reason=payload.reason.value,
|
||
)
|
||
)
|
||
db.delete(item)
|
||
db.commit()
|
||
|
||
|
||
@router.delete("/items/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
|
||
def delete_item(
|
||
item_id: int,
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(require_admin),
|
||
) -> None:
|
||
"""Einzelstück ohne Grund löschen (Korrektur)."""
|
||
db.delete(_item_or_404(db, item_id))
|
||
db.commit()
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Belege (Rechnung/Garantieschein) je Einzelstück
|
||
# --------------------------------------------------------------------------
|
||
def _document_or_404(db: Session, item_id: int, doc_id: int) -> ItemDocument:
|
||
doc = (
|
||
db.query(ItemDocument)
|
||
.filter(ItemDocument.id == doc_id, ItemDocument.item_id == item_id)
|
||
.first()
|
||
)
|
||
if doc is None:
|
||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Beleg nicht gefunden")
|
||
return doc
|
||
|
||
|
||
def _safe_filename(name: str | None) -> str:
|
||
"""Steuerzeichen/Anführungszeichen raus – sonst Header-Injektion im Download."""
|
||
cleaned = re.sub(r'[\r\n"]', "", (name or "").strip())
|
||
return cleaned[:255] or "beleg"
|
||
|
||
|
||
def _read_document(file: UploadFile, data: bytes) -> str:
|
||
"""Validiert Größe/Typ eines hochgeladenen Belegs und gibt den Content-Type."""
|
||
if not data:
|
||
raise HTTPException(status.HTTP_400_BAD_REQUEST, "Leere Datei")
|
||
if len(data) > DOC_MAX_BYTES:
|
||
raise HTTPException(
|
||
status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
|
||
f"Datei zu groß (max. {DOC_MAX_BYTES // (1024 * 1024)} MB).",
|
||
)
|
||
content_type = file.content_type or "application/octet-stream"
|
||
if content_type != "application/pdf" and not content_type.startswith("image/"):
|
||
raise HTTPException(
|
||
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE, "Nur PDF oder Bild erlaubt."
|
||
)
|
||
return content_type
|
||
|
||
|
||
def _doc_suggestions(
|
||
db: Session, data: bytes, content_type: str, item_acquired_on=None
|
||
) -> DocumentSuggestions:
|
||
"""Garantie, Preis, Kaufdatum und Shop aus einem PDF schätzen (Bilder: leer)."""
|
||
if content_type != "application/pdf":
|
||
return DocumentSuggestions()
|
||
text = extract_pdf_text(data)
|
||
shop_id, shop_name = guess_shop(text, [(s.id, s.name) for s in db.query(Shop).all()])
|
||
return DocumentSuggestions(
|
||
suggested_warranty_until=guess_warranty_until(text, acquired_on=item_acquired_on),
|
||
suggested_price_cents=guess_price_cents(text),
|
||
suggested_price_candidates=guess_price_candidates(text),
|
||
suggested_acquired_on=guess_acquired_on(text),
|
||
suggested_shop_id=shop_id,
|
||
suggested_shop_name=shop_name,
|
||
)
|
||
|
||
|
||
@router.post(
|
||
"/items/{item_id}/documents",
|
||
response_model=ItemDocumentUploadOut,
|
||
status_code=status.HTTP_201_CREATED,
|
||
)
|
||
async def upload_item_document(
|
||
item_id: int,
|
||
file: UploadFile = File(...),
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(require_admin),
|
||
) -> ItemDocumentUploadOut:
|
||
"""Beleg (PDF oder Bild) hochladen. Bei PDF werden Garantie, Preis, Kaufdatum
|
||
und Shop vorgeschlagen."""
|
||
item = _item_or_404(db, item_id)
|
||
data = await file.read()
|
||
content_type = _read_document(file, data)
|
||
|
||
doc = ItemDocument(
|
||
item_id=item.id,
|
||
filename=_safe_filename(file.filename),
|
||
content_type=content_type,
|
||
data=data,
|
||
)
|
||
db.add(doc)
|
||
db.commit()
|
||
db.refresh(doc)
|
||
|
||
vorschlag = _doc_suggestions(db, data, content_type, item.acquired_on)
|
||
return ItemDocumentUploadOut(
|
||
id=doc.id,
|
||
filename=doc.filename,
|
||
content_type=doc.content_type,
|
||
uploaded_at=doc.uploaded_at,
|
||
**vorschlag.model_dump(),
|
||
)
|
||
|
||
|
||
@router.post("/items/analyze-document", response_model=DocumentSuggestions)
|
||
async def analyze_item_document(
|
||
file: UploadFile = File(...),
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(require_admin),
|
||
) -> DocumentSuggestions:
|
||
"""Beleg nur analysieren (nichts speichern) – zum Vorbefüllen beim Anlegen."""
|
||
data = await file.read()
|
||
content_type = _read_document(file, data)
|
||
return _doc_suggestions(db, data, content_type)
|
||
|
||
|
||
@router.get("/items/{item_id}/documents/{doc_id}")
|
||
def get_item_document(
|
||
item_id: int,
|
||
doc_id: int,
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(get_current_user),
|
||
) -> Response:
|
||
"""Beleg anzeigen/herunterladen."""
|
||
doc = _document_or_404(db, item_id, doc_id)
|
||
return Response(
|
||
content=doc.data,
|
||
media_type=doc.content_type,
|
||
headers={"Content-Disposition": f'inline; filename="{doc.filename}"'},
|
||
)
|
||
|
||
|
||
@router.delete(
|
||
"/items/{item_id}/documents/{doc_id}", status_code=status.HTTP_204_NO_CONTENT
|
||
)
|
||
def delete_item_document(
|
||
item_id: int,
|
||
doc_id: int,
|
||
db: Session = Depends(get_db),
|
||
_: User = Depends(require_admin),
|
||
) -> None:
|
||
db.delete(_document_or_404(db, item_id, doc_id))
|
||
db.commit()
|