[18.0][MIG] sale_stock_mto_as_mts_orderpoint: Migration to 18.0

Author: chaule97

sale_stock_mto_as_mts_orderpoint/README.rst

@@ -37,10 +37,6 @@ by the stock rule linked to the standard MTO route or the MTO route is
 marked on the product, an orderpoint will be created on the Stock
 location of the warehouse, with min/max quantities of zero.
 
-This allows to regenerate procurement according to the
-procure_recommended_qty using module
-stock_orderpoint_manual_procurement.
-
 Finally, orderpoints with min/max quantities of zero will be archived if
 the MTO route is removed on the product.
 
@@ -86,6 +82,7 @@ Contributors
 Trobz:
 
 -  Dung Tran <[email protected]>
+-  Chau Le <[email protected]>
 
 Other credits
 -------------

sale_stock_mto_as_mts_orderpoint/__manifest__.py

@@ -3,15 +3,15 @@
 {
     "name": "Sale Stock Mto As Mts Orderpoint",
     "summary": "Materialize need from MTO route through orderpoint",
-    "version": "14.0.1.1.1",
+    "version": "18.0.1.0.0",
     "development_status": "Alpha",
     "category": "Operations/Inventory/Delivery",
     "website": "https://github.com/OCA/stock-logistics-workflow",
     "author": "Camptocamp, Odoo Community Association (OCA)",
     "license": "AGPL-3",
     "application": False,
     "installable": True,
-    "depends": ["sale_stock", "stock_orderpoint_manual_procurement"],
+    "depends": ["sale_stock", "purchase_stock"],
     "data": [
         "data/stock_data.xml",
         "views/stock_warehouse_views.xml",

sale_stock_mto_as_mts_orderpoint/data/stock_data.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <odoo noupdate="1">
-    <record id="stock.route_warehouse0_mto" model="stock.location.route">
+    <record id="stock.route_warehouse0_mto" model="stock.route">
         <field name="active" eval="True" />
     </record>
 </odoo>

sale_stock_mto_as_mts_orderpoint/migrations/14.0.1.1.0/post-migrate.py

@@ -2,4 +2,5 @@
 from . import product_product
 from . import sale_order
 from . import stock_move
+from . import stock_warehouse_orderpoint
 from . import stock_warehouse

sale_stock_mto_as_mts_orderpoint/models/__init__.py

@@ -29,11 +29,9 @@ def _template_is_not_mto(self):
         return not self._template_is_mto()
 
     def _filter_mto_products(self, mto=True):
-        mto_route = self.env.ref("stock.route_warehouse0_mto", raise_if_not_found=False)
         if mto:
             return self.filtered(lambda t: t._template_is_mto())
-        else:
-            return self.filtered(lambda t: t._template_is_not_mto())
+        return self.filtered(lambda t: t._template_is_not_mto())
 
     def _get_orderpoints_to_archive_domain(self):
         warehouses = self.env["stock.warehouse"].search([])

sale_stock_mto_as_mts_orderpoint/models/product_template.py

@@ -14,10 +14,11 @@ def _action_launch_stock_rule(self, previous_product_uom_qty=False):
         return res
 
     def _run_orderpoints_for_mto_products(self):
-        orderpoints_to_procure_ids = []
         mto_route = self.env.ref("stock.route_warehouse0_mto", raise_if_not_found=False)
         if not mto_route:
             return
+
+        orderpoints_to_procure_ids = []
         for line in self:
             delivery_moves = line.move_ids.filtered(
                 lambda m: m.picking_id.picking_type_code == "outgoing"
@@ -26,62 +27,73 @@ def _run_orderpoints_for_mto_products(self):
             for delivery_move in delivery_moves:
                 if (
                     not delivery_move.is_from_mto_route
-                    or line.product_id._variant_is_not_mto()
+                    and mto_route not in delivery_move.product_id.route_ids
                 ):
                     continue
                 if not delivery_move.warehouse_id.mto_as_mts:
                     continue
                 orderpoint = line._get_mto_orderpoint(delivery_move.product_id)
                 if orderpoint.procure_recommended_qty:
                     orderpoints_to_procure_ids.append(orderpoint.id)
-        wiz = (
-            self.env["make.procurement.orderpoint"]
-            .with_context(
-                **{
-                    "active_model": "stock.warehouse.orderpoint",
-                    "active_ids": orderpoints_to_procure_ids,
-                }
-            )
-            .create({})
+
+        orderpoints_to_procure = self.env["stock.warehouse.orderpoint"].browse(
+            orderpoints_to_procure_ids
         )
-        wiz.make_procurement()
+
+        procurements = []
+
+        for item in orderpoints_to_procure:
+            if not item.procure_recommended_qty:
+                continue
+            if item.product_uom.rounding <= 0:
+                continue
+
+            values = item._prepare_procurement_values()
+            values["date_planned"] = item.procure_recommended_date
+
+            procurements.append(
+                self.env["procurement.group"].Procurement(
+                    item.product_id,
+                    item.procure_recommended_qty,
+                    item.product_uom,
+                    item.location_id,
+                    item.name,
+                    item.name,
+                    item.company_id,
+                    values,
+                )
+            )
+
+        if procurements:
+            self.env["procurement.group"].run(procurements)
 
     def _get_mto_orderpoint(self, product_id):
         self.ensure_one()
         warehouse = self.warehouse_id or self.order_id.warehouse_id
-        orderpoint = (
-            self.env["stock.warehouse.orderpoint"]
-            .with_context(active_test=False)
-            .search(
-                [
-                    ("product_id", "=", product_id.id),
-                    (
-                        "location_id",
-                        "=",
-                        warehouse._get_locations_for_mto_orderpoints().id,
-                    ),
-                ],
-                limit=1,
-            )
+        location = warehouse._get_locations_for_mto_orderpoints()
+        orderpoint_model = self.env["stock.warehouse.orderpoint"].with_context(
+            active_test=False
         )
-        if orderpoint and not orderpoint.active:
-            orderpoint.write(
-                {"active": True, "product_min_qty": 0.0, "product_max_qty": 0.0}
-            )
-        elif not orderpoint:
-            orderpoint = (
-                self.env["stock.warehouse.orderpoint"]
-                .sudo()
-                .create(
-                    {
-                        "product_id": product_id.id,
-                        "warehouse_id": warehouse.id,
-                        "location_id": (
-                            warehouse._get_locations_for_mto_orderpoints().id
-                        ),
-                        "product_min_qty": 0.0,
-                        "product_max_qty": 0.0,
-                    }
+
+        orderpoint = orderpoint_model.search_fetch(
+            [("product_id", "=", product_id.id), ("location_id", "=", location.id)],
+            ["active"],
+            limit=1,
+        )
+
+        if orderpoint:
+            if not orderpoint.active:
+                orderpoint.write(
+                    {"active": True, "product_min_qty": 0.0, "product_max_qty": 0.0}
                 )
+        else:
+            orderpoint = orderpoint_model.sudo().create(
+                {
+                    "product_id": product_id.id,
+                    "warehouse_id": warehouse.id,
+                    "location_id": location.id,
+                    "product_min_qty": 0.0,
+                    "product_max_qty": 0.0,
+                }
             )
         return orderpoint

sale_stock_mto_as_mts_orderpoint/models/sale_order.py

@@ -12,6 +12,6 @@ def _compute_is_from_mto_route(self):
         mto_route = self.env.ref("stock.route_warehouse0_mto", raise_if_not_found=False)
         if not mto_route:
             self.update({"is_from_mto_route": False})
-        else:
-            for move in self:
-                move.is_from_mto_route = move.rule_id.route_id == mto_route
+            return
+        for move in self:
+            move.is_from_mto_route = move.rule_id.route_id == mto_route

sale_stock_mto_as_mts_orderpoint/models/stock_move.py

@@ -9,21 +9,25 @@ class StockWarehouse(models.Model):
     mto_as_mts = fields.Boolean(inverse="_inverse_mto_as_mts")
 
     def _get_locations_for_mto_orderpoints(self):
+        self.fetch(["lot_stock_id"])
         return self.mapped("lot_stock_id")
 
     def _inverse_mto_as_mts(self):
         mto_route = self.env.ref("stock.route_warehouse0_mto", raise_if_not_found=False)
         if not mto_route:
             return
-        for warehouse in self:
-            if warehouse.mto_as_mts:
-                wh_mto_rules = self.env["stock.rule"].search(
-                    [
-                        ("route_id", "=", mto_route.id),
-                        "|",
-                        ("warehouse_id", "=", warehouse.id),
-                        ("picking_type_id.warehouse_id", "=", warehouse.id),
-                    ]
-                )
-                if wh_mto_rules:
-                    wh_mto_rules.active = False
+
+        warehouses_with_mto = self.filtered("mto_as_mts")
+        if not warehouses_with_mto:
+            return
+
+        domain = [
+            ("route_id", "=", mto_route.id),
+            "|",
+            ("warehouse_id", "in", warehouses_with_mto.ids),
+            ("picking_type_id.warehouse_id", "in", warehouses_with_mto.ids),
+        ]
+
+        wh_mto_rules = self.env["stock.rule"].search(domain)
+        if wh_mto_rules:
+            wh_mto_rules.write({"active": False})

sale_stock_mto_as_mts_orderpoint/models/stock_warehouse.py

@@ -0,0 +1,87 @@
+# Copyright 2016-20 ForgeFlow S.L. (https://www.forgeflow.com)
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
+
+
+from odoo import api, fields, models
+from odoo.tools import float_compare, float_round
+
+
+class StockWarehouseOrderpoint(models.Model):
+    _inherit = "stock.warehouse.orderpoint"
+
+    procure_recommended_qty = fields.Float(
+        string="Procure Recommendation",
+        compute="_compute_procure_recommended",
+        digits="Product Unit of Measure",
+    )
+    procure_recommended_date = fields.Date(
+        string="Recommended Request Date", compute="_compute_procure_recommended"
+    )
+
+    def _get_procure_recommended_qty(self, virtual_qty, op_qtys):
+        self.ensure_one()
+
+        target_qty = max(self.product_min_qty, self.product_max_qty)
+        qty = target_qty - virtual_qty
+
+        if self.qty_multiple > 0:
+            remainder = qty % self.qty_multiple
+            if (
+                float_compare(
+                    remainder, 0.0, precision_rounding=self.product_uom.rounding
+                )
+                > 0
+            ):
+                qty += self.qty_multiple - remainder
+
+        if float_compare(qty, 0.0, precision_rounding=self.product_uom.rounding) <= 0:
+            return 0.0
+
+        qty -= op_qtys.get(self.id, 0.0)
+        qty_rounded = float_round(qty, precision_rounding=self.product_uom.rounding)
+
+        return qty_rounded if qty_rounded > 0 else 0.0
+
+    @api.depends("product_min_qty", "product_id", "qty_multiple")
+    def _compute_procure_recommended(self):
+        # '_quantity_in_progress' override in 'purchase_stock' method has not
+        # been designed to work with NewIds (resulting in KeyError exceptions).
+        # To circumvent this, we knowingly skip such records here.
+        ops = self.filtered("id")
+        # No need to call '_quantity_in_progress()' if there is no orderpoint,
+        # this leads to a heavy request done by a call to `read_group` with
+        # an empty domain on 'purchase.order.line' in the
+        # 'product.product._get_quantity_in_progress()' method.
+        op_qtys = ops._quantity_in_progress() if ops else {}
+
+        for op in self:
+            if not op.id:
+                op.update(
+                    {
+                        "procure_recommended_qty": False,
+                        "procure_recommended_date": False,
+                    }
+                )
+                continue
+
+            virtual_qty = op.with_context(
+                location=op.location_id.id
+            ).product_id.virtual_available
+
+            qty = 0.0
+            if (
+                float_compare(
+                    virtual_qty,
+                    op.product_min_qty,
+                    precision_rounding=op.product_uom.rounding or 0.01,
+                )
+                < 0
+            ):
+                qty = op._get_procure_recommended_qty(virtual_qty, op_qtys)
+
+            op.update(
+                {
+                    "procure_recommended_qty": qty,
+                    "procure_recommended_date": op.lead_days_date,
+                }
+            )