[MIG] stock_available_to_promise_release: Migration to 18.0

Author: bizzappdev

stock_available_to_promise_release/__manifest__.py

@@ -3,12 +3,12 @@
 
 {
     "name": "Stock Available to Promise Release",
-    "version": "16.0.3.7.1",
+    "version": "18.0.1.0.0",
     "summary": "Release Operations based on available to promise",
     "author": "Camptocamp, BCIM, Odoo Community Association (OCA)",
     "website": "https://github.com/OCA/wms",
     "category": "Stock Management",
-    "depends": ["stock"],
+    "depends": ["stock", "stock_warehouse_out_pull"],
     "data": [
         "security/ir.model.access.csv",
         "views/product_product_views.xml",

stock_available_to_promise_release/hooks.py

@@ -5,17 +5,17 @@
 from openupgradelib import openupgrade
 
 from odoo import SUPERUSER_ID, api
-from odoo.tools import sql
+from odoo.tools.sql import column_exists
 
 _logger = logging.getLogger(__name__)
 
 
-def init_release_policy(cr):
-    if not sql.column_exists(cr, "stock_picking", "release_policy"):
+def init_release_policy(env):
+    if not column_exists(env.cr, "stock_picking", "release_policy"):
         # Use the default sql query instead relying on ORM as all records will
         # be updated.
         _logger.info("Creating 'release_policy' field on stock.picking")
-        env = api.Environment(cr, SUPERUSER_ID, {})
+        env = api.Environment(env.cr, SUPERUSER_ID, {})
         field_spec = [
             (
                 "release_policy",
@@ -30,23 +30,23 @@ def init_release_policy(cr):
         openupgrade.add_fields(env, field_spec=field_spec)
 
 
-def pre_init_hook(cr):
+def pre_init_hook(env):
     """create and initialize the date priority column on the stock move"""
-    if not sql.column_exists(cr, "stock_move", "date_priority"):
+    if not column_exists(env.cr, "stock_move", "date_priority"):
         _logger.info("Create date_priority column")
-        cr.execute(
+        env.cr.execute(
             """
             ALTER TABLE stock_move
             ADD COLUMN date_priority timestamp;
         """
         )
         _logger.info("Initialize date_priority field")
-        cr.execute(
+        env.cr.execute(
             """
             UPDATE stock_move
             SET date_priority = create_date
             where state not in ('done', 'cancel')
         """
         )
-        _logger.info(f"{cr.rowcount} rows updated")
-    init_release_policy(cr)
+        _logger.info(f"{env.cr.rowcount} rows updated")
+    init_release_policy(env)

stock_available_to_promise_release/migrations/16.0.2.0.0/post-migrate.py

@@ -10,10 +10,8 @@ class StockLocation(models.Model):
     def _get_available_to_promise_domain(self):
         location_domain = []
         for location in self:
-            location_domain = expression.OR(
-                [
-                    location_domain,
-                    [("location_id.parent_path", "=like", location.parent_path + "%")],
-                ]
+            paths_domain = expression.OR(
+                [[("parent_path", "=like", location.parent_path + "%")]]
             )
+            location_domain = [("location_id", "any", paths_domain)]
         return location_domain

stock_available_to_promise_release/migrations/16.0.3.1.0/post-migrate.py

@@ -111,7 +111,8 @@ def _in_progress_for_unrelease(self) -> StockMoveBase:
         if printed_pickings:
             return printed_pickings
         return unreleasable_moves.filtered(
-            lambda m: not m.rule_id.allow_unrelease_return_done_move and m.quantity_done
+            lambda m: not m.rule_id.allow_unrelease_return_done_move
+            and any(ml.quantity > 0 and ml.picked for ml in m.move_line_ids)
         )
 
     def _is_unrelease_allowed_on_origin_moves(self, origin_moves):
@@ -127,7 +128,7 @@ def _is_unrelease_allowed_on_origin_moves(self, origin_moves):
             )
         origin_qty_done = sum(
             m.product_uom._compute_quantity(
-                m.quantity_done,
+                m.quantity,
                 m.product_id.uom_id,
                 rounding_method="HALF-UP",
             )
@@ -136,7 +137,7 @@ def _is_unrelease_allowed_on_origin_moves(self, origin_moves):
         dest_done_moves = origin_done_moves.move_dest_ids
         dest_qty_done = sum(
             m.product_uom._compute_quantity(
-                m.quantity_done,
+                m.quantity,
                 m.product_id.uom_id,
                 rounding_method="HALF-UP",
             )
@@ -160,7 +161,7 @@ def _unrelease_not_allowed_error(self):
             forbidden_moves_by_picking = self.browse().concat(
                 *forbidden_moves_by_picking
             )
-            message += "\n\t- %s" % picking.name
+            message += f"\n\t- {picking.name}"
             forbidden_origin_pickings = self.picking_id.browse()
             for move in forbidden_moves_by_picking:
                 iterator = move._get_chained_moves_iterator("move_orig_ids")
@@ -288,7 +289,7 @@ def _group_by_warehouse(self):
 
     def _get_previous_promised_qties(self):
         self.env.flush_all()
-        self.env["stock.move.line"].flush_model(["move_id", "reserved_qty"])
+        self.env["stock.move.line"].flush_model(["move_id", "quantity"])
         self.env["stock.location"].flush_model(["parent_path"])
         previous_promised_qties = {}
         for warehouse, moves in self._group_by_warehouse():
@@ -396,7 +397,7 @@ def _get_ordered_available_to_promise_by_warehouse(self, warehouse):
             [[("product_id", "in", self.product_id.ids)], location_domain]
         )
         location_quants = self.env["stock.quant"].read_group(
-            domain_quant, ["product_id", "quantity"], ["product_id"], orderby="id"
+            domain_quant, ["product_id", "quantity"], ["product_id"]
         )
         quants_available = {
             item["product_id"][0]: item["quantity"] for item in location_quants
@@ -476,7 +477,7 @@ def _search_ordered_available_to_promise_uom_qty(self, operator, value):
     def _should_compute_ordered_available_to_promise(self):
         return (
             self.picking_code == "outgoing"
-            and not self.product_id.type == "consu"
+            and self.product_id.is_storable
             and not self.location_id.should_bypass_reservation()
         )
 
@@ -565,6 +566,7 @@ def _run_stock_rule(self):
         for move in released_moves:
             move._before_release()
             values = move._prepare_procurement_values()
+            values["move_dest_ids"] = self
             procurement_requests.append(
                 self.env["procurement.group"].Procurement(
                     move.product_id,
@@ -688,7 +690,6 @@ def _return_quantity_in_stock(self, qty_to_return_per_move):
             return_type = picking_type.return_picking_type_id
             wiz_values = {
                 "picking_id": fields.first(pickings).id,
-                "location_id": return_type.default_location_dest_id.id,
             }
             product_return_moves = []
             if not return_type:
@@ -717,7 +718,7 @@ def _return_quantity_in_stock(self, qty_to_return_per_move):
             if product_return_moves:
                 wiz_values["product_return_moves"] = product_return_moves
                 return_wiz = self.env["stock.return.picking"].create(wiz_values)
-                action = return_wiz.create_returns()
+                action = return_wiz.action_create_returns()
 
                 cancel_picking = self.picking_id.browse(action["res_id"])
                 # Do not copy the responsible user from the source picking as somebody
@@ -899,7 +900,9 @@ def _search_picking_for_assignation_domain(self):
 
     def _get_new_picking_values(self):
         values = super()._get_new_picking_values()
-        values["release_policy"] = values["move_type"]
+        # Ensure move_type exists in values before accessing it
+        if "move_type" in values:
+            values["release_policy"] = values["move_type"]
         return values
 
     def write(self, vals):
@@ -939,8 +942,9 @@ def _update_candidate_moves_list(self, candidate_moves):
             )
             for candidates in candidate_moves
         ]
-        # filter given list of moves to keep only the new ones
-        candidate_moves[:] = new_candidate_moves
+        # clear and update the candidate set
+        candidate_moves.clear()
+        candidate_moves.update(new_candidate_moves)
         return res
 
     def _merge_moves(self, merge_into=False):

stock_available_to_promise_release/migrations/16.0.3.1.0/pre-migrate.py

@@ -134,12 +134,7 @@ def release_available_to_promise(self):
     def _release_link_backorder(self, origin_picking):
         self.backorder_id = origin_picking
         origin_picking.message_post(
-            body=_(
-                "The backorder <a href=# data-oe-model=stock.picking"
-                " data-oe-id=%(id)s>%(name)s</a> has been created.",
-                name=self.name,
-                id=self.id,
-            )
+            body=_("The backorder %s has been created.") % self._get_html_link()
         )
 
     def _after_release_update_chain(self):

stock_available_to_promise_release/models/stock_location.py

@@ -17,21 +17,22 @@ def setUpClass(cls):
                 "reception_steps": "one_step",
                 "delivery_steps": "pick_ship",
                 "code": "WHTEST",
+                "delivery_pull": True,
             }
         )
         cls.loc_stock = cls.wh.lot_stock_id
         cls.loc_customer = cls.env.ref("stock.stock_location_customers")
         cls.product1 = cls.env["product.product"].create(
-            {"name": "Product 1", "type": "product"}
+            {"name": "Product 1", "type": "consu", "is_storable": True}
         )
         cls.product2 = cls.env["product.product"].create(
-            {"name": "Product 2", "type": "product"}
+            {"name": "Product 2", "type": "consu", "is_storable": True}
         )
         cls.product3 = cls.env["product.product"].create(
-            {"name": "Product 3", "type": "product"}
+            {"name": "Product 3", "type": "consu", "is_storable": True}
         )
         cls.product4 = cls.env["product.product"].create(
-            {"name": "Product 4", "type": "product"}
+            {"name": "Product 4", "type": "consu", "is_storable": True}
         )
         cls.uom_unit = cls.env.ref("uom.product_uom_unit")
         cls.partner_delta = cls.env.ref("base.res_partner_4")
@@ -141,9 +142,13 @@ def _deliver(cls, picking, product_qty=None):
         if product_qty:
             lines = picking.move_ids.move_line_ids
             for product, qty in product_qty:
-                line = lines.filtered(lambda m: m.product_id == product)
-                line.qty_done = qty
+                line = lines.filtered(
+                    lambda m, product=product: m.product_id == product
+                )
+                line.quantity = qty
+                line.is_inventory = True
+                line.picked = True
         else:
             for line in picking.mapped("move_ids.move_line_ids"):
-                line.qty_done = line.reserved_qty
+                line.picked = True
         picking._action_done()

stock_available_to_promise_release/models/stock_move.py

@@ -26,7 +26,6 @@ def setUpClass(cls):
         )
         cls.shipping1.release_available_to_promise()
         cls.picking1 = cls._prev_picking(cls.shipping1)
-        cls.picking1.action_assign()
 
     @classmethod
     def _out_picking(cls, pickings):
@@ -46,7 +45,7 @@ def _procure(self, qty):
         values = {
             "company_id": self.wh.company_id,
             "group_id": self.shipping1.group_id,
-            "date_planned": self.shipping1.move_ids.date,
+            "date_planned": self.shipping1.move_ids[0].date,
             "warehouse_id": self.wh,
         }
         self.env["procurement.group"].run(
@@ -111,7 +110,8 @@ def test_unrelease_at_move_merge_merged(self):
 
         # partially process the picking
         move = self.picking1.move_ids
-        move.move_line_ids.qty_done = 2
+        move._action_assign()
+        move.move_line_ids.quantity = 2
         # run a new procurement for the same product in the shipment 1
         self._procure(2)
 
@@ -126,7 +126,7 @@ def test_unrelease_at_move_merge_merged(self):
         # the pick should still contain a move with the processed qty
         # and the qty to do should be the one from shipping2
         move = self.picking1.move_ids.filtered(lambda m: m.state == "assigned")
-        self.assertEqual(2, move.move_line_ids.qty_done)
+        self.assertEqual(2, move.move_line_ids.quantity)
         self.assertEqual(5, move.product_uom_qty)
 
         # if we release the ship 1 again, a new move should be created
@@ -135,7 +135,7 @@ def test_unrelease_at_move_merge_merged(self):
         move = self.picking1.move_ids.filtered(lambda m: m.state == "assigned")
         self.assertEqual(1, len(move))
         self.assertEqual(2 + original_qty_1 + original_qty_2, move.product_uom_qty)
-        self.assertEqual(2, move.move_line_ids.qty_done)
+        self.assertEqual(2, move.move_line_ids.quantity)
 
     def test_default_merge(self):
         # check that the merge is still working when the available_to_promise_defer_pull