shopfloor checkout: scan line better messages

Author: mmequignon

shopfloor/actions/message.py

@@ -560,11 +560,9 @@ def place_in_location_ask_confirmation(self, location_name):
             "body": _("Place it in {}?").format(location_name),
         }
 
-    def product_not_found_in_current_picking(self):
-        return {
-            "message_type": "error",
-            "body": _("Product is not in the current transfer."),
-        }
+    def product_not_found_in_current_picking(self, product):
+        body = _("Product {} is not in the current transfer.").format(product.name)
+        return {"message_type": "error", "body": body}
 
     def lot_mixed_package_scan_package(self):
         return {

shopfloor/services/checkout.py

@@ -471,21 +471,31 @@ def scan_line(self, picking_id, barcode, confirm_pack_all=False, confirm_lot=Non
             return self._response_for_summary(picking)
 
         # Search of the destination package
-        search_result = self._scan_line_find(picking, barcode)
-        result_handler = getattr(self, "_select_lines_from_" + search_result.type)
-        kw = {"confirm_pack_all": confirm_pack_all, "confirm_lot": confirm_lot}
-        return result_handler(picking, selection_lines, search_result.record, **kw)
+        handlers = {
+            "package": self._select_lines_from_package,
+            "product": self._select_lines_from_product,
+            "packaging": self._select_lines_from_packaging,
+            "lot": self._select_lines_from_lot,
+            "serial": self._select_lines_from_serial,
+            "delivery_packaging": self._select_lines_from_delivery_packaging,
+            "none": self._select_lines_from_none,
+        }
+        search_result = self._scan_line_find(picking, barcode, handlers.keys())
+        # setting scanned record as kwarg in order to make better logs.
+        # The reason for this is that from a product we might select various records
+        # and lose track of what was initially scanned. This forces us to display
+        # standard messages that might have no meaning for the user.
+        kwargs = {
+            "confirm_pack_all": confirm_pack_all,
+            "confirm_lot": confirm_lot,
+            "scanned_record": search_result.record,
+            "barcode": barcode,
+        }
+        handler = handlers.get(search_result.type, self._select_lines_from_none)
+        return handler(picking, selection_lines, search_result.record, **kwargs)
 
-    def _scan_line_find(self, picking, barcode, search_types=None):
+    def _scan_line_find(self, picking, barcode, search_types):
         search = self._actions_for("search")
-        search_types = (
-            "package",
-            "product",
-            "packaging",
-            "lot",
-            "serial",
-            "delivery_packaging",
-        )
         return search.find(
             barcode,
             types=search_types,
@@ -508,15 +518,14 @@ def _select_lines_from_package(
             lambda l: l.package_id == package and not l.shopfloor_checkout_done
         )
         if not lines:
-            return self._response_for_select_line(
-                picking,
-                message={
-                    "message_type": "error",
-                    "body": _("Package {} is not in the current transfer.").format(
-                        package.name
-                    ),
-                },
-            )
+            # No line for scanned package in selected picking
+            # Check if there's any picking reserving this product.
+            return_picking = self._get_pickings_for_package(package, limit=1)
+            if return_picking:
+                message = self.msg_store.reserved_for_other_picking_type(return_picking)
+            else:
+                message = self.msg_store.package_not_found_in_picking(package, picking)
+            return self._response_for_select_line(picking, message=message)
         self._select_lines(lines, prefill_qty=prefill_qty)
         if self.work.menu.no_prefill_qty:
             lines = picking.move_line_ids
@@ -533,9 +542,12 @@ def _select_lines_from_product(
 
         lines = selection_lines.filtered(lambda l: l.product_id == product)
         if not lines:
-            return self._response_for_select_line(
-                picking, message=self.msg_store.product_not_found_in_current_picking()
-            )
+            return_picking = self._get_pickings_for_product(product, limit=1)
+            if return_picking:
+                message = self.msg_store.reserved_for_other_picking_type(return_picking)
+            else:
+                message = self.msg_store.product_not_found_in_current_picking(product)
+            return self._response_for_select_line(picking, message=message)
 
         # When products are as units outside of packages, we can select them for
         # packing, but if they are in a package, we want the user to scan the packages.
@@ -1047,18 +1059,21 @@ def scan_package_action(self, picking_id, selected_line_ids, barcode):
             return self._response_for_select_document(message=message)
 
         selected_lines = self.env["stock.move.line"].browse(selected_line_ids).exists()
-        search_result = self._scan_package_find(picking, barcode)
-        message = self._check_scan_package_find(picking, search_result)
-        if message:
-            return self._response_for_select_package(
-                picking,
-                selected_lines,
-                message=message,
-            )
-        result_handler = getattr(
-            self, "_scan_package_action_from_" + search_result.type
-        )
-        return result_handler(picking, selected_lines, search_result.record)
+        handlers = {
+            "package": self._scan_package_action_from_package,
+            "product": self._scan_package_action_from_product,
+            "packaging": self._scan_package_action_from_packaging,
+            "lot": self._scan_package_action_from_lot,
+            "serial": self._scan_package_action_from_serial,
+            "delivery_packaging": self._scan_package_action_from_delivery_packaging,
+        }
+        search_result = self._scan_package_find(picking, barcode, handlers.keys())
+        handler = handlers.get(search_result.type, self._scan_package_action_from_none)
+        kwargs = {
+            "barcode": barcode,
+            "scanned_record": search_result.record,
+        }
+        return handler(picking, selected_lines, search_result.record, **kwargs)
 
     def _scan_package_find(self, picking, barcode, search_types=None):
         search = self._actions_for("search")
@@ -1079,10 +1094,6 @@ def _scan_package_find(self, picking, barcode, search_types=None):
             ),
         )
 
-    def _check_scan_package_find(self, picking, search_result):
-        # Used by inheriting modules
-        return False
-
     def _find_line_to_increment(self, product_lines):
         """Find which line should have its qty incremented.
 

shopfloor/services/service.py

@@ -3,6 +3,7 @@
 # Copyright 2020-2021 Jacques-Etienne Baudoux (BCIM) <je@bcim.be>
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
 from odoo import _, exceptions, fields
+from odoo.osv.expression import AND
 
 from odoo.addons.component.core import AbstractComponent
 
@@ -26,6 +27,22 @@ def _get_process_picking_types(self):
         """Return picking types for the menu"""
         return self.work.menu.picking_type_ids
 
+    def _get_pickings_base_domain(self):
+        return [
+            ("state", "not in", ("done", "cancel")),
+            ("location_id", "child_of", self.picking_types.default_location_src_id.ids),
+        ]
+
+    def _get_pickings_for_package(self, package, **kwargs):
+        domain = self._get_pickings_base_domain()
+        package_domain = [("move_line_ids.package_id", "=", package.id)]
+        return self.env["stock.picking"].search(AND([domain, package_domain]), **kwargs)
+
+    def _get_pickings_for_product(self, product, **kwargs):
+        domain = self._get_pickings_base_domain()
+        product_domain = [("move_line_ids.product_id", "=", product.id)]
+        return self.env["stock.picking"].search(AND([domain, product_domain]), **kwargs)
+
     @property
     def picking_types(self):
         if not hasattr(self.work, "picking_types"):

shopfloor/tests/test_checkout_scan_line.py

@@ -164,6 +164,24 @@ def test_scan_line_error_barcode_not_found(self):
         )
 
     def test_scan_line_error_package_not_in_picking(self):
+        picking = self._create_picking(lines=[(self.product_a, 10)])
+        self._fill_stock_for_moves(picking.move_lines, in_package=True)
+        picking.action_assign()
+        # Create a package for product_a
+        package = self._create_package_in_location(
+            picking.location_id, [(self.product_a, 10, None)]
+        )
+        # we work with picking, but we scan another package (not in a pick)
+        self._test_scan_line_error(
+            picking,
+            package.name,
+            {
+                "message_type": "error",
+                "body": f"Package {package.name} not found in transfer {picking.name}",
+            },
+        )
+
+    def test_scan_line_error_package_reserved_by_another_picking(self):
         picking = self._create_picking(lines=[(self.product_a, 10)])
         self._fill_stock_for_moves(picking.move_lines, in_package=True)
         picking2 = self._create_picking(lines=[(self.product_a, 10)])
@@ -176,9 +194,7 @@ def test_scan_line_error_package_not_in_picking(self):
             package.name,
             {
                 "message_type": "error",
-                "body": "Package {} is not in the current transfer.".format(
-                    package.name
-                ),
+                "body": f"Reserved for Checkout {picking2.name}",
             },
         )
 
@@ -247,7 +263,22 @@ def test_scan_line_error_product_not_in_picking(self):
             self.product_b.barcode,
             {
                 "message_type": "error",
-                "body": "Product is not in the current transfer.",
+                "body": "Product Product B is not in the current transfer.",
+            },
+        )
+
+    def test_scan_line_error_product_in_another_picking(self):
+        picking = self._create_picking(lines=[(self.product_a, 10)])
+        self._fill_stock_for_moves(picking.move_lines, in_package=True)
+        picking2 = self._create_picking(lines=[(self.product_b, 10)])
+        self._fill_stock_for_moves(picking2.move_lines, in_package=True)
+        (picking | picking2).action_assign()
+        self._test_scan_line_error(
+            picking,
+            self.product_b.barcode,
+            {
+                "message_type": "error",
+                "body": f"Reserved for Checkout {picking2.name}",
             },
         )
 

shopfloor_checkout_putinpack_restriction/services/checkout.py

@@ -16,8 +16,28 @@ def _data_response_for_select_package(self, picking, lines, message=None):
             res["no_package_enabled"] = False
         return res
 
-    def _check_scan_package_find(self, picking, search_result):
-        if search_result.type in ["package", "delivery_packaging"]:
-            if picking.put_in_pack_restriction == "no_package":
-                return self.msg_store.package_not_allowed_for_operation()
-        return super()._check_scan_package_find(picking, search_result)
+    def _scan_package_action_from_package(
+        self, picking, selected_lines, record, **kwargs
+    ):
+        if picking.put_in_pack_restriction == "no_package":
+            return self._response_for_select_package(
+                picking,
+                selected_lines,
+                message=self.msg_store.package_not_allowed_for_operation(),
+            )
+        return super()._scan_package_action_from_package(
+            picking, selected_lines, record, **kwargs
+        )
+
+    def _scan_package_action_from_delivery_packaging(
+        self, picking, selected_lines, record, **kwargs
+    ):
+        if picking.put_in_pack_restriction == "no_package":
+            return self._response_for_select_package(
+                picking,
+                selected_lines,
+                message=self.msg_store.package_not_allowed_for_operation(),
+            )
+        return super()._scan_package_action_from_delivery_packaging(
+            picking, selected_lines, record, **kwargs
+        )

shopfloor_reception/services/reception.py

@@ -412,7 +412,7 @@ def _scan_line__by_product__return(self, picking, product):
         # If we have an origin picking but no origin move, then user
         # scanned a wrong product. Warn him about this.
         if origin_moves and not origin_moves_for_product:
-            message = self.msg_store.product_not_found_in_current_picking()
+            message = self.msg_store.product_not_found_in_current_picking(product)
             return self._response_for_select_move(picking, message=message)
         if origin_moves_for_product:
             return_move = self._scan_line__create_return_move(

shopfloor_reception/tests/test_return_scan_line.py

@@ -22,7 +22,7 @@ def test_scan_product_not_in_delivery(self):
             data={"picking": self._data_for_picking_with_moves(return_picking)},
             message={
                 "message_type": "error",
-                "body": "Product is not in the current transfer.",
+                "body": f"Product {wrong_product.name} is not in the current transfer.",
             },
         )