[IMP]l10n_it_riba_oca: riba policy expenses

Author: matteo.tognini

l10n_it_riba_oca/models/account.py

@@ -173,17 +173,39 @@ def _onchange_riba_partner_bank_id(self):
                 bank_ids = allowed_banks
             self.riba_partner_bank_id = bank_ids[0] if bank_ids else None
 
-    def month_check(self, invoice_date_due, all_date_due):
+    def month_check(self, all_invoice_date):
         """
-        :param invoice_date_due: first due date of invoice
-        :param all_date_due: list of due dates for partner
-        :return: True if month of invoice_date_due is in a list of all_date_due
+        Check if collection fees should be applied based on invoice date month.
+        :param all_invoice_date: list of invoice dates for partner
+        :return: True if month of current invoice date is already in all_invoice_date
         """
-        for d in all_date_due:
-            if invoice_date_due.month == d.month and invoice_date_due.year == d.year:
+        self.ensure_one()
+        date = self.invoice_date or self.date or fields.Date.context_today(self)
+        current_invoice_month = date.strftime("%Y-%m")
+        for d in all_invoice_date:
+            if d and current_invoice_month == d.strftime("%Y-%m"):
                 return True
         return False
 
+    def maturity_check(self, invoice_date_due, all_date_due):
+        """
+        Check if expenses should be applied based on exact maturity date.
+        Used for 'one_a_maturity' policy.
+        :param invoice_date_due: due date of current invoice
+        :param all_date_due: list of existing due dates for partner
+        :return: True if invoice_date_due already exists in all_date_due
+        Example:
+        - Invoice 1: Oct -> Dec (60 days) -> expenses YES
+        - Invoice 2: Nov -> Dec (30 days) -> expenses NO (Dec already exists)
+        - Invoice with 30/60 days: 2 different dates -> 2 expenses
+        """
+        self.ensure_one()
+        if self.partner_id.riba_policy_expenses == "one_a_maturity":
+            for d in all_date_due:
+                if invoice_date_due == d:
+                    return True
+        return False
+
     def _post(self, soft=True):
         inv_riba_no_bank = self.filtered(
             lambda x: x.is_riba_payment
@@ -210,80 +232,128 @@ def _post(self, soft=True):
             )
         return super()._post(soft=soft)
 
+    def _get_riba_expense_line_vals(self, pay_date=None):
+        """
+        Prepare values for RiBa collection fees invoice line.
+        :param pay_date: optional date for the expense description
+        :return: dict with invoice line values
+        """
+        self.ensure_one()
+        service_prod = self.company_id.due_cost_service_id
+        account = service_prod.product_tmpl_id.get_product_accounts(
+            self.fiscal_position_id
+        )["income"]
+        line_vals = {
+            "partner_id": self.partner_id.id,
+            "product_id": service_prod.id,
+            "move_id": self.id,
+            "price_unit": self.invoice_payment_term_id.riba_payment_cost,
+            "due_cost_line": True,
+            "account_id": account.id,
+            "sequence": 9999,
+        }
+        if pay_date:
+            line_vals["name"] = self.env._("{line_name} for {month}-{year}").format(
+                line_name=service_prod.name,
+                month=pay_date.month,
+                year=pay_date.year,
+            )
+        if self.company_id.due_cost_service_id.taxes_id:
+            tax = self.fiscal_position_id.map_tax(service_prod.taxes_id)
+            line_vals["tax_ids"] = [(4, tax.id)]
+        return line_vals
+
+    def _add_riba_expense_line(self, pay_date=None):
+        """Add a RiBa collection fees line to the invoice."""
+        self.ensure_one()
+        line_vals = self._get_riba_expense_line_vals(pay_date)
+        self.write({"invoice_line_ids": [(0, 0, line_vals)]})
+
+    def _apply_riba_collection_fees(self):
+        """
+        Apply collection fees based on partner's riba_policy_expenses.
+        """
+        self.ensure_one()
+
+        # Get existing move lines with RiBa expenses for this partner.
+        # Use commercial_partner_id because receivable lines store that instead
+        # of the invoice partner (which may be a contact). Include draft state
+        # so that invoices being posted in the same batch are also considered.
+        move_line = self.env["account.move.line"].search(
+            [
+                (
+                    "partner_id",
+                    "=",
+                    self.partner_id.commercial_partner_id.id,
+                ),
+                ("move_id.invoice_payment_term_id.riba", "=", True),
+                ("move_id.state", "in", ("posted", "draft")),
+                ("move_id.id", "!=", self.id),
+            ]
+        )
+        move_line = move_line.filtered(
+            lambda line: any(
+                inv_line.due_cost_line for inv_line in line.move_id.invoice_line_ids
+            )
+        )
+        move_line = move_line.filtered(lambda line: line.date_maturity is not False)
+        move_line = move_line.sorted(key=lambda r: r.date_maturity)
+
+        previous_date_due = move_line.mapped("date_maturity")
+        all_invoice_date = move_line.mapped("invoice_date")
+
+        # Compute payment term dates
+        pterm_list = self.invoice_payment_term_id._compute_terms(
+            date_ref=self.invoice_date or self.date or fields.Date.context_today(self),
+            currency=self.currency_id,
+            company=self.company_id,
+            tax_amount=1,
+            tax_amount_currency=1,
+            untaxed_amount=0,
+            sign=1 if self.is_inbound(include_receipts=True) else -1,
+            untaxed_amount_currency=self.amount_untaxed,
+        )
+
+        policy = self.partner_id.riba_policy_expenses
+
+        if policy == "one_per_invoice":
+            # One expense per invoice, no date in description
+            self._add_riba_expense_line()
+        elif policy == "unlimited":
+            # One expense for each due date, no checks
+            for pay_date in pterm_list["line_ids"]:
+                self._add_riba_expense_line(pay_date["date"])
+        elif policy == "one_a_maturity":
+            # One expense per maturity date, skip if date already exists
+            for pay_date in pterm_list["line_ids"]:
+                if not self.maturity_check(pay_date["date"], previous_date_due):
+                    self._add_riba_expense_line(pay_date["date"])
+        else:
+            # Default: one_a_month - one expense per month
+            if not self.month_check(all_invoice_date):
+                pay_date = pterm_list["line_ids"][0]
+                self._add_riba_expense_line(pay_date["date"])
+
+        # Recompute invoice taxes
+        self._sync_dynamic_lines(container={"records": self, "self": self})
+
     def action_post(self):
         for invoice in self:
-            # ---- Add a line with collection fees for each due date only for first due
-            # ---- date of the month
+            # Check if collection fees should be applied
             if (
                 invoice.move_type != "out_invoice"
                 or not invoice.invoice_payment_term_id
                 or not invoice.invoice_payment_term_id.riba
                 or invoice.invoice_payment_term_id.riba_payment_cost == 0.0
+                or invoice.partner_id.commercial_partner_id.riba_exclude_expenses
             ):
                 continue
             if not invoice.company_id.due_cost_service_id:
                 raise UserError(
                     self.env._("Set a Service for Collection Fees in Company Config.")
                 )
-            # ---- Apply Collection Fees on invoice only on first due date of the month
-            # ---- Get Date of first due date
-            move_line = self.env["account.move.line"].search(
-                [("partner_id", "=", invoice.partner_id.id)]
-            )
-            if not any(line.due_cost_line for line in move_line):
-                move_line = self.env["account.move.line"]
-            # ---- Filtered recordset with date_maturity
-            move_line = move_line.filtered(lambda line: line.date_maturity is not False)
-            # ---- Sorted
-            move_line = move_line.sorted(key=lambda r: r.date_maturity)
-            # ---- Get date
-            previous_date_due = move_line.mapped("date_maturity")
-            pterm = self.env["account.payment.term"].browse(
-                self.invoice_payment_term_id.id
-            )
-            pterm_list = pterm._compute_terms(
-                date_ref=self.invoice_date,
-                currency=self.currency_id,
-                company=self.company_id,
-                tax_amount=1,
-                tax_amount_currency=1,
-                untaxed_amount=0,
-                untaxed_amount_currency=0,
-                sign=1,
-            )
+            invoice._apply_riba_collection_fees()
 
-            for pay_date in pterm_list["line_ids"]:
-                if not self.month_check(pay_date["date"], previous_date_due):
-                    # ---- Get Line values for service product
-                    service_prod = invoice.company_id.due_cost_service_id
-                    account = service_prod.product_tmpl_id.get_product_accounts(
-                        invoice.fiscal_position_id
-                    )["income"]
-                    line_vals = {
-                        "partner_id": invoice.partner_id.id,
-                        "product_id": service_prod.id,
-                        "move_id": invoice.id,
-                        "price_unit": (
-                            invoice.invoice_payment_term_id.riba_payment_cost
-                        ),
-                        "due_cost_line": True,
-                        "name": self.env._("{line_name} for {month}-{year}").format(
-                            line_name=service_prod.name,
-                            month=pay_date["date"].month,
-                            year=pay_date["date"].year,
-                        ),
-                        "account_id": account.id,
-                        "sequence": 9999,
-                    }
-                    # ---- Update Line Value with tax if is set on product
-                    if invoice.company_id.due_cost_service_id.taxes_id:
-                        tax = invoice.fiscal_position_id.map_tax(service_prod.taxes_id)
-                        line_vals.update({"tax_ids": [(4, tax.id)]})
-                    invoice.write({"invoice_line_ids": [(0, 0, line_vals)]})
-                    # ---- recompute invoice taxes
-                    invoice._sync_dynamic_lines(
-                        container={"records": invoice, "self": invoice}
-                    )
         res = super().action_post()
 
         # Automatic reconciliation for RiBa credit moves

l10n_it_riba_oca/models/partner.py

@@ -22,6 +22,20 @@ class ResPartner(models.Model):
         readonly=True,
     )
 
+    riba_exclude_expenses = fields.Boolean(
+        string="Exclude expenses Ri.Ba.",
+    )
+    riba_policy_expenses = fields.Selection(
+        [
+            ("one_a_month", "More invoices, one expense per Month"),
+            ("unlimited", "One expense per maturity"),
+            ("one_a_maturity", "More invoices, one expense per maturity"),
+            ("one_per_invoice", "One expense per invoice"),
+        ],
+        default="one_a_month",
+        string="Ri.Ba. Policy expenses",
+    )
+
     def _domain_property_riba_supplier_company_bank_id(self):
         """Allow to select bank accounts linked to the current company."""
         return self.env["res.partner.bank"]._domain_riba_partner_bank_id()

l10n_it_riba_oca/tests/__init__.py

@@ -5,6 +5,7 @@
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
 
 from . import test_account_move
+from . import test_different_payment_terms
 from . import test_menu
 from . import test_riba
 from . import riba_common

l10n_it_riba_oca/tests/test_different_payment_terms.py

@@ -0,0 +1,112 @@
+# Copyright 2026 Nextev Srl
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from odoo import fields
+
+from .riba_common import TestRibaCommon
+
+
+class TestDifferentPaymentTermsDueCost(TestRibaCommon):
+    """Regression tests: one_a_maturity must not add duplicate expenses when two
+    invoices for the same partner share a maturity date but use different RiBa
+    payment terms."""
+
+    def setUp(self):
+        super().setUp()
+        self.invoice.company_id.due_cost_service_id = self.service_due_cost.id
+        self.partner.riba_policy_expenses = "one_a_maturity"
+        # Single-maturity 60-day payment term
+        self.payment_term_60 = self.env["account.payment.term"].create(
+            {
+                "name": "RiBa 60",
+                "riba": True,
+                "riba_payment_cost": 5.00,
+                "line_ids": [
+                    (
+                        0,
+                        0,
+                        {
+                            "value": "percent",
+                            "delay_type": "days_after",
+                            "nb_days": 60,
+                            "days_next_month": "0",
+                        },
+                    )
+                ],
+            }
+        )
+
+    def _make_invoice(self, payment_term, invoice_date="2026-01-01"):
+        self.partner.property_account_receivable_id = self.account_rec1_id.id
+        return self.env["account.move"].create(
+            {
+                "invoice_date": fields.Date.from_string(invoice_date),
+                "move_type": "out_invoice",
+                "journal_id": self.sale_journal.id,
+                "partner_id": self.partner.id,
+                "invoice_payment_term_id": payment_term.id,
+                "riba_partner_bank_id": self.partner.bank_ids[0].id,
+                "invoice_line_ids": [
+                    (
+                        0,
+                        0,
+                        {
+                            "name": self.product1.name,
+                            "product_id": self.product1.id,
+                            "quantity": 1.0,
+                            "price_unit": 100.00,
+                            "account_id": self.sale_account.id,
+                            "tax_ids": [[6, 0, []]],
+                        },
+                    )
+                ],
+            }
+        )
+
+    def _due_cost_count(self, invoice):
+        return len(invoice.invoice_line_ids.filtered("due_cost_line"))
+
+    def test_no_duplicate_sequential_different_terms(self):
+        """FATTURA 1 (30/60GG) is posted first; its 60-day maturity coincides
+        with FATTURA 2 (60GG). Posting FATTURA 2 afterwards must not create a
+        second expense for that shared date."""
+        # Same invoice date so the 60-day maturities coincide exactly.
+        inv1 = self._make_invoice(self.payment_term1)  # 30/60GG -> 2 maturities
+        inv2 = self._make_invoice(
+            self.payment_term_60
+        )  # 60GG   -> 1 maturity (same as inv1's second)
+
+        inv1.action_post()
+        inv2.action_post()
+
+        # inv1 keeps expenses for both maturities (30-day and 60-day)
+        self.assertEqual(self._due_cost_count(inv1), 2)
+        # inv2's only maturity is already covered by inv1 – no new expense
+        self.assertEqual(self._due_cost_count(inv2), 0)
+
+    def test_no_duplicate_batch_different_terms(self):
+        """Same scenario but both invoices are confirmed in a single action_post
+        call (batch). inv1 is not yet 'posted' when inv2 is checked, so the fix
+        must find inv1's draft receivable lines to detect the shared maturity."""
+        inv1 = self._make_invoice(self.payment_term1)
+        inv2 = self._make_invoice(self.payment_term_60)
+
+        (inv1 | inv2).action_post()
+
+        self.assertEqual(self._due_cost_count(inv1), 2)
+        self.assertEqual(self._due_cost_count(inv2), 0)
+
+    def test_expense_added_when_different_maturity(self):
+        """Control: if FATTURA 2's maturity is genuinely new (no overlap with
+        FATTURA 1), an expense must still be added for it."""
+        # inv1: 30/60GG from 2026-01-01 -> maturities 2026-01-31 and 2026-03-02
+        inv1 = self._make_invoice(self.payment_term1, invoice_date="2026-01-01")
+        # inv2: 60GG from 2026-02-01 -> maturity 2026-04-02 (not in inv1's set)
+        inv2 = self._make_invoice(self.payment_term_60, invoice_date="2026-02-01")
+
+        inv1.action_post()
+        inv2.action_post()
+
+        self.assertEqual(self._due_cost_count(inv1), 2)
+        # New maturity -> expense must be present
+        self.assertEqual(self._due_cost_count(inv2), 1)