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

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

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

{lambda_erp-0.1.28 → lambda_erp-0.1.29}/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.29}/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.29}/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.29}/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.29}/pyproject.toml

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