import math import uuid from decimal import Decimal from pathlib import Path from typing import Annotated from fastapi import APIRouter, Depends, File, Form, Query, UploadFile from app.application.exceptions import ValidationError from app.application.services.purchase_service import PurchaseService from app.domain.entities.user_registration import UserRegistration from app.domain.enums import ( GrnStatus, PaymentTerms, PreferredPaymentMethod, PurchaseOrderStatus, PurchasePaymentStatus, VendorBillStatus, VendorBusinessType, ) from app.presentation.auth_dependencies import get_current_user from app.presentation.company_dependencies import get_validated_company_id_query from app.presentation.dependencies import get_purchase_service from app.presentation.schemas.common import DataTableResponse, MessageResponse from app.presentation.schemas.purchase import ( GoodsReceiptCreate, GoodsReceiptResponse, PurchaseOrderCreate, PurchaseOrderResponse, PurchaseOrderUpdate, PurchasePaymentCreate, PurchasePaymentResponse, VendorBillCreate, VendorBillResponse, VendorResponse, ) router = APIRouter(prefix="/purchase", tags=["Purchase"]) CompanyId = Annotated[str, Depends(get_validated_company_id_query)] _STATIC_ROOT = Path(__file__).resolve().parents[4] / "static" _LOGO_ALLOWED_EXT = {".png", ".jpg", ".jpeg"} _ATTACHMENT_ALLOWED_EXT = {".png", ".jpg", ".jpeg", ".pdf", ".doc", ".docx", ".xls", ".xlsx"} _LOGO_MAX_BYTES = 2 * 1024 * 1024 _ATTACHMENT_MAX_BYTES = 5 * 1024 * 1024 def _build_datatable(data: list, total: int, page: int, page_size: int) -> DataTableResponse: return DataTableResponse( data=data, total=total, page=page, page_size=page_size, total_pages=max(1, math.ceil(total / page_size)) if page_size else 1, ) async def _save_vendor_logo(company_id: str, logo: UploadFile) -> str: filename = logo.filename or "" ext = Path(filename).suffix.lower() if ext not in _LOGO_ALLOWED_EXT: raise ValidationError("Logo must be JPG or PNG") content = await logo.read() if len(content) > _LOGO_MAX_BYTES: raise ValidationError("Logo must be 2MB or smaller") dest_dir = _STATIC_ROOT / "vendors" / company_id dest_dir.mkdir(parents=True, exist_ok=True) stored_name = f"{uuid.uuid4().hex}{ext}" (dest_dir / stored_name).write_bytes(content) return f"/static/vendors/{company_id}/{stored_name}" async def _save_po_attachment(company_id: str, file: UploadFile) -> str: filename = file.filename or "" ext = Path(filename).suffix.lower() if ext not in _ATTACHMENT_ALLOWED_EXT: raise ValidationError("Attachment must be image, PDF, Word, or Excel") content = await file.read() if len(content) > _ATTACHMENT_MAX_BYTES: raise ValidationError("Attachment must be 5MB or smaller") dest_dir = _STATIC_ROOT / "purchase-orders" / company_id dest_dir.mkdir(parents=True, exist_ok=True) stored_name = f"{uuid.uuid4().hex}{ext}" (dest_dir / stored_name).write_bytes(content) return f"/static/purchase-orders/{company_id}/{stored_name}" def _to_vendor_response(vendor) -> VendorResponse: return VendorResponse( id=vendor.id or "", company_id=vendor.company_id, code=vendor.code, name=vendor.name, business_type=vendor.business_type, contact_person=vendor.contact_person, designation=vendor.designation, phone=vendor.phone, alternate_phone=vendor.alternate_phone, email=vendor.email, website=vendor.website, ntn=vendor.ntn, sales_tax_no=vendor.sales_tax_no, address_line1=vendor.address_line1, address_line2=vendor.address_line2, city=vendor.city, state_province=vendor.state_province, country=vendor.country, postal_code=vendor.postal_code, notes=vendor.notes, payment_terms=vendor.payment_terms, payment_terms_days=vendor.payment_terms_days, credit_limit=vendor.credit_limit, opening_balance=vendor.opening_balance, currency=vendor.currency, po_prefix=vendor.po_prefix, default_warehouse_id=vendor.default_warehouse_id, default_warehouse_code=getattr(vendor, "default_warehouse_code", None), default_warehouse_name=getattr(vendor, "default_warehouse_name", None), preferred_payment_method=vendor.preferred_payment_method, logo=vendor.logo, address=vendor.address, account_id=vendor.account_id, is_active=vendor.is_active, created_at=vendor.created_at, updated_at=vendor.updated_at, ) # ---- Vendors ---- @router.post("/vendors", response_model=VendorResponse, status_code=201) async def create_vendor( company_id: CompanyId, name: Annotated[str, Form(min_length=1, max_length=200, description="Vendor / Supplier name")], contact_person: Annotated[str, Form(min_length=1, max_length=200)], phone: Annotated[str, Form(min_length=1, max_length=50)], address_line1: Annotated[str, Form(min_length=1, max_length=255)], city: Annotated[str, Form(min_length=1, max_length=100)], code: Annotated[ str | None, Form(min_length=1, max_length=30, description="Auto VEN-00001 if left blank"), ] = None, business_type: Annotated[VendorBusinessType | None, Form()] = None, designation: Annotated[str | None, Form(max_length=100)] = None, alternate_phone: Annotated[str | None, Form(max_length=50)] = None, email: Annotated[str | None, Form(max_length=255)] = None, website: Annotated[str | None, Form(max_length=255)] = None, ntn: Annotated[str | None, Form(max_length=50)] = None, sales_tax_no: Annotated[str | None, Form(max_length=50)] = None, address_line2: Annotated[str | None, Form(max_length=255)] = None, state_province: Annotated[str | None, Form(max_length=100)] = None, country: Annotated[str, Form(min_length=1, max_length=100)] = "Pakistan", postal_code: Annotated[str | None, Form(max_length=30)] = None, notes: Annotated[str | None, Form(max_length=500)] = None, payment_terms: Annotated[PaymentTerms | None, Form()] = None, payment_terms_days: Annotated[int, Form(ge=0)] = 30, credit_limit: Annotated[Decimal, Form(ge=0)] = Decimal("0.00"), opening_balance: Annotated[Decimal, Form()] = Decimal("0.00"), currency: Annotated[str, Form(max_length=10)] = "PKR", po_prefix: Annotated[str | None, Form(max_length=30)] = None, default_warehouse_id: Annotated[str | None, Form()] = None, preferred_payment_method: Annotated[PreferredPaymentMethod | None, Form()] = None, account_id: Annotated[str | None, Form()] = None, is_active: Annotated[bool, Form(description="Status Active/Inactive")] = True, logo: Annotated[ UploadFile | None, File(description="JPG or PNG — max 2MB"), ] = None, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): payload = { "code": code, "name": name, "business_type": business_type.value if business_type else None, "contact_person": contact_person, "designation": designation, "phone": phone, "alternate_phone": alternate_phone, "email": email, "website": website, "ntn": ntn, "sales_tax_no": sales_tax_no, "address_line1": address_line1, "address_line2": address_line2, "city": city, "state_province": state_province, "country": country, "postal_code": postal_code, "notes": notes, "payment_terms": payment_terms.value if payment_terms else None, "payment_terms_days": payment_terms_days, "credit_limit": credit_limit, "opening_balance": opening_balance, "currency": currency, "po_prefix": po_prefix, "default_warehouse_id": default_warehouse_id, "preferred_payment_method": ( preferred_payment_method.value if preferred_payment_method else None ), "account_id": account_id, "is_active": is_active, } if logo is not None and logo.filename: payload["logo"] = await _save_vendor_logo(company_id, logo) vendor = await service.create_vendor(current_user, company_id, payload) return _to_vendor_response(vendor) @router.get("/vendors", response_model=DataTableResponse[VendorResponse]) async def list_vendors( company_id: CompanyId, is_active: bool | None = None, page: int = Query(1, ge=1), page_size: int = Query(20, ge=1, le=500), current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): skip = (page - 1) * page_size items, total = await service.list_vendors( current_user, company_id, is_active, skip, page_size ) return _build_datatable( [_to_vendor_response(i) for i in items], total, page, page_size ) @router.get("/vendors/{vendor_id}", response_model=VendorResponse) async def get_vendor( company_id: CompanyId, vendor_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): vendor = await service.get_vendor(current_user, company_id, vendor_id) return _to_vendor_response(vendor) @router.put("/vendors/{vendor_id}", response_model=VendorResponse) async def update_vendor( company_id: CompanyId, vendor_id: str, code: Annotated[str | None, Form(min_length=1, max_length=30)] = None, name: Annotated[str | None, Form(min_length=1, max_length=200)] = None, business_type: Annotated[VendorBusinessType | None, Form()] = None, contact_person: Annotated[str | None, Form(min_length=1, max_length=200)] = None, designation: Annotated[str | None, Form(max_length=100)] = None, phone: Annotated[str | None, Form(min_length=1, max_length=50)] = None, alternate_phone: Annotated[str | None, Form(max_length=50)] = None, email: Annotated[str | None, Form(max_length=255)] = None, website: Annotated[str | None, Form(max_length=255)] = None, ntn: Annotated[str | None, Form(max_length=50)] = None, sales_tax_no: Annotated[str | None, Form(max_length=50)] = None, address_line1: Annotated[str | None, Form(min_length=1, max_length=255)] = None, address_line2: Annotated[str | None, Form(max_length=255)] = None, city: Annotated[str | None, Form(min_length=1, max_length=100)] = None, state_province: Annotated[str | None, Form(max_length=100)] = None, country: Annotated[str | None, Form(min_length=1, max_length=100)] = None, postal_code: Annotated[str | None, Form(max_length=30)] = None, notes: Annotated[str | None, Form(max_length=500)] = None, payment_terms: Annotated[PaymentTerms | None, Form()] = None, payment_terms_days: Annotated[int | None, Form(ge=0)] = None, credit_limit: Annotated[Decimal | None, Form(ge=0)] = None, opening_balance: Annotated[Decimal | None, Form()] = None, currency: Annotated[str | None, Form(max_length=10)] = None, po_prefix: Annotated[str | None, Form(max_length=30)] = None, default_warehouse_id: Annotated[str | None, Form()] = None, preferred_payment_method: Annotated[PreferredPaymentMethod | None, Form()] = None, account_id: Annotated[str | None, Form()] = None, is_active: Annotated[bool | None, Form()] = None, logo: Annotated[ UploadFile | None, File(description="JPG or PNG — max 2MB"), ] = None, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): payload: dict = {} if code is not None: payload["code"] = code if name is not None: payload["name"] = name if business_type is not None: payload["business_type"] = business_type.value if contact_person is not None: payload["contact_person"] = contact_person if designation is not None: payload["designation"] = designation if phone is not None: payload["phone"] = phone if alternate_phone is not None: payload["alternate_phone"] = alternate_phone if email is not None: payload["email"] = email if website is not None: payload["website"] = website if ntn is not None: payload["ntn"] = ntn if sales_tax_no is not None: payload["sales_tax_no"] = sales_tax_no if address_line1 is not None: payload["address_line1"] = address_line1 if address_line2 is not None: payload["address_line2"] = address_line2 if city is not None: payload["city"] = city if state_province is not None: payload["state_province"] = state_province if country is not None: payload["country"] = country if postal_code is not None: payload["postal_code"] = postal_code if notes is not None: payload["notes"] = notes if payment_terms is not None: payload["payment_terms"] = payment_terms.value if payment_terms_days is not None: payload["payment_terms_days"] = payment_terms_days if credit_limit is not None: payload["credit_limit"] = credit_limit if opening_balance is not None: payload["opening_balance"] = opening_balance if currency is not None: payload["currency"] = currency if po_prefix is not None: payload["po_prefix"] = po_prefix if default_warehouse_id is not None: payload["default_warehouse_id"] = default_warehouse_id or None if preferred_payment_method is not None: payload["preferred_payment_method"] = preferred_payment_method.value if account_id is not None: payload["account_id"] = account_id or None if is_active is not None: payload["is_active"] = is_active if logo is not None and logo.filename: payload["logo"] = await _save_vendor_logo(company_id, logo) vendor = await service.update_vendor(current_user, company_id, vendor_id, payload) return _to_vendor_response(vendor) @router.delete("/vendors/{vendor_id}", response_model=MessageResponse) async def delete_vendor( company_id: CompanyId, vendor_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): await service.delete_vendor(current_user, company_id, vendor_id) return MessageResponse(message="Vendor deleted successfully") # ---- Purchase orders ---- @router.post("/orders", response_model=PurchaseOrderResponse, status_code=201) async def create_order( company_id: CompanyId, payload: PurchaseOrderCreate, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): """Save as Draft — creates a draft purchase order (use submit endpoint to submit).""" order = await service.create_purchase_order(current_user, company_id, payload.model_dump()) return PurchaseOrderResponse.model_validate(order) @router.get("/orders", response_model=DataTableResponse[PurchaseOrderResponse]) async def list_orders( company_id: CompanyId, status: PurchaseOrderStatus | None = None, vendor_id: str | None = None, page: int = Query(1, ge=1), page_size: int = Query(20, ge=1, le=500), current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): skip = (page - 1) * page_size items, total = await service.list_purchase_orders( current_user, company_id, status, vendor_id, skip, page_size ) return _build_datatable( [PurchaseOrderResponse.model_validate(i) for i in items], total, page, page_size ) @router.get("/orders/{order_id}", response_model=PurchaseOrderResponse) async def get_order( company_id: CompanyId, order_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): order = await service.get_purchase_order(current_user, company_id, order_id) return PurchaseOrderResponse.model_validate(order) @router.put("/orders/{order_id}", response_model=PurchaseOrderResponse) async def update_order( company_id: CompanyId, order_id: str, payload: PurchaseOrderUpdate, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): order = await service.update_purchase_order( current_user, company_id, order_id, payload.model_dump(exclude_unset=True) ) return PurchaseOrderResponse.model_validate(order) @router.post("/orders/{order_id}/attachments", response_model=PurchaseOrderResponse) async def upload_order_attachments( company_id: CompanyId, order_id: str, files: Annotated[ list[UploadFile], File(description="Supporting documents (image/PDF/Office) — max 5MB each"), ], current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): paths: list[str] = [] for file in files: if file.filename: paths.append(await _save_po_attachment(company_id, file)) if not paths: raise ValidationError("At least one attachment file is required") order = await service.add_purchase_order_attachments( current_user, company_id, order_id, paths ) return PurchaseOrderResponse.model_validate(order) @router.post("/orders/{order_id}/submit", response_model=PurchaseOrderResponse) async def submit_order( company_id: CompanyId, order_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): """Vendor confirmation — moves pending PO to confirmed status.""" order = await service.submit_purchase_order(current_user, company_id, order_id) return PurchaseOrderResponse.model_validate(order) @router.post("/orders/{order_id}/confirm-vendor", response_model=PurchaseOrderResponse) async def confirm_vendor( company_id: CompanyId, order_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): order = await service.confirm_vendor(current_user, company_id, order_id) return PurchaseOrderResponse.model_validate(order) @router.post("/orders/{order_id}/approve", response_model=PurchaseOrderResponse) async def approve_order( company_id: CompanyId, order_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): order = await service.approve_purchase_order(current_user, company_id, order_id) return PurchaseOrderResponse.model_validate(order) @router.post("/orders/{order_id}/cancel", response_model=PurchaseOrderResponse) async def cancel_order( company_id: CompanyId, order_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): order = await service.cancel_purchase_order(current_user, company_id, order_id) return PurchaseOrderResponse.model_validate(order) @router.post("/orders/{order_id}/close", response_model=PurchaseOrderResponse) async def close_order( company_id: CompanyId, order_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): order = await service.close_purchase_order(current_user, company_id, order_id) return PurchaseOrderResponse.model_validate(order) # ---- Goods receipts ---- @router.post("/goods-receipts", response_model=GoodsReceiptResponse, status_code=201) async def create_goods_receipt( company_id: CompanyId, payload: GoodsReceiptCreate, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): receipt = await service.create_goods_receipt(current_user, company_id, payload.model_dump()) return GoodsReceiptResponse.model_validate(receipt) @router.get("/goods-receipts", response_model=DataTableResponse[GoodsReceiptResponse]) async def list_goods_receipts( company_id: CompanyId, status: GrnStatus | None = None, purchase_order_id: str | None = None, page: int = Query(1, ge=1), page_size: int = Query(20, ge=1, le=500), current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): skip = (page - 1) * page_size items, total = await service.list_goods_receipts( current_user, company_id, status, purchase_order_id, skip, page_size ) return _build_datatable( [GoodsReceiptResponse.model_validate(i) for i in items], total, page, page_size ) @router.get("/goods-receipts/{receipt_id}", response_model=GoodsReceiptResponse) async def get_goods_receipt( company_id: CompanyId, receipt_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): receipt = await service.get_goods_receipt(current_user, company_id, receipt_id) return GoodsReceiptResponse.model_validate(receipt) @router.post("/goods-receipts/{receipt_id}/confirm", response_model=GoodsReceiptResponse) async def confirm_goods_receipt( company_id: CompanyId, receipt_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): receipt = await service.confirm_goods_receipt(current_user, company_id, receipt_id) return GoodsReceiptResponse.model_validate(receipt) # ---- Bills ---- @router.post("/bills", response_model=VendorBillResponse, status_code=201) async def create_bill( company_id: CompanyId, payload: VendorBillCreate, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): bill = await service.create_vendor_bill(current_user, company_id, payload.model_dump()) return VendorBillResponse.model_validate(bill) @router.get("/bills", response_model=DataTableResponse[VendorBillResponse]) async def list_bills( company_id: CompanyId, status: VendorBillStatus | None = None, vendor_id: str | None = None, page: int = Query(1, ge=1), page_size: int = Query(20, ge=1, le=500), current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): skip = (page - 1) * page_size items, total = await service.list_vendor_bills( current_user, company_id, status, vendor_id, skip, page_size ) return _build_datatable( [VendorBillResponse.model_validate(i) for i in items], total, page, page_size ) @router.get("/bills/{bill_id}", response_model=VendorBillResponse) async def get_bill( company_id: CompanyId, bill_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): bill = await service.get_vendor_bill(current_user, company_id, bill_id) return VendorBillResponse.model_validate(bill) @router.post("/bills/{bill_id}/post", response_model=VendorBillResponse) async def post_bill( company_id: CompanyId, bill_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): bill = await service.post_vendor_bill(current_user, company_id, bill_id) return VendorBillResponse.model_validate(bill) # ---- Payments ---- @router.post("/payments", response_model=PurchasePaymentResponse, status_code=201) async def create_payment( company_id: CompanyId, payload: PurchasePaymentCreate, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): payment = await service.create_payment(current_user, company_id, payload.model_dump()) return PurchasePaymentResponse.model_validate(payment) @router.get("/payments", response_model=DataTableResponse[PurchasePaymentResponse]) async def list_payments( company_id: CompanyId, status: PurchasePaymentStatus | None = None, vendor_id: str | None = None, page: int = Query(1, ge=1), page_size: int = Query(20, ge=1, le=500), current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): skip = (page - 1) * page_size items, total = await service.list_payments( current_user, company_id, status, vendor_id, skip, page_size ) return _build_datatable( [PurchasePaymentResponse.model_validate(i) for i in items], total, page, page_size ) @router.get("/payments/{payment_id}", response_model=PurchasePaymentResponse) async def get_payment( company_id: CompanyId, payment_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): payment = await service.get_payment(current_user, company_id, payment_id) return PurchasePaymentResponse.model_validate(payment) @router.post("/payments/{payment_id}/post", response_model=PurchasePaymentResponse) async def post_payment( company_id: CompanyId, payment_id: str, current_user: UserRegistration = Depends(get_current_user), service: PurchaseService = Depends(get_purchase_service), ): payment = await service.post_payment(current_user, company_id, payment_id) return PurchasePaymentResponse.model_validate(payment)