lambda-erp 1.4.1__tar.gz → 1.4.3__tar.gz

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 1.4.1
+Version: 1.4.3
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/api/auth.py

@@ -762,6 +762,30 @@ def _setting_enabled(db, key: str) -> bool:
     return str(value) == "1"
 
 
+def disable_public_demo_if_switched_off() -> int:
+    """With LAMBDA_ERP_ENABLE_PUBLIC_DEMO explicitly "0", no public demo user
+    stays active.
+
+    Demo mode is the enabled ``public_manager`` user: requests without a
+    credential fall back to it (get_current_user, the chat WebSocket). It is
+    created by booting with the flag at 1 or from the admin UI, and survived
+    switching the flag back off, leaving anonymous write access on a
+    deployment that once ran the demo. Unset keeps today's behaviour (the
+    admin UI toggle decides). Returns the number of users disabled.
+    """
+    if os.environ.get("LAMBDA_ERP_ENABLE_PUBLIC_DEMO") != "0":
+        return 0
+    db = get_db()
+    active = db.sql('SELECT name FROM "User" WHERE role = \'public_manager\' AND enabled = 1')
+    for row in active:
+        db.set_value("User", row["name"], {"enabled": 0, "modified": now()})
+    if active:
+        db.commit()
+        print(f"[public-demo] LAMBDA_ERP_ENABLE_PUBLIC_DEMO=0: disabled {len(active)} public demo "
+              "user(s); requests without a credential are now refused", flush=True)
+    return len(active)
+
+
 def ensure_seed_admin() -> dict | None:
     """Idempotently provision an admin account from the environment.
 

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/api/main.py

@@ -88,8 +88,9 @@ async def lifespan(app: FastAPI):
         # Seed a deterministic admin from the environment (if configured) before
         # anyone can register. On deployments whose DB is recreated each rollout
         # this stops the first visitor after a redeploy from grabbing admin.
-        from api.auth import ensure_seed_admin
+        from api.auth import disable_public_demo_if_switched_off, ensure_seed_admin
         ensure_seed_admin()
+        disable_public_demo_if_switched_off()
 
         # When packaged as a demo container, land visitors straight in demo mode.
         if os.environ.get("LAMBDA_ERP_AUTO_DEMO") == "1":

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/api/routers/masters.py

@@ -270,6 +270,8 @@ def _validate_master_input(master_type, doctype, data, name=None):
     for field, table in MASTER_LINK_FIELDS.get(master_type, {}).items():
         if merged.get(field) and not db.exists(table, merged[field]):
             raise ValidationError(f'{doctype}: {field} must reference an existing {table}')
+    if master_type == 'item' and data.get('valuation_method') not in (None, '', 'Moving Average'):
+        raise ValidationError('Item: valuation_method must be Moving Average; it is the only valuation the stock ledger implements')
     if master_type == 'company' and data.get('default_sales_tax_template'):
         template = db.get_value('Tax Template', data['default_sales_tax_template'], ['company', 'tax_type'])
         if not template or template['company'] != (name or data.get('name')) or template['tax_type'] != 'Sales':
@@ -300,6 +302,9 @@ def _create_master_record(master_type: str, data: dict) -> dict:
     doc = _normalize_master_data(data)
     doc.pop("creation", None)
     doc.pop("modified", None)
+    if master_type == "item" and not doc.get("valuation_method"):
+        # Databases created before 1.4.2 still carry the column default FIFO.
+        doc["valuation_method"] = "Moving Average"
 
     # Let callers set the code under its intuitive alias (item_code -> name).
     # Conflicting identities must never silently select one of the records.

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/accounting/pos_invoice.py

@@ -20,6 +20,7 @@ from lambda_erp.controllers.defaults import (
 from lambda_erp.controllers.item_price import set_item_defaults
 from lambda_erp.exceptions import ValidationError
 from lambda_erp.stock.stock_ledger import (
+    make_cancel_sl_entries,
     make_sl_entries,
     build_sell_side_sles,
     build_cost_basis_gl,
@@ -183,7 +184,7 @@ class POSInvoice(Document):
         if flt(self._data.get("update_stock")):
             reversed_sles = reverse_stock_sles(self._get_sl_entries())
             if reversed_sles:
-                make_sl_entries(reversed_sles, allow_negative_stock=True)
+                make_cancel_sl_entries(reversed_sles)
 
         make_reverse_gl_entries(
             voucher_type=self.DOCTYPE,

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/accounting/purchase_invoice.py

@@ -21,9 +21,11 @@ from lambda_erp.controllers.defaults import (
 from lambda_erp.controllers.item_price import set_item_defaults
 from lambda_erp.accounting.general_ledger import make_gl_entries, make_reverse_gl_entries, to_base_currency
 from lambda_erp.stock.stock_ledger import (
+    make_cancel_sl_entries,
     make_sl_entries,
     build_buy_side_sles,
     reverse_stock_sles,
+    stock_account_for,
 )
 from lambda_erp.exceptions import ValidationError
 
@@ -123,9 +125,6 @@ class PurchaseInvoice(Document):
         stock_received_account = db.get_value(
             "Company", self.company, "stock_received_but_not_billed"
         )
-        stock_in_hand_account = db.get_value(
-            "Company", self.company, "stock_in_hand_account"
-        )
         default_cc = db.get_value("Company", self.company, "default_cost_center")
         directly_receiving = flt(self.get("update_stock")) == 1
 
@@ -134,8 +133,10 @@ class PurchaseInvoice(Document):
                 is_stock = 0
                 if item.get("item_code"):
                     is_stock = db.get_value("Item", item["item_code"], "is_stock_item") or 0
-                if is_stock and directly_receiving and stock_in_hand_account:
-                    item["expense_account"] = stock_in_hand_account
+                stock_account = (stock_account_for(self.company, item.get("warehouse"))
+                                 if is_stock and directly_receiving else None)
+                if stock_account:
+                    item["expense_account"] = stock_account
                 elif is_stock and stock_received_account:
                     item["expense_account"] = stock_received_account
                 else:
@@ -200,7 +201,12 @@ class PurchaseInvoice(Document):
     def _validate_no_double_receipt(self):
         """Block update_stock=1 when the referenced Purchase Order already has
         a Purchase Receipt for the line. Otherwise stock arrives twice: once
-        via the PR and again when this invoice submits. Returns are exempt."""
+        via the PR and again when this invoice submits. Returns are exempt.
+
+        A line linked to its order line (`purchase_order_item`) is covered more
+        precisely by workflow.validate_order_quantities (receipts plus
+        direct-stock invoices may not exceed the ordered quantity), so the rest
+        of a partly received line can still be received with this invoice."""
         if not flt(self.get("update_stock")) or self.is_return:
             return
         db = get_db()
@@ -209,6 +215,8 @@ class PurchaseInvoice(Document):
             po_item = item.get("purchase_order_item")
             if not (po or po_item):
                 continue
+            if po_item:
+                continue  # order-line capacity check (validate_order_quantities)
             pr_rows = db.sql(
                 'SELECT pr.name AS pr_name '
                 'FROM "Purchase Receipt Item" pri '
@@ -309,7 +317,7 @@ class PurchaseInvoice(Document):
         if flt(self.get("update_stock")):
             reversed_sles = reverse_stock_sles(self._get_stock_sl_entries())
             if reversed_sles:
-                make_sl_entries(reversed_sles, allow_negative_stock=True)
+                make_cancel_sl_entries(reversed_sles)
 
         make_reverse_gl_entries(
             voucher_type=self.DOCTYPE,

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/accounting/sales_invoice.py

@@ -25,6 +25,7 @@ from lambda_erp.controllers.defaults import (
 from lambda_erp.controllers.item_price import set_item_defaults
 from lambda_erp.accounting.general_ledger import make_gl_entries, make_reverse_gl_entries, to_base_currency
 from lambda_erp.stock.stock_ledger import (
+    make_cancel_sl_entries,
     make_sl_entries,
     build_sell_side_sles,
     build_cost_basis_gl,
@@ -167,7 +168,13 @@ class SalesInvoice(Document):
         """Block update_stock=1 when the referenced Sales Order already has a
         Delivery Note for the line. Otherwise stock ships twice: once via the
         DN and again when this invoice submits. Returns are exempt (they
-        reverse the SI's own earlier shipment, not a separate DN)."""
+        reverse the SI's own earlier shipment, not a separate DN).
+
+        A line linked to its order line (`sales_order_item`) is covered more
+        precisely by workflow.validate_order_quantities: delivery notes plus
+        direct-stock invoices may not move more than the line ordered, so the
+        rest of a partly delivered line can still ship with this invoice. The
+        coarse check stays for lines that only name the order."""
         if not flt(self.get("update_stock")) or self.is_return:
             return
         db = get_db()
@@ -176,6 +183,8 @@ class SalesInvoice(Document):
             so = item.get("sales_order")
             if not (so or so_item):
                 continue
+            if item.get("sales_order_item"):
+                continue  # order-line capacity check (validate_order_quantities)
             dn_rows = db.sql(
                 'SELECT dn.name AS dn_name '
                 'FROM "Delivery Note Item" dni '
@@ -305,7 +314,7 @@ class SalesInvoice(Document):
         if flt(self.get("update_stock")):
             reversed_sles = reverse_stock_sles(self._get_stock_sl_entries())
             if reversed_sles:
-                make_sl_entries(reversed_sles, allow_negative_stock=True)
+                make_cancel_sl_entries(reversed_sles)
 
         make_reverse_gl_entries(
             voucher_type=self.DOCTYPE,

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/controllers/defaults.py

@@ -109,6 +109,12 @@ def derived_pricing_fields(source, *, is_return=False):
 
 
 def derived_line_pricing_fields(item):
-    return {field: item.get(field) for field in (
-        "ignore_pricing_rule", "external_line_reference", "pricing_rule",
+    """Line pricing provenance for a converted line. The price was agreed in
+    the source document, so pricing rules must not re-run on it (with a later
+    date or a newly added rule); lines added to the new document still get
+    rules."""
+    fields = {field: item.get(field) for field in (
+        "external_line_reference", "pricing_rule",
     )}
+    fields["ignore_pricing_rule"] = 1
+    return fields

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/controllers/pricing_rule.py

@@ -17,6 +17,19 @@ tightest quantity band, then name. Priority is the deliberate override — it is
 campaign beat a customer's standing rate without rewriting either.
 
 One rule applies per line. Rules do not stack.
+
+Rules match on the document's own date (posting_date / transaction_date), not
+on today. A Rate or Discount Amount rule is a number in one currency
+(`currency`, defaulting to the company's); it only applies to documents in
+that currency. A Discount Percentage rule applies in any currency.
+
+What the rules never override: a rate the user changed on a saved line (the
+line is then marked `ignore_pricing_rule`), lines carried over from a source
+document by a conversion (their price was agreed there), free lines and lines
+with a written deduction. A Rate rule sets the line rate but leaves
+`price_list_rate` at the list price, so the base stays honest when the rule is
+later disabled; a line whose rule no longer matches falls back to its list
+price.
 """
 
 from lambda_erp.model import Document
@@ -68,6 +81,7 @@ class PricingRule(Document):
             normalize_pricing_number(self, field, 1 if field == "enabled" else 0, integer=True)
         if not self.title:
             raise ValidationError("Title is required")
+        self._set_currency()
 
         apply_on = self.apply_on or "Item Code"
         if apply_on not in APPLY_ON:
@@ -117,6 +131,25 @@ class PricingRule(Document):
             raise ValidationError("Min Amt cannot be greater than Max Amt")
 
 
+    def _set_currency(self):
+        """A Rate / Discount Amount is a number in a currency: default it to
+        the company's, or to the one currency all companies share. A global
+        rule across companies with different currencies stays empty and then
+        counts in each document's company currency."""
+        if self._data.get("currency"):
+            return
+        db = get_db()
+        if self.company:
+            self._data["currency"] = db.get_value("Company", self.company, "default_currency")
+            return
+        if (self.rate_or_discount or "Discount Percentage") == "Discount Percentage":
+            return
+        currencies = {r["default_currency"] for r in db.sql(
+            'SELECT DISTINCT default_currency FROM "Company" WHERE default_currency IS NOT NULL')}
+        if len(currencies) == 1:
+            self._data["currency"] = currencies.pop()
+
+
 def _trade_side(doc):
     """(is_selling, is_buying) for a document, by type."""
     doctype = getattr(doc, "DOCTYPE", None)
@@ -178,15 +211,21 @@ def apply_pricing_rules(doc):
         return
 
     db = get_db()
-    today = nowdate()
+    on_date = doc._data.get("posting_date") or doc._data.get("transaction_date") or nowdate()
     is_selling, is_buying = _trade_side(doc)
     if not (is_selling or is_buying):
         return
     party = _party_context(db, doc, is_selling)
+    company_currency = db.get_value("Company", doc.get("company"), "default_currency") if doc.get("company") else None
+    doc_currency = doc._data.get("currency") or company_currency
+    stored = _stored_lines(db, doc)
 
     for item in doc.get("items") or []:
         if flt(item.get("ignore_pricing_rule")):
             continue
+        if _rate_changed_by_user(item, stored.get(item.get("name"))):
+            _keep_manual_rate(item)
+            continue
         # An explicit free line must not acquire a price from a rule.
         if item.get('rate') is not None and flt(item['rate']) == 0:
             continue
@@ -229,7 +268,7 @@ def apply_pricing_rules(doc):
             [
                 doc.get('company'),
                 int(bool(is_selling)), int(bool(is_buying)),
-                today, today,
+                on_date, on_date,
                 qty, qty,
                 amount, amount,
                 item_code, item_group,
@@ -238,7 +277,12 @@ def apply_pricing_rules(doc):
             ],
         )
 
+        rules = [r for r in rules
+                 if (r.get("rate_or_discount") or "Discount Percentage") == "Discount Percentage"
+                 or (r.get("currency") or company_currency) == doc_currency]
         if not rules:
+            if item.get("pricing_rule"):
+                _drop_rule(item)
             continue
 
         # Priority is the explicit override; specificity is the sensible
@@ -257,7 +301,8 @@ def apply_pricing_rules(doc):
 
         if rtype == "Rate":
             item["rate"] = flt(rule["rate"])
-            item["price_list_rate"] = flt(rule["rate"])
+            if base_rate:
+                item["price_list_rate"] = base_rate
             item["discount_percentage"] = 0
             item["discount_amount"] = 0
         elif rtype == "Discount Percentage":
@@ -274,3 +319,47 @@ def apply_pricing_rules(doc):
             item["rate"] = flt(base_rate - amt, 2)
 
         item["pricing_rule"] = rule.get("name")
+
+
+def _stored_lines(db, doc):
+    """The saved state of this document's lines, by row name (empty for a new
+    document). Lets pricing tell a user's rate edit from a rule's output."""
+    if not getattr(doc, "name", None) or "items" not in getattr(doc, "CHILD_TABLES", {}):
+        return {}
+    table = doc.CHILD_TABLES["items"][0]
+    rows = db.sql(f'SELECT name, item_code, rate, price_list_rate FROM "{table}" WHERE parent = ?', [doc.name])
+    return {r["name"]: r for r in rows}
+
+
+def _rate_changed_by_user(item, saved):
+    """True when a saved line comes back with a different rate but the same
+    item and list price: the user typed a price and it must survive."""
+    if not saved or item.get("rate") is None:
+        return False
+    if item.get("item_code") != saved.get("item_code"):
+        return False
+    if flt(item.get("price_list_rate"), 2) != flt(saved.get("price_list_rate"), 2):
+        return False
+    return flt(item.get("rate"), 2) != flt(saved.get("rate"), 2)
+
+
+def _keep_manual_rate(item):
+    """Freeze a user-set rate: no rule applies to this line any more, and the
+    discount fields say how far it is below the list price (totals would
+    otherwise recompute the rate from a leftover discount percentage)."""
+    rate = flt(item.get("rate"))
+    list_rate = flt(item.get("price_list_rate"))
+    item["ignore_pricing_rule"] = 1
+    item["pricing_rule"] = None
+    item["discount_percentage"] = 0
+    item["discount_amount"] = flt(list_rate - rate, 2) if list_rate > rate else 0
+
+
+def _drop_rule(item):
+    """The line's rule no longer matches (disabled, expired, other currency,
+    quantity changed): back to the list price."""
+    item["pricing_rule"] = None
+    item["discount_percentage"] = 0
+    item["discount_amount"] = 0
+    if flt(item.get("price_list_rate")):
+        item["rate"] = flt(item["price_list_rate"])

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/database.py

@@ -484,7 +484,7 @@ class Database:
                 is_stock_item INTEGER DEFAULT 1,
                 is_fixed_asset INTEGER DEFAULT 0,
                 is_asset_tracked INTEGER DEFAULT 0,
-                valuation_method TEXT DEFAULT 'FIFO',
+                valuation_method TEXT DEFAULT 'Moving Average',
                 default_warehouse TEXT,
                 standard_rate REAL DEFAULT 0,
                 description TEXT
@@ -1318,6 +1318,7 @@ class Database:
                 valid_upto TEXT,
                 priority INTEGER DEFAULT 0,
                 company TEXT,
+                currency TEXT,
                 enabled INTEGER DEFAULT 1,
                 status TEXT DEFAULT 'Active',
                 docstatus INTEGER DEFAULT 0,
@@ -3163,6 +3164,42 @@ def _m046_pdf_templates_all_documents(db: "Database") -> None:
     db.conn.commit()
 
 
+def _m047_sales_order_status_left_to_do(db: "Database") -> None:
+    """Sales Order status says what is left to do. Before 1.4.2 a fully
+    delivered, unbilled order read "To Deliver and Bill" (and a fully billed,
+    undelivered one too); recompute submitted orders with the fixed rule."""
+    db.sql('UPDATE "Sales Order" SET status = CASE '
+           'WHEN COALESCE(per_delivered, 0) < 100 AND COALESCE(per_billed, 0) < 100 THEN \'To Deliver and Bill\' '
+           'WHEN COALESCE(per_delivered, 0) < 100 THEN \'To Deliver\' '
+           'WHEN COALESCE(per_billed, 0) < 100 THEN \'To Bill\' '
+           'ELSE \'Completed\' END WHERE docstatus = 1')
+
+
+def _m048_item_valuation_moving_average(db: "Database") -> None:
+    """Item.valuation_method defaulted to FIFO although the stock ledger only
+    implements moving average; make the stored value say what happens."""
+    db.sql('UPDATE "Item" SET valuation_method = \'Moving Average\' '
+           'WHERE valuation_method IS NULL OR valuation_method <> \'Moving Average\'')
+
+
+def _m049_pricing_rule_currency(db: "Database") -> None:
+    """A Rate / Discount Amount rule is a number in one currency. Backfill the
+    company's currency, and for global rules the one currency all companies
+    share (left empty when companies differ: such a rule then counts in each
+    document's company currency)."""
+    db.ensure_column("Pricing Rule", "currency", "TEXT")
+    for company in db.sql('SELECT name, default_currency FROM "Company" WHERE default_currency IS NOT NULL'):
+        db.sql('UPDATE "Pricing Rule" SET currency = ? '
+               'WHERE (currency IS NULL OR currency = \'\') AND company = ?',
+               [company["default_currency"], company["name"]])
+    currencies = [r["default_currency"] for r in db.sql(
+        'SELECT DISTINCT default_currency FROM "Company" WHERE default_currency IS NOT NULL')]
+    if len(currencies) == 1:
+        db.sql('UPDATE "Pricing Rule" SET currency = ? '
+               'WHERE (currency IS NULL OR currency = \'\') AND (company IS NULL OR company = \'\')',
+               [currencies[0]])
+
+
 def _m042_record_notes(db: "Database") -> None:
     """Internal team notes on any document or master (see api.record_notes)."""
     db.conn.execute(
@@ -3229,6 +3266,9 @@ Database.MIGRATIONS = [
     (44, "quotation_intro_text", _m044_quotation_intro_text),
     (45, "line_discount_label", _m045_line_discount_label),
     (46, "pdf_templates_all_documents", _m046_pdf_templates_all_documents),
+    (47, "sales_order_status_left_to_do", _m047_sales_order_status_left_to_do),
+    (48, "item_valuation_moving_average", _m048_item_valuation_moving_average),
+    (49, "pricing_rule_currency", _m049_pricing_rule_currency),
 ]
 
 

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/selling/sales_order.py

@@ -96,17 +96,16 @@ class SalesOrder(Document):
         elif self.docstatus == 2:
             self._data["status"] = "Cancelled"
         elif self.docstatus == 1:
-            per_delivered = flt(self.per_delivered)
-            per_billed = flt(self.per_billed)
-
-            if per_delivered >= 100 and per_billed >= 100:
-                self._data["status"] = "Completed"
-            elif per_delivered > 0 and per_delivered < 100:
-                self._data["status"] = "To Deliver"
-            elif per_billed > 0 and per_billed < 100:
-                self._data["status"] = "To Bill"
-            else:
-                self._data["status"] = "To Deliver and Bill"
+            to_deliver = flt(self.per_delivered) < 100
+            to_bill = flt(self.per_billed) < 100
+            # What is still left to do (fully delivered but not billed is "To
+            # Bill", not "To Deliver and Bill").
+            self._data["status"] = (
+                "To Deliver and Bill" if to_deliver and to_bill
+                else "To Deliver" if to_deliver
+                else "To Bill" if to_bill
+                else "Completed"
+            )
 
     def _update_reserved_qty(self, direction=1):
         from lambda_erp.workflow import refresh_order_progress

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/stock/delivery_note.py

@@ -17,6 +17,7 @@ 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
 from lambda_erp.stock.stock_ledger import (
+    make_cancel_sl_entries,
     make_sl_entries,
     build_sell_side_sles,
     build_cost_basis_gl,
@@ -116,7 +117,7 @@ class DeliveryNote(Document):
     def on_cancel(self):
         reversed_sles = reverse_stock_sles(self._get_sl_entries())
         if reversed_sles:
-            make_sl_entries(reversed_sles, allow_negative_stock=True)
+            make_cancel_sl_entries(reversed_sles)
 
         make_reverse_gl_entries(
             voucher_type=self.DOCTYPE,

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/stock/purchase_receipt.py

@@ -16,7 +16,7 @@ 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
-from lambda_erp.stock.stock_ledger import make_sl_entries, reverse_stock_sles
+from lambda_erp.stock.stock_ledger import make_cancel_sl_entries, make_sl_entries, reverse_stock_sles, stock_account_for
 from lambda_erp.accounting.general_ledger import make_gl_entries, make_reverse_gl_entries, to_base_currency
 
 class PurchaseReceipt(Document):
@@ -116,7 +116,7 @@ class PurchaseReceipt(Document):
         # rolls back. Cheap check first, expensive work after.
         self._check_no_linked_purchase_invoice()
 
-        make_sl_entries(reverse_stock_sles(self._get_sl_entries()), allow_negative_stock=True)
+        make_cancel_sl_entries(reverse_stock_sles(self._get_sl_entries()))
 
         make_reverse_gl_entries(
             voucher_type=self.DOCTYPE,
@@ -188,28 +188,34 @@ class PurchaseReceipt(Document):
         db = get_db()
         gl_entries = []
 
-        stock_account = db.get_value("Company", self.company, "stock_in_hand_account")
         srbnb_account = db.get_value("Company", self.company, "stock_received_but_not_billed")
 
-        if not stock_account or not srbnb_account:
+        if not stock_account_for(self.company) or not srbnb_account:
             return []
 
         total = sum(flt(item.get("amount", 0)) for item in self.get("items"))
         if not total:
             return []
 
-        # Dr: Stock In Hand
-        gl_entries.append(_dict(
-            account=stock_account,
-            debit=flt(total, 2),
-            debit_in_account_currency=flt(total, 2),
-            credit=0,
-            credit_in_account_currency=0,
-            voucher_type=self.DOCTYPE,
-            voucher_no=self.name,
-            posting_date=self.posting_date,
-            company=self.company,
-        ))
+        # Dr: each warehouse's stock account
+        by_account = {}
+        for item in self.get("items"):
+            account = stock_account_for(self.company, item.get("warehouse"))
+            by_account[account] = by_account.get(account, 0) + flt(item.get("amount", 0))
+        for account, amount in by_account.items():
+            if not flt(amount, 2):
+                continue
+            gl_entries.append(_dict(
+                account=account,
+                debit=flt(amount, 2),
+                debit_in_account_currency=flt(amount, 2),
+                credit=0,
+                credit_in_account_currency=0,
+                voucher_type=self.DOCTYPE,
+                voucher_no=self.name,
+                posting_date=self.posting_date,
+                company=self.company,
+            ))
 
         # Cr: Stock Received But Not Billed
         gl_entries.append(_dict(

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/stock/stock_entry.py

@@ -13,7 +13,7 @@ GL entries for perpetual inventory.
 from lambda_erp.model import Document
 from lambda_erp.utils import _dict, flt, nowdate
 from lambda_erp.database import get_db
-from lambda_erp.stock.stock_ledger import make_sl_entries, reverse_stock_sles
+from lambda_erp.stock.stock_ledger import make_cancel_sl_entries, make_sl_entries, reverse_stock_sles, stock_account_for
 from lambda_erp.accounting.general_ledger import make_gl_entries, make_reverse_gl_entries
 from lambda_erp.exceptions import ValidationError
 import math
@@ -192,7 +192,7 @@ class StockEntry(Document):
         for row in reversals:
             row['incoming_rate_is_explicit'] = True
             row['outgoing_rate_is_explicit'] = True
-        make_sl_entries(reversals, allow_negative_stock=True)
+        make_cancel_sl_entries(reversals)
         make_reverse_gl_entries(voucher_type=self.DOCTYPE, voucher_no=self.name)
 
     def _get_gl_entries(self):
@@ -205,13 +205,9 @@ class StockEntry(Document):
             value = flt(row.value, 2)
             if not value:
                 continue
-            account = db.get_value('Warehouse', row.warehouse, 'account') or db.get_value(
-                'Account', {'company': self.company, 'account_type': 'Stock', 'is_group': 0}, 'name')
+            account = stock_account_for(self.company, row.warehouse)
             if not account:
                 raise ValidationError('Stock account is required before posting a valued stock movement')
-            info = db.get_value('Account', account, ['company', 'is_group', 'account_type'])
-            if not info or info.company != self.company or info.is_group or info.account_type != 'Stock':
-                raise ValidationError('Warehouse stock account must be a Stock account belonging to Company')
             amounts[account] = amounts.get(account, 0) + value
         if self.stock_entry_type != 'Material Transfer':
             total = sum(amounts.values())

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/lambda_erp/stock/stock_ledger.py

@@ -83,6 +83,27 @@ def make_sl_entries(sl_entries, allow_negative_stock=False):
     if not db._in_transaction:
         db.commit()
 
+def make_cancel_sl_entries(sl_entries):
+    """Post the reversal of a voucher's stock entries on cancel.
+
+    Unlike before 1.4.2 (every cancel passed allow_negative_stock=True), a
+    reversal may not take stock below zero: cancelling a receipt whose goods
+    have since been delivered or issued is refused, the caller's transaction
+    rolls back, and nothing is half-reversed. Reversals that put stock back
+    (cancelling a delivery or an issue) are never affected.
+    """
+    try:
+        make_sl_entries(sl_entries, allow_negative_stock=False)
+    except NegativeStockError as exc:
+        first = sl_entries[0] if sl_entries else {}
+        voucher = f"{first.get('voucher_type') or 'this document'} {first.get('voucher_no') or ''}".strip()
+        raise NegativeStockError(
+            f"Cannot cancel {voucher}: its goods have already left the warehouse "
+            f"(they were delivered, issued or moved since). Cancel or return those "
+            f"documents first. {exc}"
+        ) from exc
+
+
 def update_stock_values(sle, allow_negative_stock=False):
     """Calculate qty_after_transaction, valuation_rate, stock_value.
 
@@ -270,63 +291,74 @@ def build_buy_side_sles(doc, items):
         ))
     return sl_entries
 
+def stock_account_for(company, warehouse=None):
+    """The Stock account a warehouse's stock value is booked on.
+
+    The warehouse's own `account` if set, else the company's
+    `stock_in_hand_account`, else the company's first leaf account of type
+    Stock. Every stock-moving document resolves it here: before 1.4.2 Stock
+    Entry used the warehouse account (falling back to *any* Stock account)
+    while receipts, invoices and deliveries always used the company's
+    stock_in_hand_account, so the GL drifted from the warehouses' stock value
+    as soon as a warehouse had its own account (or a chart had several Stock
+    accounts).
+    """
+    from lambda_erp.exceptions import ValidationError
+
+    db = get_db()
+    account = db.get_value("Warehouse", warehouse, "account") if warehouse else None
+    if account:
+        info = db.get_value("Account", account, ["company", "is_group", "account_type"])
+        if not info or info.company != company or info.is_group or info.account_type != "Stock":
+            raise ValidationError(
+                f"Warehouse {warehouse}: its account {account} must be a Stock account belonging to {company}")
+        return account
+    return db.get_value("Company", company, "stock_in_hand_account") or db.get_value(
+        "Account", {"company": company, "account_type": "Stock", "is_group": 0}, "name")
+
+
 def build_cost_basis_gl(doc, *, remarks=None):
     """Dr COGS / Cr Stock In Hand at cost for a sell-side doc.
 
     Reads stock_value_difference from the SLEs already posted for this
     voucher, so call this AFTER make_sl_entries. Sign handles returns:
     stock_value_difference is negative for outgoing (Dr COGS/Cr SIH) and
-    positive for returns (Cr COGS/Dr SIH).
+    positive for returns (Cr COGS/Dr SIH). The stock side is booked per
+    warehouse on its stock account (stock_account_for).
     """
     db = get_db()
 
     default_expense = db.get_value("Company", doc.company, "default_expense_account")
-    stock_account = db.get_value("Company", doc.company, "stock_in_hand_account")
-    if not default_expense or not stock_account:
+    if not default_expense or not stock_account_for(doc.company):
         return []
 
-    cost_rows = db.sql(
-        'SELECT COALESCE(SUM(stock_value_difference), 0) as diff '
+    rows = db.sql(
+        'SELECT warehouse, COALESCE(SUM(stock_value_difference), 0) as diff '
         'FROM "Stock Ledger Entry" '
-        'WHERE voucher_type = ? AND voucher_no = ? AND is_cancelled = 0',
+        'WHERE voucher_type = ? AND voucher_no = ? AND is_cancelled = 0 GROUP BY warehouse',
         [doc.DOCTYPE, doc.name],
     )
-    cost_diff = flt(cost_rows[0]["diff"]) if cost_rows else 0
+    by_account = {}
+    for row in rows:
+        diff = flt(row["diff"])
+        if diff:
+            account = stock_account_for(doc.company, row["warehouse"])
+            by_account[account] = by_account.get(account, 0) + diff
+    cost_diff = sum(by_account.values())
     if not cost_diff:
         return []
 
-    cogs_debit = -cost_diff
-    sih_credit = -cost_diff
     cost_center = db.get_value("Company", doc.company, "default_cost_center")
     remark = remarks or f"{doc.DOCTYPE} {doc.name}"
-
-    return [
-        _dict(
-            account=default_expense,
-            debit=flt(cogs_debit, 2),
-            debit_in_account_currency=flt(cogs_debit, 2),
-            credit=0,
-            credit_in_account_currency=0,
-            cost_center=cost_center,
-            voucher_type=doc.DOCTYPE,
-            voucher_no=doc.name,
-            posting_date=doc.posting_date,
-            company=doc.company,
-            remarks=remark,
-        ),
-        _dict(
-            account=stock_account,
-            debit=0,
-            debit_in_account_currency=0,
-            credit=flt(sih_credit, 2),
-            credit_in_account_currency=flt(sih_credit, 2),
-            voucher_type=doc.DOCTYPE,
-            voucher_no=doc.name,
-            posting_date=doc.posting_date,
-            company=doc.company,
-            remarks=remark,
-        ),
-    ]
+    common = dict(voucher_type=doc.DOCTYPE, voucher_no=doc.name, posting_date=doc.posting_date,
+                  company=doc.company, remarks=remark)
+
+    gl = [_dict(account=default_expense, debit=flt(-cost_diff, 2), debit_in_account_currency=flt(-cost_diff, 2),
+                credit=0, credit_in_account_currency=0, cost_center=cost_center, **common)]
+    for account, diff in by_account.items():
+        gl.append(_dict(account=account, debit=0, debit_in_account_currency=0,
+                        credit=flt(-diff, 2), credit_in_account_currency=flt(-diff, 2), **common))
+    return gl
 
 def reverse_stock_sles(sl_entries):
     """Flip actual_qty and swap incoming/outgoing rates for cancel-time

{lambda_erp-1.4.1 → lambda_erp-1.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "1.4.1"
+version = "1.4.3"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "Apache-2.0"