lambda-erp 0.1.0__py3-none-any.whl

lambda_erp/buying/purchase_order.py

@@ -0,0 +1,165 @@
+"""
+Purchase Order.
+
+Purchase Order is the buying-side equivalent of Sales Order:
+  Purchase Order -> Purchase Receipt -> Purchase Invoice
+
+Key behaviors:
+- Does NOT create GL entries
+- Updates ordered_qty in Bin (for MRP planning)
+- Tracks receipt and billing status
+"""
+
+from lambda_erp.model import Document
+from lambda_erp.utils import _dict, flt, getdate, nowdate
+from lambda_erp.database import get_db
+from lambda_erp.controllers.taxes_and_totals import calculate_taxes_and_totals
+from lambda_erp.controllers.defaults import set_default_currency
+from lambda_erp.exceptions import ValidationError
+
+class PurchaseOrder(Document):
+    DOCTYPE = "Purchase Order"
+    CHILD_TABLES = {
+        "items": ("Purchase Order Item", None),
+        "taxes": ("Sales Taxes and Charges", None),
+    }
+    PREFIX = "PO"
+
+    LINK_FIELDS = {
+        "supplier": "Supplier",
+        "company": "Company",
+    }
+    CHILD_LINK_FIELDS = {
+        "items": {
+            "item_code": "Item",
+            "warehouse": "Warehouse",
+        },
+        "taxes": {
+            "account_head": "Account",
+            "cost_center": "Cost Center",
+        },
+    }
+
+    def validate(self):
+        if not self.supplier:
+            raise ValidationError("Supplier is required")
+        if not self.get("items"):
+            raise ValidationError("At least one item is required")
+        if not self.transaction_date:
+            self.transaction_date = nowdate()
+
+        self._set_supplier_name()
+        self._set_item_defaults()
+
+        from lambda_erp.controllers.pricing_rule import apply_pricing_rules
+        apply_pricing_rules(self)
+
+        set_default_currency(self, "Supplier", "supplier")
+
+        calculate_taxes_and_totals(self)
+
+    def _set_supplier_name(self):
+        if not self.supplier_name and self.supplier:
+            db = get_db()
+            self.supplier_name = db.get_value("Supplier", self.supplier, "supplier_name")
+
+    def _set_item_defaults(self):
+        db = get_db()
+        for item in self.get("items"):
+            if item.get("item_code") and not item.get("item_name"):
+                item_data = db.get_value(
+                    "Item", item["item_code"],
+                    ["item_name", "description", "stock_uom", "standard_rate"]
+                )
+                if item_data:
+                    item["item_name"] = item_data.item_name
+                    item["description"] = item.get("description") or item_data.description
+                    item["uom"] = item.get("uom") or item_data.stock_uom
+                    if not item.get("rate"):
+                        item["rate"] = flt(item_data.standard_rate)
+
+    def on_submit(self):
+        """Update ordered_qty in Bin for MRP planning."""
+        self._update_ordered_qty(1)
+
+    def on_cancel(self):
+        self._update_ordered_qty(-1)
+
+    def _update_ordered_qty(self, direction=1):
+        db = get_db()
+        for item in self.get("items"):
+            if item.get("warehouse") and item.get("item_code"):
+                qty = flt(item.get("qty", 0)) * direction
+                bin_data = db.get_value(
+                    "Bin",
+                    {"item_code": item["item_code"], "warehouse": item["warehouse"]},
+                    ["name", "ordered_qty"],
+                )
+                if bin_data:
+                    new_ordered = flt(bin_data.ordered_qty) + qty
+                    db.set_value("Bin", bin_data.name, "ordered_qty", max(0, new_ordered))
+                elif direction > 0:
+                    db.insert("Bin", _dict(
+                        name=f"{item['item_code']}-{item['warehouse']}",
+                        item_code=item["item_code"],
+                        warehouse=item["warehouse"],
+                        ordered_qty=qty,
+                    ))
+        db.commit()
+
+    def update_receipt_status(self):
+        """Update per_received based on received quantities."""
+        total_qty = sum(flt(item.get("qty")) for item in self.get("items"))
+        received_qty = sum(flt(item.get("received_qty")) for item in self.get("items"))
+        if total_qty:
+            self._data["per_received"] = flt(received_qty / total_qty * 100, 2)
+        self._persist()
+
+def make_purchase_invoice(purchase_order_name):
+    """Convert a Purchase Order into a Purchase Invoice."""
+    from lambda_erp.accounting.purchase_invoice import PurchaseInvoice
+
+    db = get_db()
+    po = PurchaseOrder.load(purchase_order_name)
+
+    if po.docstatus != 1:
+        raise ValidationError("Purchase Order must be submitted before creating Purchase Invoice")
+
+    pi = PurchaseInvoice(
+        supplier=po.supplier,
+        supplier_name=po.supplier_name,
+        company=po.company,
+        currency=po.currency,
+        conversion_rate=po.conversion_rate,
+        posting_date=nowdate(),
+        purchase_order=po.name,
+    )
+
+    for item in po.get("items"):
+        unbilled = flt(item.get("qty")) - flt(item.get("billed_qty"))
+        if unbilled <= 0:
+            continue
+
+        pi.append("items", _dict(
+            item_code=item.get("item_code"),
+            item_name=item.get("item_name"),
+            description=item.get("description"),
+            qty=unbilled,
+            uom=item.get("uom"),
+            rate=item.get("rate"),
+            warehouse=item.get("warehouse"),
+            purchase_order=po.name,
+            purchase_order_item=item.get("name"),
+        ))
+
+    for tax in po.get("taxes") or []:
+        pi.append("taxes", _dict(
+            charge_type=tax.get("charge_type"),
+            account_head=tax.get("account_head"),
+            description=tax.get("description"),
+            rate=tax.get("rate"),
+            tax_amount=0,
+            included_in_print_rate=tax.get("included_in_print_rate"),
+        ))
+
+    return pi

lambda_erp/controllers/currency.py

@@ -0,0 +1,52 @@
+"""Currency exchange-rate lookup.
+
+Rates live in the `Currency Exchange` table (date, from_currency, to_currency,
+exchange_rate). A lookup carries forward the most recent rate on or before a
+given date. The looked-up rate is snapshotted onto each document at posting
+time (its `conversion_rate` column), so editing this table never changes a
+book that has already been posted — the snapshot is what guarantees historical
+reproducibility, not any immutability of the table itself.
+"""
+
+from lambda_erp.database import get_db
+from lambda_erp.utils import flt, nowdate
+from lambda_erp.exceptions import ValidationError
+
+
+def get_exchange_rate(from_currency, to_currency, date=None):
+    """Return units of to_currency per 1 unit of from_currency on/before date.
+
+    - Same currency (or a missing currency) -> 1.0.
+    - Otherwise the newest Currency Exchange rate with date <= the given date
+      (carry-forward). If only the reverse pair exists, its inverse is used.
+    - If no rate is found at all, raises rather than silently assuming 1.0 —
+      booking a foreign-currency document at 1.0 would corrupt the base ledger.
+    """
+    if not from_currency or not to_currency or from_currency == to_currency:
+        return 1.0
+
+    db = get_db()
+    on_date = date or nowdate()
+
+    direct = db.sql(
+        'SELECT exchange_rate FROM "Currency Exchange" '
+        'WHERE from_currency = ? AND to_currency = ? AND date <= ? '
+        'ORDER BY date DESC LIMIT 1',
+        [from_currency, to_currency, on_date],
+    )
+    if direct and flt(direct[0]["exchange_rate"]) > 0:
+        return flt(direct[0]["exchange_rate"])
+
+    inverse = db.sql(
+        'SELECT exchange_rate FROM "Currency Exchange" '
+        'WHERE from_currency = ? AND to_currency = ? AND date <= ? '
+        'ORDER BY date DESC LIMIT 1',
+        [to_currency, from_currency, on_date],
+    )
+    if inverse and flt(inverse[0]["exchange_rate"]) > 0:
+        return flt(1.0 / flt(inverse[0]["exchange_rate"]), 6)
+
+    raise ValidationError(
+        f"No exchange rate found for {from_currency} -> {to_currency} on or before "
+        f"{on_date}. Add a Currency Exchange entry or pass conversion_rate explicitly."
+    )

lambda_erp/controllers/defaults.py

@@ -0,0 +1,51 @@
+"""Shared default-setting helpers for transactional documents."""
+
+from lambda_erp.database import get_db
+from lambda_erp.utils import flt
+from lambda_erp.controllers.currency import get_exchange_rate
+
+
+def set_default_company(doc):
+    """Set company to the first available company if not specified."""
+    if doc._data.get("company"):
+        return
+    db = get_db()
+    companies = db.get_all("Company", fields=["name"], limit=1)
+    if companies:
+        doc._data["company"] = companies[0]["name"]
+
+
+def set_default_currency(doc, party_type=None, party_field=None):
+    """Default a transaction's currency and conversion_rate for new entries.
+
+    Currency precedence: a value already on the doc -> the party's
+    default_currency -> the company's (base/functional) default_currency ->
+    "USD".
+
+    conversion_rate is forced to 1.0 whenever the document currency equals the
+    company's base currency. For a foreign currency the caller-supplied rate is
+    kept; if none was supplied it is looked up from the Currency Exchange table
+    for the document's date. A foreign currency with no rate on file raises
+    (via get_exchange_rate) rather than silently booking at 1.0.
+    """
+    db = get_db()
+    company = doc._data.get("company")
+    base_currency = db.get_value("Company", company, "default_currency") if company else None
+
+    currency = doc._data.get("currency")
+    if not currency:
+        if party_type and party_field:
+            party = doc._data.get(party_field)
+            if party:
+                currency = db.get_value(party_type, party, "default_currency")
+        currency = currency or base_currency or "USD"
+        doc._data["currency"] = currency
+
+    rate = flt(doc._data.get("conversion_rate"))
+    if base_currency and currency == base_currency:
+        rate = 1.0
+    elif rate <= 0:
+        # No rate supplied — look one up (carry-forward) for the doc's date.
+        doc_date = doc._data.get("posting_date") or doc._data.get("transaction_date")
+        rate = get_exchange_rate(currency, base_currency or "USD", doc_date)
+    doc._data["conversion_rate"] = rate

lambda_erp/controllers/pricing_rule.py

@@ -0,0 +1,103 @@
+"""
+Pricing Rule.
+
+Pricing Rules define automatic discounts applied to transaction items.
+A rule matches by item_code, quantity threshold, and date range, then
+applies either a rate override, a discount percentage, or a discount amount.
+"""
+
+from lambda_erp.model import Document
+from lambda_erp.utils import _dict, flt, getdate, nowdate
+from lambda_erp.database import get_db
+from lambda_erp.exceptions import ValidationError
+
+class PricingRule(Document):
+    DOCTYPE = "Pricing Rule"
+    CHILD_TABLES = {}
+    PREFIX = "PRULE"
+
+    def validate(self):
+        if not self.title:
+            raise ValidationError("Title is required")
+        if not self.item_code:
+            raise ValidationError("Item Code is required")
+        if not self._data.get("selling") and not self._data.get("buying"):
+            raise ValidationError("At least one of Selling or Buying must be enabled")
+
+        rtype = self.rate_or_discount or "Discount Percentage"
+        if rtype == "Rate" and not flt(self.rate):
+            raise ValidationError("Rate is required when Rate type is selected")
+        if rtype == "Discount Percentage" and not flt(self.discount_percentage):
+            raise ValidationError("Discount Percentage is required")
+        if rtype == "Discount Amount" and not flt(self.discount_amount):
+            raise ValidationError("Discount Amount is required")
+
+        if self.valid_from and self.valid_upto:
+            if getdate(self.valid_from) > getdate(self.valid_upto):
+                raise ValidationError("Valid From cannot be after Valid Upto")
+
+def apply_pricing_rules(doc):
+    """Apply matching pricing rules to a transaction document.
+
+    Called during validate() of Quotation, SO, SI, PO, PI.
+    For each item, finds the best matching rule and applies it.
+    """
+    db = get_db()
+    today = nowdate()
+
+    # Determine if selling or buying
+    is_selling = hasattr(doc, "customer") and doc.customer
+    is_buying = hasattr(doc, "supplier") and doc.supplier
+
+    for item in doc.get("items") or []:
+        item_code = item.get("item_code")
+        if not item_code:
+            continue
+
+        qty = flt(item.get("qty", 0))
+
+        # Query matching rules
+        rules = db.sql(
+            """
+            SELECT * FROM "Pricing Rule"
+            WHERE item_code = ?
+              AND enabled = 1
+              AND (valid_from IS NULL OR valid_from = '' OR valid_from <= ?)
+              AND (valid_upto IS NULL OR valid_upto = '' OR valid_upto >= ?)
+              AND (min_qty = 0 OR min_qty <= ?)
+            ORDER BY priority DESC, min_qty DESC
+            LIMIT 1
+            """,
+            [item_code, today, today, qty],
+        )
+
+        if not rules:
+            continue
+
+        rule = rules[0]
+
+        # Check selling/buying applicability
+        if is_selling and not rule.get("selling"):
+            continue
+        if is_buying and not rule.get("buying"):
+            continue
+
+        rtype = rule.get("rate_or_discount", "Discount Percentage")
+
+        if rtype == "Rate":
+            item["rate"] = flt(rule["rate"])
+            item["price_list_rate"] = flt(rule["rate"])
+            item["discount_percentage"] = 0
+            item["discount_amount"] = 0
+        elif rtype == "Discount Percentage":
+            pct = flt(rule["discount_percentage"])
+            item["discount_percentage"] = pct
+            rate = flt(item.get("price_list_rate") or item.get("rate", 0))
+            item["rate"] = flt(rate * (1 - pct / 100), 2)
+        elif rtype == "Discount Amount":
+            amt = flt(rule["discount_amount"])
+            item["discount_amount"] = amt
+            rate = flt(item.get("price_list_rate") or item.get("rate", 0))
+            item["rate"] = flt(rate - amt, 2)
+
+        item["pricing_rule"] = rule.get("name")