[FIX] purchase_ux: complete the pending criterion in purchase matching

The lines offered by the 'Match purchase lines' button were filtered
with product_qty > qty_invoiced for every document type, which misses
three cases. The first two were already fixed on 18.0 and never reached
this branch.

* Credit notes: product_qty does not drop with a return, so a fully
  billed line with a pending credit gave 0 and was hidden. Use
  qty_to_invoice < 0 on in_refund.

* Over receipt on bills: when the vendor delivers more than ordered the
  line ends up fully ordered but not fully billed (ordered 40, received
  41, billed 40), and the quantity left to bill was hidden. Add
  qty_to_invoice > 0 as a second term, the same criterion the native
  view uses. The first term is still needed for a confirmed purchase
  order with no receipt yet, where qty_to_invoice is 0 on products
  controlled on received quantities.

* Orders set as 'Nothing to Bill': the matching view already excludes
  orders forced as 'No Bill to Receive', but not the other forced
  status, even though both mean the order is closed for billing.
  Exclude any forced invoice status.

Add tests for the bill criterion (no receipt, partial receipt, over
receipt, fully billed, forced status) and for the credit note one
(pending refund from a return, return already credited).

Author: mav-adhoc

purchase_ux/models/account_move.py

@@ -3,6 +3,7 @@
 # directory
 ##############################################################################
 from odoo import fields, models
+from odoo.tools import float_compare
 
 
 class AccountMove(models.Model):
@@ -100,7 +101,9 @@ def action_purchase_matching(self):
                 else c
                 for c in res.get("domain", [])
             ]
-            # Show only POLs where ordered qty > invoiced qty (fully invoiced lines excluded).
+            # Show only POLs with something pending: on a bill, ordered qty not billed yet or qty
+            # pending to bill (an over receipt is fully ordered but not fully billed); on a credit
+            # note, the pending refund left by a return on an already fully billed line.
             all_pols = self.env["purchase.order.line"].search(
                 [
                     ("partner_id", "in", commercial_partner.ids),
@@ -109,9 +112,20 @@ def action_purchase_matching(self):
             )
             # exclude POLs already matched to a line in this bill (qty_invoiced ignores drafts)
             already_matched = set(self.invoice_line_ids.filtered("purchase_line_id").mapped("purchase_line_id").ids)
-            pending_pol_ids = all_pols.filtered(
-                lambda p: p.product_qty > p.qty_invoiced and p.id not in already_matched
-            ).ids
+            is_refund = self.move_type == "in_refund"
+            uom_precision = self.env["decimal.precision"].precision_get("Product Unit of Measure")
+
+            def _pending(pol):
+                if pol.id in already_matched:
+                    return False
+                if is_refund:
+                    return float_compare(pol.qty_to_invoice, 0.0, precision_digits=uom_precision) < 0
+                return (
+                    float_compare(pol.product_qty, pol.qty_invoiced, precision_digits=uom_precision) > 0
+                    or float_compare(pol.qty_to_invoice, 0.0, precision_digits=uom_precision) > 0
+                )
+
+            pending_pol_ids = all_pols.filtered(_pending).ids
             domain = list(res.get("domain") or [])
             domain += ["|", ("pol_id", "=", False), ("pol_id", "in", pending_pol_ids)]
             res["domain"] = domain

purchase_ux/models/purchase_bill_line_match.py

@@ -39,12 +39,13 @@ def _compute_reference_description(self):
 
     @property
     def _table_query(self):
+        # any forced invoice status closes the order for billing, also 'no' (nothing to bill)
         return SQL(
             """
             SELECT base.* FROM (%s) AS base
             WHERE base.purchase_order_id IS NULL
                OR base.purchase_order_id NOT IN (
-                   SELECT id FROM purchase_order WHERE force_invoiced_status = 'invoiced'
+                   SELECT id FROM purchase_order WHERE force_invoiced_status IS NOT NULL
                )
             """,
             super()._table_query,

purchase_ux/tests/__init__.py

@@ -3,4 +3,5 @@
 # directory
 ##############################################################################
 
+from . import test_purchase_matching
 from . import test_purchase_order

purchase_ux/tests/test_purchase_matching.py

@@ -0,0 +1,98 @@
+##############################################################################
+# For copyright and license notices, see __manifest__.py file in module root
+# directory
+##############################################################################
+from odoo import Command, fields
+from odoo.addons.account.tests.common import AccountTestInvoicingCommon
+from odoo.tests import tagged
+
+
+@tagged("post_install", "-at_install")
+class TestPurchaseMatching(AccountTestInvoicingCommon):
+    """Lines offered by the purchase matching action, ordered/received/billed."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        # forcing the invoice status of a PO is restricted to settings managers
+        cls.env.user.group_ids |= cls.env.ref("base.group_system")
+        cls.vendor = cls.env["res.partner"].create({"name": "Test Vendor Matching"})
+        # a service controlled on received quantities lets us set qty_received by hand
+        cls.product = cls.env["product.product"].create(
+            {
+                "name": "Test Service On Received",
+                "type": "service",
+                "purchase_method": "receive",
+            }
+        )
+
+    def _line(self, ordered, received=0.0, forced=False):
+        purchase = self.env["purchase.order"].create(
+            {
+                "partner_id": self.vendor.id,
+                "order_line": [
+                    Command.create({"product_id": self.product.id, "product_qty": ordered, "price_unit": 100.0})
+                ],
+            }
+        )
+        purchase.button_confirm()
+        purchase.order_line.qty_received = received
+        purchase.force_invoiced_status = forced
+        return purchase.order_line
+
+    def _bill(self, line, quantity, move_type="in_invoice"):
+        self.env["account.move"].create(
+            {
+                "move_type": move_type,
+                "partner_id": self.vendor.id,
+                "invoice_date": fields.Date.today(),
+                "invoice_line_ids": [
+                    Command.create(
+                        {
+                            "product_id": self.product.id,
+                            "quantity": quantity,
+                            "price_unit": 100.0,
+                            "purchase_line_id": line.id,
+                            "tax_ids": False,
+                        }
+                    )
+                ],
+            }
+        ).action_post()
+
+    def _offered(self, move_type="in_invoice"):
+        move = self.env["account.move"].create({"move_type": move_type, "partner_id": self.vendor.id})
+        action = move.action_purchase_matching()
+        self.env.flush_all()  # the matching model is a SQL view read from the database
+        return self.env["purchase.bill.line.match"].search(action["domain"]).pol_id
+
+    def test_bill_not_received(self):
+        self.assertIn(self._line(100), self._offered())
+
+    def test_bill_partially_received(self):
+        self.assertIn(self._line(100, received=60), self._offered())
+
+    def test_bill_over_receipt(self):
+        line = self._line(40, received=41)
+        self._bill(line, 40)
+        self.assertIn(line, self._offered())
+
+    def test_bill_fully_billed(self):
+        line = self._line(100, received=100)
+        self._bill(line, 100)
+        self.assertNotIn(line, self._offered())
+
+    def test_bill_forced_invoiced_status(self):
+        for forced in ("invoiced", "no"):
+            self.assertNotIn(self._line(100, forced=forced), self._offered())
+
+    def test_refund_pending_from_return(self):
+        line = self._line(600, received=500)
+        self._bill(line, 600)
+        self.assertIn(line, self._offered(move_type="in_refund"))
+
+    def test_refund_already_credited(self):
+        line = self._line(600, received=500)
+        self._bill(line, 600)
+        self._bill(line, 100, move_type="in_refund")
+        self.assertNotIn(line, self._offered(move_type="in_refund"))