lambda-erp 0.8.26__tar.gz → 0.8.28__tar.gz

{lambda_erp-0.8.26 → lambda_erp-0.8.28}/PKG-INFO

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

{lambda_erp-0.8.26 → lambda_erp-0.8.28}/api/chat.py

@@ -899,11 +899,17 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "reconcile_bank_transaction",
-            "description": "Reconcile one imported bank transaction after explicit user confirmation. mode=invoice_payment creates and submits a Payment Entry allocated to one or more invoices; mode=existing_voucher links an already-submitted Payment Entry or Journal Entry with an exactly matching bank leg; mode=journal creates and submits a two-sided Journal Entry against a non-bank, non-AR/AP account. This posts or links real accounting data. Never call in the same turn as the first proposal; confirmed must reflect a later explicit confirmation.",
+            "description": "Reconcile imported bank transactions after explicit user confirmation. Always pass bank_transactions: use a one-item list for an individual reconciliation and the complete list returned by an existing_voucher_group suggestion for a grouped reconciliation. mode=invoice_payment creates and submits a Payment Entry allocated to one or more invoices; mode=existing_voucher links an already-submitted Payment Entry or Journal Entry with an exactly matching bank leg, atomically for a group; mode=journal creates and submits a two-sided Journal Entry against a non-bank, non-AR/AP account. invoice_payment and journal accept exactly one bank transaction. This posts or links real accounting data. Never call in the same turn as the first proposal; confirmed must reflect a later explicit confirmation.",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "bank_transaction": {"type": "string"},
+                    "bank_transactions": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "minItems": 1,
+                        "maxItems": 100,
+                        "description": "Bank Transaction names to reconcile: exactly one for an individual match/payment/journal, or the complete exact group returned by the suggestion.",
+                    },
                     "mode": {"type": "string", "enum": ["invoice_payment", "existing_voucher", "journal"]},
                     "allocations": {
                         "type": "array",
@@ -924,7 +930,7 @@ TOOLS = [
                     "remarks": {"type": "string"},
                     "confirmed": {"type": "boolean"},
                 },
-                "required": ["bank_transaction", "mode", "confirmed"],
+                "required": ["bank_transactions", "mode", "confirmed"],
             },
         },
     },
@@ -932,7 +938,7 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "undo_bank_reconciliation",
-            "description": "Reverse an active bank reconciliation after explicit user confirmation. Vouchers created by reconciliation are cancelled and reversed; an existing linked voucher is only unlinked and remains submitted. Never call without explaining that distinction and receiving confirmation.",
+            "description": "Reverse an active bank reconciliation after explicit user confirmation. Vouchers created by reconciliation are cancelled and reversed; an existing linked voucher is only unlinked and remains submitted. If the selected transaction belongs to a group, every transaction in that group is unlinked atomically. Never call without listing the affected group, explaining that distinction, and receiving confirmation.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -2076,26 +2082,32 @@ def _handle_reconcile_bank_transaction(args, user_info: dict | None = None):
             )
         }
     from lambda_erp.accounting.bank_reconciliation import (
-        reconcile_with_existing_voucher,
+        reconcile_with_existing_voucher_group,
         reconcile_with_journal,
         reconcile_with_payment,
     )
     user = (user_info or {}).get("name")
     mode = args.get("mode")
+    bank_transactions = args.get("bank_transactions")
+    if not isinstance(bank_transactions, list) or not bank_transactions:
+        return {"error": "bank_transactions must contain at least one Bank Transaction name"}
+    if mode in {"invoice_payment", "journal"} and len(bank_transactions) != 1:
+        return {"error": f"mode={mode} requires exactly one bank transaction"}
+    bank_transaction = bank_transactions[0]
     try:
         if mode == "invoice_payment":
             return reconcile_with_payment(
-                args.get("bank_transaction"), args.get("allocations") or [],
+                bank_transaction, args.get("allocations") or [],
                 conversion_rate=args.get("conversion_rate"), user=user, confirmed=True,
             )
         if mode == "existing_voucher":
-            return reconcile_with_existing_voucher(
-                args.get("bank_transaction"), args.get("voucher_type"), args.get("voucher_no"),
+            return reconcile_with_existing_voucher_group(
+                bank_transactions, args.get("voucher_type"), args.get("voucher_no"),
                 user=user, confirmed=True,
             )
         if mode == "journal":
             return reconcile_with_journal(
-                args.get("bank_transaction"), args.get("counterparty_account"),
+                bank_transaction, args.get("counterparty_account"),
                 conversion_rate=args.get("conversion_rate"), remarks=args.get("remarks"),
                 user=user, confirmed=True,
             )
@@ -2550,15 +2562,21 @@ masked in ordinary chat responses.
 ### Bank reconciliation
 Use `list_bank_reconciliation_queue` and then `suggest_bank_reconciliation`; never guess from a raw
 description alone. Explain one exact proposal before doing anything. Reconciliation has three safe
-paths: (1) link an existing submitted Payment/Journal voucher whose bank leg matches exactly,
+paths: (1) link an existing submitted Payment/Journal voucher whose bank leg matches exactly—either
+one transaction or every transaction in an exact `existing_voucher_group`,
 (2) create and submit a Payment Entry allocated to one or more open invoices of the same party, or
 (3) create and submit a Journal Entry against a user-selected non-bank, non-AR/AP account. A created
 voucher changes the GL and may change invoice outstanding amounts. Ask for explicit confirmation in
 a later user turn, then call `reconcile_bank_transaction` with `confirmed=true`. Clearly disclose any
-unallocated on-account remainder. Never match a Bank Transaction directly to an invoice because that
+unallocated on-account remainder. Disclose all group members and their total before asking for
+confirmation. Every reconciliation call uses `bank_transactions`: pass a one-item list for an
+individual reconciliation; for a group, copy the complete list from the suggestion and never add or
+omit IDs.
+Never match a Bank Transaction directly to an invoice because that
 would omit the cash posting. For reversals, first explain whether the voucher was created by the
 reconciliation (it will be cancelled and reversed) or merely linked (it will only be unlinked), and
-then require explicit confirmation before `undo_bank_reconciliation`.
+whether the selected transaction belongs to a group that will be unlinked together, and then require
+explicit confirmation before `undo_bank_reconciliation`.
 
 ### Sales Cycle
 Quotation → Sales Order → Delivery Note (shipping) / Sales Invoice (billing) → Payment Entry

{lambda_erp-0.8.26 → lambda_erp-0.8.28}/api/routers/bank_reconciliation.py

@@ -6,6 +6,7 @@ from api.auth import require_role
 from lambda_erp.accounting.bank_reconciliation import (
     list_bank_transactions,
     reconcile_with_existing_voucher,
+    reconcile_with_existing_voucher_group,
     reconcile_with_journal,
     reconcile_with_payment,
     suggest_matches,
@@ -58,6 +59,15 @@ def post_journal(data: dict, user: dict = Depends(require_role("manager"))):
 
 @router.post("/bank-reconciliation/match-existing")
 def match_existing(data: dict, user: dict = Depends(require_role("manager"))):
+    bank_transactions = data.get("bank_transactions")
+    if bank_transactions:
+        return reconcile_with_existing_voucher_group(
+            bank_transactions,
+            data.get("voucher_type"),
+            data.get("voucher_no"),
+            user=user.get("name"),
+            confirmed=data.get("confirmed") is True,
+        )
     return reconcile_with_existing_voucher(
         data.get("bank_transaction"),
         data.get("voucher_type"),

{lambda_erp-0.8.26 → lambda_erp-0.8.28}/frontend/src/api/client.ts

@@ -172,7 +172,7 @@ export interface BankInvoiceSuggestion {
 }
 
 export interface BankVoucherSuggestion {
-  kind: "existing_voucher";
+  kind: "existing_voucher" | "existing_voucher_group";
   voucher_type: "Payment Entry" | "Journal Entry";
   voucher_no: string;
   posting_date: string;
@@ -180,6 +180,15 @@ export interface BankVoucherSuggestion {
   currency: string;
   score: number;
   reasons: string[];
+  bank_transactions: Array<{
+    name: string;
+    posting_date: string;
+    amount: number;
+    deposit: number;
+    withdrawal: number;
+    counterparty_name: string | null;
+    description: string | null;
+  }>;
 }
 
 export interface BankReconciliationSuggestions {
@@ -327,6 +336,7 @@ export const api = {
 
   reconcileBankExistingVoucher: (data: {
     bank_transaction: string;
+    bank_transactions?: string[];
     voucher_type: string;
     voucher_no: string;
     confirmed: boolean;

{lambda_erp-0.8.26 → lambda_erp-0.8.28}/lambda_erp/accounting/bank_reconciliation.py

@@ -2,9 +2,10 @@
 
 An imported Bank Transaction is evidence from the bank, not a ledger posting.
 Reconciliation either links that evidence to an existing submitted voucher or
-creates and submits the appropriate Payment Entry / Journal Entry.  The active
-link is unique and every reversal remains in ``Bank Reconciliation`` as audit
-history.
+creates and submits the appropriate Payment Entry / Journal Entry. One exact
+voucher bank leg may cover a group of imported transactions, but it can only be
+consumed by one active group. Every transaction keeps its own audit row and
+every reversal remains in ``Bank Reconciliation`` as history.
 """
 
 from __future__ import annotations
@@ -59,6 +60,10 @@ def _is_deposit(tx: dict) -> bool:
     return flt(tx.get("deposit")) > 0
 
 
+def _signed_amount(tx: dict) -> float:
+    return _amount(tx) if _is_deposit(tx) else -_amount(tx)
+
+
 def _active_reconciliation(bank_transaction: str) -> dict | None:
     rows = get_db().sql(
         'SELECT * FROM "Bank Reconciliation" '
@@ -68,6 +73,25 @@ def _active_reconciliation(bank_transaction: str) -> dict | None:
     return dict(rows[0]) if rows else None
 
 
+def _group_rows(group_id: str | None, *, status: str = "Active") -> list[dict]:
+    if not group_id:
+        return []
+    return [dict(row) for row in get_db().sql(
+        'SELECT * FROM "Bank Reconciliation" '
+        'WHERE group_id = ? AND status = ? ORDER BY group_head DESC, name',
+        [group_id, status],
+    )]
+
+
+def _public_active_reconciliation(active: dict | None) -> dict | None:
+    if not active:
+        return None
+    result = dict(active)
+    rows = _group_rows(result.get("group_id"))
+    result["bank_transactions"] = [row["bank_transaction"] for row in rows]
+    return result
+
+
 def _ensure_available(tx: dict) -> None:
     if _amount(tx) <= 0 or tx.get("status") == "Informational":
         raise ValidationError("Informational or zero-value bank transactions cannot be reconciled")
@@ -244,6 +268,93 @@ def _invoice_candidates(tx: dict, limit: int) -> list[dict]:
     return candidates[:limit]
 
 
+def _compact_group_transaction(tx: dict) -> dict:
+    return {
+        "name": tx.get("name"),
+        "posting_date": tx.get("posting_date"),
+        "amount": _amount(tx),
+        "deposit": flt(tx.get("deposit"), 2),
+        "withdrawal": flt(tx.get("withdrawal"), 2),
+        "counterparty_name": tx.get("counterparty_name"),
+        "description": tx.get("description"),
+    }
+
+
+def _same_day_group_pool(tx: dict, voucher_date: str) -> list[dict] | None:
+    rows = [dict(row) for row in get_db().sql(
+        'SELECT name, posting_date, deposit, withdrawal, counterparty_name, description '
+        'FROM "Bank Transaction" WHERE bank_account = ? AND currency = ? '
+        'AND posting_date = ? AND status = ? AND bank_statement_import IS NOT NULL '
+        'ORDER BY name LIMIT 101',
+        [tx["bank_account"], tx.get("currency"), voucher_date, "Unreconciled"],
+    )]
+    return None if len(rows) > 100 else rows
+
+
+def _same_day_transaction_group(tx: dict, target_movement: float,
+                                voucher_date: str | None,
+                                pool: list[dict] | None) -> list[dict] | None:
+    """Find a deterministic exact same-day subset that includes ``tx``.
+
+    Group suggestions intentionally stay conservative: automatic grouping is
+    limited to imported, unreconciled transactions on the exact voucher date,
+    bank account, currency, and movement direction. Explicit reconciliation
+    still validates the complete supplied group independently.
+    """
+    if not voucher_date or tx.get("posting_date") != voucher_date:
+        return None
+    if (target_movement > 0) != _is_deposit(tx):
+        return None
+    target_cents = round(abs(target_movement) * 100)
+    selected_cents = round(_amount(tx) * 100)
+    if selected_cents <= 0 or selected_cents >= target_cents:
+        return None
+
+    if pool is None:
+        return None
+    selected = next((row for row in pool if row["name"] == tx["name"]), None)
+    if not selected:
+        return None
+    companions = [
+        row for row in pool
+        if row["name"] != tx["name"]
+        and (_is_deposit(row) == _is_deposit(tx))
+        and 0 < round(_amount(row) * 100) <= target_cents - selected_cents
+    ]
+    remainder = target_cents - selected_cents
+
+    if companions and sum(round(_amount(row) * 100) for row in companions) == remainder:
+        return [selected, *companions]
+
+    # Retain up to two ways to reach each subtotal. A suggestion is emitted only
+    # when the exact subset is unique; ambiguity is left for manual review.
+    states: dict[int, list[tuple[dict, ...]]] = {0: [()]}
+    for row in companions:
+        cents = round(_amount(row) * 100)
+        additions: dict[int, list[tuple[dict, ...]]] = {}
+        for subtotal, variants in list(states.items()):
+            for members in variants:
+                if len(members) >= 19:
+                    continue
+                new_total = subtotal + cents
+                if new_total > remainder:
+                    continue
+                bucket = additions.setdefault(new_total, [])
+                candidate = (*members, row)
+                if candidate not in bucket and len(bucket) < 2:
+                    bucket.append(candidate)
+        for subtotal, variants in additions.items():
+            bucket = states.setdefault(subtotal, [])
+            for variant in variants:
+                if variant not in bucket and len(bucket) < 2:
+                    bucket.append(variant)
+        # Refuse an expensive or ambiguous search instead of guessing.
+        if len(states) > 50_000:
+            return None
+    matches = states.get(remainder, [])
+    return [selected, *matches[0]] if len(matches) == 1 else None
+
+
 def _voucher_candidates(tx: dict, limit: int) -> list[dict]:
     db = get_db()
     rows = db.sql(
@@ -256,7 +367,7 @@ def _voucher_candidates(tx: dict, limit: int) -> list[dict]:
         'AND gle.voucher_type IN (?, ?) '
         'AND NOT EXISTS (SELECT 1 FROM "Bank Reconciliation" br '
         '  WHERE br.voucher_type = gle.voucher_type AND br.voucher_no = gle.voucher_no '
-        '  AND br.status = ? AND br.bank_account = ?) '
+        '  AND br.status = ? AND br.bank_account = ? AND br.group_head = 1) '
         'GROUP BY gle.voucher_type, gle.voucher_no '
         'ORDER BY MIN(gle.posting_date) DESC LIMIT 500',
         [tx["bank_account"], "Payment Entry", "Journal Entry", "Active", tx["bank_account"]],
@@ -264,6 +375,8 @@ def _voucher_candidates(tx: dict, limit: int) -> list[dict]:
     expected = _amount(tx)
     deposit = _is_deposit(tx)
     out = []
+    same_day_pool: list[dict] | None = None
+    same_day_pool_loaded = False
     for row in rows:
         item = dict(row)
         debit_ccy = flt(item.get("debit_ccy"), 2)
@@ -271,7 +384,7 @@ def _voucher_candidates(tx: dict, limit: int) -> list[dict]:
         movement = debit_ccy - credit_ccy
         if not tx.get("currency") or tx.get("currency") == tx.get("base_currency"):
             movement = flt(item.get("debit"), 2) - flt(item.get("credit"), 2)
-        if (movement > 0) != deposit or abs(abs(movement) - expected) > 0.01:
+        if (movement > 0) != deposit:
             continue
         try:
             days = abs((date.fromisoformat(tx["posting_date"]) - date.fromisoformat(item["posting_date"])).days)
@@ -279,16 +392,34 @@ def _voucher_candidates(tx: dict, limit: int) -> list[dict]:
             days = 9999
         if days > 45:
             continue
+        exact = abs(abs(movement) - expected) <= 0.01
+        group = None
+        if not exact and item.get("posting_date") == tx.get("posting_date"):
+            if not same_day_pool_loaded:
+                same_day_pool = _same_day_group_pool(tx, item["posting_date"])
+                same_day_pool_loaded = True
+            group = _same_day_transaction_group(
+                tx, movement, item.get("posting_date"), same_day_pool,
+            )
+        if not exact and not group:
+            continue
         score = 80 + (20 if days == 0 else max(0, 15 - days))
         out.append({
-            "kind": "existing_voucher",
+            "kind": "existing_voucher" if exact else "existing_voucher_group",
             "voucher_type": item["voucher_type"],
             "voucher_no": item["voucher_no"],
             "posting_date": item["posting_date"],
-            "amount": expected,
+            "amount": abs(flt(movement, 2)),
             "currency": tx.get("currency"),
             "score": score,
-            "reasons": ["exact_bank_movement", "same_date" if days == 0 else "date_near"],
+            "reasons": [
+                "exact_bank_movement" if exact else "exact_grouped_bank_movement",
+                "same_date" if days == 0 else "date_near",
+            ],
+            "bank_transactions": [
+                _compact_group_transaction(member)
+                for member in (group or [tx])
+            ],
         })
     out.sort(key=lambda item: (-item["score"], item["voucher_no"]))
     return out[:limit]
@@ -299,19 +430,22 @@ def suggest_matches(bank_transaction: str, *, limit: int = 12) -> dict:
     active = _active_reconciliation(bank_transaction)
     return {
         "transaction": _public_transaction(tx),
-        "active_reconciliation": active,
+        "active_reconciliation": _public_active_reconciliation(active),
         "existing_vouchers": [] if active else _voucher_candidates(tx, limit),
         "invoices": [] if active else _invoice_candidates(tx, limit),
     }
 
 
 def _new_audit(tx: dict, *, mode: str, voucher_type: str, voucher_no: str,
-               user: str | None) -> str:
+               user: str | None, group_id: str | None = None,
+               group_head: bool = True) -> str:
     name = new_name("BRC")
     get_db().insert("Bank Reconciliation", {
         "name": name,
         "bank_transaction": tx["name"],
         "bank_account": tx["bank_account"],
+        "group_id": group_id or name,
+        "group_head": 1 if group_head else 0,
         "mode": mode,
         "voucher_type": voucher_type,
         "voucher_no": voucher_no,
@@ -359,12 +493,12 @@ def reverse_generated_reconciliation(reconciliation: str | None, *, voucher_type
     if reconciliation:
         row = db.get_value(
             "Bank Reconciliation", reconciliation,
-            ["name", "bank_transaction", "voucher_type", "voucher_no", "status", "reversed_by"],
+            ["name", "bank_transaction", "group_id", "voucher_type", "voucher_no", "status", "reversed_by"],
         )
-        rows = [row] if row else []
+        rows = _group_rows(row.get("group_id")) if row else []
     else:
         rows = db.sql(
-            'SELECT name, bank_transaction, voucher_type, voucher_no, status, reversed_by '
+            'SELECT name, bank_transaction, group_id, voucher_type, voucher_no, status, reversed_by '
             'FROM "Bank Reconciliation" WHERE voucher_type = ? AND voucher_no = ? '
             'AND status = ?',
             [voucher_type, voucher_no, "Active"],
@@ -580,25 +714,38 @@ def reconcile_with_journal(bank_transaction: str, counterparty_account: str, *,
     }
 
 
-def _validate_existing_voucher(tx: dict, voucher_type: str, voucher_no: str) -> None:
+def _validate_existing_voucher_group(transactions: list[dict], voucher_type: str,
+                                     voucher_no: str) -> None:
+    if not transactions:
+        raise ValidationError("At least one bank transaction is required")
     if voucher_type not in _VOUCHER_TYPES:
         raise ValidationError("Only submitted Payment Entries or Journal Entries can be matched")
     document = get_db().get_value(voucher_type, voucher_no, ["docstatus", "company"])
     if not document or flt(document.get("docstatus")) != 1:
         raise ValidationError(f"{voucher_type} {voucher_no} is unavailable or not submitted")
-    if document.get("company") != tx["company"]:
+    first = transactions[0]
+    if document.get("company") != first["company"]:
         raise ValidationError("Voucher and bank transaction belong to different companies")
+    for tx in transactions[1:]:
+        if tx.get("company") != first.get("company"):
+            raise ValidationError("All grouped bank transactions must belong to the same company")
+        if tx.get("bank_account") != first.get("bank_account"):
+            raise ValidationError("All grouped bank transactions must use the same bank account")
+        if tx.get("currency") != first.get("currency"):
+            raise ValidationError("All grouped bank transactions must use the same currency")
+        if _is_deposit(tx) != _is_deposit(first):
+            raise ValidationError("Grouped bank transactions must have the same movement direction")
     db = get_db()
     used = db.sql(
-        'SELECT bank_transaction FROM "Bank Reconciliation" '
+        'SELECT group_id, bank_transaction FROM "Bank Reconciliation" '
         'WHERE voucher_type = ? AND voucher_no = ? AND bank_account = ? '
-        'AND status = ? LIMIT 1',
-        [voucher_type, voucher_no, tx["bank_account"], "Active"],
+        'AND status = ? AND group_head = 1 LIMIT 1',
+        [voucher_type, voucher_no, first["bank_account"], "Active"],
     )
     if used:
         raise ValidationError(
             f"The {voucher_type} {voucher_no} bank movement on account "
-            f"{tx['bank_account']} is already reconciled with {used[0]['bank_transaction']}"
+            f"{first['bank_account']} is already reconciled by group {used[0]['group_id']}"
         )
     rows = db.sql(
         'SELECT COALESCE(SUM(debit), 0) AS debit, COALESCE(SUM(credit), 0) AS credit, '
@@ -606,36 +753,75 @@ def _validate_existing_voucher(tx: dict, voucher_type: str, voucher_no: str) ->
         'COALESCE(SUM(credit_in_account_currency), 0) AS credit_ccy '
         'FROM "GL Entry" WHERE voucher_type = ? AND voucher_no = ? '
         'AND account = ? AND is_cancelled = 0',
-        [voucher_type, voucher_no, tx["bank_account"]],
+        [voucher_type, voucher_no, first["bank_account"]],
     )
     row = rows[0]
     movement = flt(row["debit_ccy"], 2) - flt(row["credit_ccy"], 2)
-    if tx.get("currency") == tx.get("base_currency"):
+    if first.get("currency") == first.get("base_currency"):
         movement = flt(row["debit"], 2) - flt(row["credit"], 2)
-    expected = _amount(tx) if _is_deposit(tx) else -_amount(tx)
+    expected = flt(sum(_signed_amount(tx) for tx in transactions), 2)
     if abs(movement - expected) > 0.01:
         raise ValidationError(
-            f"Voucher bank movement ({movement}) does not equal transaction movement ({expected})"
+            f"Voucher bank movement ({movement}) does not equal grouped transaction movement ({expected})"
         )
 
 
-def reconcile_with_existing_voucher(bank_transaction: str, voucher_type: str, voucher_no: str, *,
-                                    user: str | None = None, confirmed: bool = False) -> dict:
+def _begin_existing_voucher_transaction(db, voucher_type: str, voucher_no: str) -> None:
+    """Serialize consumers of one voucher while the group is validated."""
+    db._in_transaction = True
+    if db.dialect == "sqlite":
+        db.conn.execute("BEGIN IMMEDIATE")
+    else:
+        # ``voucher_type`` is checked against the fixed allowlist before this
+        # helper is called, so quoting the table name is safe.
+        db.conn.execute(
+            f'SELECT name FROM "{voucher_type}" WHERE name = ? FOR UPDATE',
+            [voucher_no],
+        ).fetchone()
+
+
+def reconcile_with_existing_voucher_group(bank_transactions: list[str], voucher_type: str,
+                                           voucher_no: str, *, user: str | None = None,
+                                           confirmed: bool = False) -> dict:
+    """Atomically link an exact group to one submitted voucher bank leg."""
     if confirmed is not True:
         raise ValidationError("Explicit confirmation is required before matching an existing voucher")
-    tx = _transaction(bank_transaction)
-    _ensure_available(tx)
-    _validate_existing_voucher(tx, voucher_type, voucher_no)
+    if voucher_type not in _VOUCHER_TYPES:
+        raise ValidationError("Only submitted Payment Entries or Journal Entries can be matched")
+    if not isinstance(bank_transactions, list) or not bank_transactions:
+        raise ValidationError("At least one bank transaction is required")
+    names = []
+    for value in bank_transactions:
+        name = str(value or "").strip()
+        if not name:
+            raise ValidationError("Every grouped bank transaction needs a name")
+        if name in names:
+            raise ValidationError(f"Bank Transaction {name} occurs more than once in the group")
+        names.append(name)
+
     db = get_db()
-    db._in_transaction = True
     try:
-        reconciliation = _new_audit(
-            tx, mode="Existing Voucher", voucher_type=voucher_type,
-            voucher_no=voucher_no, user=user,
-        )
-        activate_generated_reconciliation(
-            reconciliation, voucher_type=voucher_type, voucher_no=voucher_no,
-        )
+        _begin_existing_voucher_transaction(db, voucher_type, voucher_no)
+        transactions = [_transaction(name) for name in names]
+        for tx in transactions:
+            _ensure_available(tx)
+        _validate_existing_voucher_group(transactions, voucher_type, voucher_no)
+
+        reconciliations: list[str] = []
+        group_id = None
+        for index, tx in enumerate(transactions):
+            reconciliation = _new_audit(
+                tx, mode="Existing Voucher", voucher_type=voucher_type,
+                voucher_no=voucher_no, user=user, group_id=group_id,
+                group_head=index == 0,
+            )
+            if group_id is None:
+                group_id = reconciliation
+            reconciliations.append(reconciliation)
+        for reconciliation in reconciliations:
+            activate_generated_reconciliation(
+                reconciliation, voucher_type=voucher_type, voucher_no=voucher_no,
+            )
         db.commit()
     except Exception:
         db.conn.rollback()
@@ -643,14 +829,27 @@ def reconcile_with_existing_voucher(bank_transaction: str, voucher_type: str, vo
     finally:
         db._in_transaction = False
     return {
-        "bank_transaction": bank_transaction,
-        "reconciliation": reconciliation,
+        "bank_transaction": names[0],
+        "bank_transactions": names,
+        "reconciliation": reconciliations[0],
+        "reconciliations": reconciliations,
+        "group_id": group_id,
         "voucher_type": voucher_type,
         "voucher_no": voucher_no,
         "status": "Reconciled",
+        "amount": flt(sum(_amount(tx) for tx in transactions), 2),
+        "currency": transactions[0].get("currency"),
     }
 
 
+def reconcile_with_existing_voucher(bank_transaction: str, voucher_type: str, voucher_no: str, *,
+                                    user: str | None = None, confirmed: bool = False) -> dict:
+    return reconcile_with_existing_voucher_group(
+        [bank_transaction], voucher_type, voucher_no,
+        user=user, confirmed=confirmed,
+    )
+
+
 def undo_reconciliation(bank_transaction: str, *, user: str | None = None,
                         confirmed: bool = False) -> dict:
     if confirmed is not True:
@@ -674,15 +873,18 @@ def undo_reconciliation(bank_transaction: str, *, user: str | None = None,
     else:
         db._in_transaction = True
         try:
-            db.set_value("Bank Reconciliation", audit["name"], {
-                "status": "Reversed", "reversed_by": user, "reversed_at": now(),
-            })
-            db.set_value("Bank Transaction", bank_transaction, {
-                "reference_doctype": None, "reference_name": None,
-                "allocated_amount": 0, "unallocated_amount": _amount(tx),
-                "status": "Unreconciled", "reconciled_by": None,
-                "reconciled_at": None, "modified": now(),
-            })
+            group = _group_rows(audit.get("group_id")) or [audit]
+            for member in group:
+                member_tx = _transaction(member["bank_transaction"])
+                db.set_value("Bank Reconciliation", member["name"], {
+                    "status": "Reversed", "reversed_by": user, "reversed_at": now(),
+                })
+                db.set_value("Bank Transaction", member_tx["name"], {
+                    "reference_doctype": None, "reference_name": None,
+                    "allocated_amount": 0, "unallocated_amount": _amount(member_tx),
+                    "status": "Unreconciled", "reconciled_by": None,
+                    "reconciled_at": None, "modified": now(),
+                })
             db.commit()
         except Exception:
             db.conn.rollback()
@@ -691,6 +893,10 @@ def undo_reconciliation(bank_transaction: str, *, user: str | None = None,
             db._in_transaction = False
     return {
         "bank_transaction": bank_transaction,
+        "bank_transactions": [
+            row["bank_transaction"]
+            for row in (_group_rows(audit.get("group_id"), status="Reversed") or [audit])
+        ],
         "reversed_reconciliation": audit["name"],
         "voucher_type": audit["voucher_type"],
         "voucher_no": audit["voucher_no"],

{lambda_erp-0.8.26 → lambda_erp-0.8.28}/lambda_erp/database.py

@@ -1431,6 +1431,8 @@ class Database:
                 name TEXT PRIMARY KEY,
                 bank_transaction TEXT NOT NULL,
                 bank_account TEXT NOT NULL,
+                group_id TEXT,
+                group_head INTEGER DEFAULT 1,
                 mode TEXT NOT NULL,
                 voucher_type TEXT NOT NULL,
                 voucher_no TEXT NOT NULL,
@@ -2448,6 +2450,25 @@ def _m025_bank_reconciliation_multi_account_voucher(db: "Database") -> None:
     ], ["Bank Reconciliation"])
 
 
+def _m026_bank_reconciliation_groups(db: "Database") -> None:
+    """Allow one exact voucher bank leg to cover a group of transactions.
+
+    A group has one head row so the database can still enforce that a voucher's
+    bank-account movement is consumed at most once, while every imported bank
+    transaction retains its own auditable reconciliation row.
+    """
+    db.ensure_column("Bank Reconciliation", "group_id", "TEXT")
+    db.ensure_column("Bank Reconciliation", "group_head", "INTEGER DEFAULT 1")
+    db._alter_table_lock_safe([
+        'UPDATE "Bank Reconciliation" SET group_id = name WHERE group_id IS NULL',
+        'UPDATE "Bank Reconciliation" SET group_head = 1 WHERE group_head IS NULL',
+        'DROP INDEX IF EXISTS "ux_bank_reconciliation_active_voucher_account"',
+        'CREATE UNIQUE INDEX IF NOT EXISTS "ux_bank_reconciliation_active_group_head" '
+        'ON "Bank Reconciliation" (voucher_type, voucher_no, bank_account) '
+        "WHERE status = 'Active' AND group_head = 1",
+    ], ["Bank Reconciliation"])
+
+
 Database.MIGRATIONS = [
     (1, "chat_message_session_id", _m001_chat_message_session_id),
     (2, "chat_session_user_id", _m002_chat_session_user_id),
@@ -2474,6 +2495,7 @@ Database.MIGRATIONS = [
     (23, "camt_bank_statement_import", _m023_camt_bank_statement_import),
     (24, "bank_reconciliation", _m024_bank_reconciliation),
     (25, "bank_reconciliation_multi_account_voucher", _m025_bank_reconciliation_multi_account_voucher),
+    (26, "bank_reconciliation_groups", _m026_bank_reconciliation_groups),
 ]
 
 

{lambda_erp-0.8.26 → lambda_erp-0.8.28}/pyproject.toml

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