stock_available_to_promise_release: Allow unrelease processed qties

Author: mmequignon

stock_available_to_promise_release/models/stock_location_route.py

@@ -7,6 +7,14 @@
 class Route(models.Model):
     _inherit = "stock.location.route"
 
+    allow_unrelease_on_cancel = fields.Boolean(
+        string="Reverse done transfer on cancellation",
+        default=False,
+        help=(
+            "If checked, this option will create new inverse internal operations "
+            "on done internal operations"
+        ),
+    )
     available_to_promise_defer_pull = fields.Boolean(
         string="Release based on Available to Promise",
         default=False,

stock_available_to_promise_release/models/stock_move.py

@@ -100,8 +100,14 @@ def _is_unrelease_allowed_on_origin_moves(self, origin_moves):
             # The picking is printed, we can't unrelease the move
             # because the processing of the origin moves is started.
             return False
+        # If allow_unrelease_on_cancel is not checked, only release assigned/waiting
+        # moves. If checked, also unrelease done moves.
+        if self.rule_id.allow_unrelease_on_cancel:
+            unreleasable_states = ("cancel",)
+        else:
+            unreleasable_states = ("done", "cancel")
         origin_moves = origin_moves.filtered(
-            lambda m: m.state not in ("done", "cancel")
+            lambda m: m.state not in unreleasable_states
         )
         origin_qty_todo = sum(origin_moves.mapped("product_qty"))
         return (
@@ -591,6 +597,39 @@ def _get_chained_moves_iterator(self, chain_field):
             yield moves
             moves = moves.mapped(chain_field)
 
+    def _return_quantity_in_stock(self, quantity_to_return):
+        picking = self.picking_id
+        picking.ensure_one()
+
+        returned_quantity = 0
+        # create return
+        return_type = picking.picking_type_id.return_picking_type_id
+        wiz_values = {
+            "picking_id": picking.id,
+            "original_location_id": picking.location_dest_id.id,
+            "location_id": return_type.default_location_dest_id.id,
+        }
+        product_return_moves = []
+        for move in self:
+            if not move.state == "done":
+                continue
+            move_qty = min(quantity_to_return, move.quantity_done)
+            return_move_vals = {
+                "product_id": move.product_id.id,
+                "quantity": move_qty,
+                "uom_id": move.product_id.uom_id.id,
+                "move_id": move.id,
+            }
+            product_return_moves.append((0, 0, return_move_vals))
+            returned_quantity += move_qty
+            if returned_quantity == quantity_to_return:
+                break
+        if product_return_moves:
+            wiz_values["product_return_moves"] = product_return_moves
+            return_wiz = self.env["stock.return.picking"].create(wiz_values)
+            return_wiz.create_returns()
+        return returned_quantity
+
     def unrelease(self, safe_unrelease=False):
         """Unrelease unreleasavbe moves
 
@@ -605,13 +644,22 @@ def unrelease(self, safe_unrelease=False):
         impacted_picking_ids = set()
 
         for move in moves_to_unrelease:
+            # When a move is returned, it is going straight to WH/Stock,
+            # skipping all intermediate zones (pick/pack).
+            # That is why we need to keep track of qty returned along the way.
+            # We do not want to return the same goods at each step.
+            # At a given step (pick/pack/ship), qty to return is
+            # move.product_uom_qty - cancelled_qty_at_step - already returned qties
+            qty_to_unrelease = move.product_uom_qty
+            qty_returned_for_move = 0
             iterator = move._get_chained_moves_iterator("move_orig_ids")
             moves_to_cancel = self.env["stock.move"]
             # backup procure_method as when you don't propagate cancel, the
             # destination move is forced to make_to_stock
             procure_method = move.procure_method
             next(iterator)  # skip the current move
             for origin_moves in iterator:
+                done_moves = origin_moves.filtered(lambda m: m.state == "done")
                 origin_moves = origin_moves.filtered(
                     lambda m: m.state not in ("done", "cancel")
                 )
@@ -622,6 +670,30 @@ def unrelease(self, safe_unrelease=False):
                     origin_moves.write({"propagate_cancel": False})
                     # origin_moves._action_cancel()
                     moves_to_cancel |= origin_moves
+                # checking that for the current step (pick/pack/ship)
+                # move.product_uom_qty == step.cancelled_qty + move.returned_quanty
+                # If not the case, we have to move back goods in stock.
+                qty_cancelled_at_step = sum(origin_moves.mapped("product_uom_qty"))
+                qty_to_return_at_step = (
+                    qty_to_unrelease - qty_cancelled_at_step - qty_returned_for_move
+                )
+                # TODO check move.rule_id.allow_unrelease_on_cancel ?
+                if not qty_to_return_at_step:
+                    continue
+                # Multiple pickings can satisfy a move
+                # -> len(move.move_orig_ids.picking_id) > 1
+                # Group done_moves per picking, and create returns
+                groups_iterator = groupby(done_moves, key=lambda m: m.picking_id)
+                for __, moves_list in groups_iterator:
+                    moves_to_return = self.browse([move.id for move in moves_list])
+                    returned_qty = moves_to_return._return_quantity_in_stock(
+                        qty_to_return_at_step
+                    )
+                    qty_returned_for_move += returned_qty
+                    qty_to_return_at_step -= returned_qty
+                    if qty_to_return_at_step == 0:
+                        break
+
             moves_to_cancel._action_cancel()
             # restore the procure_method overwritten by _action_cancel()
             move.procure_method = procure_method

stock_available_to_promise_release/models/stock_rule.py

@@ -14,6 +14,10 @@ class StockRule(models.Model):
         related="route_id.available_to_promise_defer_pull", store=True
     )
 
+    allow_unrelease_on_cancel = fields.Boolean(
+        related="route_id.allow_unrelease_on_cancel", store=True
+    )
+
     no_backorder_at_release = fields.Boolean(
         related="route_id.no_backorder_at_release", store=True
     )

stock_available_to_promise_release/tests/common.py

@@ -128,8 +128,18 @@ def _out_picking(cls, pickings):
         return pickings.filtered(lambda r: r.picking_type_code == "outgoing")
 
     @classmethod
-    def _deliver(cls, picking):
+    def _get_backorder_for_pickings(cls, pickings):
+        return cls.env["stock.picking"].search([("backorder_id", "in", pickings.ids)])
+
+    @classmethod
+    def _deliver(cls, picking, product_qty=None):
         picking.action_assign()
-        for line in picking.mapped("move_lines.move_line_ids"):
-            line.qty_done = line.product_uom_qty
+        if product_qty:
+            lines = picking.move_lines.move_line_ids
+            for product, qty in product_qty:
+                line = lines.filtered(lambda m: m.product_id == product)
+                line.qty_done = qty
+        else:
+            for line in picking.mapped("move_lines.move_line_ids"):
+                line.qty_done = line.product_uom_qty
         picking._action_done()

stock_available_to_promise_release/tests/test_unrelease_cancel.py

@@ -0,0 +1,136 @@
+# Copyright 2025 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+from datetime import datetime
+
+from .common import PromiseReleaseCommonCase
+
+
+class TestAvailableToPromiseReleaseCancel(PromiseReleaseCommonCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        cls.wh.delivery_steps = "pick_pack_ship"
+        cls._update_qty_in_location(cls.loc_bin1, cls.product1, 15.0)
+
+        delivery_route = cls.wh.delivery_route_id
+        ship_rule = delivery_route.rule_ids.filtered(
+            lambda r: r.location_id == cls.loc_customer
+        )
+        cls.loc_output = ship_rule.location_src_id
+        pack_rule = delivery_route.rule_ids.filtered(
+            lambda r: r.location_id == cls.loc_output
+        )
+        cls.loc_pack = pack_rule.location_src_id
+        pick_rule = delivery_route.rule_ids.filtered(
+            lambda r: r.location_id == cls.loc_pack
+        )
+        cls.pick_type = pick_rule.picking_type_id
+        cls.pack_type = pack_rule.picking_type_id
+
+        cls.picking_chain = cls._create_picking_chain(
+            cls.wh, [(cls.product1, 10)], date=datetime(2019, 9, 2, 16, 0)
+        )
+        cls.ship_picking = cls._out_picking(cls.picking_chain)
+        cls.pack_picking = cls._prev_picking(cls.ship_picking)
+        cls.pick_picking = cls._prev_picking(cls.pack_picking)
+
+        # Why is this not working when creating picking after enabling this setting?
+        delivery_route.write(
+            {
+                "available_to_promise_defer_pull": True,
+                "allow_unrelease_on_cancel": True,
+            }
+        )
+        cls.ship_picking.release_available_to_promise()
+        cls.cleanup_type = cls.env["stock.picking.type"].create(
+            {
+                "name": "Cancel Cleanup",
+                "default_location_dest_id": cls.loc_stock.id,
+                "sequence_code": "CCP",
+                "code": "internal",
+            }
+        )
+        cls.pick_type.return_picking_type_id = cls.cleanup_type
+        cls.pack_type.return_picking_type_id = cls.cleanup_type
+
+    @classmethod
+    def _get_cleanup_picking(cls):
+        return cls.env["stock.picking"].search(
+            [("picking_type_id", "=", cls.cleanup_type.id)]
+        )
+
+    def test_unrelease_picked(self):
+        # In this case, we should get 1 return picking from
+        # WH/PACK to WH/STOCK
+        self._deliver(self.pick_picking)
+        self.ship_picking.unrelease()
+        self.assertTrue(self.ship_picking.need_release)
+        self.assertEqual(self.pack_picking.state, "cancel")
+        self.assertEqual(self.pick_picking.state, "done")
+        cancel_picking = self._get_cleanup_picking()
+        self.assertEqual(len(cancel_picking), 1)
+        self.assertEqual(cancel_picking.location_id, self.loc_pack)
+        self.assertEqual(cancel_picking.location_dest_id, self.loc_stock)
+
+    def test_unrelease_packed(self):
+        # In this case, we should get 1 return picking from
+        # WH/OUT to WH/STOCK
+        self._deliver(self.pick_picking)
+        self._deliver(self.pack_picking)
+        self.ship_picking.unrelease()
+        self.assertTrue(self.ship_picking.need_release)
+        self.assertEqual(self.pack_picking.state, "done")
+        self.assertEqual(self.pick_picking.state, "done")
+        cancel_picking = self._get_cleanup_picking()
+        self.assertEqual(len(cancel_picking), 1)
+        self.assertEqual(cancel_picking.location_id, self.loc_output)
+        self.assertEqual(cancel_picking.location_dest_id, self.loc_stock)
+
+    def test_unrelease_picked_partial(self):
+        qty_picked = [(self.product1, 5.0)]
+        self._deliver(self.pick_picking, product_qty=qty_picked)
+        pick_backorder = self._get_backorder_for_pickings(self.pick_picking)
+        self.assertTrue(pick_backorder)
+        self.ship_picking.unrelease()
+        self.assertTrue(self.ship_picking.need_release)
+        self.assertEqual(self.pack_picking.state, "cancel")
+        self.assertEqual(self.pick_picking.state, "done")
+        cancel_picking = self._get_cleanup_picking()
+        # In the end, we cancelled 5 units for the pick backorder, and returned
+        # 5 units from pack -> stock
+        self.assertEqual(pick_backorder.state, "cancel")
+        self.assertEqual(cancel_picking.location_id, self.loc_pack)
+        self.assertEqual(cancel_picking.location_dest_id, self.loc_stock)
+        self.assertEqual(cancel_picking.move_lines.product_uom_qty, 5.0)
+
+    def test_unrelease_packed_partial(self):
+        self._deliver(self.pick_picking)
+        qty_packed = [(self.product1, 5.0)]
+        self._deliver(self.pack_picking, product_qty=qty_packed)
+        pack_backorder = self._get_backorder_for_pickings(self.pack_picking)
+        self.assertTrue(pack_backorder)
+        self.ship_picking.unrelease()
+        self.assertTrue(self.ship_picking.need_release)
+        self.assertEqual(self.pack_picking.state, "done")
+        self.assertEqual(self.pick_picking.state, "done")
+        cancel_pickings = self._get_cleanup_picking()
+        self.assertEqual(len(cancel_pickings), 2)
+        # In the end, we cancelled 5 units for the pack backorder, returned
+        # 5 units from pack -> stock, and 5 units from output -> stock
+        pack_cancel = cancel_pickings.filtered(lambda p: p.location_id == self.loc_pack)
+        ship_cancel = cancel_pickings.filtered(
+            lambda p: p.location_id == self.loc_output
+        )
+        self.assertEqual(pack_cancel.move_lines.product_uom_qty, 5.0)
+        self.assertEqual(ship_cancel.move_lines.product_uom_qty, 5.0)
+
+    def test_unrelease_shipped(self):
+        self._deliver(self.pick_picking)
+        self._deliver(self.pack_picking)
+        self._deliver(self.ship_picking)
+        self.ship_picking.unrelease()
+        # Did nothing
+        self.assertEqual(self.ship_picking.state, "done")
+        self.assertEqual(self.pack_picking.state, "done")
+        self.assertEqual(self.pick_picking.state, "done")

stock_available_to_promise_release/views/stock_location_route_views.xml

@@ -7,6 +7,7 @@
         <field name="arch" type="xml">
             <xpath expr="//group/field[@name='company_id']" position="after">
                 <field name="available_to_promise_defer_pull" />
+                <field name="allow_unrelease_on_cancel" />
                 <field name="no_backorder_at_release" />
             </xpath>
         </field>