odoo-addon-contract 17.0.1.4.4__py3-none-any.whl → 18.0.2.0.8__py3-none-any.whl

odoo/addons/contract/models/{contract_recurrency_mixin.py → contract_recurring_mixin.py}

@@ -1,5 +1,10 @@
-# Copyright 2018 ACSONE SA/NV.
-# Copyright 2020 Tecnativa - Pedro M. Baeza
+# Copyright 2004-2010 OpenERP SA
+# Copyright 2014 Angel Moya <angel.moya@domatix.com>
+# Copyright 2015-2020 Tecnativa - Pedro M. Baeza
+# Copyright 2016-2018 Tecnativa - Carlos Dauden
+# Copyright 2016-2017 LasLabs Inc.
+# Copyright 2018 ACSONE SA/NV
+# Copyright 2021 Tecnativa - Víctor Martínez
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
 
 from dateutil.relativedelta import relativedelta
@@ -7,9 +12,23 @@ from dateutil.relativedelta import relativedelta
 from odoo import api, fields, models
 
 
-class ContractRecurrencyBasicMixin(models.AbstractModel):
-    _name = "contract.recurrency.basic.mixin"
-    _description = "Basic recurrency mixin for abstract contract models"
+class ContractRecurringMixin(models.AbstractModel):
+    """Abstract model to support recurring invoicing logic."""
+
+    _name = "contract.recurring.mixin"
+    _description = "Contract Recurring Mixin"
+
+    date_start = fields.Date(
+        index=True,
+        default=lambda self: fields.Date.context_today(self),
+        help="Contract activation date (first recurrence starts here)",
+    )
+    date_end = fields.Date(
+        index=True, help="Optional contract termination date (limits recurrence)"
+    )
+
+    # === Recurrence Rule Fields ===
+    # Define how often the contract recurs (e.g., monthly, yearly) and the interval.
 
     recurring_rule_type = fields.Selection(
         [
@@ -23,7 +42,12 @@ class ContractRecurrencyBasicMixin(models.AbstractModel):
         ],
         default="monthly",
         string="Recurrence",
-        help="Specify Interval for automatic invoice generation.",
+        help="Specify interval for automatic invoice generation.",
+    )
+    recurring_interval = fields.Integer(
+        default=1,
+        string="Invoice Every",
+        help="Invoice every (Days/Week/Month/Year)",
     )
     recurring_invoicing_type = fields.Selection(
         [("pre-paid", "Pre-paid"), ("post-paid", "Post-paid")],
@@ -42,45 +66,20 @@ class ContractRecurrencyBasicMixin(models.AbstractModel):
             "date (in post-paid mode) or start date (in pre-paid mode)."
         ),
     )
-    recurring_interval = fields.Integer(
-        default=1,
-        string="Invoice Every",
-        help="Invoice every (Days/Week/Month/Year)",
-    )
-    date_start = fields.Date()
-    recurring_next_date = fields.Date(string="Date of Next Invoice")
-
-    @api.depends("recurring_invoicing_type", "recurring_rule_type")
-    def _compute_recurring_invoicing_offset(self):
-        for rec in self:
-            method = self._get_default_recurring_invoicing_offset
-            rec.recurring_invoicing_offset = method(
-                rec.recurring_invoicing_type, rec.recurring_rule_type
-            )
-
-    @api.model
-    def _get_default_recurring_invoicing_offset(
-        self, recurring_invoicing_type, recurring_rule_type
-    ):
-        if (
-            recurring_invoicing_type == "pre-paid"
-            or recurring_rule_type == "monthlylastday"
-        ):
-            return 0
-        else:
-            return 1
-
-
-class ContractRecurrencyMixin(models.AbstractModel):
-    _inherit = "contract.recurrency.basic.mixin"
-    _name = "contract.recurrency.mixin"
-    _description = "Recurrency mixin for contract models"
+    # === Invoicing Configuration Fields ===
+    # Define when and how invoices should be issued within the recurrence.
 
-    date_start = fields.Date(default=lambda self: fields.Date.context_today(self))
+    last_date_invoiced = fields.Date(
+        readonly=True,
+        copy=False,
+    )
     recurring_next_date = fields.Date(
-        compute="_compute_recurring_next_date", store=True, readonly=False, copy=True
+        string="Date of Next Invoice",
+        compute="_compute_recurring_next_date",
+        store=True,
+        readonly=False,
+        copy=True,
     )
-    date_end = fields.Date(index=True)
     next_period_date_start = fields.Date(
         string="Next Period Start",
         compute="_compute_next_period_date_start",
@@ -89,22 +88,10 @@ class ContractRecurrencyMixin(models.AbstractModel):
         string="Next Period End",
         compute="_compute_next_period_date_end",
     )
-    last_date_invoiced = fields.Date(readonly=True, copy=False)
-
-    @api.depends("next_period_date_start")
-    def _compute_recurring_next_date(self):
-        for rec in self:
-            rec.recurring_next_date = self.get_next_invoice_date(
-                rec.next_period_date_start,
-                rec.recurring_invoicing_type,
-                rec.recurring_invoicing_offset,
-                rec.recurring_rule_type,
-                rec.recurring_interval,
-                max_date_end=rec.date_end,
-            )
 
     @api.depends("last_date_invoiced", "date_start", "date_end")
     def _compute_next_period_date_start(self):
+        """Compute the start date of the next billing period."""
         for rec in self:
             if rec.last_date_invoiced:
                 next_period_date_start = rec.last_date_invoiced + relativedelta(days=1)
@@ -128,6 +115,7 @@ class ContractRecurrencyMixin(models.AbstractModel):
         "recurring_next_date",
     )
     def _compute_next_period_date_end(self):
+        """Compute the end date of the next billing period."""
         for rec in self:
             rec.next_period_date_end = self.get_next_period_date_end(
                 rec.next_period_date_start,
@@ -139,13 +127,40 @@ class ContractRecurrencyMixin(models.AbstractModel):
                 recurring_invoicing_offset=rec.recurring_invoicing_offset,
             )
 
+    @api.depends("recurring_invoicing_type", "recurring_rule_type")
+    def _compute_recurring_invoicing_offset(self):
+        """Compute the invoicing offset based on type and rule."""
+        for rec in self:
+            method = self._get_default_recurring_invoicing_offset
+            rec.recurring_invoicing_offset = method(
+                rec.recurring_invoicing_type, rec.recurring_rule_type
+            )
+
+    @api.depends(
+        "next_period_date_start",
+        "recurring_invoicing_type",
+        "recurring_invoicing_offset",
+        "recurring_rule_type",
+        "recurring_interval",
+        "date_end",
+    )
+    def _compute_recurring_next_date(self):
+        """Compute the next invoice date."""
+        for rec in self:
+            rec.recurring_next_date = self.get_next_invoice_date(
+                rec.next_period_date_start,
+                rec.recurring_invoicing_type,
+                rec.recurring_invoicing_offset,
+                rec.recurring_rule_type,
+                rec.recurring_interval,
+                max_date_end=rec.date_end,
+            )
+
+    # === Utility Methods ===
+
     @api.model
     def get_relative_delta(self, recurring_rule_type, interval):
-        """Return a relativedelta for one period.
-
-        When added to the first day of the period,
-        it gives the first day of the next period.
-        """
+        """Return a relativedelta for one period based on rule type."""
         if recurring_rule_type == "daily":
             return relativedelta(days=interval)
         elif recurring_rule_type == "weekly":
@@ -158,7 +173,7 @@ class ContractRecurrencyMixin(models.AbstractModel):
             return relativedelta(months=3 * interval)
         elif recurring_rule_type == "semesterly":
             return relativedelta(months=6 * interval)
-        else:
+        else:  # yearly
             return relativedelta(years=interval)
 
     @api.model
@@ -172,28 +187,21 @@ class ContractRecurrencyMixin(models.AbstractModel):
         recurring_invoicing_type=False,
         recurring_invoicing_offset=False,
     ):
-        """Compute the end date for the next period.
-
-        The next period normally depends on recurrence options only.
-        It is however possible to provide it a next invoice date, in
-        which case this method can adjust the next period based on that
-        too. In that scenario it required the invoicing type and offset
-        arguments.
-        """
-        if not next_period_date_start:
-            return False
-        if max_date_end and next_period_date_start > max_date_end:
-            # start is past max date end: there is no next period
+        """Compute the end date for the next period."""
+        if not next_period_date_start or (
+            max_date_end and next_period_date_start > max_date_end
+        ):
             return False
+
         if not next_invoice_date:
-            # regular algorithm
+            # Regular case: use relative delta
             next_period_date_end = (
                 next_period_date_start
                 + self.get_relative_delta(recurring_rule_type, recurring_interval)
                 - relativedelta(days=1)
             )
         else:
-            # special algorithm when the next invoice date is forced
+            # Forced invoice date: back-calculate period end
             if recurring_invoicing_type == "pre-paid":
                 next_period_date_end = (
                     next_invoice_date
@@ -205,8 +213,8 @@ class ContractRecurrencyMixin(models.AbstractModel):
                 next_period_date_end = next_invoice_date - relativedelta(
                     days=recurring_invoicing_offset
                 )
+
         if max_date_end and next_period_date_end > max_date_end:
-            # end date is past max_date_end: trim it
             next_period_date_end = max_date_end
         return next_period_date_end
 
@@ -220,6 +228,7 @@ class ContractRecurrencyMixin(models.AbstractModel):
         recurring_interval,
         max_date_end,
     ):
+        """Compute the date of the next invoice based on all parameters."""
         next_period_date_end = self.get_next_period_date_end(
             next_period_date_start,
             recurring_rule_type,
@@ -228,12 +237,22 @@ class ContractRecurrencyMixin(models.AbstractModel):
         )
         if not next_period_date_end:
             return False
+
         if recurring_invoicing_type == "pre-paid":
-            recurring_next_date = next_period_date_start + relativedelta(
-                days=recurring_invoicing_offset
-            )
-        else:  # post-paid
-            recurring_next_date = next_period_date_end + relativedelta(
+            return next_period_date_start + relativedelta(
                 days=recurring_invoicing_offset
             )
-        return recurring_next_date
+        else:
+            return next_period_date_end + relativedelta(days=recurring_invoicing_offset)
+
+    @api.model
+    def _get_default_recurring_invoicing_offset(
+        self, recurring_invoicing_type, recurring_rule_type
+    ):
+        """Return default offset in days based on invoicing type and rule."""
+        if (
+            recurring_invoicing_type == "pre-paid"
+            or recurring_rule_type == "monthlylastday"
+        ):
+            return 0
+        return 1

odoo/addons/contract/models/contract_tag.py

@@ -10,8 +10,6 @@ class ContractTag(models.Model):
 
     name = fields.Char(required=True)
     company_id = fields.Many2one(
-        "res.company",
-        string="Company",
-        default=lambda self: self.env.company.id,
+        "res.company", string="Company", default=lambda self: self.env.company
     )
     color = fields.Integer("Color Index", default=0)

odoo/addons/contract/models/contract_template.py

@@ -6,13 +6,66 @@
 # Copyright 2018 ACSONE SA/NV
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
 
-from odoo import fields, models
+from odoo import api, fields, models
 
 
 class ContractTemplate(models.Model):
     _name = "contract.template"
-    _inherit = "contract.abstract.contract"
     _description = "Contract Template"
+    _inherit = "contract.recurring.mixin"
+    _check_company_auto = True
+
+    # Fields not synced to the actual contract
+    NO_SYNC = ["name", "partner_id", "company_id"]
+
+    # === Basic Info ===
+
+    name = fields.Char(required=True)
+    partner_id = fields.Many2one(
+        comodel_name="res.partner",
+        string="Partner",
+        index=True,
+    )
+    company_id = fields.Many2one(
+        comodel_name="res.company",
+        string="Company",
+        required=True,
+        default=lambda self: self.env.company,
+    )
+    pricelist_id = fields.Many2one(
+        comodel_name="product.pricelist",
+        string="Pricelist",
+    )
+
+    # === Contract Settings ===
+
+    contract_type = fields.Selection(
+        selection=[("sale", "Customer"), ("purchase", "Supplier")],
+        default="sale",
+        index=True,
+    )
+    line_recurrence = fields.Boolean(
+        string="Recurrence at line level?",
+        help="Check this if you want to control recurrence at the line level "
+        "instead of for the whole contract.",
+    )
+    generation_type = fields.Selection(
+        selection=[("invoice", "Invoice")],
+        default=lambda self: self._default_generation_type(),
+        help="Defines what document is automatically generated by the cron.",
+    )
+    journal_id = fields.Many2one(
+        comodel_name="account.journal",
+        string="Journal",
+        domain="[('type', '=', contract_type)]",
+        compute="_compute_journal_id",
+        store=True,
+        readonly=False,
+        index=True,
+        check_company=True,
+    )
+
+    # === Contract Line Templates ===
 
     contract_line_ids = fields.One2many(
         comodel_name="contract.template.line",
@@ -20,3 +73,29 @@ class ContractTemplate(models.Model):
         copy=True,
         string="Contract template lines",
     )
+
+    def _get_valid_journal_type(self):
+        self.ensure_one()
+        if self.contract_type == "sale":
+            return ["sale"]
+        elif self.contract_type == "purchase":
+            return ["purchase"]
+
+    @api.model
+    def _default_generation_type(self):
+        """Default generation type for the contract."""
+        return "invoice"
+
+    @api.depends("contract_type", "company_id")
+    def _compute_journal_id(self):
+        """Auto-select a journal based on contract type and company."""
+        AccountJournal = self.env["account.journal"]
+        for contract in self:
+            # See Odoo account_move._search_default_journal()
+            company = contract.company_id or contract.env.company
+            domain = [
+                *self.env["account.journal"]._check_company_domain(company),
+                ("type", "in", contract._get_valid_journal_type()),
+            ]
+
+            contract.journal_id = AccountJournal.search(domain, limit=1).id or None

odoo/addons/contract/models/contract_template_line.py

@@ -6,18 +6,265 @@
 # Copyright 2018 ACSONE SA/NV
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
 
-from odoo import fields, models
+from odoo import api, fields, models
+from odoo.exceptions import ValidationError
 
 
 class ContractTemplateLine(models.Model):
     _name = "contract.template.line"
-    _inherit = "contract.abstract.contract.line"
+    _inherit = "contract.recurring.mixin"
     _description = "Contract Template Line"
     _order = "sequence,id"
 
+    sequence = fields.Integer(
+        default=10,
+        help="Defines line ordering in the contract.",
+    )
     contract_id = fields.Many2one(
-        string="Contract",
         comodel_name="contract.template",
+        string="Contract",
         required=True,
         ondelete="cascade",
     )
+    company_id = fields.Many2one(
+        related="contract_id.company_id", store=True, readonly=True
+    )
+    partner_id = fields.Many2one(
+        comodel_name="res.partner", related="contract_id.partner_id"
+    )
+    # === Product & UOM ===
+    product_id = fields.Many2one("product.product", string="Product")
+    name = fields.Text(
+        string="Description",
+        required=True,
+        compute="_compute_name",
+        store=True,
+        readonly=False,
+    )
+    quantity = fields.Float(default=1.0, required=True)
+    product_uom_category_id = fields.Many2one(
+        comodel_name="uom.category",
+        related="product_id.uom_id.category_id",
+        readonly=True,
+    )
+    uom_id = fields.Many2one(
+        comodel_name="uom.uom",
+        compute="_compute_uom_id",
+        store=True,
+        readonly=False,
+        string="Unit of Measure",
+        domain="[('category_id', '=', product_uom_category_id)]",
+    )
+
+    # === Pricing ===
+
+    automatic_price = fields.Boolean(
+        string="Auto-price?",
+        compute="_compute_automatic_price",
+        store=True,
+        readonly=False,
+        help=(
+            "If checked, the price will be taken from the pricelist. "
+            "Otherwise, it must be set manually."
+        ),
+    )
+    specific_price = fields.Float()
+    price_unit = fields.Float(
+        string="Unit Price",
+        compute="_compute_price_unit",
+        inverse="_inverse_price_unit",
+    )
+    currency_id = fields.Many2one(
+        "res.currency"
+    )  # Placeholder, overwritten in contract.line
+    price_subtotal = fields.Monetary(
+        string="Sub Total",
+        compute="_compute_price_subtotal",
+    )
+    discount = fields.Float(
+        string="Discount (%)",
+        digits="Discount",
+        help="Discount to apply on generated invoices. Must be ≤ 100.",
+    )
+
+    # === Recurrence Configuration ===
+
+    is_canceled = fields.Boolean(string="Canceled", default=False)
+
+    # === Display / Notes ===
+
+    display_type = fields.Selection(
+        selection=[("line_section", "Section"), ("line_note", "Note")],
+        default=False,
+        help="Technical field for UX purposes.",
+    )
+    note_invoicing_mode = fields.Selection(
+        selection=[
+            ("with_previous_line", "With previous line"),
+            ("with_next_line", "With next line"),
+            ("custom", "Custom"),
+        ],
+        default="with_previous_line",
+        help="When to invoice this note line relative to others.",
+    )
+    is_recurring_note = fields.Boolean(
+        compute="_compute_is_recurring_note",
+        string="Recurring Note",
+    )
+
+    # === Line-Level Recurrence Fields (computed from contract or local) ===
+
+    recurring_rule_type = fields.Selection(
+        compute="_compute_recurring_rule_type",
+        store=True,
+        readonly=False,
+        required=True,
+        copy=True,
+    )
+    recurring_invoicing_type = fields.Selection(
+        compute="_compute_recurring_invoicing_type",
+        store=True,
+        readonly=False,
+        required=True,
+        copy=True,
+    )
+    recurring_interval = fields.Integer(
+        compute="_compute_recurring_interval",
+        store=True,
+        readonly=False,
+        required=True,
+        copy=True,
+    )
+    date_start = fields.Date(
+        compute="_compute_date_start",
+        store=True,
+        readonly=False,
+        copy=True,
+    )
+
+    @api.depends("product_id")
+    def _compute_name(self):
+        for line in self:
+            if line.product_id:
+                partner = line.contract_id.partner_id or line.env.user.partner_id
+                product = line.product_id.with_context(
+                    lang=partner.lang,
+                    partner=partner.id,
+                )
+                line.name = product.get_product_multiline_description_sale()
+
+    @api.depends("product_id")
+    def _compute_uom_id(self):
+        for line in self:
+            if not line.uom_id or (
+                line.product_id.uom_id.category_id.id != line.uom_id.category_id.id
+            ):
+                line.uom_id = line.product_id.uom_id
+
+    @api.depends("contract_id.contract_type")
+    def _compute_automatic_price(self):
+        """Reset automatic price if contract is switched to 'purchase'."""
+        self.filtered(
+            lambda line: line.contract_id.contract_type == "purchase"
+            and line.automatic_price
+        ).automatic_price = False
+
+    @api.depends("display_type", "note_invoicing_mode")
+    def _compute_is_recurring_note(self):
+        for record in self:
+            record.is_recurring_note = (
+                record.display_type == "line_note"
+                and record.note_invoicing_mode == "custom"
+            )
+
+    @api.depends(
+        "automatic_price",
+        "specific_price",
+        "product_id",
+        "quantity",
+        "contract_id.pricelist_id",
+        "contract_id.partner_id",
+    )
+    def _compute_price_unit(self):
+        for line in self:
+            if line.automatic_price and line.product_id:
+                pricelist = (
+                    line.contract_id.pricelist_id
+                    or line.contract_id.partner_id.with_company(
+                        line.contract_id.company_id
+                    ).property_product_pricelist
+                )
+                qty = line.env.context.get("contract_line_qty", line.quantity)
+                product = line.product_id.with_context(
+                    quantity=qty,
+                    pricelist=pricelist.id,
+                    partner=line.contract_id.partner_id.id,
+                    uom=line.uom_id.id,
+                    date=line.env.context.get(
+                        "old_date", fields.Date.context_today(line)
+                    ),
+                )
+                line.price_unit = pricelist._get_product_price(product, quantity=qty)
+            else:
+                line.price_unit = line.specific_price
+
+    # Tip in https://github.com/odoo/odoo/issues/23891#issuecomment-376910788
+    @api.onchange("price_unit")
+    def _inverse_price_unit(self):
+        for line in self.filtered(lambda x: not x.automatic_price):
+            line.specific_price = line.price_unit
+
+    @api.depends("quantity", "price_unit", "discount")
+    def _compute_price_subtotal(self):
+        for line in self:
+            subtotal = line.quantity * line.price_unit
+            subtotal *= 1 - (line.discount / 100)
+            cur = (
+                line.contract_id.pricelist_id.currency_id
+                if line.contract_id.pricelist_id
+                else None
+            )
+            line.price_subtotal = cur.round(subtotal) if cur else subtotal
+
+    # === Recurrence Field Synchronization ===
+
+    def _set_recurrence_field(self, field):
+        """Sync recurrence field from header or keep local depending on config."""
+        for record in self:
+            record[field] = (
+                record[field]
+                if record.contract_id.line_recurrence
+                else record.contract_id[field]
+            )
+
+    @api.depends("contract_id.recurring_rule_type", "contract_id.line_recurrence")
+    def _compute_recurring_rule_type(self):
+        self._set_recurrence_field("recurring_rule_type")
+
+    @api.depends("contract_id.recurring_invoicing_type", "contract_id.line_recurrence")
+    def _compute_recurring_invoicing_type(self):
+        self._set_recurrence_field("recurring_invoicing_type")
+
+    @api.depends("contract_id.recurring_interval", "contract_id.line_recurrence")
+    def _compute_recurring_interval(self):
+        self._set_recurrence_field("recurring_interval")
+
+    @api.depends("contract_id.date_start", "contract_id.line_recurrence")
+    def _compute_date_start(self):
+        self._set_recurrence_field("date_start")
+
+    @api.depends("contract_id.line_recurrence")
+    def _compute_recurring_next_date(self):
+        res = super()._compute_recurring_next_date()
+        self._set_recurrence_field("recurring_next_date")
+        return res
+
+    # === Constraints & Onchange ===
+
+    @api.constrains("discount")
+    def _check_discount(self):
+        for line in self:
+            if line.discount > 100:
+                raise ValidationError(
+                    self.env._("Discount should be less or equal to 100")
+                )

odoo/addons/contract/report/contract_views.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <odoo>
-
     <record id="report_contract" model="ir.actions.report">
         <field name="name">Contract</field>
         <field name="model">contract.contract</field>
@@ -10,5 +9,4 @@
         <field name="binding_model_id" ref="model_contract_contract" />
         <field name="binding_type">report</field>
     </record>
-
 </odoo>