lambda-erp 1.4.0__tar.gz → 1.4.2__tar.gz

{lambda_erp-1.4.0 → lambda_erp-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 1.4.0
+Version: 1.4.2
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0
@@ -164,6 +164,7 @@ The result is booked in one step — chart of accounts, sensible default account
 - Custom analytics drafts via chat (persisted, shareable, editable)
 - Server-side aggregation tool for in-chat factual answers across large datasets
 - PDF / image attachment → add invoices, create quotations, etc. all directly by adding them in the chat
+- **PDF output with your own layouts** — every offer, order, invoice, purchase order, delivery note, proposal and reservation prints as a PDF. Layouts are HTML/CSS templates with your own images and fonts, edited in the settings or simply by asking the chat ("make the offer layout look like our letterhead"), previewed against real documents, then published as versions; submitted documents keep the exact layout they were issued with. See [`docs/pdf-output.md`](docs/pdf-output.md).
 - **Programmatic API** — drive the ERP from external systems with per-user, role-capped Bearer keys: a [chat API](docs/chat-api.md) (converse with the agent) and a [REST API](docs/rest-api.md) (documents, masters, reports — the same endpoints the web app uses, so a connector or sync job can create and submit documents directly). Both off by default; an admin enables each independently and issues keys.
 - **MCP server** — the ERP speaks the [Model Context Protocol](https://modelcontextprotocol.io) at `POST /api/mcp`, so **any MCP-capable agent (Claude, Codex, an IDE assistant) can drive it directly** — list/create/update/submit documents, manage master data, run reports — as *structured, validated tool calls*, not brittle screen-scraping or hand-written HTTP glue. The tool list is built from the live registries, so a plugin's own doctypes (e.g. a CRM's leads/contacts) are exposed automatically. It reuses the *same* Bearer keys and roles as the REST API — a viewer key is read-only, a manager key can write — so access is scoped, auditable, and off by default. In practice: point your assistant at your instance and ask "which invoices are overdue?" or "create a quotation for Acme with 3× SVC-SPARK" and it operates on real data, from wherever you already work. The API-keys settings page hands you ready-to-paste Claude and Codex config the moment you create a key.
 - Auth with admin/manager/viewer roles plus a public demo mode
@@ -178,7 +179,6 @@ The result is booked in one step — chart of accounts, sensible default account
 - Manufacturing (BOM, work orders)
 - HR / Payroll beyond the journal-entry workaround
 - Regional compliance packs (GST, VAT returns, etc.) - see below
-- PDF report creation directly inside the chat
 
 ---
 

{lambda_erp-1.4.0 → lambda_erp-1.4.2}/README.md

@@ -134,6 +134,7 @@ The result is booked in one step — chart of accounts, sensible default account
 - Custom analytics drafts via chat (persisted, shareable, editable)
 - Server-side aggregation tool for in-chat factual answers across large datasets
 - PDF / image attachment → add invoices, create quotations, etc. all directly by adding them in the chat
+- **PDF output with your own layouts** — every offer, order, invoice, purchase order, delivery note, proposal and reservation prints as a PDF. Layouts are HTML/CSS templates with your own images and fonts, edited in the settings or simply by asking the chat ("make the offer layout look like our letterhead"), previewed against real documents, then published as versions; submitted documents keep the exact layout they were issued with. See [`docs/pdf-output.md`](docs/pdf-output.md).
 - **Programmatic API** — drive the ERP from external systems with per-user, role-capped Bearer keys: a [chat API](docs/chat-api.md) (converse with the agent) and a [REST API](docs/rest-api.md) (documents, masters, reports — the same endpoints the web app uses, so a connector or sync job can create and submit documents directly). Both off by default; an admin enables each independently and issues keys.
 - **MCP server** — the ERP speaks the [Model Context Protocol](https://modelcontextprotocol.io) at `POST /api/mcp`, so **any MCP-capable agent (Claude, Codex, an IDE assistant) can drive it directly** — list/create/update/submit documents, manage master data, run reports — as *structured, validated tool calls*, not brittle screen-scraping or hand-written HTTP glue. The tool list is built from the live registries, so a plugin's own doctypes (e.g. a CRM's leads/contacts) are exposed automatically. It reuses the *same* Bearer keys and roles as the REST API — a viewer key is read-only, a manager key can write — so access is scoped, auditable, and off by default. In practice: point your assistant at your instance and ask "which invoices are overdue?" or "create a quotation for Acme with 3× SVC-SPARK" and it operates on real data, from wherever you already work. The API-keys settings page hands you ready-to-paste Claude and Codex config the moment you create a key.
 - Auth with admin/manager/viewer roles plus a public demo mode
@@ -148,7 +149,6 @@ The result is booked in one step — chart of accounts, sensible default account
 - Manufacturing (BOM, work orders)
 - HR / Payroll beyond the journal-entry workaround
 - Regional compliance packs (GST, VAT returns, etc.) - see below
-- PDF report creation directly inside the chat
 
 ---
 

{lambda_erp-1.4.0 → lambda_erp-1.4.2}/api/attachments.py

@@ -9,6 +9,7 @@ import time
 import uuid
 from typing import Optional
 
+import httpx
 import openpyxl
 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
 from fastapi.responses import Response
@@ -17,6 +18,7 @@ from openai import OpenAI
 from lambda_erp.database import get_db
 from lambda_erp.utils import now
 from api.auth import require_role, get_current_user
+from api.llm_provider import client_kwargs
 from api.demo_limits import demo_max_attachment_bytes, is_demo_role
 
 logger = logging.getLogger(__name__)
@@ -105,7 +107,6 @@ _OPENAI_FILE_TTL_SECONDS = 30 * 24 * 3600      # 30 days
 _OPENAI_FILE_REUSE_MARGIN = 300               # re-upload if within 5 min of expiry
 SPREADSHEET_ROW_WARN_LIMIT = 1000             # OpenAI augments ~1000 rows/sheet
 
-_openai_singleton: Optional[OpenAI] = None
 _expires_after_supported = True               # flips off if the API rejects it once
 
 # The single Office spreadsheet mime we can cheaply row-count (openpyxl).
@@ -113,12 +114,9 @@ _XLSX_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 
 
 def _openai_client() -> OpenAI:
-    """Lazily build a module-level OpenAI client for Files uploads (a separate
-    call from the chat completion; same OPENAI_API_KEY)."""
-    global _openai_singleton
-    if _openai_singleton is None:
-        _openai_singleton = OpenAI(api_key=os.environ.get("OPENAI_API_KEY", ""))
-    return _openai_singleton
+    """An OpenAI client for Files uploads (a separate call from the chat
+    turn; same provider and key, see api/llm_provider.py)."""
+    return OpenAI(**client_kwargs(httpx.Timeout(60.0, connect=10.0)))
 
 
 def _create_openai_file(att: dict):

{lambda_erp-1.4.0 → lambda_erp-1.4.2}/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.0 → lambda_erp-1.4.2}/api/chat.py

@@ -39,6 +39,7 @@ from api.demo_limits import (
     is_demo_role,
     limiter as demo_limiter,
 )
+from api.llm_provider import client_kwargs, llm_configured, not_configured_message
 from api.providers import cost_of_openai_call, cost_of_transcription
 from api.routers.masters import create_master_record, update_master_record, delete_master_record
 from api.routers.analytics import DATASET_FILTER_DESCRIPTION
@@ -3034,7 +3035,7 @@ Users can attach PDFs and images (receipts, bills, contracts, screenshots) to th
 # GPT-6.1 Sol acts as the planner/orchestrator. When it decides a report needs
 # a custom analytics view it calls the create/update custom analytics tools.
 # Those handlers make a separate, narrowly prompted GPT-6.1 Sol call for the bounded
-# declarative report spec. Both roles use the existing OPENAI_API_KEY.
+# declarative report spec. Both roles use the same provider and key (api/llm_provider.py).
 # ---------------------------------------------------------------------------
 
 
@@ -3246,9 +3247,8 @@ def _generate_report_spec_via_openai(
     user_role: str | None = None,
     session_id: str | None = None,
 ) -> dict:
-    api_key = os.environ.get("OPENAI_API_KEY", "")
-    if not api_key or api_key == "sk-your-key-here":
-        raise RuntimeError("OPENAI_API_KEY is not configured")
+    if not llm_configured():
+        raise RuntimeError(not_configured_message())
 
     model = _report_specialist_model()
 
@@ -3278,10 +3278,7 @@ def _generate_report_spec_via_openai(
     )
     user_msg = "\n\n".join(user_parts)
 
-    client = OpenAI(
-        api_key=api_key,
-        timeout=httpx.Timeout(120.0, connect=10.0),
-    )
+    client = OpenAI(**client_kwargs(httpx.Timeout(120.0, connect=10.0)))
     validation_feedback: str | None = None
     max_attempts = 2
 
@@ -3402,16 +3399,12 @@ async def generate_title(
     title shows up while the reply is still being written. Without a text
     message (attachments only) it runs after the first reply and uses that too.
     """
-    api_key = os.environ.get("OPENAI_API_KEY", "")
-    if not api_key or api_key == "sk-your-key-here":
+    if not llm_configured():
         return
 
     title_model = _title_model()
     try:
-        client = OpenAI(
-            api_key=api_key,
-            timeout=httpx.Timeout(30.0, connect=5.0),
-        )
+        client = OpenAI(**client_kwargs(httpx.Timeout(30.0, connect=5.0)))
         reservation_id = None
         if is_demo_role(user_role):
             _blocked, reservation_id = demo_limiter.reserve(
@@ -3708,15 +3701,14 @@ async def run_thinking_loop(
     declarative-spec step to a separate narrowly prompted GPT-6.1 Sol call. We emit an
     `llm_provider` event around that delegation so the UI can surface it.
     """
-    openai_api_key = os.environ.get("OPENAI_API_KEY", "")
-    if not openai_api_key or openai_api_key == "sk-your-key-here":
-        await on_event({"type": "error", "content": "Error: OPENAI_API_KEY is not configured. Please set it in the .env file."})
+    if not llm_configured():
+        await on_event({"type": "error", "content": f"Error: {not_configured_message()}. Set it in the environment (.env)."})
         return
 
-    openai_client = OpenAI(
-        api_key=openai_api_key,
-        timeout=httpx.Timeout(120.0, connect=10.0),
-    )
+    openai_client = OpenAI(**client_kwargs(
+        httpx.Timeout(120.0, connect=10.0),
+        erp_user=user_info.get("name") if user_info else None,
+    ))
 
     # Closures below read through this reference so a live role/key refresh
     # immediately affects resource-aware handlers as well as the shared policy.
@@ -4079,14 +4071,14 @@ VOICE_TRANSCRIBE_PROMPT = (
 _MIN_TRANSCRIBE_BYTES = 1500  # ~1s of webm/opus at the ~1.5 KB/s we assume below
 
 
-def transcribe_audio(audio_bytes: bytes, audio_format: str, api_key: str) -> str:
+def transcribe_audio(audio_bytes: bytes, audio_format: str, erp_user: str | None = None) -> str:
     """Transcribe audio to text via OpenAI gpt-4o-transcribe.
 
     Returns the transcript, or "" when the model detects silence/near-silence
     (empty result or a prompt-echo hallucination on a near-silent clip).
     Raises on an actual API error so the caller can surface it.
     """
-    client = OpenAI(api_key=api_key, timeout=httpx.Timeout(60.0, connect=10.0))
+    client = OpenAI(**client_kwargs(httpx.Timeout(60.0, connect=10.0), erp_user=erp_user))
 
     audio_file = io.BytesIO(audio_bytes)
     audio_file.name = f"voice.{audio_format or 'webm'}"
@@ -4583,11 +4575,10 @@ async def chat_websocket(
                 # Voice → text: transcribe a recorded clip and return the text
                 # for the composer. No LLM turn here — the user reviews/edits
                 # the text and sends it like any typed message.
-                openai_api_key = os.environ.get("OPENAI_API_KEY", "")
-                if not openai_api_key or openai_api_key == "sk-your-key-here":
+                if not llm_configured():
                     await send_event(
                         "transcription_result", request_id=request_id,
-                        success=False, error="Speech-to-text is not available (OPENAI_API_KEY not configured).",
+                        success=False, error=f"Speech-to-text is not available ({not_configured_message()}).",
                     )
                     continue
 
@@ -4620,7 +4611,7 @@ async def chat_websocket(
 
                 try:
                     text = await asyncio.to_thread(
-                        transcribe_audio, audio_bytes, audio_format, openai_api_key,
+                        transcribe_audio, audio_bytes, audio_format, ws_user_id,
                     )
                 except Exception as e:
                     logger.warning("Transcription failed: %s", e)

lambda_erp-1.4.2/api/llm_provider.py

@@ -0,0 +1,97 @@
+"""Where the ERP's model calls go.
+
+    LAMBDA_ERP_LLM_PROVIDER=openai   (default) OpenAI directly with OPENAI_API_KEY.
+                                     OPENAI_BASE_URL is honoured by the SDK as
+                                     before, for any OpenAI-compatible endpoint.
+    LAMBDA_ERP_LLM_PROVIDER=lambda   Lambda's model gateway (lambda.dev): the
+                                     same OpenAI API, billed to the Lambda
+                                     organization the key belongs to.
+                                       LAMBDA_LLM_API_KEY   a Lambda model key
+                                                            (scope llm:erp)
+                                       LAMBDA_LLM_BASE_URL  default
+                                                            https://platform.lambda.dev/v1/llm/openai
+
+The gateway relays what the ERP uses: Responses (chat, report specialist,
+titles), file uploads for attachments and voice transcription. Chat
+Completions (ERP_CHAT_API=chat) is not available through it. With the lambda
+provider each call names the ERP user (``X-Lambda-ERP-User``, the login name),
+so Lambda's usage view can split the organization's cost by person; OpenAI
+never sees that header.
+
+Every OpenAI client in the ERP is built from ``client_kwargs()``.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+import httpx
+from openai import OpenAI
+
+DEFAULT_LAMBDA_BASE_URL = "https://platform.lambda.dev/v1/llm/openai"
+ERP_USER_HEADER = "X-Lambda-ERP-User"
+_PLACEHOLDERS = {"", "sk-your-key-here"}
+
+
+@dataclass(frozen=True)
+class LLMSettings:
+    provider: str            # "openai" or "lambda"
+    api_key: str
+    base_url: Optional[str]  # None: the SDK's default (or OPENAI_BASE_URL)
+    key_variable: str        # the env variable the key comes from, for messages
+
+    @property
+    def configured(self) -> bool:
+        return self.api_key.strip() not in _PLACEHOLDERS
+
+
+def llm_settings() -> LLMSettings:
+    """Read on every call, so a changed environment applies without a restart."""
+    provider = (os.environ.get("LAMBDA_ERP_LLM_PROVIDER") or "openai").strip().lower()
+    if provider == "lambda":
+        return LLMSettings(
+            provider="lambda",
+            api_key=os.environ.get("LAMBDA_LLM_API_KEY", ""),
+            base_url=(os.environ.get("LAMBDA_LLM_BASE_URL") or DEFAULT_LAMBDA_BASE_URL).rstrip("/"),
+            key_variable="LAMBDA_LLM_API_KEY",
+        )
+    if provider != "openai":
+        raise RuntimeError(f"LAMBDA_ERP_LLM_PROVIDER={provider!r}: use 'openai' or 'lambda'")
+    return LLMSettings(provider="openai", api_key=os.environ.get("OPENAI_API_KEY", ""),
+                       base_url=None, key_variable="OPENAI_API_KEY")
+
+
+def llm_configured() -> bool:
+    try:
+        return llm_settings().configured
+    except RuntimeError:
+        return False
+
+
+def not_configured_message() -> str:
+    try:
+        settings = llm_settings()
+    except RuntimeError as exc:
+        return str(exc)
+    return f"{settings.key_variable} is not configured"
+
+
+def client_kwargs(timeout: httpx.Timeout, erp_user: Optional[str] = None) -> dict:
+    """Keyword arguments for ``OpenAI(...)`` with the configured provider."""
+    settings = llm_settings()
+    headers = {}
+    if settings.provider == "lambda" and erp_user:
+        headers[ERP_USER_HEADER] = str(erp_user)[:100]
+    kwargs = {"api_key": settings.api_key, "timeout": timeout}
+    if settings.base_url:
+        kwargs["base_url"] = settings.base_url
+    if headers:
+        kwargs["default_headers"] = headers
+    return kwargs
+
+
+def openai_client(timeout: httpx.Timeout, erp_user: Optional[str] = None) -> OpenAI:
+    """An OpenAI client for the configured provider."""
+    return OpenAI(**client_kwargs(timeout, erp_user))

{lambda_erp-1.4.0 → lambda_erp-1.4.2}/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.0 → lambda_erp-1.4.2}/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.0 → lambda_erp-1.4.2}/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.0 → lambda_erp-1.4.2}/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.0 → lambda_erp-1.4.2}/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.0 → lambda_erp-1.4.2}/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