monkeybrain-runtime 1.0.0__py3-none-any.whl

services/shipping/models/waybill.py

@@ -0,0 +1,189 @@
+from datetime import datetime, timezone
+from decimal import Decimal
+from enum import Enum
+from typing import Annotated, Optional
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel, Field, model_validator
+
+from services.shipping.models.carrier import Address
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class WaybillStatus(str, Enum):
+    DRAFT = "draft"
+    ISSUED = "issued"
+    IN_TRANSIT = "in_transit"
+    DELIVERED = "delivered"
+    CANCELLED = "cancelled"
+    RETURNED = "returned"
+
+
+class ShipmentMode(str, Enum):
+    AIR = "air"
+    ROAD = "road"
+    RAIL = "rail"
+    SEA = "sea"
+    MULTIMODAL = "multimodal"
+
+
+class PaymentTerms(str, Enum):
+    PREPAID = "prepaid"
+    COLLECT = "collect"
+    THIRD_PARTY = "third_party"
+
+
+class WeightUnit(str, Enum):
+    KG = "kg"
+    LB = "lb"
+
+
+class ChargeType(str, Enum):
+    FREIGHT = "freight"
+    FUEL = "fuel"
+    HANDLING = "handling"
+    INSURANCE = "insurance"
+    CUSTOMS = "customs"
+    OTHER = "other"
+
+
+class WaybillPackage(BaseModel):
+    package_reference: Optional[str] = Field(None, max_length=100)
+    description: Optional[str] = Field(None, max_length=255)
+    quantity: int = Field(..., ge=1)
+    gross_weight: Annotated[Decimal, Field(gt=0)]
+    length_cm: Optional[Annotated[Decimal, Field(gt=0)]] = None
+    width_cm: Optional[Annotated[Decimal, Field(gt=0)]] = None
+    height_cm: Optional[Annotated[Decimal, Field(gt=0)]] = None
+
+    model_config = {"str_strip_whitespace": True}
+
+
+class FreightCharge(BaseModel):
+    charge_type: ChargeType = ChargeType.FREIGHT
+    description: Optional[str] = Field(None, max_length=255)
+    amount: Annotated[Decimal, Field(ge=0)]
+    currency: str = Field(default="USD", min_length=3, max_length=3)
+
+    model_config = {"str_strip_whitespace": True}
+
+
+class CustomsInfo(BaseModel):
+    customs_declaration_id: Optional[str] = Field(None, max_length=100)
+    hs_code: Optional[str] = Field(None, max_length=20)
+    country_of_origin: Optional[str] = Field(None, min_length=2, max_length=2)
+    declared_value: Optional[Annotated[Decimal, Field(ge=0)]] = None
+    currency: str = Field(default="USD", min_length=3, max_length=3)
+    notes: Optional[str] = None
+
+    model_config = {"str_strip_whitespace": True}
+
+
+class Waybill(BaseModel):
+    id: UUID = Field(default_factory=uuid4)
+    waybill_number: str = Field(..., min_length=1, max_length=100, description="Unique waybill / AWB / BOL number")
+    status: WaybillStatus = WaybillStatus.DRAFT
+    shipment_mode: ShipmentMode
+    issue_date: datetime = Field(default_factory=utc_now)
+    pickup_date: Optional[datetime] = None
+    estimated_delivery_date: Optional[datetime] = None
+    actual_delivery_date: Optional[datetime] = None
+    shipper: Address = Field(..., description="Sender / consignor")
+    consignee: Address = Field(..., description="Recipient / consignee")
+    notify_party: Optional[Address] = Field(None, description="Third party to be notified upon arrival")
+    carrier_name: str = Field(..., min_length=1, max_length=200)
+    carrier_code: Optional[str] = Field(None, max_length=20, description="IATA carrier code or SCAC (road/rail)")
+    service_type: Optional[str] = Field(None, max_length=100, description="E.g. Express, Economy, Same-Day")
+    payment_terms: PaymentTerms = PaymentTerms.PREPAID
+    origin_port: Optional[str] = Field(None, max_length=20, description="IATA / LOCODE of origin hub")
+    destination_port: Optional[str] = Field(None, max_length=20, description="IATA / LOCODE of destination hub")
+    routing: Optional[str] = Field(None, max_length=255, description="Intermediate routing points, e.g. 'BOM-DXB-LHR'")
+    packages: list[WaybillPackage] = Field(..., min_length=1)
+    total_packages: Optional[int] = Field(None, ge=1)
+    total_gross_weight: Optional[Annotated[Decimal, Field(gt=0)]] = None
+    total_volumetric_weight: Optional[Annotated[Decimal, Field(gt=0)]] = None
+    weight_unit: WeightUnit = WeightUnit.KG
+    freight_charges: list[FreightCharge] = Field(default_factory=list)
+    total_charges: Optional[Annotated[Decimal, Field(ge=0)]] = None
+    currency: str = Field(default="USD", min_length=3, max_length=3)
+    customs_info: Optional[CustomsInfo] = None
+    special_instructions: Optional[str] = None
+    reference_number: Optional[str] = Field(None, max_length=100, description="Shipper's reference or PO number")
+    barcode: Optional[str] = Field(None, max_length=100)
+    created_at: datetime = Field(default_factory=utc_now)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    model_config = {"str_strip_whitespace": True}
+
+    @model_validator(mode="after")
+    def compute_totals(self) -> "Waybill":
+        if self.total_packages is None:
+            self.total_packages = sum(package.quantity for package in self.packages)
+        if self.total_gross_weight is None:
+            self.total_gross_weight = sum(
+                package.gross_weight * package.quantity for package in self.packages
+            )
+        if self.total_charges is None and self.freight_charges:
+            self.total_charges = sum(charge.amount for charge in self.freight_charges)
+        return self
+
+    @model_validator(mode="after")
+    def delivery_date_after_pickup(self) -> "Waybill":
+        if self.pickup_date and self.estimated_delivery_date:
+            if self.estimated_delivery_date < self.pickup_date:
+                raise ValueError("estimated_delivery_date must be on or after pickup_date")
+        return self
+
+
+class WaybillCreate(Waybill):
+    pass
+
+
+class WaybillUpdate(BaseModel):
+    waybill_number: Optional[str] = Field(None, min_length=1, max_length=100)
+    status: Optional[WaybillStatus] = None
+    shipment_mode: Optional[ShipmentMode] = None
+    issue_date: Optional[datetime] = None
+    pickup_date: Optional[datetime] = None
+    estimated_delivery_date: Optional[datetime] = None
+    actual_delivery_date: Optional[datetime] = None
+    shipper: Optional[Address] = None
+    consignee: Optional[Address] = None
+    notify_party: Optional[Address] = None
+    carrier_name: Optional[str] = Field(None, min_length=1, max_length=200)
+    carrier_code: Optional[str] = Field(None, max_length=20)
+    service_type: Optional[str] = Field(None, max_length=100)
+    payment_terms: Optional[PaymentTerms] = None
+    origin_port: Optional[str] = Field(None, max_length=20)
+    destination_port: Optional[str] = Field(None, max_length=20)
+    routing: Optional[str] = Field(None, max_length=255)
+    packages: Optional[list[WaybillPackage]] = Field(None, min_length=1)
+    total_packages: Optional[int] = Field(None, ge=1)
+    total_gross_weight: Optional[Annotated[Decimal, Field(gt=0)]] = None
+    total_volumetric_weight: Optional[Annotated[Decimal, Field(gt=0)]] = None
+    weight_unit: Optional[WeightUnit] = None
+    freight_charges: Optional[list[FreightCharge]] = None
+    total_charges: Optional[Annotated[Decimal, Field(ge=0)]] = None
+    currency: Optional[str] = Field(None, min_length=3, max_length=3)
+    customs_info: Optional[CustomsInfo] = None
+    special_instructions: Optional[str] = None
+    reference_number: Optional[str] = Field(None, max_length=100)
+    barcode: Optional[str] = Field(None, max_length=100)
+    updated_at: Optional[datetime] = None
+
+    model_config = {"str_strip_whitespace": True}
+
+
+class WaybillResponse(Waybill):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedWaybillResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[WaybillResponse]

services/shipping/routers/__init__.py

@@ -0,0 +1,15 @@
+"""shipping service routers package."""
+
+__all__ = [
+    "carrier",
+    "customs_declaration",
+    "delivery_note",
+    "package",
+    "pallet",
+    "route",
+    "shipping_information",
+    "shipping_provider_details",
+    "shipping_provider_metadata",
+    "vehicle",
+    "waybill",
+]

services/shipping/routers/carrier.py

@@ -0,0 +1,99 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.auth import require_permission
+from services.common.db import get_database
+from services.shipping.helpers import carrier as crud
+from services.shipping.models.carrier import (
+    CarrierCreate,
+    CarrierResponse,
+    CarrierUpdate,
+    PaginatedCarrierResponse,
+)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedCarrierResponse)
+async def list_carriers(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedCarrierResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/by-code/{code}", response_model=CarrierResponse)
+async def get_carrier_by_code(
+    code: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_code(db, code)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Carrier with code '{code}' not found")
+    return record
+
+
+@router.get("/by-name/{name}", response_model=list[CarrierResponse])
+async def list_carriers_by_name(
+    name: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_name(db, name)
+
+
+@router.get("/{carrier_id}", response_model=CarrierResponse)
+async def get_carrier(
+    carrier_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_id(db, carrier_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Carrier '{carrier_id}' not found")
+    return record
+
+
+@router.post("/", response_model=CarrierResponse, status_code=status.HTTP_201_CREATED)
+async def create_carrier(
+    data: CarrierCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-products")),
+):
+    carrier_id = str(data.id)
+    if await crud.get_by_id(db, carrier_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Carrier '{carrier_id}' already exists")
+    if await crud.get_by_code(db, data.code):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Carrier with code '{data.code}' already exists")
+    return await crud.create(db, data)
+
+
+@router.patch("/{carrier_id}", response_model=CarrierResponse)
+async def update_carrier(
+    carrier_id: str,
+    data: CarrierUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-products")),
+):
+    if data.code:
+        existing = await crud.get_by_code(db, data.code)
+        if existing and existing.get("id") != carrier_id:
+            raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Carrier with code '{data.code}' already exists")
+    updated = await crud.update(db, carrier_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Carrier '{carrier_id}' not found")
+    return updated
+
+
+@router.delete("/{carrier_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_carrier(
+    carrier_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-products")),
+):
+    if not await crud.delete(db, carrier_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Carrier '{carrier_id}' not found")

services/shipping/routers/customs_declaration.py

@@ -0,0 +1,132 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.auth import require_permission
+from services.common.db import get_database
+from services.shipping.helpers import customs_declaration as crud
+from services.shipping.models.customs_declaration import (
+    CustomsDeclarationCreate,
+    CustomsDeclarationResponse,
+    CustomsDeclarationUpdate,
+    PaginatedCustomsDeclarationResponse,
+)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedCustomsDeclarationResponse)
+async def list_customs_declarations(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedCustomsDeclarationResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/by-reference/{declaration_reference}", response_model=CustomsDeclarationResponse)
+async def get_customs_declaration_by_reference(
+    declaration_reference: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_reference(db, declaration_reference)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Customs declaration '{declaration_reference}' not found")
+    return record
+
+
+@router.get("/by-type/{declaration_type}", response_model=list[CustomsDeclarationResponse])
+async def list_customs_declarations_by_type(
+    declaration_type: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_type(db, declaration_type)
+
+
+@router.get("/by-shipment/{shipment_id}", response_model=list[CustomsDeclarationResponse])
+async def list_customs_declarations_by_shipment(
+    shipment_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_shipment(db, shipment_id)
+
+
+@router.get("/by-delivery-note/{delivery_note_id}", response_model=list[CustomsDeclarationResponse])
+async def list_customs_declarations_by_delivery_note(
+    delivery_note_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_delivery_note(db, delivery_note_id)
+
+
+@router.get("/by-clearance/{customs_cleared}", response_model=list[CustomsDeclarationResponse])
+async def list_customs_declarations_by_clearance(
+    customs_cleared: bool,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_clearance(db, customs_cleared)
+
+
+@router.get("/{declaration_id}", response_model=CustomsDeclarationResponse)
+async def get_customs_declaration(
+    declaration_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_id(db, declaration_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Customs declaration '{declaration_id}' not found")
+    return record
+
+
+@router.post("/", response_model=CustomsDeclarationResponse, status_code=status.HTTP_201_CREATED)
+async def create_customs_declaration(
+    data: CustomsDeclarationCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-products")),
+):
+    declaration_id = str(data.id)
+    if await crud.get_by_id(db, declaration_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Customs declaration '{declaration_id}' already exists")
+    if await crud.get_by_reference(db, data.declaration_reference):
+        raise HTTPException(
+            status.HTTP_409_CONFLICT,
+            detail=f"Customs declaration '{data.declaration_reference}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+@router.patch("/{declaration_id}", response_model=CustomsDeclarationResponse)
+async def update_customs_declaration(
+    declaration_id: str,
+    data: CustomsDeclarationUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-products")),
+):
+    if data.declaration_reference:
+        existing = await crud.get_by_reference(db, data.declaration_reference)
+        if existing and existing.get("id") != declaration_id:
+            raise HTTPException(
+                status.HTTP_409_CONFLICT,
+                detail=f"Customs declaration '{data.declaration_reference}' already exists",
+            )
+    updated = await crud.update(db, declaration_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Customs declaration '{declaration_id}' not found")
+    return updated
+
+
+@router.delete("/{declaration_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_customs_declaration(
+    declaration_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-products")),
+):
+    if not await crud.delete(db, declaration_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Customs declaration '{declaration_id}' not found")

services/shipping/routers/delivery_note.py

@@ -0,0 +1,150 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.auth import require_permission
+from services.common.db import get_database
+from services.shipping.helpers import delivery_note as crud
+from services.shipping.models.delivery_note import (
+    DeliveryNoteCreate,
+    DeliveryNoteResponse,
+    DeliveryNoteUpdate,
+    PaginatedDeliveryNoteResponse,
+)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedDeliveryNoteResponse)
+async def list_delivery_notes(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedDeliveryNoteResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/by-number/{delivery_note_number}", response_model=DeliveryNoteResponse)
+async def get_delivery_note_by_number(
+    delivery_note_number: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_number(db, delivery_note_number)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Delivery note '{delivery_note_number}' not found")
+    return record
+
+
+@router.get("/by-status/{status_value}", response_model=list[DeliveryNoteResponse])
+async def list_delivery_notes_by_status(
+    status_value: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_status(db, status_value)
+
+
+@router.get("/by-carrier/{carrier_id}", response_model=list[DeliveryNoteResponse])
+async def list_delivery_notes_by_carrier(
+    carrier_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_carrier(db, carrier_id)
+
+
+@router.get("/by-vehicle/{vehicle_id}", response_model=list[DeliveryNoteResponse])
+async def list_delivery_notes_by_vehicle(
+    vehicle_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_vehicle(db, vehicle_id)
+
+
+@router.get("/by-tracking/{tracking_number}", response_model=DeliveryNoteResponse)
+async def get_delivery_note_by_tracking_number(
+    tracking_number: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_tracking_number(db, tracking_number)
+    if not record:
+        raise HTTPException(
+            status.HTTP_404_NOT_FOUND,
+            detail=f"Delivery note with tracking number '{tracking_number}' not found",
+        )
+    return record
+
+
+@router.get("/{delivery_note_id}", response_model=DeliveryNoteResponse)
+async def get_delivery_note(
+    delivery_note_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_id(db, delivery_note_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Delivery note '{delivery_note_id}' not found")
+    return record
+
+
+@router.post("/", response_model=DeliveryNoteResponse, status_code=status.HTTP_201_CREATED)
+async def create_delivery_note(
+    data: DeliveryNoteCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-products")),
+):
+    delivery_note_id = str(data.id)
+    if await crud.get_by_id(db, delivery_note_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Delivery note '{delivery_note_id}' already exists")
+    if await crud.get_by_number(db, data.delivery_note_number):
+        raise HTTPException(
+            status.HTTP_409_CONFLICT,
+            detail=f"Delivery note '{data.delivery_note_number}' already exists",
+        )
+    if data.tracking_number and await crud.get_by_tracking_number(db, data.tracking_number):
+        raise HTTPException(
+            status.HTTP_409_CONFLICT,
+            detail=f"Delivery note with tracking number '{data.tracking_number}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+@router.patch("/{delivery_note_id}", response_model=DeliveryNoteResponse)
+async def update_delivery_note(
+    delivery_note_id: str,
+    data: DeliveryNoteUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-products")),
+):
+    if data.delivery_note_number:
+        existing = await crud.get_by_number(db, data.delivery_note_number)
+        if existing and existing.get("id") != delivery_note_id:
+            raise HTTPException(
+                status.HTTP_409_CONFLICT,
+                detail=f"Delivery note '{data.delivery_note_number}' already exists",
+            )
+    if data.tracking_number:
+        existing = await crud.get_by_tracking_number(db, data.tracking_number)
+        if existing and existing.get("id") != delivery_note_id:
+            raise HTTPException(
+                status.HTTP_409_CONFLICT,
+                detail=f"Delivery note with tracking number '{data.tracking_number}' already exists",
+            )
+    updated = await crud.update(db, delivery_note_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Delivery note '{delivery_note_id}' not found")
+    return updated
+
+
+@router.delete("/{delivery_note_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_delivery_note(
+    delivery_note_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-products")),
+):
+    if not await crud.delete(db, delivery_note_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Delivery note '{delivery_note_id}' not found")