odoo-addon-shopfloor 16.0.1.0.0.24__py3-none-any.whl

odoo/addons/shopfloor/tests/test_checkout_list_package.py

@@ -0,0 +1,327 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import fields
+
+from .test_checkout_base import CheckoutCommonCase
+from .test_checkout_select_package_base import CheckoutSelectPackageMixin
+
+# pylint: disable=missing-return
+
+
+class SelectDestPackageMixin:
+    def _assert_response_select_dest_package(
+        self, response, picking, selected_lines, packages, message=None
+    ):
+        picking_data = self.data.picking(picking)
+        picking_data.update(
+            {
+                "note": None,
+                "origin": None,
+                "weight": 110.0,
+                "move_line_count": len(picking.move_line_ids),
+            }
+        )
+        self.assert_response(
+            response,
+            next_state="select_dest_package",
+            data={
+                "picking": picking_data,
+                "packages": [
+                    self._package_data(
+                        package.with_context(picking_id=picking.id), picking
+                    )
+                    for package in packages
+                ],
+                "selected_move_lines": [
+                    self._move_line_data(ml) for ml in selected_lines.sorted()
+                ],
+            },
+            message=message,
+        )
+
+
+class CheckoutListDestPackageCase(
+    CheckoutCommonCase, CheckoutSelectPackageMixin, SelectDestPackageMixin
+):
+    def test_list_dest_package_ok(self):
+        picking = self._create_picking(
+            lines=[
+                (self.product_a, 10),
+                (self.product_b, 10),
+                (self.product_c, 10),
+                (self.product_d, 10),
+            ]
+        )
+        self._fill_stock_for_moves(picking.move_ids[:2], in_package=True)
+        self._fill_stock_for_moves(picking.move_ids[2], in_package=True)
+        self._fill_stock_for_moves(picking.move_ids[3], in_package=True)
+        picking.action_assign()
+        delivery_packaging = self.env.ref(
+            "stock_storage_type.product_product_9_packaging_single_bag"
+        )
+        delivery_package = self.env["stock.quant.package"].create(
+            {"package_type_id": delivery_packaging.id}
+        )
+        picking.move_ids[1].move_line_ids.result_package_id = delivery_package
+        response = self.service.dispatch(
+            "list_dest_package",
+            params={
+                "picking_id": picking.id,
+                "selected_line_ids": picking.move_line_ids.ids,
+            },
+        )
+        self._assert_response_select_dest_package(
+            response, picking, picking.move_line_ids, delivery_package
+        )
+
+    def test_list_dest_package_error_no_package(self):
+        picking = self._create_picking(
+            lines=[
+                (self.product_a, 10),
+                (self.product_b, 10),
+                (self.product_c, 10),
+                (self.product_d, 10),
+            ]
+        )
+        self._fill_stock_for_moves(picking.move_ids)
+        picking.action_assign()
+        self.assertEqual(picking.state, "assigned")
+        response = self.service.dispatch(
+            "list_dest_package",
+            params={
+                "picking_id": picking.id,
+                "selected_line_ids": picking.move_line_ids.ids,
+            },
+        )
+        self._assert_selected_response(
+            response,
+            picking.move_line_ids,
+            message={"message_type": "warning", "body": "No valid package to select."},
+        )
+
+
+class CheckoutScanSetDestPackageCase(CheckoutCommonCase, SelectDestPackageMixin):
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        picking = cls._create_picking(
+            lines=[
+                (cls.product_a, 10),
+                (cls.product_b, 10),
+                (cls.product_c, 10),
+                (cls.product_d, 10),
+            ]
+        )
+        pack1_moves = picking.move_ids[:3]
+        pack2_moves = picking.move_ids[3:]
+        # put in 2 packs, for this test, we'll work on pack1
+        cls._fill_stock_for_moves(pack1_moves, in_package=True)
+        cls._fill_stock_for_moves(pack2_moves, in_package=True)
+        picking.action_assign()
+
+        cls.selected_lines = pack1_moves.move_line_ids
+        cls.pack1 = pack1_moves.move_line_ids.package_id
+        cls.delivery_packaging = cls.env.ref(
+            "stock_storage_type.product_product_9_packaging_single_bag"
+        )
+        cls.delivery_package = cls.env["stock.quant.package"].create(
+            {"package_type_id": cls.delivery_packaging.id}
+        )
+        cls.move_line1, cls.move_line2, cls.move_line3 = cls.selected_lines
+        # The 'scan_dest_package' and 'set_dest_package' methods can not be
+        # used at all if there is no valid delivery package on the picking
+        # (the user is redirected to the 'select_package' step in that case),
+        # so we need at least to set one to pass this check in order to test
+        # them
+        cls.move_line1.result_package_id = cls.delivery_package
+        # We'll put only product A and B in the destination package
+        cls.move_line1.qty_done = cls.move_line1.reserved_uom_qty
+        cls.move_line2.qty_done = cls.move_line2.reserved_uom_qty
+        cls.move_line3.qty_done = 0
+
+        cls.picking = picking
+
+    def _get_allowed_packages(self, picking):
+        return (
+            picking.mapped("move_line_ids.package_id")
+            | picking.mapped("move_line_ids.result_package_id")
+        ).filtered("package_type_id")
+
+    def _assert_package_set(self, response):
+        self.assertRecordValues(
+            self.move_line1 + self.move_line2 + self.move_line3,
+            [
+                {
+                    "result_package_id": self.delivery_package.id,
+                    "shopfloor_checkout_done": True,
+                },
+                {
+                    "result_package_id": self.delivery_package.id,
+                    "shopfloor_checkout_done": True,
+                },
+                # qty_done was zero so we don't set it as packed
+                {"result_package_id": self.pack1.id, "shopfloor_checkout_done": False},
+            ],
+        )
+        self.assert_response(
+            response,
+            # go pack to the screen to select lines to put in packages
+            next_state="select_line",
+            data=self._data_for_select_line(self.picking),
+            message=self.msg_store.goods_packed_in(self.delivery_package),
+        )
+
+    def test_scan_dest_package_ok(self):
+        response = self.service.dispatch(
+            "scan_dest_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": self.selected_lines.ids,
+                # we keep the goods in the same package, so we scan the source package
+                "barcode": self.delivery_package.name,
+            },
+        )
+        self._assert_package_set(response)
+
+    def test_scan_dest_package_error_not_found(self):
+        barcode = "NO BARCODE"
+        response = self.service.dispatch(
+            "scan_dest_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": self.selected_lines.ids,
+                "barcode": barcode,
+            },
+        )
+        self._assert_response_select_dest_package(
+            response,
+            self.picking,
+            self.selected_lines,
+            self._get_allowed_packages(self.picking),
+            message=self.service.msg_store.package_not_found_for_barcode(barcode),
+        )
+
+    def test_scan_dest_package_error_not_allowed(self):
+        package = self.env["stock.quant.package"].create({})
+        response = self.service.dispatch(
+            "scan_dest_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": self.selected_lines.ids,
+                "barcode": package.name,
+            },
+        )
+        self._assert_response_select_dest_package(
+            response,
+            self.picking,
+            self.selected_lines,
+            self._get_allowed_packages(self.picking),
+            message=self.service.msg_store.dest_package_not_valid(package),
+        )
+
+    def test_set_dest_package_ok(self):
+        response = self.service.dispatch(
+            "set_dest_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": self.selected_lines.ids,
+                "package_id": self.delivery_package.id,
+            },
+        )
+        self._assert_package_set(response)
+
+    def test_set_dest_package_ok_on_partial_qty_done(self):
+        # Partially process line three 3 quantiy out of 10
+        self.move_line3.qty_done = 3
+        response = self.service.dispatch(
+            "set_dest_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": self.selected_lines.ids,
+                "package_id": self.delivery_package.id,
+            },
+        )
+        # self._assert_package_set(response)
+        self.assertRecordValues(
+            self.move_line1 + self.move_line2 + self.move_line3,
+            [
+                {
+                    "result_package_id": self.delivery_package.id,
+                    "shopfloor_checkout_done": True,
+                },
+                {
+                    "result_package_id": self.delivery_package.id,
+                    "shopfloor_checkout_done": True,
+                },
+                # Line 3 has been split
+                {
+                    "result_package_id": self.delivery_package.id,
+                    "shopfloor_checkout_done": True,
+                    "product_uom_qty": 3,
+                    "qty_done": 3,
+                },
+            ],
+        )
+        # Left quantity to do from line 3
+        new_move_line = self.picking.move_line_ids.filtered(
+            lambda line: line.qty_done == 0 and line.reserved_uom_qty == 7
+        )
+        self.assertTrue(new_move_line)
+        self.assertFalse(new_move_line.shopfloor_checkout_done)
+        self.assert_response(
+            response,
+            # go pack to the screen to select lines to put in packages
+            next_state="select_line",
+            data=self._data_for_select_line(self.picking),
+            message=self.msg_store.goods_packed_in(self.delivery_package),
+        )
+
+    def test_set_dest_package_error_not_found(self):
+        response = self.service.dispatch(
+            "set_dest_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": self.selected_lines.ids,
+                "package_id": 0,
+            },
+        )
+        self._assert_response_select_dest_package(
+            response,
+            self.picking,
+            self.selected_lines,
+            self._get_allowed_packages(self.picking),
+            message=self.service.msg_store.record_not_found(),
+        )
+
+    def test_set_dest_package_error_not_allowed(self):
+        package = self.env["stock.quant.package"].create({})
+        response = self.service.dispatch(
+            "set_dest_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": self.selected_lines.ids,
+                "package_id": package.id,
+            },
+        )
+        self._assert_response_select_dest_package(
+            response,
+            self.picking,
+            self.selected_lines,
+            self._get_allowed_packages(self.picking),
+            message=self.service.msg_store.dest_package_not_valid(package),
+        )
+
+    def test_set_dest_package_error_qty_done_above(self):
+        # If the qty_done of a selected line goes beyond
+        # the maximum allowed, a message should be displayed
+        # and the user shouldn't be allowed to select a package.
+        line = fields.first(self.picking.move_line_ids)
+        line.qty_done = line.reserved_uom_qty + 1
+        response = self.service.dispatch(
+            "list_dest_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": self.picking.move_line_ids.ids,
+            },
+        )
+        self._assert_select_package_qty_above(response, self.picking)

odoo/addons/shopfloor/tests/test_checkout_new_package.py

@@ -0,0 +1,88 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import fields
+
+from .test_checkout_base import CheckoutCommonCase
+from .test_checkout_select_package_base import CheckoutSelectPackageMixin
+
+
+class CheckoutNewPackageCase(CheckoutCommonCase, CheckoutSelectPackageMixin):
+    def test_new_package_ok(self):
+        picking = self._create_picking(
+            lines=[
+                (self.product_a, 10),
+                (self.product_b, 10),
+                (self.product_c, 10),
+                (self.product_d, 10),
+            ]
+        )
+        pack1_moves = picking.move_ids[:3]
+        pack2_moves = picking.move_ids[3:]
+        # put in 2 packs, for this test, we'll work on pack1
+        self._fill_stock_for_moves(pack1_moves, in_package=True)
+        self._fill_stock_for_moves(pack2_moves, in_package=True)
+        picking.action_assign()
+
+        selected_lines = pack1_moves.move_line_ids
+        pack1 = pack1_moves.move_line_ids.package_id
+
+        move_line1, move_line2, move_line3 = selected_lines
+        # we'll put only the first 2 lines (product A and B) in the new package
+        move_line1.qty_done = move_line1.reserved_uom_qty
+        move_line2.qty_done = move_line2.reserved_uom_qty
+        move_line3.qty_done = 0
+
+        response = self.service.dispatch(
+            "new_package",
+            params={"picking_id": picking.id, "selected_line_ids": selected_lines.ids},
+        )
+
+        new_package = move_line1.result_package_id
+        self.assertNotEqual(pack1, new_package)
+
+        self.assertRecordValues(
+            move_line1,
+            [{"result_package_id": new_package.id, "shopfloor_checkout_done": True}],
+        )
+        self.assertRecordValues(
+            move_line2,
+            [{"result_package_id": new_package.id, "shopfloor_checkout_done": True}],
+        )
+        self.assertRecordValues(
+            move_line3,
+            # qty_done was zero so we don't set it as packed and it remains in
+            # the same package
+            [{"result_package_id": pack1.id, "shopfloor_checkout_done": False}],
+        )
+        self.assert_response(
+            response,
+            # go pack to the screen to select lines to put in packages
+            next_state="select_line",
+            data=self._data_for_select_line(picking),
+            message=self.msg_store.goods_packed_in(new_package),
+        )
+
+    def test_set_dest_package_error_qty_done_above(self):
+        picking = self._create_picking(
+            lines=[
+                (self.product_a, 10),
+                (self.product_b, 10),
+            ]
+        )
+        moves = picking.move_ids
+        self._fill_stock_for_moves(moves, in_package=True)
+        picking.action_assign()
+        # If the qty_done of a selected line goes beyond
+        # the maximum allowed, a message should be displayed
+        # and the user shouldn't be allowed to select a package.
+        selected_lines = moves.move_line_ids
+        line = fields.first(selected_lines)
+        line.qty_done = line.reserved_uom_qty + 1
+        response = self.service.dispatch(
+            "list_dest_package",
+            params={
+                "picking_id": picking.id,
+                "selected_line_ids": picking.move_line_ids.ids,
+            },
+        )
+        self._assert_select_package_qty_above(response, picking)

odoo/addons/shopfloor/tests/test_checkout_no_package.py

@@ -0,0 +1,95 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+import werkzeug
+
+from odoo import fields
+
+from .test_checkout_base import CheckoutCommonCase
+from .test_checkout_select_package_base import CheckoutSelectPackageMixin
+
+
+# pylint: disable=missing-return
+class CheckoutNoPackageCase(CheckoutCommonCase, CheckoutSelectPackageMixin):
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.picking = picking = cls._create_picking(
+            lines=[
+                (cls.product_a, 10),
+                (cls.product_b, 10),
+                (cls.product_c, 10),
+                (cls.product_d, 10),
+            ]
+        )
+        cls.pack1_moves = pack1_moves = picking.move_ids[:3]
+        cls.pack2_moves = pack2_moves = picking.move_ids[3:]
+        # put in 2 packs, for this test, we'll work on pack1
+        cls._fill_stock_for_moves(pack1_moves)
+        cls._fill_stock_for_moves(pack2_moves)
+        picking.action_assign()
+
+    def test_no_package_ok(self):
+        move_line1, move_line2, move_line3 = self.pack1_moves.move_line_ids
+        selected_lines = move_line1 + move_line2
+
+        # we'll put only the first 2 lines (product A and B) w/ no package
+        move_line1.qty_done = move_line1.reserved_uom_qty
+        move_line2.qty_done = move_line2.reserved_uom_qty
+        move_line3.qty_done = 0
+        response = self.service.dispatch(
+            "no_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+            },
+        )
+
+        self.assertRecordValues(
+            move_line1,
+            [{"result_package_id": False, "shopfloor_checkout_done": True}],
+        )
+        self.assertRecordValues(
+            move_line2,
+            [{"result_package_id": False, "shopfloor_checkout_done": True}],
+        )
+        self.assertRecordValues(
+            move_line3,
+            [{"result_package_id": False, "shopfloor_checkout_done": False}],
+        )
+        self.assert_response(
+            response,
+            # go pack to the screen to select lines to put in packages
+            next_state="select_line",
+            data=self._data_for_select_line(self.picking),
+            message={
+                "message_type": "success",
+                "body": "Product(s) processed as raw product(s)",
+            },
+        )
+
+    def test_no_package_disabled(self):
+        self.service.work.options = {"checkout__disable_no_package": True}
+        with self.assertRaises(werkzeug.exceptions.BadRequest) as err:
+            self.service.dispatch(
+                "no_package",
+                params={
+                    "picking_id": self.picking.id,
+                    "selected_line_ids": self.pack1_moves.move_line_ids.ids,
+                },
+            )
+            self.assertEqual(repr(err), "`checkout.no_package` endpoint is not enabled")
+
+    def test_set_dest_package_error_qty_done_above(self):
+        # If the qty_done of a selected line goes beyond
+        # the maximum allowed, a message should be displayed
+        # and the user shouldn't be allowed to select a package.
+        line = fields.first(self.picking.move_line_ids)
+        line.qty_done = line.reserved_uom_qty + 1
+        response = self.service.dispatch(
+            "list_dest_package",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": self.picking.move_line_ids.ids,
+            },
+        )
+        self._assert_select_package_qty_above(response, self.picking)

odoo/addons/shopfloor/tests/test_checkout_scan.py

@@ -0,0 +1,174 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from .test_checkout_base import CheckoutCommonCase
+
+
+class CheckoutScanCase(CheckoutCommonCase):
+    def _test_scan_ok(self, barcode_func, in_package=True):
+        picking = self._create_picking()
+        self._fill_stock_for_moves(picking.move_ids, in_package=in_package)
+        picking.action_assign()
+        barcode = barcode_func(picking)
+        response = self.service.dispatch("scan_document", params={"barcode": barcode})
+        self.assert_response(
+            response,
+            next_state="select_line",
+            data=self._data_for_select_line(picking),
+        )
+
+    def test_scan_document_stock_picking_ok(self):
+        self._test_scan_ok(lambda picking: picking.name)
+
+    def test_scan_document_location_ok(self):
+        self._test_scan_ok(lambda picking: picking.move_line_ids.location_id.barcode)
+
+    def test_scan_document_package_ok(self):
+        self._test_scan_ok(lambda picking: picking.move_line_ids.package_id.name)
+
+    def test_scan_document_product_ok(self):
+        self._test_scan_ok(
+            lambda picking: picking.move_line_ids.product_id[0].barcode,
+            in_package=False,
+        )
+
+    def test_scan_document_packaging_ok(self):
+        self._test_scan_ok(
+            lambda picking: picking.move_line_ids.product_id[0].packaging_ids.barcode,
+            in_package=False,
+        )
+
+    def test_scan_document_error_not_found(self):
+        response = self.service.dispatch("scan_document", params={"barcode": "NOPE"})
+        self.assert_response(
+            response,
+            next_state="select_document",
+            message={"message_type": "error", "body": "Barcode not found"},
+        )
+
+    def _test_scan_document_error_not_available(self, barcode_func):
+        picking = self._create_picking()
+        # in this test, we want the picking not to be available, but
+        # if we leave the shipping policy to direct, a single move assigned
+        # would make the picking available
+        picking.move_type = "one"
+        # the picking will have one line available, so the endpoint can find
+        # something from a location or package but should reject the picking as
+        # it is not entirely available
+        self._fill_stock_for_moves(picking.move_ids[0], in_package=True)
+        picking.action_assign()
+        barcode = barcode_func(picking)
+        response = self.service.dispatch("scan_document", params={"barcode": barcode})
+        self.assert_response(
+            response,
+            next_state="select_document",
+            message={
+                "message_type": "error",
+                "body": "Transfer {} is not available.".format(picking.name),
+            },
+        )
+
+    def test_scan_document_error_not_available_picking(self):
+        self._test_scan_document_error_not_available(lambda picking: picking.name)
+
+    def test_scan_document_error_not_available_location(self):
+        self._test_scan_document_error_not_available(
+            lambda picking: picking.move_line_ids.location_id.barcode
+        )
+
+    def test_scan_document_error_not_available_package(self):
+        self._test_scan_document_error_not_available(
+            lambda picking: picking.move_line_ids.package_id.name
+        )
+
+    def test_scan_document_error_location_not_child_of_type(self):
+        picking = self._create_picking()
+        picking.location_id = self.dispatch_location
+        self._fill_stock_for_moves(picking.move_ids, in_package=True)
+        picking.action_assign()
+        response = self.service.dispatch(
+            "scan_document", params={"barcode": picking.location_id.barcode}
+        )
+        self.assert_response(
+            response,
+            next_state="select_document",
+            message={"message_type": "error", "body": "Location not allowed here."},
+        )
+
+    def _test_scan_document_error_different_picking_type(self, barcode_func):
+        picking = self._create_picking(picking_type=self.wh.pick_type_id)
+        self._fill_stock_for_moves(picking.move_ids, in_package=True)
+        picking.action_assign()
+        barcode = barcode_func(picking)
+        response = self.service.dispatch("scan_document", params={"barcode": barcode})
+        self.assert_response(
+            response,
+            next_state="select_document",
+            message={
+                "message_type": "error",
+                "body": "You cannot move this using this menu.",
+            },
+        )
+
+    def test_scan_document_error_different_picking_type_picking(self):
+        self._test_scan_document_error_different_picking_type(
+            lambda picking: picking.name
+        )
+
+    def test_scan_document_error_different_picking_type_package(self):
+        self._test_scan_document_error_different_picking_type(
+            lambda picking: picking.move_line_ids.package_id.name
+        )
+
+    def test_scan_document_error_location_several_pickings(self):
+        picking = self._create_picking()
+        # create a second picking at the same place so we don't
+        # know which picking to use
+        picking2 = self._create_picking()
+        pickings = picking | picking2
+        self._fill_stock_for_moves(pickings.move_ids, in_package=True)
+        pickings.action_assign()
+        response = self.service.dispatch(
+            "scan_document",
+            params={"barcode": picking.move_line_ids.location_id.barcode},
+        )
+        self.assert_response(
+            response,
+            next_state="select_document",
+            message={
+                "message_type": "error",
+                "body": "Several transfers found, please scan a package"
+                " or select a transfer manually.",
+            },
+        )
+
+    def test_scan_document_recover(self):
+        """If the user starts to process a line, and for whatever reason he
+        stops there and restarts the scenario from the beginning, he should
+        still be able to find the previous line.
+        """
+        picking = self._create_picking()
+        self._fill_stock_for_moves(picking.move_ids, in_package=True)
+        picking.action_assign()
+        package = picking.move_line_ids.package_id
+        # The user selects a line, then stops working in the middle of the process
+        response = self.service.dispatch(
+            "scan_document", params={"barcode": package.name}
+        )
+        data = response["data"]["select_line"]
+        self.assertEqual(data["picking"]["move_line_count"], 2)
+        self.assertEqual(len(data["picking"]["move_lines"]), 2)
+        self.assertFalse(picking.move_line_ids.shopfloor_user_id)
+        response = self.service.dispatch(
+            "select_line",
+            params={"picking_id": picking.id, "package_id": package.id},
+        )
+        self.assertTrue(all(m.qty_done for m in picking.move_line_ids))
+        self.assertEqual(picking.move_line_ids.shopfloor_user_id, self.env.user)
+        # He restarts the scenario and try to select again the previous line
+        # to continue its job
+        response = self.service.dispatch(
+            "scan_document", params={"barcode": package.name}
+        )
+        data = response["data"]["select_line"]
+        self.assertEqual(data["picking"]["move_line_count"], 2)
+        self.assertEqual(len(data["picking"]["move_lines"]), 2)  # Lines found