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

Two cases were still wrong in the lines offered by the 'Match purchase
lines' button:

* Over receipt: when the vendor delivers more than ordered, the line
  ends up fully ordered but not fully billed (ordered 40, received 41,
  billed 40). The bill criterion product_qty > qty_invoiced gives False
  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.

* Forced invoice status: a purchase order set as 'No Bill to Receive' /
  'Nothing to Bill' kept offering its lines, because neither the filter
  nor the native view look at force_invoiced_status. Exclude them, on
  bills and on credit notes: the user already declared that order as
  nothing left to bill.

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

@@ -95,12 +95,14 @@ def action_purchase_matching(self):
             res["context"] = ctx
             # Show POLs with something pending, with a different criterion per document type:
             # * on a bill (in_invoice): ordered qty not billed yet (product_qty > qty_invoiced),
-            #   received or not. qty_to_invoice cannot be used here because on products
-            #   controlled on received quantities it is qty_received - qty_invoiced, so a
+            #   received or not, or qty pending to bill (qty_to_invoice > 0) for an over receipt,
+            #   fully ordered but not fully billed. qty_to_invoice cannot be used alone because on
+            #   products controlled on received quantities it is qty_received - qty_invoiced, so a
             #   confirmed PO with no receipt yet gives 0 and the line would be hidden.
             # * on a credit note (in_refund): lines left with a pending refund by a return,
             #   ie. billed more than received (qty_to_invoice < 0). product_qty cannot be used
             #   here because it does not drop with a return, so a fully billed line gives 0.
+            # POs with a forced invoice status are excluded: nothing left to bill on them.
             all_pols = self.env["purchase.order.line"].search(
                 [
                     ("partner_id", "in", (self.partner_id | self.partner_id.commercial_partner_id).ids),
@@ -113,11 +115,14 @@ def action_purchase_matching(self):
             uom_precision = self.env["decimal.precision"].precision_get("Product Unit of Measure")
 
             def _pending(pol):
-                if pol.id in already_matched:
+                if pol.id in already_matched or pol.order_id.force_invoiced_status:
                     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
+                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 [])

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,97 @@
+##############################################################################
+# 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.groups_id |= 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):
+        self.assertNotIn(self._line(100, forced="invoiced"), 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"))