[ADD] account_perf_obligation_start_end_dates

Author: baimont

account_perf_obligation/models/perf_obligation.py

@@ -47,6 +47,11 @@ class PerfObligation(models.Model):
         string="Total Amount to Recognize",
         required=True,
     )
+    recognition_at_date_method = fields.Selection(
+        selection=[],
+        help="Method used to compute the amount to recognize at a given date. "
+        "Leave empty for manual recognition only.",
+    )
     move_line_ids = fields.One2many(
         comodel_name="account.move.line",
         inverse_name="perf_obligation_id",
@@ -131,6 +136,47 @@ def _get_recognition_config(self) -> RecognitionConfig:
             )
         return RecognitionConfig(**values)
 
+    # ------------------------------------------------------------------
+    # Recognition at date
+    # ------------------------------------------------------------------
+
+    def _supports_recognition_at_date(self):
+        """Return whether this obligation supports automatic recognition
+        at date computation.
+
+        Override this method to add support for other recognition methods.
+        """
+        self.ensure_one()
+        return bool(self.recognition_at_date_method)
+
+    def _compute_amount_to_recognize_at_date(self, date):
+        """Compute the cumulative amount to recognize at the given date.
+
+        Dispatches to the method matching ``recognition_at_date_method``.
+        Raises if no recognition method is configured.
+        """
+        self.ensure_one()
+        if not self._supports_recognition_at_date():
+            raise ValidationError(
+                _(
+                    "No recognition at date method configured "
+                    "on performance obligation %(name)s.",
+                    name=self.display_name,
+                )
+            )
+        method_name = f"_compute_amount_to_recognize_{self.recognition_at_date_method}"
+        compute_method = getattr(self, method_name, None)
+        if compute_method is None:
+            raise ValidationError(
+                _(
+                    "Unknown recognition method '%(method)s' "
+                    "on performance obligation %(name)s.",
+                    method=self.recognition_at_date_method,
+                    name=self.display_name,
+                )
+            )
+        return compute_method(date)
+
     # ------------------------------------------------------------------
     # Balance helpers
     # ------------------------------------------------------------------

account_perf_obligation/tests/test_recognition.py

@@ -1,7 +1,7 @@
 # Copyright 2026 ACSONE SA/NV
 # License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
 
-from odoo import Command
+from odoo import Command, fields
 from odoo.exceptions import UserError, ValidationError
 
 from .common import PerfObligationCommon
@@ -657,3 +657,21 @@ def test_expense_scenario4_bill_in_middle(self):
         self.assertAlmostEqual(debit_bs.credit, 100)
         self.assertAlmostEqual(pl.debit, 100)
         self._assert_bs(po, "2026-04-30", self.exp_debit_bs, 0, self.exp_credit_bs, 0)
+
+    # =========================================================
+    # Recognition at date (base dispatch)
+    # =========================================================
+
+    def test_no_recognition_method_raises(self):
+        """Without recognition method, _compute_amount_to_recognize_at_date
+        raises ValidationError."""
+        po = self._create_obligation(total_amount=1000.0)
+        self.assertFalse(po.recognition_at_date_method)
+        with self.assertRaises(ValidationError):
+            po._compute_amount_to_recognize_at_date(fields.Date.today())
+
+    def test_supports_recognition_at_date_false_by_default(self):
+        """Without recognition method, _supports_recognition_at_date
+        returns False."""
+        po = self._create_obligation(total_amount=1000.0)
+        self.assertFalse(po._supports_recognition_at_date())

account_perf_obligation/views/perf_obligation.xml

@@ -44,6 +44,7 @@
                             <field name="name" />
                             <field name="perf_type" />
                             <field name="total_amount" />
+                            <field name="recognition_at_date_method" />
                         </group>
                         <group>
                             <field name="create_date" />

account_perf_obligation_start_end_dates/README.rst

@@ -0,0 +1,40 @@
+==================================================
+Performance Obligations - Start/End Dates
+==================================================
+
+Extends the **Performance Obligations (IFRS 15)** module to support
+time-based income and expense recognition using start and end dates.
+
+Purpose
+=======
+
+When a performance obligation spans a defined period, this module computes
+the amount to recognize at any given date using the **daily pro-rata** method.
+
+The architecture is designed so that alternative computation methods
+(e.g. full-month based) can be easily added by extending the selection
+field and implementing the corresponding method.
+
+Usage
+=====
+
+#. On a performance obligation, select a **Recognition at Date Method**
+   (e.g. "Daily Pro-Rata")
+#. Fill in the **Start Date** and **End Date**
+   (these fields appear and become required when the daily pro-rata
+   method is selected)
+#. When opening the **Recognize Income/Expense** wizard, the
+   **Suggested Amount** is automatically computed based on the selected
+   date and the obligation period
+#. The suggested amount pre-fills the **Amount to Recognize** field,
+   but can be modified before confirmation
+
+Extensibility
+=============
+
+To implement a different recognition formula:
+
+#. Extend the ``recognition_at_date_method`` selection field on ``perf.obligation``
+   to add a new key (e.g. ``"monthly"``)
+#. Implement the corresponding
+   ``_compute_amount_to_recognize_monthly(date)`` method on the same model

account_perf_obligation_start_end_dates/__init__.py

@@ -0,0 +1,2 @@
+from . import models
+from . import wizards

account_perf_obligation_start_end_dates/__manifest__.py

@@ -0,0 +1,20 @@
+# Copyright 2026 ACSONE SA/NV
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
+
+{
+    "name": "Performance Obligations - Start/End Dates",
+    "summary": """Add start/end dates on performance obligations
+     for time-based income/expense recognition""",
+    "version": "18.0.1.0.0",
+    "category": "Accounting",
+    "license": "LGPL-3",
+    "author": "ACSONE SA/NV",
+    "website": "https://github.com/acsone/ifrs15",
+    "depends": [
+        "account_perf_obligation",
+    ],
+    "data": [
+        "wizards/perf_obligation_recognize.xml",
+        "views/perf_obligation.xml",
+    ],
+}

account_perf_obligation_start_end_dates/models/__init__.py

@@ -0,0 +1 @@
+from . import perf_obligation

account_perf_obligation_start_end_dates/models/perf_obligation.py

@@ -0,0 +1,88 @@
+# Copyright 2026 ACSONE SA/NV
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
+
+from odoo import _, api, fields, models
+from odoo.exceptions import ValidationError
+from odoo.tools import float_round
+
+
+class PerfObligation(models.Model):
+    _inherit = "perf.obligation"
+
+    recognition_at_date_method = fields.Selection(
+        selection_add=[
+            ("daily", "Daily Pro-Rata"),
+        ],
+    )
+    start_date = fields.Date()
+    end_date = fields.Date()
+    is_start_date_required = fields.Boolean(
+        compute="_compute_is_date_required",
+    )
+    is_end_date_required = fields.Boolean(
+        compute="_compute_is_date_required",
+    )
+
+    @api.depends("recognition_at_date_method")
+    def _compute_is_date_required(self):
+        for rec in self:
+            method = rec.recognition_at_date_method
+            rec.is_start_date_required = method == "daily"
+            rec.is_end_date_required = method == "daily"
+
+    @api.constrains("start_date", "end_date")
+    def _check_dates(self):
+        for rec in self:
+            if rec.start_date and rec.end_date and rec.start_date > rec.end_date:
+                raise ValidationError(
+                    _(
+                        "The start date must be before or equal to "
+                        "the end date on performance obligation %(name)s.",
+                        name=rec.display_name,
+                    )
+                )
+
+    @api.constrains("recognition_at_date_method", "start_date", "end_date")
+    def _check_recognition_method_dates(self):
+        for rec in self:
+            if not rec.is_start_date_required and not rec.is_end_date_required:
+                continue
+            if (rec.is_start_date_required and not rec.start_date) or (
+                rec.is_end_date_required and not rec.end_date
+            ):
+                raise ValidationError(
+                    _(
+                        "Start and end dates are required when the daily "
+                        "pro-rata recognition method is selected "
+                        "on performance obligation %(name)s.",
+                        name=rec.display_name,
+                    )
+                )
+
+    def _compute_amount_to_recognize_daily(self, date):
+        """Daily pro-rata recognition method.
+
+        Computes the amount to recognize based on the number of calendar
+        days elapsed from ``start_date`` (inclusive) to ``date`` (inclusive),
+        over the total number of days of the period.
+
+        Rounding strategy: each intermediate amount is rounded using the
+        currency's decimal precision. The last day always returns exactly
+        ``total_amount`` to avoid any residual rounding difference.
+        """
+        self.ensure_one()
+        start_date = self.start_date
+        end_date = self.end_date
+
+        if date < start_date:
+            return 0.0
+        if date >= end_date:
+            return self.total_amount
+
+        precision = self.currency_id.decimal_places
+        total_days = (end_date - start_date).days + 1
+        elapsed_days = (date - start_date).days + 1
+        daily_amount = self.total_amount / total_days
+        amount = float_round(daily_amount * elapsed_days, precision_digits=precision)
+        # Safety cap: never exceed total
+        return min(amount, self.total_amount)

account_perf_obligation_start_end_dates/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["whool"]
+build-backend = "whool.buildapi"

account_perf_obligation_start_end_dates/tests/__init__.py

@@ -0,0 +1 @@
+from . import test_start_end_dates