[FIX] stock_ux: return in the delivered move UoM on "Return All"

The core "Return All" button (action_create_returns_all) copies the
delivered quantity into a return line interpreted in the product's
reference UoM, while that quantity is expressed in the move UoM. When
they differ (e.g. with stock.propagate_uom enabled, which keeps
deliveries in the sale/purchase line UoM) the return came out with the
raw, unconverted number in the wrong unit.

Instead of converting to the reference UoM, make the return inherit the
UoM of the move it reverses, backporting the behaviour Odoo 19 already
ships: the return line UoM is computed from move_id.product_uom and the
return move is created in that unit. This keeps the return document in
the same unit as the delivery it reverts, avoids the round-up
over-return on products whose reference ratio is not exact, and does not
reintroduce the bug reversed once the module is ported to 19.

Change note:
El botón "Devolver todo" dejaba la devolución en una unidad de medida
distinta a la de la entrega cuando el producto se opera en una UdM
distinta a la de referencia (con "Propagar UdM" activo). Ahora la
devolución queda en la misma unidad que la entrega que revierte y
devuelve exactamente lo entregado, sin el redondeo que en algunos
productos devolvía de más.

Author: Juan Ignacio Carreras

stock_ux/models/stock_return_picking.py

@@ -2,7 +2,8 @@
 # For copyright and license notices, see __manifest__.py file in module root
 # directory
 ##############################################################################
-from odoo import fields, models
+from odoo import api, fields, models
+from odoo.tools.float_utils import float_round
 
 
 class StockReturnPicking(models.TransientModel):
@@ -15,3 +16,63 @@ def _create_return(self):
         picking = super()._create_return()
         picking.write({"note": self.reason})
         return picking
+
+    @api.model
+    def _prepare_stock_return_picking_line_vals_from_move(self, stock_move):
+        # `uom_id` pasa a computarse desde el movimiento (ver StockReturnPickingLine),
+        # así que no lo forzamos acá a la UdM de referencia del producto.
+        vals = super()._prepare_stock_return_picking_line_vals_from_move(stock_move)
+        vals.pop("uom_id", None)
+        return vals
+
+    def action_create_returns_all(self):
+        # Backport del comportamiento de la 19: "Devolver todo" hereda la UdM del
+        # movimiento que revierte, en vez de convertir a la UdM de referencia del
+        # producto. Así el remito de devolución queda en la misma unidad que la
+        # entrega (no contradice al remito que revierte), no hay redondeo hacia
+        # arriba (que en productos con ratio no exacto devolvía de más) y no se
+        # reintroduce el bug al portar a la 19, donde el core ya hace exactamente
+        # esto. El core de la 18 copiaba `stock_move.quantity` (en la UdM del
+        # movimiento) dentro de una línea interpretada en la UdM de referencia, por
+        # eso salía el número crudo sin convertir. Ver ticket 125517.
+        self.ensure_one()
+        for return_move in self.product_return_moves:
+            stock_move = return_move.move_id
+            if not stock_move or stock_move.state == "cancel" or stock_move.scrapped:
+                continue
+            quantity = stock_move.quantity
+            for move in stock_move.move_dest_ids:
+                if not move.origin_returned_move_id or move.origin_returned_move_id != stock_move:
+                    continue
+                quantity -= move.quantity
+            return_move.quantity = float_round(quantity, precision_rounding=stock_move.product_uom.rounding)
+        return self.action_create_returns()
+
+
+class StockReturnPickingLine(models.TransientModel):
+    _inherit = "stock.return.picking.line"
+
+    # En el core de la 18 `uom_id` es related a `product_id.uom_id` (UdM de
+    # referencia). Lo hacemos computado desde el movimiento para que la línea —y el
+    # movimiento de devolución que se crea a partir de ella— queden en la misma UdM
+    # que la entrega original, igual que en la 19. Ver ticket 125517.
+    uom_id = fields.Many2one(
+        "uom.uom",
+        string="Unit of Measure",
+        related=False,
+        store=False,
+        readonly=True,
+        compute="_compute_uom_id",
+    )
+
+    @api.depends("move_id.product_uom", "product_id.uom_id")
+    def _compute_uom_id(self):
+        for line in self:
+            line.uom_id = line.move_id.product_uom or line.product_id.uom_id
+
+    def _prepare_move_default_values(self, new_picking):
+        # el movimiento de devolución se crea en la UdM de la línea (heredada del
+        # movimiento original), no en la de referencia del producto.
+        vals = super()._prepare_move_default_values(new_picking)
+        vals["product_uom"] = self.uom_id.id
+        return vals

stock_ux/tests/__init__.py

@@ -1,2 +1,3 @@
 from . import test_mto_warehouse_propagation
 from . import test_stock_orderpoint_multiple_over_max
+from . import test_return_all_uom

stock_ux/tests/test_return_all_uom.py

@@ -0,0 +1,104 @@
+from odoo.tests import TransactionCase, tagged
+
+
+@tagged("post_install", "-at_install")
+class TestReturnAllUom(TransactionCase):
+    """ "Devolver todo" debe devolver en la UdM del movimiento entregado.
+
+    Backport del comportamiento de la 19: cuando la entrega está en una UdM
+    distinta a la de referencia del producto (p.ej. con `stock.propagate_uom`
+    activo, que deja las entregas en la UdM de la línea), la devolución hereda la
+    UdM del movimiento y devuelve exactamente lo entregado, sin convertir a la UdM
+    de referencia (que dejaba el remito en otra unidad y redondeaba de más). Ver
+    ticket 125517.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.uom_dozen = cls.env.ref("uom.product_uom_dozen")
+        cls.uom_unit = cls.env.ref("uom.product_uom_unit")
+        cls.stock_location = cls.env.ref("stock.stock_location_stock")
+        cls.customer_location = cls.env.ref("stock.stock_location_customers")
+        cls.picking_type_out = cls.env.ref("stock.picking_type_out")
+
+    def _deliver(self, product, uom, qty):
+        """Confirma y valida una entrega de `qty` en `uom`, devuelve el picking hecho."""
+        picking = self.env["stock.picking"].create(
+            {
+                "picking_type_id": self.picking_type_out.id,
+                "location_id": self.stock_location.id,
+                "location_dest_id": self.customer_location.id,
+                "move_ids": [
+                    (
+                        0,
+                        0,
+                        {
+                            "name": product.name,
+                            "product_id": product.id,
+                            "product_uom": uom.id,
+                            "product_uom_qty": qty,
+                            "location_id": self.stock_location.id,
+                            "location_dest_id": self.customer_location.id,
+                        },
+                    )
+                ],
+            }
+        )
+        picking.action_confirm()
+        move = picking.move_ids
+        move.quantity = qty
+        move.picked = True
+        picking._action_done()
+        self.assertEqual(move.state, "done")
+        self.assertEqual(move.product_uom, uom)
+        return picking
+
+    def _return_all(self, picking):
+        wizard = (
+            self.env["stock.return.picking"]
+            .with_context(active_id=picking.id, active_ids=picking.ids, active_model="stock.picking")
+            .create({})
+        )
+        action = wizard.action_create_returns_all()
+        return self.env["stock.picking"].browse(action["res_id"]).move_ids
+
+    def test_return_all_keeps_move_uom(self):
+        """Entrega en Unidades de un producto con referencia en Docenas -> la
+        devolución queda en Unidades (misma UdM que la entrega), no en Docenas.
+
+        Sin el fix el core copiaba el número crudo (24) interpretándolo en la UdM
+        de referencia, así que salían 24 Docenas.
+        """
+        product = self.env["product.product"].create(
+            {
+                "name": "Producto con referencia en docenas",
+                "is_storable": True,
+                "uom_id": self.uom_dozen.id,
+                "uom_po_id": self.uom_dozen.id,
+            }
+        )
+        picking = self._deliver(product, self.uom_unit, 24)
+        return_move = self._return_all(picking)
+        self.assertEqual(return_move.product_uom, self.uom_unit)
+        self.assertEqual(return_move.product_uom_qty, 24.0)
+
+    def test_return_all_no_overreturn_on_non_exact_ratio(self):
+        """Ratio no exacto: devolver 1 Unidad de un producto con referencia en
+        Docenas no debe devolver de más.
+
+        Convertir a Docenas redondeaba 1/12 hacia arriba (0,09 Docenas = 1,08
+        Unidades). Heredando la UdM del movimiento la devolución es 1 Unidad exacta.
+        """
+        product = self.env["product.product"].create(
+            {
+                "name": "Producto docenas ratio no exacto",
+                "is_storable": True,
+                "uom_id": self.uom_dozen.id,
+                "uom_po_id": self.uom_dozen.id,
+            }
+        )
+        picking = self._deliver(product, self.uom_unit, 1)
+        return_move = self._return_all(picking)
+        self.assertEqual(return_move.product_uom, self.uom_unit)
+        self.assertEqual(return_move.product_uom_qty, 1.0)