[IMP] account,sale: move amount_to_invoice computation to SO line

In 16.2, the amount to invoice was introduced to effectively compute the total receivable of a partner.
The goal was to take into account the confirmed SOs that are not invoiced yet, in order to trigger the partner's credit limit warning.
Since then:
- The total receivable of a partner = unpaid posted invoices + SOs amount to invoice.
- Where the amount to invoice = SO total - confirmed down payments.
The issue with that method is that we go against the Sales philosophy, which considers that a SOL (Sales Order Line) is invoiced as soon as the invoiced quantity (whatever the invoice status) equals the ordered quantity.
That can lead to incoherent situations.
For example:
Let's imagine a SO with 2 products:
- 3 desks at €100
- 5 chairs at €50.
We invoice 3 desks at 90€ because of a price change and 5 chairs at 50€.
Sales will consider the SO to be done ("nothing to invoice"), whereas Accounting consider that there's still €30 to invoice.
The bottom line is that:
- We should consider the amount to invoice per SOL and not per SO total.
- We should remain consistent with the Sales methodology, to avoid weird cases as demonstrated before.

task-3764582

Part-of: odoo#164963
Related: odoo/enterprise#62208
Related: odoo/upgrade#6425
Signed-off-by: William André (wan) <[email protected]>

Author: epictete

addons/account/models/account_move.py

@@ -1596,7 +1596,7 @@ def _compute_partner_credit_warning(self):
             move.partner_credit_warning = ''
             show_warning = move.state == 'draft' and \
                            move.move_type == 'out_invoice' and \
-                           move.company_id.account_use_credit_limit
+                           self.env.company.account_use_credit_limit
             if show_warning:
                 total_field = 'amount_total' if move.currency_id == move.company_currency_id else 'amount_total_company_currency'
                 current_amount = move.tax_totals[total_field]

addons/sale/models/res_partner.py

@@ -74,20 +74,22 @@ def _compute_credit_to_invoice(self):
         # EXTENDS 'account'
         super()._compute_credit_to_invoice()
         company = self.env.company
-        domain = [
+        if not company.account_use_credit_limit:
+            return
+
+        sale_orders = self.env['sale.order'].search([
             ('company_id', '=', company.id),
             ('partner_id', 'in', self.ids),
-            ('amount_to_invoice', '>', 0),
-            ('state', '=', 'sale')
-        ]
-
-        group = self.env['sale.order']._read_group(domain, ['partner_id', 'currency_id'], ['amount_to_invoice:sum'])
-        for partner, currency, amount_to_invoice_sum in group:
+            ('order_line', 'any', [('untaxed_amount_to_invoice', '>', 0)]),
+            ('state', '=', 'sale'),
+        ])
+        for (partner, currency), orders in sale_orders.grouped(lambda so: (so.partner_id, so.currency_id)).items():
+            amount_to_invoice_sum = sum(orders.mapped('amount_to_invoice'))
             credit_company_currency = currency._convert(
                 amount_to_invoice_sum,
                 company.currency_id,
                 company,
-                fields.Date.context_today(self)
+                fields.Date.context_today(self),
             )
             partner.credit_to_invoice += credit_company_currency
 

addons/sale/models/sale_order.py

@@ -220,7 +220,7 @@ def _rec_names_search(self):
     amount_untaxed = fields.Monetary(string="Untaxed Amount", store=True, compute='_compute_amounts', tracking=5)
     amount_tax = fields.Monetary(string="Taxes", store=True, compute='_compute_amounts')
     amount_total = fields.Monetary(string="Total", store=True, compute='_compute_amounts', tracking=4)
-    amount_to_invoice = fields.Monetary(string="Amount to invoice", store=True, compute='_compute_amount_to_invoice')
+    amount_to_invoice = fields.Monetary(string="Un-invoiced Balance", compute='_compute_amount_to_invoice')
     amount_invoiced = fields.Monetary(string="Already invoiced", compute='_compute_amount_invoiced')
 
     invoice_count = fields.Integer(string="Invoice Count", compute='_get_invoiced')
@@ -650,32 +650,26 @@ def _compute_tax_country_id(self):
             else:
                 record.tax_country_id = record.company_id.account_fiscal_country_id
 
-    @api.depends('invoice_ids.state', 'currency_id', 'amount_total')
+    @api.depends('order_line.amount_to_invoice')
     def _compute_amount_to_invoice(self):
-        for order in self:
-            # If the invoice status is 'Fully Invoiced' force the amount to invoice to equal zero and return early.
-            if order.invoice_status == 'invoiced':
-                order.amount_to_invoice = 0.0
-                continue
-
-            invoices = order.invoice_ids.filtered(lambda x: x.state == 'posted')
-            # Note: A negative amount can happen, since we can invoice more than the sales order amount.
-            # Care has to be taken when summing amount_to_invoice of multiple orders.
-            # E.g. consider one invoiced order with -100 and one uninvoiced order of 100: 100 + -100 = 0
-            order.amount_to_invoice = order.amount_total - invoices._get_sale_order_invoiced_amount(order)
+        if not self.env.company.account_use_credit_limit:
+            self.amount_to_invoice = 0.0
+        else:
+            for order in self:
+                order.amount_to_invoice = sum(order.order_line.mapped('amount_to_invoice'))
 
-    @api.depends('amount_total', 'amount_to_invoice')
+    @api.depends('order_line.amount_invoiced')
     def _compute_amount_invoiced(self):
         for order in self:
-            order.amount_invoiced = order.amount_total - order.amount_to_invoice
+            order.amount_invoiced = sum(order.order_line.mapped('amount_invoiced'))
 
     @api.depends('company_id', 'partner_id', 'amount_total')
     def _compute_partner_credit_warning(self):
         for order in self:
             order.with_company(order.company_id)
             order.partner_credit_warning = ''
             show_warning = order.state in ('draft', 'sent') and \
-                           order.company_id.account_use_credit_limit
+                           self.env.company.account_use_credit_limit
             if show_warning:
                 order.partner_credit_warning = self.env['account.move']._build_credit_warning_message(
                     order,

addons/sale/models/sale_order_line.py

@@ -243,6 +243,10 @@ class SaleOrderLine(models.Model):
         compute='_compute_qty_invoiced',
         digits='Product Unit of Measure',
         store=True)
+    qty_invoiced_posted = fields.Float(
+        string="Invoiced Quantity (posted)",
+        compute='_compute_qty_invoiced_posted',
+        digits='Product Unit of Measure')
     qty_to_invoice = fields.Float(
         string="Quantity To Invoice",
         compute='_compute_qty_to_invoice',
@@ -273,10 +277,16 @@ class SaleOrderLine(models.Model):
         string="Untaxed Invoiced Amount",
         compute='_compute_untaxed_amount_invoiced',
         store=True)
+    amount_invoiced = fields.Monetary(
+        string="Invoiced Amount",
+        compute='_compute_amount_invoiced')
     untaxed_amount_to_invoice = fields.Monetary(
         string="Untaxed Amount To Invoice",
         compute='_compute_untaxed_amount_to_invoice',
         store=True)
+    amount_to_invoice = fields.Monetary(
+        string="Amount to invoice",
+        compute='_compute_amount_to_invoice')
 
     # Technical computed fields for UX purposes (hide/make fields readonly, ...)
     product_type = fields.Selection(related='product_id.type', depends=['product_id'])
@@ -887,6 +897,23 @@ def _compute_qty_invoiced(self):
                         qty_invoiced -= invoice_line.product_uom_id._compute_quantity(invoice_line.quantity, line.product_uom)
             line.qty_invoiced = qty_invoiced
 
+    @api.depends('invoice_lines.move_id.state', 'invoice_lines.quantity')
+    def _compute_qty_invoiced_posted(self):
+        """
+        This method is almost identical to '_compute_qty_invoiced()'. The only difference lies in the fact that
+        for accounting purposes, we only want the quantities of the posted invoices.
+        We need a dedicated computation because the triggers are different and could lead to incorrect values for
+        'qty_invoiced' when computed together.
+        """
+        for line in self:
+            qty_invoiced_posted = 0.0
+            for invoice_line in line._get_invoice_lines():
+                if invoice_line.move_id.state == 'posted':
+                    qty_unsigned = invoice_line.product_uom_id._compute_quantity(invoice_line.quantity, line.product_uom)
+                    qty_signed = qty_unsigned * -invoice_line.move_id.direction_sign
+                    qty_invoiced_posted += qty_signed
+            line.qty_invoiced_posted = qty_invoiced_posted
+
     def _get_invoice_lines(self):
         self.ensure_one()
         if self._context.get('accrual_entry_date'):
@@ -973,6 +1000,18 @@ def _compute_untaxed_amount_invoiced(self):
                         amount_invoiced -= invoice_line.currency_id._convert(invoice_line.price_subtotal, line.currency_id, line.company_id, invoice_date)
             line.untaxed_amount_invoiced = amount_invoiced
 
+    @api.depends('invoice_lines', 'invoice_lines.price_total', 'invoice_lines.move_id.state')
+    def _compute_amount_invoiced(self):
+        for line in self:
+            amount_invoiced = 0.0
+            for invoice_line in line._get_invoice_lines():
+                invoice = invoice_line.move_id
+                if invoice.state == 'posted':
+                    invoice_date = invoice.invoice_date or fields.Date.context_today(self)
+                    amount_invoiced_unsigned = invoice_line.currency_id._convert(invoice_line.price_total, line.currency_id, line.company_id, invoice_date)
+                    amount_invoiced += amount_invoiced_unsigned * -invoice.direction_sign
+            line.amount_invoiced = amount_invoiced
+
     @api.depends('state', 'product_id', 'untaxed_amount_invoiced', 'qty_delivered', 'product_uom_qty', 'price_unit')
     def _compute_untaxed_amount_to_invoice(self):
         """ Total of remaining amount to invoice on the sale order line (taxes excl.) as
@@ -1021,6 +1060,20 @@ def _compute_untaxed_amount_to_invoice(self):
 
             line.untaxed_amount_to_invoice = amount_to_invoice
 
+    @api.depends('discount', 'price_total', 'product_uom_qty', 'qty_delivered', 'qty_invoiced_posted')
+    def _compute_amount_to_invoice(self):
+        if not self.company_id.account_use_credit_limit:
+            self.amount_to_invoice = 0.0
+        for line in self:
+            if line.product_uom_qty:
+                uom_qty_to_consider = line.qty_delivered if line.product_id.invoice_policy == 'delivery' else line.product_uom_qty
+                qty_to_invoice = uom_qty_to_consider - line.qty_invoiced_posted
+                unit_price_total = line.price_total / line.product_uom_qty
+                price_reduce = unit_price_total * (1 - (line.discount or 0.0) / 100.0)
+                line.amount_to_invoice = price_reduce * qty_to_invoice
+            else:
+                line.amount_to_invoice = 0.0
+
     @api.depends('order_id.partner_id', 'product_id')
     def _compute_analytic_distribution(self):
         for line in self:

addons/sale/tests/test_credit_limit.py

@@ -35,11 +35,10 @@ def test_credit_limit_multi_company(self):
         # multi-company setup
         company2 = self.company_data_2['company']
 
-        # Activate the Credit Limit feature and set a value for partner_a.
-        self.env.company.account_use_credit_limit = True
-        self.partner_a.credit_limit = 1000.0
+        # Activate the Credit Limit feature
+        company2.account_use_credit_limit = True
 
-        # Create and confirm a SO for another company
+        # Create and confirm a SO for that company
         sale_order = company2.env['sale.order'].create({
             'company_id': company2.id,
             'partner_id': self.partner_a.id,
@@ -56,6 +55,7 @@ def test_credit_limit_multi_company(self):
         sale_order.action_confirm()
 
         self.partner_a.invalidate_recordset(['credit', 'credit_to_invoice'])
+        self.assertEqual(self.partner_a.credit_to_invoice, 0.0)
         self.assertEqual(self.partner_a.with_company(company2).credit_to_invoice, 1000.0)
         partner_a_multi_company = self.partner_a.with_context(allowed_company_ids=[self.env.company.id, company2.id])
         self.assertEqual(partner_a_multi_company.credit_to_invoice, 0.0)

addons/sale/tests/test_sale_to_invoice.py

@@ -938,6 +938,7 @@ def test_amount_to_invoice_multiple_so(self):
         """ Testing creating two SOs with the same customer and invoicing them together. We have to ensure
             that the amount to invoice is correct for each SO.
         """
+        self.env.company.account_use_credit_limit = True
         sale_order_1 = self.env['sale.order'].create({
             'partner_id': self.partner_a.id,
             'order_line': [
@@ -976,6 +977,7 @@ def test_amount_to_invoice_one_line_multiple_so(self):
         """ Testing creating two SOs linked to the same invoice line. Drawback: the substracted
             amount to the amount_total will take both sale order into account.
         """
+        self.env.company.account_use_credit_limit = True
         sale_order_1 = self.env['sale.order'].create({
             'partner_id': self.partner_a.id,
             'order_line': [
@@ -1012,3 +1014,47 @@ def test_amount_to_invoice_one_line_multiple_so(self):
 
         self.assertEqual(sale_order_1.amount_to_invoice, -700.0)
         self.assertEqual(sale_order_2.amount_to_invoice, 0.0)
+
+    def test_amount_to_invoice_price_unit_change(self):
+        """
+        We check that the 'amount_to_invoice' relies only on the posted invoice quantity,
+        and is not affected by price changes that occurred during invoice creation.
+        """
+        self.env.company.account_use_credit_limit = True
+        so = self.env['sale.order'].create({
+            'partner_id': self.partner_a.id,
+            'partner_invoice_id': self.partner_a.id,
+            'partner_shipping_id': self.partner_a.id,
+            'pricelist_id': self.company_data['default_pricelist'].id,
+        })
+
+        sol_prod_deliver = self.env['sale.order.line'].create({
+            'product_id': self.company_data['product_order_no'].id,
+            'product_uom_qty': 5,
+            'order_id': so.id,
+            'tax_id': False,
+        })
+
+        so.action_confirm()
+        sol_prod_deliver.write({'qty_delivered': 5.0})
+
+        invoice_vals = self.env['sale.advance.payment.inv'].create({
+            'advance_payment_method': 'delivered',
+            'sale_order_ids': [Command.set(so.ids)],
+        }).create_invoices()
+
+        # Invoice is created in draft, which should impact 'qty_invoiced', but not 'amount_to_invoice'.
+        self.assertEqual(sol_prod_deliver.qty_invoiced, 5.0)
+        self.assertEqual(sol_prod_deliver.amount_to_invoice, sol_prod_deliver.price_total)
+        self.assertEqual(sol_prod_deliver.amount_invoiced, 0.0)
+
+        # Then we change the 'price_unit' on the invoice (keeping the quantity untouched).
+        invoice = self.env[invoice_vals['res_model']].browse(invoice_vals['res_id'])
+        invoice.invoice_line_ids.price_unit /= 2
+        invoice.action_post()
+
+        # In the end, the 'amount_to_invoice' should be 0.0, since all quantities have been invoiced,
+        # even if the price was changed manually on the invoice.
+        self.assertEqual(sol_prod_deliver.qty_invoiced, 5.0)
+        self.assertEqual(sol_prod_deliver.amount_to_invoice, 0.0)
+        self.assertEqual(sol_prod_deliver.amount_invoiced, sol_prod_deliver.price_total / 2)

addons/sale/views/sale_order_views.xml

@@ -156,7 +156,6 @@
                     decoration-warning="invoice_status == 'upselling'"
                     widget="badge"
                     optional="show"/>
-                <field name="amount_to_invoice" optional="hide"/>
                 <field name="client_order_ref" optional="hide"/>
                 <field name="validity_date" optional="hide"/>
             </list>
@@ -196,9 +195,6 @@
             <field name="invoice_status" position="attributes">
                 <attribute name="optional">hide</attribute>
             </field>
-            <field name="amount_to_invoice" position="attributes">
-                <attribute name="column_invisible">1</attribute>
-            </field>
         </field>
     </record>