monkeybrain-runtime 1.0.0__py3-none-any.whl

services/orders/models/orders.py

@@ -0,0 +1,64 @@
+from typing import Optional
+
+from pydantic import BaseModel, model_validator
+
+from services.orders.models.order_customer_metrics import (
+    CustomerOrderMetricsCreate,
+    CustomerOrderMetricsResponse,
+    CustomerOrderMetricsUpdate,
+)
+from services.orders.models.order_details import (
+    OrderDetailsCreate,
+    OrderDetailsResponse,
+    OrderDetailsUpdate,
+)
+from services.orders.models.order_metadata import (
+    OrderMetadataCreate,
+    OrderMetadataResponse,
+    OrderMetadataUpdate,
+)
+from services.orders.models.order_payment_metadata import (
+    OrderPaymentMetadataCreate,
+    OrderPaymentMetadataResponse,
+    OrderPaymentMetadataUpdate,
+)
+
+
+class OrderCreate(BaseModel):
+    details: OrderDetailsCreate
+    metadata: Optional[OrderMetadataCreate] = None
+    payment: Optional[OrderPaymentMetadataCreate] = None
+    metrics: Optional[CustomerOrderMetricsCreate] = None
+
+    @model_validator(mode="after")
+    def child_order_ids_match(self) -> "OrderCreate":
+        order_id = self.details.order_id
+        for label, payload in (
+            ("metadata", self.metadata),
+            ("payment", self.payment),
+            ("metrics", self.metrics),
+        ):
+            if payload is not None and payload.order_id and payload.order_id != order_id:
+                raise ValueError(f"{label}.order_id must match details.order_id")
+        return self
+
+
+class OrderUpdate(BaseModel):
+    details: Optional[OrderDetailsUpdate] = None
+    metadata: Optional[OrderMetadataUpdate] = None
+    payment: Optional[OrderPaymentMetadataUpdate] = None
+    metrics: Optional[CustomerOrderMetricsUpdate] = None
+
+class OrderResponse(BaseModel):
+    order_id: str
+    details: OrderDetailsResponse
+    metadata: Optional[OrderMetadataResponse] = None
+    payment: Optional[OrderPaymentMetadataResponse] = None
+    metrics: Optional[CustomerOrderMetricsResponse] = None
+
+
+class PaginatedOrderResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[OrderResponse]

services/orders/models/sales_orders.py

@@ -0,0 +1,130 @@
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from services.products.models.product_common import utc_now
+
+
+class SalesOrderStatus(str, Enum):
+    DRAFT = "draft"
+    CONFIRMED = "confirmed"
+    ALLOCATED = "allocated"
+    SHIPPED = "shipped"
+    DELIVERED = "delivered"
+    CANCELLED = "cancelled"
+
+
+class SalesOrderLine(BaseModel):
+    line_id: str | None = None
+    product_id: str | None = None
+    sku: str = Field(..., min_length=1)
+    product_name: str | None = None
+    workflow_id: str | None = None
+    workflow_name: str | None = None
+    quantity: float = Field(..., gt=0)
+    unit_of_measure: str = "piece"
+    unit_price: float = Field(default=0, ge=0)
+    discount_amount: float = Field(default=0, ge=0)
+    tax_amount: float = Field(default=0, ge=0)
+    line_total: float | None = None
+    notes: str | None = None
+
+    @model_validator(mode="after")
+    def compute_line_total(self):
+        self.line_total = round(
+            (self.quantity * self.unit_price) - self.discount_amount + self.tax_amount,
+            2,
+        )
+        return self
+
+
+class SalesOrderBase(BaseModel):
+    sales_order_number: str | None = None
+    customer_id: str = Field(..., min_length=1)
+    customer_name: str | None = None
+    order_date: datetime = Field(default_factory=utc_now)
+    requested_delivery_date: datetime | None = None
+    promised_delivery_date: datetime | None = None
+    status: SalesOrderStatus = SalesOrderStatus.DRAFT
+
+    currency: str = Field(default="USD", min_length=3, max_length=3)
+    lines: list[SalesOrderLine] = Field(default_factory=list)
+
+    subtotal: float | None = Field(default=None, ge=0)
+    discount_total: float = Field(default=0, ge=0)
+    tax_total: float = Field(default=0, ge=0)
+    shipping_total: float = Field(default=0, ge=0)
+    grand_total: float | None = Field(default=None, ge=0)
+
+    payment_terms: str | None = None
+    payment_status: str | None = None
+    shipping_address: str | None = None
+    billing_address: str | None = None
+    sales_channel: str | None = None
+    salesperson_id: str | None = None
+    notes: str | None = None
+    metadata: dict[str, Any] | None = None
+
+    created_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def compute_totals(self):
+        lines_subtotal = round(
+            sum(line.quantity * line.unit_price for line in self.lines),
+            2,
+        )
+        lines_discount = round(sum(line.discount_amount for line in self.lines), 2)
+        lines_tax = round(sum(line.tax_amount for line in self.lines), 2)
+
+        self.subtotal = lines_subtotal
+        self.discount_total = max(self.discount_total, lines_discount)
+        self.tax_total = max(self.tax_total, lines_tax)
+        self.grand_total = round(
+            self.subtotal - self.discount_total + self.tax_total + self.shipping_total,
+            2,
+        )
+        return self
+
+
+class SalesOrderCreate(SalesOrderBase):
+    """Schema for creating a sales order."""
+
+
+class SalesOrderUpdate(BaseModel):
+    sales_order_number: str | None = None
+    customer_id: str | None = None
+    customer_name: str | None = None
+    order_date: datetime | None = None
+    requested_delivery_date: datetime | None = None
+    promised_delivery_date: datetime | None = None
+    status: SalesOrderStatus | None = None
+    currency: str | None = Field(default=None, min_length=3, max_length=3)
+    lines: list[SalesOrderLine] | None = None
+    discount_total: float | None = Field(default=None, ge=0)
+    tax_total: float | None = Field(default=None, ge=0)
+    shipping_total: float | None = Field(default=None, ge=0)
+    payment_terms: str | None = None
+    payment_status: str | None = None
+    shipping_address: str | None = None
+    billing_address: str | None = None
+    sales_channel: str | None = None
+    salesperson_id: str | None = None
+    notes: str | None = None
+    metadata: dict[str, Any] | None = None
+
+
+class SalesOrderResponse(SalesOrderBase):
+    id: str
+    sales_order_id: str
+    updated_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class PaginatedSalesOrderResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[SalesOrderResponse]

services/orders/routers/__init__.py

@@ -0,0 +1,11 @@
+"""orders service routers package."""
+
+__all__ = [
+    "invoices",
+    "order_customer_metrics",
+    "order_details",
+    "order_metadata",
+    "order_payment_metadata",
+    "orders",
+    "sales_orders",
+]

services/orders/routers/invoices.py

@@ -0,0 +1,111 @@
+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.orders.helpers import invoices as crud
+from services.orders.models.invoices import (
+    InvoiceCreate,
+    InvoiceResponse,
+    InvoiceStatus,
+    InvoiceUpdate,
+    PaginatedInvoiceResponse,
+)
+
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedInvoiceResponse)
+async def list_invoices(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=1000),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedInvoiceResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/by-number/{invoice_no}", response_model=InvoiceResponse)
+async def get_invoice_by_number(
+    invoice_no: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    record = await crud.get_by_invoice_number(db, invoice_no)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Invoice '{invoice_no}' not found")
+    return record
+
+
+@router.get("/by-customer/{customer_id}", response_model=list[InvoiceResponse])
+async def list_invoices_by_customer(
+    customer_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    return await crud.get_by_customer_id(db, customer_id)
+
+
+@router.get("/by-status/{invoice_status}", response_model=list[InvoiceResponse])
+async def list_invoices_by_status(
+    invoice_status: InvoiceStatus,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    return await crud.get_by_status(db, invoice_status.value)
+
+
+@router.get("/{invoice_id}", response_model=InvoiceResponse)
+async def get_invoice(
+    invoice_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    record = await crud.get_by_id(db, invoice_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Invoice '{invoice_id}' not found")
+    return record
+
+
+@router.post("/", response_model=InvoiceResponse, status_code=status.HTTP_201_CREATED)
+async def create_invoice(
+    data: InvoiceCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-order")),
+):
+    invoice_no = data.invoice_details.invoice_no if data.invoice_details else None
+    if invoice_no and await crud.get_by_invoice_number(db, invoice_no):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Invoice '{invoice_no}' already exists")
+    return await crud.create(db, data)
+
+
+@router.patch("/{invoice_id}", response_model=InvoiceResponse)
+async def update_invoice(
+    invoice_id: str,
+    data: InvoiceUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-order")),
+):
+    if data.invoice_details and data.invoice_details.invoice_no:
+        existing = await crud.get_by_invoice_number(db, data.invoice_details.invoice_no)
+        if existing and existing.get("id") != invoice_id:
+            raise HTTPException(
+                status.HTTP_409_CONFLICT,
+                detail=f"Invoice '{data.invoice_details.invoice_no}' already exists",
+            )
+    updated = await crud.update(db, invoice_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Invoice '{invoice_id}' not found")
+    return updated
+
+
+@router.delete("/{invoice_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_invoice(
+    invoice_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-order")),
+):
+    if not await crud.delete(db, invoice_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Invoice '{invoice_id}' not found")

services/orders/routers/order_customer_metrics.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.orders.helpers import order_customer_metrics as crud
+from services.common.auth import require_permission
+from services.orders.models.order_customer_metrics import (
+    CustomerOrderMetricsCreate,
+    CustomerOrderMetricsResponse,
+    CustomerOrderMetricsUpdate,
+    PaginatedCustomerOrderMetricsResponse,
+)
+
+router = APIRouter()
+
+@router.get("/", response_model=PaginatedCustomerOrderMetricsResponse)
+async def list_order_customer_metrics(
+    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-order")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedCustomerOrderMetricsResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=records,
+    )
+
+
+@router.get("/{order_id}", response_model=CustomerOrderMetricsResponse)
+async def get_order_customer_metrics(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    record = await crud.get_by_order_id(db, order_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order customer metrics for order '{order_id}' not found",
+        )
+    return record
+
+
+@router.post("/", response_model=CustomerOrderMetricsResponse, status_code=status.HTTP_201_CREATED)
+async def create_order_customer_metrics(
+    data: CustomerOrderMetricsCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-order")),
+):
+    if await crud.get_by_order_id(db, data.order_id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Order customer metrics for order '{data.order_id}' already exist",
+        )
+    return await crud.create(db, data)
+
+
+@router.patch("/{order_id}", response_model=CustomerOrderMetricsResponse)
+async def update_order_customer_metrics(
+    order_id: str,
+    data: CustomerOrderMetricsUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-order")),
+):
+    updated = await crud.update(db, order_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order customer metrics for order '{order_id}' not found",
+        )
+    return updated
+
+
+@router.delete("/{order_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_order_customer_metrics(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-order")),
+):
+    if not await crud.delete(db, order_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order customer metrics for order '{order_id}' not found",
+        )

services/orders/routers/order_details.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.orders.helpers import order_details as crud
+from services.common.auth import require_permission
+from services.orders.models.order_details import (
+    OrderDetailsCreate,
+    OrderDetailsResponse,
+    OrderDetailsUpdate,
+    PaginatedOrderDetailsResponse,
+)
+
+router = APIRouter()
+
+@router.get("/", response_model=PaginatedOrderDetailsResponse)
+async def list_order_details(
+    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-order")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedOrderDetailsResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=records,
+    )
+
+
+@router.get("/{order_id}", response_model=OrderDetailsResponse)
+async def get_order_details(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    record = await crud.get_by_order_id(db, order_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order details for order '{order_id}' not found",
+        )
+    return record
+
+
+@router.post("/", response_model=OrderDetailsResponse, status_code=status.HTTP_201_CREATED)
+async def create_order_details(
+    data: OrderDetailsCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-order")),
+):
+    if await crud.get_by_order_id(db, data.order_id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Order details for order '{data.order_id}' already exist",
+        )
+    return await crud.create(db, data)
+
+
+@router.patch("/{order_id}", response_model=OrderDetailsResponse)
+async def update_order_details(
+    order_id: str,
+    data: OrderDetailsUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-order")),
+):
+    updated = await crud.update(db, order_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order details for order '{order_id}' not found",
+        )
+    return updated
+
+
+@router.delete("/{order_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_order_details(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-order")),
+):
+    if not await crud.delete(db, order_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order details for order '{order_id}' not found",
+        )

services/orders/routers/order_metadata.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.orders.helpers import order_metadata as crud
+from services.common.auth import require_permission
+from services.orders.models.order_metadata import (
+    OrderMetadataCreate,
+    OrderMetadataResponse,
+    OrderMetadataUpdate,
+    PaginatedOrderMetadataResponse,
+)
+
+router = APIRouter()
+
+@router.get("/", response_model=PaginatedOrderMetadataResponse)
+async def list_order_metadata(
+    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-order")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedOrderMetadataResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=records,
+    )
+
+
+@router.get("/{order_id}", response_model=OrderMetadataResponse)
+async def get_order_metadata(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    record = await crud.get_by_order_id(db, order_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order metadata for order '{order_id}' not found",
+        )
+    return record
+
+
+@router.post("/", response_model=OrderMetadataResponse, status_code=status.HTTP_201_CREATED)
+async def create_order_metadata(
+    data: OrderMetadataCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-order")),
+):
+    if data.order_id and await crud.get_by_order_id(db, data.order_id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Order metadata for order '{data.order_id}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+@router.patch("/{order_id}", response_model=OrderMetadataResponse)
+async def update_order_metadata(
+    order_id: str,
+    data: OrderMetadataUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-order")),
+):
+    updated = await crud.update(db, order_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order metadata for order '{order_id}' not found",
+        )
+    return updated
+
+
+@router.delete("/{order_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_order_metadata(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-order")),
+):
+    if not await crud.delete(db, order_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order metadata for order '{order_id}' not found",
+        )

services/orders/routers/order_payment_metadata.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.orders.helpers import order_payment_metadata as crud
+from services.common.auth import require_permission
+from services.orders.models.order_payment_metadata import (
+    OrderPaymentMetadataCreate,
+    OrderPaymentMetadataResponse,
+    OrderPaymentMetadataUpdate,
+    PaginatedOrderPaymentMetadataResponse,
+)
+
+router = APIRouter()
+
+@router.get("/", response_model=PaginatedOrderPaymentMetadataResponse)
+async def list_order_payment_metadata(
+    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-order")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedOrderPaymentMetadataResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=records,
+    )
+
+
+@router.get("/{order_id}", response_model=OrderPaymentMetadataResponse)
+async def get_order_payment_metadata(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    record = await crud.get_by_order_id(db, order_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order payment metadata for order '{order_id}' not found",
+        )
+    return record
+
+
+@router.post("/", response_model=OrderPaymentMetadataResponse, status_code=status.HTTP_201_CREATED)
+async def create_order_payment_metadata(
+    data: OrderPaymentMetadataCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-order")),
+):
+    if await crud.get_by_order_id(db, data.order_id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Order payment metadata for order '{data.order_id}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+@router.patch("/{order_id}", response_model=OrderPaymentMetadataResponse)
+async def update_order_payment_metadata(
+    order_id: str,
+    data: OrderPaymentMetadataUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-order")),
+):
+    updated = await crud.update(db, order_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order payment metadata for order '{order_id}' not found",
+        )
+    return updated
+
+
+@router.delete("/{order_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_order_payment_metadata(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-order")),
+):
+    if not await crud.delete(db, order_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Order payment metadata for order '{order_id}' not found",
+        )