{kitchen_name}
{addr_html}
{f'
Tel: {kitchen_phone}
' if kitchen_phone else ''}
{f'
{kitchen_email}
' if kitchen_email else ''}
PURCHASE ORDER
{po_number}
Supplier
{supplier_name}
{f'
Account: {account_number}
' if account_number else ''}
Date
{order_date}
Status: {po.status}
{items_html}
Total: {currency}{total_amount:.2f}
{f'
Notes:
{notes}
' if notes else ''}
"""
@router.get("/{po_id}/preview")
async def preview_purchase_order(
po_id: int,
request: Request,
token: Optional[str] = Query(None),
db: AsyncSession = Depends(get_db),
):
"""Return a print-friendly HTML preview of the purchase order. Cookie auth preferred; ?token= accepted as fallback."""
current_user = None
if token:
current_user = await get_current_user_from_token(token, db)
if not current_user:
try:
current_user = await get_current_user(request)
except HTTPException:
pass
if not current_user:
raise HTTPException(status_code=401, detail="Not authenticated")
po = await _load_po(db, po_id, current_user.kitchen_id)
# Load kitchen settings for letterhead
settings_result = await db.execute(
select(KitchenSettings).where(KitchenSettings.kitchen_id == current_user.kitchen_id)
)
kitchen = settings_result.scalar_one_or_none()
if not kitchen:
kitchen = KitchenSettings(kitchen_id=current_user.kitchen_id)
currency = kitchen.currency_symbol or "£"
html = _build_po_html(po, kitchen, currency)
return HTMLResponse(content=html)
@router.post("/{po_id}/send-email")
async def send_po_email(
po_id: int,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
"""Email the PO to the supplier's order_email address."""
po = await _load_po(db, po_id, current_user.kitchen_id)
# Validate supplier has an order email
if not po.supplier or not po.supplier.order_email:
raise HTTPException(status_code=400, detail="Supplier does not have an order email address configured")
# Load kitchen settings for SMTP + letterhead
settings_result = await db.execute(
select(KitchenSettings).where(KitchenSettings.kitchen_id == current_user.kitchen_id)
)
kitchen = settings_result.scalar_one_or_none()
if not kitchen or not kitchen.smtp_host or not kitchen.smtp_from_email:
raise HTTPException(status_code=400, detail="SMTP email is not configured in Settings")
currency = kitchen.currency_symbol or "£"
html = _build_po_html(po, kitchen, currency)
po_number = f"PO-{po.id}"
kitchen_name = kitchen.kitchen_display_name or "Kitchen"
subject = f"Purchase Order {po_number} from {kitchen_name}"
email_service = EmailService(kitchen)
success = email_service.send_email(
to_email=po.supplier.order_email,
subject=subject,
html_body=html,
plain_body=f"Please find attached Purchase Order {po_number}. Total: {currency}{float(po.total_amount or 0):.2f}",
)
if not success:
raise HTTPException(status_code=500, detail="Failed to send email. Check SMTP settings.")
# Update status to PENDING if currently DRAFT
if po.status == "DRAFT":
po.status = "PENDING"
po.updated_by = current_user.id
await db.commit()
return {"ok": True, "message": f"PO emailed to {po.supplier.order_email}", "new_status": po.status}
# ── Invoice Matching ─────────────────────────────────────────────────────────
class LinkRequest(BaseModel):
invoice_id: int
@router.get("/matching/for-invoice")
async def get_matching_pos(
invoice_id: int,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
"""Find pending POs that match a given invoice (by supplier)."""
from services.po_matching import find_matching_pos
# Load the invoice
inv_result = await db.execute(
select(Invoice).where(
Invoice.id == invoice_id,
Invoice.kitchen_id == current_user.kitchen_id,
)
)
invoice = inv_result.scalar_one_or_none()
if not invoice:
raise HTTPException(status_code=404, detail="Invoice not found")
if not invoice.supplier_id:
return {"matches": [], "linked_po": None}
# Check if invoice already has a linked PO
linked_result = await db.execute(
select(PurchaseOrder)
.where(
PurchaseOrder.kitchen_id == current_user.kitchen_id,
PurchaseOrder.linked_invoice_id == invoice_id,
PurchaseOrder.status == "LINKED",
)
.options(
selectinload(PurchaseOrder.supplier),
selectinload(PurchaseOrder.line_items),
)
)
linked_po = linked_result.scalar_one_or_none()
if linked_po:
return {
"matches": [],
"linked_po": {
"po_id": linked_po.id,
"order_date": linked_po.order_date.isoformat() if linked_po.order_date else None,
"total_amount": float(linked_po.total_amount) if linked_po.total_amount else None,
"order_reference": linked_po.order_reference,
"status": linked_po.status,
"order_type": linked_po.order_type,
},
}
# Find matching POs
matches = await find_matching_pos(
db,
kitchen_id=current_user.kitchen_id,
supplier_id=invoice.supplier_id,
invoice_date=invoice.invoice_date,
invoice_total=invoice.total,
)
return {"matches": matches, "linked_po": None}
@router.post("/{po_id}/link", response_model=PurchaseOrderOut)
async def link_po_to_invoice(
po_id: int,
data: LinkRequest,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
"""Link a PO to an invoice. Sets PO status to LINKED."""
from services.po_matching import link_po_to_invoice as do_link
po = await do_link(db, po_id, data.invoice_id, current_user.kitchen_id, current_user.id)
if not po:
raise HTTPException(status_code=404, detail="PO or invoice not found")
return po_to_out(await _load_po(db, po.id, current_user.kitchen_id))
@router.post("/{po_id}/unlink", response_model=PurchaseOrderOut)
async def unlink_po_from_invoice(
po_id: int,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
"""Unlink a PO from its invoice. Returns PO to PENDING status."""
from services.po_matching import unlink_po as do_unlink
po = await do_unlink(db, po_id, current_user.kitchen_id, current_user.id)
if not po:
raise HTTPException(status_code=404, detail="PO not found")
return po_to_out(await _load_po(db, po.id, current_user.kitchen_id))