lambda-erp 0.1.28__tar.gz → 0.1.30__tar.gz

{lambda_erp-0.1.28 → lambda_erp-0.1.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-erp
-Version: 0.1.28
+Version: 0.1.30
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: MIT

{lambda_erp-0.1.28 → lambda_erp-0.1.30}/api/chat.py

@@ -1708,11 +1708,19 @@ Shape — note it does NOT use `items`:
 
 To build one: ensure each offer already exists as its own Quotation (create them first if needed), then call create_document with doctype "proposal" and a data object whose `quotations` array references those quotations by name. Do NOT submit it; link the user to the PDF at `/api/documents/proposal/<name>/pdf` (and the editor at `/app/proposal/<name>`).
 
+### Recurring offer lines (quotation line `frequency`)
+A **Quotation** line item carries an optional `frequency` that controls how it is billed and totalled on the offer:
+- `One-time` (the default) — a normal one-off line.
+- `Monthly` / `Quarterly` / `Half-Yearly` / `Yearly` — a recurring line.
+When a quote mixes one-time and recurring lines, the one-time lines form the headline grand total (the "Gesamttotal"), and each recurring cadence is totalled **separately** (its own net + MWSt) so a monthly fee never inflates the one-time total. To put a recurring service ON the offer as a real line, set that line's `frequency` alongside its item_code / qty / rate — e.g. a CHF 380 line with `frequency` set to `Monthly`. These values match the Subscription billing intervals exactly; the Quotation itself still posts nothing to the ledger.
+
+Use the line `frequency` for a recurring item that is genuinely part of the quote. For recurring info you only want to SHOW but that is NOT part of the quotation (a "billed separately after implementation" aside), use the `>> … | …` notes markup below instead — that is cosmetic free text, not a line item, and never enters any total.
+
 ### Notes / Terms markup (the `remarks` field)
 The `remarks` (Notes / Terms) field on quotations, sales orders, and invoices renders on the PDF with a small markup vocabulary, so when a user dictates offer notes, conditions, recurring services, or a sign-off you can compose a polished closing block instead of a flat paragraph. Put this ONLY in `remarks` (never in item descriptions):
 - `# Heading` at the start of a line -> bold heading
 - `*italic*` or `_italic_` -> italic; `**bold**` -> bold
-- `>> Period | Amount` at the start of a line -> a right-aligned price line that sits beside the heading/description above it; use it for separately- or recurring-billed items, e.g. `>> Monatlich | CHF 380.—`
+- A line starting with `>>` is a price line, split by the FIRST `|` pipe: the text BEFORE the pipe goes in the left (frequency) column, the text AFTER it in the right (amount) column — both placed literally as you write them, NOT interpreted (it does not know "Monatlich" is a frequency or that "CHF 380" is a number). Omit the pipe to put everything in the amount column. The two columns line up with the line-items table's frequency/amount columns, so use it for a separately- or recurring-billed item, e.g. `>> Monatlich | CHF 380.—`.
 - Separate blocks with a blank line; a single newline is just a line break.
 Plain text (no special characters) still renders fine, so only reach for the markup when it improves a customer-facing note.
 

{lambda_erp-0.1.28 → lambda_erp-0.1.30}/api/pdf.py

@@ -7,6 +7,7 @@ from weasyprint import HTML
 from lambda_erp.database import get_db
 from api.services import load_document
 from api.remarks_md import render_remarks
+from lambda_erp.controllers.taxes_and_totals import split_by_frequency
 
 TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates")
 
@@ -182,6 +183,15 @@ def generate_pdf(doctype_slug: str, name: str) -> bytes:
     page_size_row = db.sql('SELECT value FROM "Settings" WHERE key = \'pdf_page_size\'')
     page_size = page_size_row[0]["value"] if page_size_row else "A4"
 
+    # Billing-frequency split: recurring line groups for the per-period blocks,
+    # and whether to show the frequency column at all (any recurring line, or a
+    # `>>` price line in the notes — which renders in that same column).
+    _one_time, recurring_summary = split_by_frequency(doc)
+    _remarks = doc.get("remarks") or ""
+    show_frequency = bool(recurring_summary) or any(
+        line.lstrip().startswith(">>") for line in _remarks.splitlines()
+    )
+
     # Render
     template = _jinja_env.get_template("document.html")
     # base_url = the resolved template's own directory, so a template (e.g. a
@@ -207,6 +217,13 @@ def generate_pdf(doctype_slug: str, name: str) -> bytes:
         # emitted classes. Falls back to plain `doc.remarks` if a template
         # doesn't use it. See api/remarks_md.py.
         remarks_html=render_remarks(doc.get("remarks")),
+        # Billing-frequency split (offers with recurring lines). `recurring_summary`
+        # is the per-period totals (one entry per Monatlich/Quartalsweise/… group);
+        # the doc's own net_total/grand_total already reflect the one-time part only.
+        # `show_frequency` tells a template to render the (untitled) frequency column,
+        # true when any line is recurring OR the notes carry a `>>` price line.
+        recurring_summary=recurring_summary,
+        show_frequency=show_frequency,
     )
 
     # Let deployment plugins augment the context (e.g. a Swiss QR-bill image for

{lambda_erp-0.1.28 → lambda_erp-0.1.30}/lambda_erp/controllers/taxes_and_totals.py

@@ -367,3 +367,76 @@ class TaxCalculator:
 def calculate_taxes_and_totals(doc):
     """Convenience function matching the reference implementation's pattern."""
     TaxCalculator(doc).calculate()
+
+
+# --- Billing frequency split (offers with recurring lines) -----------------
+#
+# A line item may carry a `frequency`: one-time ("Einmalig") or a recurring
+# cadence. On an offer the one-time and recurring lines are totalled
+# separately — a recurring line must not inflate the one-time grand total —
+# and each recurring period shows its own net / tax / grand. These helpers run
+# the SAME tax engine on each frequency group independently so every period
+# carries correct taxes; nothing here changes the shared calculation above.
+
+ONE_TIME_FREQUENCY = "One-time"
+# Recurring cadences in display order. These match the Subscription doctype's
+# billing_interval values exactly, so a recurring offer line maps 1:1 onto a
+# Subscription later. (Templates localize these labels for display.)
+RECURRING_FREQUENCY_ORDER = ["Monthly", "Quarterly", "Half-Yearly", "Yearly"]
+
+
+def _item_frequency(item):
+    return (item.get("frequency") or ONE_TIME_FREQUENCY)
+
+
+def has_recurring_items(doc):
+    """True if any line item carries a recurring (non-Einmalig) frequency."""
+    return any(_item_frequency(it) != ONE_TIME_FREQUENCY for it in (doc.get("items") or []))
+
+
+def split_by_frequency(doc):
+    """Group a doc's items by `frequency` and total each group independently.
+
+    Returns `(one_time, recurring)` where `one_time` is a totals dict for the
+    Einmalig group and `recurring` is an ordered list of
+    `{frequency, net_total, total_taxes_and_charges, grand_total}` — one per
+    recurring period present. Each group is run through the standard tax engine
+    with the doc's tax rows and conversion rate, so taxes are correct per
+    period. (Document-level discounts are not distributed across groups.)
+    """
+    import copy
+
+    items = doc.get("items") or []
+    taxes = doc.get("taxes") or []
+    conversion_rate = doc.get("conversion_rate") or 1.0
+
+    groups = {}
+    for it in items:
+        groups.setdefault(_item_frequency(it), []).append(it)
+
+    def totals_for(group_items):
+        tmp = {
+            "items": copy.deepcopy(group_items),
+            "taxes": copy.deepcopy(taxes),
+            "conversion_rate": conversion_rate,
+        }
+        calculate_taxes_and_totals(tmp)
+        return {
+            "net_total": flt(tmp.get("net_total"), 2),
+            "total_taxes_and_charges": flt(tmp.get("total_taxes_and_charges"), 2),
+            "grand_total": flt(tmp.get("grand_total"), 2),
+        }
+
+    one_time = totals_for(groups.get(ONE_TIME_FREQUENCY, []))
+
+    recurring, seen = [], set()
+    for freq in RECURRING_FREQUENCY_ORDER:
+        if groups.get(freq):
+            recurring.append({"frequency": freq, **totals_for(groups[freq])})
+            seen.add(freq)
+    # Any custom/unknown recurring label, kept in insertion order after the known ones.
+    for freq, gitems in groups.items():
+        if freq != ONE_TIME_FREQUENCY and freq not in seen:
+            recurring.append({"frequency": freq, **totals_for(gitems)})
+
+    return one_time, recurring

{lambda_erp-0.1.28 → lambda_erp-0.1.30}/lambda_erp/database.py

@@ -509,6 +509,7 @@ class Database:
                 item_code TEXT,
                 item_name TEXT,
                 description TEXT,
+                frequency TEXT DEFAULT 'One-time',
                 qty REAL DEFAULT 0,
                 uom TEXT DEFAULT 'Nos',
                 rate REAL DEFAULT 0,
@@ -1849,6 +1850,14 @@ def _m017_proposal_cover_template(db: "Database") -> None:
     db._add_column_if_missing("Company", "proposal_cover_template", "TEXT")
 
 
+def _m018_quotation_item_frequency(db: "Database") -> None:
+    """Add Quotation Item.frequency — the billing cadence of an offer line
+    (One-time / Monthly / Quarterly / Half-Yearly / Yearly, matching the
+    Subscription billing intervals). One-time and recurring lines are totalled
+    separately on the offer; existing rows are NULL, treated as One-time."""
+    db._add_column_if_missing("Quotation Item", "frequency", "TEXT")
+
+
 Database.MIGRATIONS = [
     (1, "chat_message_session_id", _m001_chat_message_session_id),
     (2, "chat_session_user_id", _m002_chat_session_user_id),
@@ -1867,6 +1876,7 @@ Database.MIGRATIONS = [
     (15, "document_discarded", _m015_document_discarded),
     (16, "customer_contact_person", _m016_customer_contact_person),
     (17, "proposal_cover_template", _m017_proposal_cover_template),
+    (18, "quotation_item_frequency", _m018_quotation_item_frequency),
 ]
 
 

{lambda_erp-0.1.28 → lambda_erp-0.1.30}/lambda_erp/selling/quotation.py

@@ -68,6 +68,51 @@ class Quotation(Document):
 
         # Calculate taxes and totals (the core shared calculation)
         calculate_taxes_and_totals(self)
+        self._apply_frequency_split()
+
+    def _apply_frequency_split(self):
+        """When the offer mixes one-time and recurring lines, the headline
+        totals AND the tax rows reflect the ONE-TIME part only — recurring
+        periods are presented separately (on the PDF) and must not inflate the
+        one-time grand total. A quote with no recurring lines is left exactly as
+        the shared engine computed it."""
+        import copy
+        from lambda_erp.controllers.taxes_and_totals import (
+            has_recurring_items, calculate_taxes_and_totals,
+            ONE_TIME_FREQUENCY, _item_frequency,
+        )
+
+        if not has_recurring_items(self):
+            return
+
+        items = self.get("items") or []
+        one_time_items = [it for it in items if _item_frequency(it) == ONE_TIME_FREQUENCY]
+        taxes = self.get("taxes") or []
+
+        # Re-run the standard engine on the one-time items alone, then copy its
+        # results back so the document's totals and tax rows are self-consistent.
+        tmp = {
+            "items": copy.deepcopy(one_time_items),
+            "taxes": copy.deepcopy(taxes),
+            "conversion_rate": self.get("conversion_rate") or 1.0,
+        }
+        calculate_taxes_and_totals(tmp)
+
+        total_fields = [
+            "total", "base_total", "net_total", "base_net_total",
+            "total_taxes_and_charges", "base_total_taxes_and_charges",
+            "grand_total", "base_grand_total", "rounded_total", "rounding_adjustment",
+        ]
+        for f in total_fields:
+            self[f] = flt(tmp.get(f) or 0, 2)
+
+        # Bring each tax row down to its one-time amount so the printed MWSt line
+        # matches the one-time Gesamttotal.
+        tmp_taxes = tmp.get("taxes") or []
+        for i, tax in enumerate(taxes):
+            src = tmp_taxes[i] if i < len(tmp_taxes) else {}
+            for tf in ("tax_amount", "base_tax_amount", "total", "base_total"):
+                tax[tf] = flt(src.get(tf) or 0, 2)
 
     def _validate_valid_till(self):
         if self.valid_till and getdate(self.valid_till) < getdate(self.transaction_date):

{lambda_erp-0.1.28 → lambda_erp-0.1.30}/pyproject.toml

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