+ Destination:
+ {{ state.data.location_dest.name }}
+
+
+
+
+
diff --git a/shopfloor_mobile_packing/static/src/js/cluster-picking.js b/shopfloor_mobile_packing/static/src/js/cluster-picking.js
new file mode 100644
index 00000000000..d592f2c50a9
--- /dev/null
+++ b/shopfloor_mobile_packing/static/src/js/cluster-picking.js
@@ -0,0 +1,352 @@
+/**
+ * Copyright 2021 ACSONE SA/NV
+ * License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+ */
+
+import {process_registry} from "/shopfloor_mobile_base/static/wms/src/services/process_registry.js";
+
+const registry_key = "cluster_picking";
+const ClusterPickingBase = process_registry.get(registry_key);
+
+let template = ClusterPickingBase.component.template;
+ClusterPickingBase.component.template = template.replace(
+ "",
+ `
+ Shopfloor Mobile Packing
+ + +
Shopfloor mobile extension for packing operation into cluster picking.
+Table of contents
+
+
+-
+
- Bug Tracker +
- Credits + +
+
+Bug Tracker
+Bugs are tracked on GitHub Issues. +In case of trouble, please check there if your issue has already been reported. +If you spotted it first, help us to smash it by providing a detailed and welcomed +feedback.
+Do not contact contributors directly about support or help with technical issues.
+
+
+Credits
+
+
+Authors
+-
+
- ACSONE SA/NV +
+
+Contributors
+-
+
- Souheil Bejaoui <souheil.bejaoui@acsone.eu> +
- Denis Roussel <denis.roussel@acsone.eu> +
- Jacques-Étienne Baudoux <je@bcim.be> +
+
+
+
+Maintainers
+This module is maintained by the OCA.
+ +
+
+OCA, or the Odoo Community Association, is a nonprofit organization whose +mission is to support the collaborative development of Odoo features and +promote its widespread use.
+This module is part of the OCA/wms project on GitHub.
+You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
+
+
+
+
+
+
+
+
+
+`
+);
+
+// Keep the pointer to the orginal method
+let data_result_method = ClusterPickingBase.component.data;
+
+ClusterPickingBase.component.computed.searchbar_input_type = function () {
+ if (this.state_is("pack_picking_put_in_pack")) {
+ return "number";
+ }
+ return "text";
+};
+
+ClusterPickingBase.component.computed.existing_package_select_fields = function () {
+ return [
+ {path: "weight"},
+ {path: "move_line_count", label: "Line count"},
+ {path: "packaging.name"},
+ ];
+};
+
+ClusterPickingBase.component.methods.select_package_manual_select_opts = function () {
+ return {
+ multiple: true,
+ initValue: this.selected_line_ids(),
+ card_klass: "loud-labels",
+ list_item_component: "picking-select-package-content",
+ list_item_options: {actions: ["action_qty_edit"]},
+ };
+};
+
+ClusterPickingBase.component.methods.select_delivery_packaging_manual_select_options =
+ function () {
+ return {
+ showActions: false,
+ };
+ };
+
+ClusterPickingBase.component.methods.selected_line_ids = function () {
+ return this.selected_lines().map(_.property("id"));
+};
+
+ClusterPickingBase.component.methods.selected_line_ids_for_packing = function () {
+ return this.selectable_lines_for_packing().map(_.property("id"));
+};
+
+ClusterPickingBase.component.methods.selectable_lines = function () {
+ const stored = this.state_get_data("select_package");
+ return _.result(stored, "selected_move_lines", []);
+};
+
+ClusterPickingBase.component.methods.selectable_line_ids = function () {
+ return this.selectable_lines().map(_.property("id"));
+};
+
+ClusterPickingBase.component.methods.selected_lines = function () {
+ return this.selectable_lines().filter(function (x) {
+ return x.qty_done > 0;
+ });
+};
+
+ClusterPickingBase.component.methods.selectable_lines_for_packing = function () {
+ const lines = this.state.data.selected_lines_for_packing;
+ return lines;
+};
+
+// Replace the data method with our new method to add
+// our new state
+let component = ClusterPickingBase.component;
+let data = function () {
+ // we must bin the original method to this to put it into
+ // the object context
+ let result = data_result_method.bind(this)();
+ // add our new state
+ result.states.pack_picking_put_in_pack = {
+ display_info: {
+ title: this.$t("cluster_picking.pack_picking_put_in_pack.title"),
+ scan_placeholder: this.$t(
+ "cluster_picking.pack_picking_put_in_pack.scan_placeholder"
+ ),
+ },
+ on_scan: (scanned) => {
+ let endpoint, endpoint_data;
+ const data = this.state.data;
+ endpoint = "put_in_pack";
+ endpoint_data = {
+ picking_batch_id: this.current_batch().id,
+ picking_id: data.id,
+ nbr_packages: parseInt(scanned.text, 10),
+ };
+ this.wait_call(this.odoo.call(endpoint, endpoint_data));
+ },
+ };
+ result.states.pack_picking_scan_pack = {
+ display_info: {
+ title: this.$t("cluster_picking.pack_picking_scan_pack.title"),
+ scan_placeholder: this.$t(
+ "cluster_picking.pack_picking_scan_pack.scan_placeholder"
+ ),
+ },
+ on_scan: (scanned) => {
+ let endpoint, endpoint_data;
+ const data = this.state.data;
+ endpoint = "scan_packing_to_pack";
+ endpoint_data = {
+ picking_batch_id: this.current_batch().id,
+ picking_id: data.id,
+ barcode: scanned.text,
+ };
+ this.wait_call(this.odoo.call(endpoint, endpoint_data));
+ },
+ };
+ result.states.select_package = {
+ // TODO: /set_line_qty is not handled yet
+ // because is not clear how to handle line selection
+ // and qty set.
+ // ATM given that manual-select uses v-list-item-group
+ // when you touch a line you select/unselect it
+ // which means we cannot rely on this to go to edit.
+ // If we need it, we have to change manual-select
+ // to use pure list + checkboxes.
+ display_info: {
+ title: "Select package",
+ scan_placeholder: "Scan existing package / package type",
+ },
+ events: {
+ qty_edit: "on_qty_edit",
+ select: "on_select",
+ back: "on_back",
+ },
+ on_scan: (scanned) => {
+ this.wait_call(
+ this.odoo.call("scan_package_action", {
+ picking_id: this.state.data.picking.id,
+ selected_line_ids: this.selectable_line_ids(),
+ barcode: scanned.text,
+ })
+ );
+ },
+ on_select: (selected) => {
+ return;
+ // TODO:
+ // if (!selected) {
+ // return;
+ // }
+ // const orig_selected = $instance.selected_line_ids();
+ // const selected_ids = selected.map(_.property("id"));
+ // const to_select = _.head(
+ // $instance.selectable_lines().filter(function (x) {
+ // return selected_ids.includes(x.id) && !orig_selected.includes(x.id);
+ // })
+ // );
+ // const to_unselect = _.head(
+ // $instance.selectable_lines().filter(function (x) {
+ // return !selected_ids.includes(x.id) && orig_selected.includes(x.id);
+ // })
+ // );
+ // let endpoint, move_line;
+ // if (to_unselect) {
+ // endpoint = "reset_line_qty";
+ // move_line = to_unselect;
+ // } else if (to_select) {
+ // endpoint = "set_line_qty";
+ // move_line = to_select;
+ // }
+ // $instance.wait_call(
+ // $instance.odoo.call(endpoint, {
+ // picking_id: $instance.state.data.picking.id,
+ // selected_line_ids: $instance.selectable_line_ids(),
+ // move_line_id: move_line.id,
+ // })
+ // );
+ },
+ on_qty_edit: (record) => {
+ return;
+ // TODO:
+ // $instance.state_set_data(
+ // {
+ // picking: $instance.state.data.picking,
+ // line: record,
+ // selected_line_ids: $instance.selectable_line_ids(),
+ // },
+ // "change_quantity"
+ // );
+ // $instance.state_to("change_quantity");
+ },
+ on_new_pack: () => {
+ /**
+ * Trigger the call to list delivery package types
+ * as user wants to put products in a new pack.
+ */
+ let endpoint, endpoint_data;
+ const data = this.state.data;
+ endpoint = "list_delivery_package_types";
+ endpoint_data = {
+ picking_batch_id: this.current_batch().id,
+ picking_id: data.picking.id,
+ selected_line_ids: this.selectable_line_ids(),
+ };
+ this.wait_call(this.odoo.call(endpoint, endpoint_data));
+ },
+ on_existing_pack: () => {
+ return;
+ // TODO:
+ // $instance.wait_call(
+ // $instance.odoo.call("list_dest_package", {
+ // picking_id: $instance.state.data.picking.id,
+ // selected_line_ids: $instance.selectable_line_ids(),
+ // })
+ // );
+ },
+ on_without_pack: () => {
+ return;
+ // TODO:
+ // $instance.wait_call(
+ // $instance.odoo.call("no_package", {
+ // picking_id: $instance.state.data.picking.id,
+ // selected_line_ids: $instance.selectable_line_ids(),
+ // })
+ // );
+ },
+ on_back: () => {
+ $instance.state_to("select_line");
+ $instance.reset_notification();
+ },
+ };
+ result.states.select_delivery_packaging = {
+ /**
+ * This will catch user events when selecting the delivery packaging type
+ * from:
+ * - the scanned barcode
+ * - the direct selection on screen
+ */
+ display_info: {
+ title: "Select delivery packaging or scan it",
+ scan_placeholder: "Scan package type",
+ },
+ events: {
+ select: "on_select",
+ back: "on_back",
+ },
+ on_select: (selected) => {
+ const picking = this.current_doc().record;
+ const data = this.state.data.picking;
+ const ids = this.selected_line_ids_for_packing();
+ this.wait_call(
+ this.odoo.call("put_in_pack", {
+ picking_batch_id: this.current_batch().id,
+ picking_id: data.id,
+ selected_line_ids: ids,
+ package_type_id: selected.id,
+ })
+ );
+ },
+ on_scan: (scanned) => {
+ const picking = this.current_doc().record;
+ const data = this.state.data;
+ this.wait_call(
+ this.odoo.call("scan_package_action", {
+ picking_id: data.picking.id,
+ selected_line_ids: this.selected_line_ids(),
+ barcode: scanned.text,
+ })
+ );
+ },
+ };
+
+ return result;
+};
+
+ClusterPickingBase.component.data = data;
diff --git a/shopfloor_mobile_packing/static/src/js/components/pack_picking.js b/shopfloor_mobile_packing/static/src/js/components/pack_picking.js
new file mode 100644
index 00000000000..b4101a2d3ab
--- /dev/null
+++ b/shopfloor_mobile_packing/static/src/js/components/pack_picking.js
@@ -0,0 +1,94 @@
+/**
+ * Copyright 2021 ACSONE SA/NV
+ * License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+ */
+
+/* eslint-disable strict */
+Vue.component("pack-picking", {
+ props: ["record"],
+ methods: {
+ move_lines_color_klass(rec) {
+ let line = rec;
+ if (line._is_group) {
+ line = line.records[0];
+ }
+ let klass = "";
+ if (this.record.scanned_packs.includes(line.package_dest.id)) {
+ klass = "done screen_step_done lighten-1";
+ } else {
+ klass = "not-done screen_step_todo lighten-1";
+ }
+ return "move-line-" + klass;
+ },
+ line_list_options() {
+ return {
+ card_klass: "loud-labels",
+ key_title: "",
+ showCounters: false,
+ list_item_options: {
+ fields: this.line_list_fields(),
+ list_item_klass_maker: this.move_lines_color_klass,
+ },
+ };
+ },
+ line_list_fields() {
+ self = this;
+ return [
+ {
+ path: "product.display_name",
+ action_val_path: "product.default_code",
+ klass: "loud",
+ },
+ {
+ path: "package_src.name",
+ label: "Pack",
+ action_val_path: "package_src.name",
+ },
+ {path: "lot.name", label: "Lot", action_val_path: "lot.name"},
+ {
+ path: "qty_done",
+ label: "Qty",
+ render_component: "packaging-qty-picker-display",
+ render_props: function (record) {
+ return self.utils.wms.move_line_qty_picker_props(record, {
+ qtyInit: record.qty_done,
+ });
+ },
+ },
+ ];
+ },
+ grouped_lines() {
+ const groups = this.utils.wms.group_by_pack(
+ this.record.move_lines.filter((op) => {
+ if (op.package_dest != null && op.package_dest.is_internal) {
+ return op;
+ }
+ })
+ );
+ const self = this;
+ _.forEach(groups, function (item) {
+ item.group_color = self.record.scanned_packs.includes(item.pack.id)
+ ? self.utils.colors.color_for("screen_step_done")
+ : self.utils.colors.color_for("screen_step_todo");
+ });
+ return groups;
+ },
+ },
+ template: `
+
+
+
+
+
+
+
+`,
+});
diff --git a/shopfloor_mobile_packing/static/src/js/i18n/en.json b/shopfloor_mobile_packing/static/src/js/i18n/en.json
new file mode 100644
index 00000000000..440c46a98aa
--- /dev/null
+++ b/shopfloor_mobile_packing/static/src/js/i18n/en.json
@@ -0,0 +1,6 @@
+{
+ "cluster_picking.pack_picking_put_in_pack.title": "Packing: Enter the number of boxes used.",
+ "cluster_picking.pack_picking_put_in_pack.scan_placeholder": "Number of boxes used",
+ "cluster_picking.pack_picking_scan_pack.title": "Packing: Validate bin to pack.",
+ "cluster_picking.pack_picking_scan_pack.scan_placeholder": "Bin barcode "
+}
diff --git a/shopfloor_mobile_packing/static/src/js/i18n/fr.json b/shopfloor_mobile_packing/static/src/js/i18n/fr.json
new file mode 100644
index 00000000000..cad33dee5dc
--- /dev/null
+++ b/shopfloor_mobile_packing/static/src/js/i18n/fr.json
@@ -0,0 +1,6 @@
+{
+ "cluster_picking.pack_picking_put_in_pack.title": "Emballage: Nombre de colis.",
+ "cluster_picking.pack_picking_put_in_pack.scan_placeholder": "Nombre de colis créés?",
+ "cluster_picking.pack_picking_scan_pack.title": "Emballage: Validation emplacement à emballer.",
+ "cluster_picking.pack_picking_scan_pack.scan_placeholder": "Code-barre emplacement charriot "
+}
diff --git a/shopfloor_mobile_packing/static/src/js/translation_registry.js b/shopfloor_mobile_packing/static/src/js/translation_registry.js
new file mode 100644
index 00000000000..c8e11f06f69
--- /dev/null
+++ b/shopfloor_mobile_packing/static/src/js/translation_registry.js
@@ -0,0 +1,10 @@
+import {translation_registry} from "/shopfloor_mobile_base/static/wms/src/services/translation_registry.js";
+
+translation_registry.load(
+ "fr-FR",
+ "/shopfloor_mobile_packing/static/src/js/i18n/fr.json"
+);
+translation_registry.load(
+ "en-US",
+ "/shopfloor_mobile_packing/static/src/js/i18n/en.json"
+);
diff --git a/shopfloor_mobile_packing/templates/assets.xml b/shopfloor_mobile_packing/templates/assets.xml
new file mode 100644
index 00000000000..49352669958
--- /dev/null
+++ b/shopfloor_mobile_packing/templates/assets.xml
@@ -0,0 +1,27 @@
+
+
+
+ {{ record.name }} : {{ record.partner.name }}
+
+
+
+
+
diff --git a/shopfloor_packing/tests/__init__.py b/shopfloor_packing/tests/__init__.py
new file mode 100644
index 00000000000..b3db59427f7
--- /dev/null
+++ b/shopfloor_packing/tests/__init__.py
@@ -0,0 +1,5 @@
+from . import (
+ test_cluster_picking_pack_picking,
+ test_cluster_picking_pick_pack,
+ test_cluster_picking_unload,
+)
diff --git a/shopfloor_packing/tests/common.py b/shopfloor_packing/tests/common.py
new file mode 100644
index 00000000000..0655d670229
--- /dev/null
+++ b/shopfloor_packing/tests/common.py
@@ -0,0 +1,16 @@
+# Copyright 2021 ACSONE SA/NV
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from odoo.addons.shopfloor.tests.test_cluster_picking_unload import (
+ ClusterPickingUnloadingCommonCase,
+)
+
+
+# pylint: disable=missing-return
+class ClusterPickingUnloadPackingCommonCase(ClusterPickingUnloadingCommonCase):
+ @classmethod
+ def setUpClassBaseData(cls, *args, **kwargs):
+ super().setUpClassBaseData(*args, **kwargs)
+ cls.bin1.write({"name": "bin1", "is_internal": True})
+ cls.bin2.write({"name": "bin2", "is_internal": True})
+ cls.menu.sudo().pack_pickings = True
diff --git a/shopfloor_packing/tests/test_cluster_picking_pack_picking.py b/shopfloor_packing/tests/test_cluster_picking_pack_picking.py
new file mode 100644
index 00000000000..49ee460c398
--- /dev/null
+++ b/shopfloor_packing/tests/test_cluster_picking_pack_picking.py
@@ -0,0 +1,480 @@
+# Copyright 2021 ACSONE SA/NV
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+from .common import ClusterPickingUnloadPackingCommonCase
+
+
+class TestClusterPickingPrepareUnload(ClusterPickingUnloadPackingCommonCase):
+ def test_scan_destination_pack_bin_not_internal(self):
+ """Scan a destination package that is not an internal package."""
+ self.bin2.is_internal = False
+ move_line = self.move_lines[0]
+ response = self.service.dispatch(
+ "scan_destination_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "move_line_id": move_line.id,
+ # this bin is used for the other picking
+ "barcode": self.bin2.name,
+ "quantity": move_line.reserved_qty,
+ },
+ )
+ self.assert_response(
+ response,
+ next_state="scan_destination",
+ data=self._line_data(move_line),
+ message=self.service.msg_store.bin_should_be_internal(self.bin2),
+ )
+
+ def test_prepare_unload_all_same_dest(self):
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[:1], self.bin2)
+ self._set_dest_package_and_done(move_lines[1:], self.bin1)
+ move_lines.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ location = self.packing_location
+ # The first bin to process is bin1 we should therefore scan the bin 1
+ # to pack and put in pack
+ picking = move_lines[-1].picking_id
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_put_in_pack",
+ data=data,
+ )
+ # we process to the put in pack
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "nbr_packages": 4,
+ },
+ )
+ message = self.service.msg_store.stock_picking_packed_successfully(picking)
+ result_package = picking.move_line_ids.mapped("result_package_id")
+ self.assertEqual(len(result_package), 1)
+ self.assertEqual(result_package[0].number_of_parcels, 4)
+
+ picking = move_lines[0].picking_id
+ data = self.data.pack_picking(picking)
+ # message = self.service.msg_store.stock_picking_packed_successfully(picking)
+ self.assert_response(
+ response, next_state="pack_picking_scan_pack", data=data, message=message
+ )
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin2.name,
+ },
+ )
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_put_in_pack",
+ data=data,
+ )
+ # we process to the put in pack
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": move_lines.ids,
+ "nbr_packages": 2,
+ },
+ )
+ data = self._data_for_batch(self.batch, location)
+ message = self.service.msg_store.stock_picking_packed_successfully(picking)
+ self.assert_response(
+ response, next_state="unload_all", data=data, message=message
+ )
+
+ result_package = picking.move_line_ids.mapped("result_package_id")
+ self.assertEqual(len(result_package), 1)
+ self.assertEqual(result_package[0].number_of_parcels, 2)
+
+ def test_prepare_unload_different_dest(self):
+ """All move lines have different destination locations."""
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[:1], self.bin2)
+ self._set_dest_package_and_done(move_lines[1:], self.bin1)
+ move_lines[:1].write({"location_dest_id": self.packing_a_location.id})
+ move_lines[1:].write({"location_dest_id": self.packing_b_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ # The first bin to process is bin1 we should therefore a pack_picking
+ # step with the picking info of the last move_line
+ picking = move_lines[-1].picking_id
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_put_in_pack",
+ data=data,
+ )
+ # we process to the put in pack
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "nbr_packages": 4,
+ },
+ )
+
+ message = self.service.msg_store.stock_picking_packed_successfully(picking)
+
+ # next picking..
+ picking = move_lines[0].picking_id
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response, next_state="pack_picking_scan_pack", data=data, message=message
+ )
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin2.name,
+ },
+ )
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_put_in_pack",
+ data=data,
+ )
+ # we process to the put in pack
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "nbr_packages": 2,
+ },
+ )
+ # Since the last move_line has been put in pack first, the first pack
+ # to unload is the one from the last move_line
+ new_bin = move_lines[-1].result_package_id
+ location = move_lines[-1].location_dest_id
+ data = self._data_for_batch(self.batch, location, pack=new_bin)
+ message = self.service.msg_store.stock_picking_packed_successfully(picking)
+ self.assert_response(
+ response, next_state="unload_single", data=data, message=message
+ )
+
+ def test_prepare_full_bin_unload(self):
+ # process one move_line and call unload
+ # the unload should return a pack_picking state
+ # and once processed continue with next move_lines
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[0], self.bin1)
+ move_lines.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ # step with the picking info of the last move_line
+ picking = move_lines[0].picking_id
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ # we scan the pack and process to the put in pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_put_in_pack",
+ data=data,
+ )
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "nbr_packages": 4,
+ },
+ )
+ result_package = picking.move_line_ids.mapped("result_package_id")
+ self.assertEqual(len(result_package), 1)
+ self.assertEqual(result_package[0].number_of_parcels, 4)
+
+ # now we must unload
+ location = move_lines[0].location_dest_id
+ data = self._data_for_batch(self.batch, location)
+ self.assert_response(
+ response,
+ next_state="unload_all",
+ data=data,
+ message=self.service.msg_store.stock_picking_packed_successfully(picking),
+ )
+ response = self.service.dispatch(
+ "set_destination_all",
+ params={
+ "picking_batch_id": self.batch.id,
+ "barcode": self.packing_location.barcode,
+ },
+ )
+
+ # once the unload is done, we must process the others move_lines
+ move_line = self.service._next_line_for_pick(self.batch)
+ while move_line:
+ picking = move_line.picking_id
+ self.assertEqual(response["next_state"], "start_line")
+ response = self.service.dispatch(
+ "scan_destination_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "move_line_id": move_line.id,
+ "barcode": self.bin1.name,
+ "quantity": move_line.reserved_uom_qty,
+ },
+ )
+ move_line = self.service._next_line_for_pick(self.batch)
+
+ # everything is processed, we should put in pack...
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ # we scan the pack and process to the put in pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "barcode": self.bin1.name,
+ },
+ )
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_put_in_pack",
+ data=data,
+ )
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "nbr_packages": 2,
+ },
+ )
+ data = self._data_for_batch(self.batch, location)
+ self.assert_response(
+ response,
+ next_state="unload_all",
+ data=data,
+ message=self.service.msg_store.stock_picking_packed_successfully(picking),
+ )
+
+ result_package = picking.move_line_ids.mapped("result_package_id")
+ self.assertEqual(len(result_package), 1)
+ self.assertEqual(result_package[0].number_of_parcels, 2)
+
+ def test_response_for_scan_destination(self):
+ """Check that non internal package are not proposed as package_dest."""
+ line1 = self.two_lines_picking.move_line_ids[0]
+ # we already scan and put the first line in bin1
+ self._set_dest_package_and_done(line1, self.bin1)
+ self.bin1.is_internal = False
+ self.assertFalse(self.service._last_picked_line(line1.picking_id))
+ response = self.service._response_for_scan_destination(line1)
+ self.assertFalse(response["data"]["scan_destination"]["package_dest"])
+
+ def test_put_in_pack_partial_qty(self):
+ """
+ Special case.
+
+ If a partially available product becomes completely available and the reserved
+ quantity increases after the "put in pack" action, a new move line will be
+ created with the done quantity as a copy of the line that will be packed.
+ The original line will keep the result package, which is the package scanned
+ by the operator, and the remaining quantity to do.
+
+ Since the package is an internal package, the line with the remaining quantity
+ to do will be proposed in the packing process and considered as picked. If the
+ operator don't pay attention, and confirm the packaging, both lines will be set
+ to done.
+ Test:
+ - The new line is correctly packed.
+ - The original line has no result package.
+ - After the "put in pack" of the partial quantity, the scenario returns
+ the unload step.
+ """
+ move_line = self.move_lines[0]
+ picking = move_line.picking_id
+ self.assertEqual(len(picking.move_line_ids), 1)
+ move_line.reserved_uom_qty = 5
+ response = self.service.dispatch(
+ "scan_destination_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "move_line_id": move_line.id,
+ "barcode": self.bin1.name,
+ # collect half the demanded qty
+ "quantity": 5,
+ },
+ )
+ move_line.reserved_uom_qty = 10
+ self.assertEqual(response["next_state"], "start_line")
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": move_line.picking_id.id,
+ "barcode": self.bin1.name,
+ },
+ )
+ self.assertEqual(response["next_state"], "pack_picking_put_in_pack")
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "nbr_packages": 2,
+ },
+ )
+ # after the put in pack, a new line is created with the remaining qty to do
+ self.assertEqual(len(picking.move_line_ids), 2)
+ self.assertFalse(move_line.result_package_id)
+ self.assertTrue((picking.move_line_ids - move_line).result_package_id)
+ self.assertFalse(
+ (picking.move_line_ids - move_line).result_package_id.is_internal
+ )
+ self.assertEqual(response["next_state"], "unload_all")
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": move_line.picking_id.id,
+ "barcode": self.bin1.name,
+ },
+ )
+ self.assertEqual(response["next_state"], "unload_all")
+
+ def _product_put_in_pack(self):
+ batch = self._create_picking_batch(
+ [[self.BatchProduct(product=self.product_a, quantity=10)]]
+ )
+ move_line = batch.move_line_ids
+ self._set_dest_package_and_done(move_line, self.bin1)
+ move_line.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": batch.id}
+ )
+
+ # The first bin to process is bin1 scan the pack and try to put in pack
+ picking = move_line.picking_id
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_put_in_pack",
+ data=data,
+ )
+ # we process to the put in pack
+ self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": move_line.ids,
+ "nbr_packages": 4,
+ },
+ )
+ return move_line
+
+ def test_put_in_pack_set_correct_package_type(self):
+ """Shopfloor should set the package type if possible."""
+ pt_model = self.env["stock.package.type"].sudo()
+ package_type_4 = pt_model.create({"name": "PT4", "number_of_parcels": 4})
+ package_type_7 = pt_model.create({"name": "PT7", "number_of_parcels": 7})
+ self.product_a.package_type_id = package_type_7
+ move_line = self._product_put_in_pack()
+ self.assertEqual(move_line.result_package_id.number_of_parcels, 4)
+ self.assertEqual(move_line.result_package_id.package_type_id, package_type_4)
+ move_line.picking_id._action_done()
+ self.assertEqual(move_line.result_package_id.number_of_parcels, 4)
+ self.assertEqual(move_line.result_package_id.package_type_id, package_type_4)
+
+ def test_put_in_pack_cant_set_correct_package_type(self):
+ """If shopfloor can't find a package type, storage_type shouldn't overwrite
+ number_of_parcels."""
+ pt_model = self.env["stock.package.type"].sudo()
+ package_type_7 = pt_model.create({"name": "PT7", "number_of_parcels": 7})
+ self.product_a.package_type_id = package_type_7
+ move_line = self._product_put_in_pack()
+ self.assertEqual(move_line.result_package_id.number_of_parcels, 4)
+ self.assertFalse(move_line.result_package_id.package_type_id)
+ move_line.picking_id._action_done()
+ self.assertEqual(move_line.result_package_id.number_of_parcels, 4)
+ self.assertFalse(move_line.result_package_id.package_type_id)
diff --git a/shopfloor_packing/tests/test_cluster_picking_pick_pack.py b/shopfloor_packing/tests/test_cluster_picking_pick_pack.py
new file mode 100644
index 00000000000..eb4baa2622c
--- /dev/null
+++ b/shopfloor_packing/tests/test_cluster_picking_pick_pack.py
@@ -0,0 +1,557 @@
+# Copyright 2024 ACSONE SA/NV
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+from odoo.fields import first
+
+from .common import ClusterPickingUnloadPackingCommonCase
+
+
+class TestClusterPickingPrepareUnload(ClusterPickingUnloadPackingCommonCase):
+ def _create_package_type(self):
+ self.carrier_product = (
+ self.env["product.product"]
+ .sudo()
+ .create(
+ {
+ "name": "Test Product",
+ "type": "service",
+ }
+ )
+ )
+ self.carrier = (
+ self.env["delivery.carrier"]
+ .sudo()
+ .create(
+ {
+ "name": "Test Carrier",
+ "product_id": self.carrier_product.id,
+ }
+ )
+ )
+ self.package_type = (
+ self.env["stock.package.type"]
+ .sudo()
+ .create(
+ {
+ "name": "BOX-5",
+ "package_carrier_type": "none",
+ "number_of_parcels": 5.0,
+ "barcode": "BOX-5",
+ }
+ )
+ )
+ self.package_types = self.env["stock.package.type"].search(
+ [("package_carrier_type", "=", "none")], order="number_of_parcels,name"
+ )
+
+ def test_prepare_unload_all_same_dest_with_dest_package(self):
+ """
+ Activate the behavior that allows to pack at the pick step (cluster)
+ Activate the behavior that change the default action -> Scan the package type
+ At the unload step, ask to select a delivery package (from types)
+ """
+ self.menu.sudo().write(
+ {
+ "pick_pack_same_time": True,
+ "default_pack_pickings_action": "package_type",
+ }
+ )
+
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[:1], self.bin2)
+ self._set_dest_package_and_done(move_lines[1:], self.bin1)
+ move_lines.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ location = self.packing_location
+ # The first bin to process is bin1 we should therefore scan the bin 1
+ # to pack and put in pack
+ picking = move_lines[-1].picking_id
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ lines = picking.move_line_ids.filtered(
+ lambda ml: ml.result_package_id.is_internal
+ ).sorted(key=lambda ml: ml.result_package_id.name)
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+
+ data = self.data.select_package(picking, lines)
+ self.assert_response(
+ response,
+ next_state="select_package",
+ data=data,
+ )
+ # we process to the put in pack
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "nbr_packages": 4,
+ },
+ )
+ message = self.service.msg_store.stock_picking_packed_successfully(picking)
+ result_package = picking.move_line_ids.mapped("result_package_id")
+ self.assertEqual(len(result_package), 1)
+ self.assertEqual(result_package[0].number_of_parcels, 4)
+
+ picking = move_lines[0].picking_id
+ data = self.data.pack_picking(picking)
+ # message = self.service.msg_store.stock_picking_packed_successfully(picking)
+ self.assert_response(
+ response, next_state="pack_picking_scan_pack", data=data, message=message
+ )
+ lines = picking.move_line_ids.filtered(
+ lambda ml: ml.result_package_id.is_internal
+ ).sorted(key=lambda ml: ml.result_package_id.name)
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin2.name,
+ },
+ )
+ data = self.data.select_package(picking, lines)
+ self.assert_response(
+ response,
+ next_state="select_package",
+ data=data,
+ )
+ # we process to the put in pack
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "nbr_packages": 2,
+ },
+ )
+ data = self._data_for_batch(self.batch, location)
+ message = self.service.msg_store.stock_picking_packed_successfully(picking)
+ self.assert_response(
+ response, next_state="unload_all", data=data, message=message
+ )
+
+ result_package = picking.move_line_ids.mapped("result_package_id")
+ self.assertEqual(len(result_package), 1)
+ self.assertEqual(result_package[0].number_of_parcels, 2)
+
+ def test_pack_no_package_type(self):
+ """
+ Activate the behavior that allows to pack at the pick step (cluster)
+ Activate the behavior that change the default action -> Scan the package type
+ At the unload step, ask to select a delivery package (from types)
+ """
+ self.menu.sudo().write(
+ {
+ "pick_pack_same_time": True,
+ "default_pack_pickings_action": "package_type",
+ }
+ )
+
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[:1], self.bin2)
+ self._set_dest_package_and_done(move_lines[1:], self.bin1)
+ move_lines.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ # The first bin to process is bin1 we should therefore scan the bin 1
+ # to pack and put in pack
+ picking = move_lines[-1].picking_id
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ lines = picking.move_line_ids.filtered(
+ lambda ml: ml.result_package_id.is_internal
+ ).sorted(key=lambda ml: ml.result_package_id.name)
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+
+ data = self.data.select_package(picking, lines)
+ self.assert_response(
+ response,
+ next_state="select_package",
+ data=data,
+ )
+ # We use new pack
+ response = self.service.dispatch(
+ "list_delivery_package_types",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": lines.ids,
+ },
+ )
+ message = {
+ "message_type": "warning",
+ "body": "No delivery package type available.",
+ }
+ data = self.data.select_package(picking, lines)
+ self.assert_response(
+ response, next_state="select_package", data=data, message=message
+ )
+
+ def test_list_delivery_package_picking_done(self):
+ """ """
+ self.menu.sudo().write(
+ {
+ "pick_pack_same_time": True,
+ "default_pack_pickings_action": "package_type",
+ }
+ )
+
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[:1], self.bin2)
+ self._set_dest_package_and_done(move_lines[1:], self.bin1)
+ move_lines.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ # The first bin to process is bin1 we should therefore scan the bin 1
+ # to pack and put in pack
+ picking = move_lines[-1].picking_id
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ lines = picking.move_line_ids.filtered(
+ lambda ml: ml.result_package_id.is_internal
+ ).sorted(key=lambda ml: ml.result_package_id.name)
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+
+ data = self.data.select_package(picking, lines)
+ self.assert_response(
+ response,
+ next_state="select_package",
+ data=data,
+ )
+
+ picking._action_done()
+ # Delivery is already done
+ response = self.service.dispatch(
+ "list_delivery_package_types",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": lines.ids,
+ },
+ )
+ message = {"message_type": "info", "body": "Operation already processed."}
+ data = {}
+ self.assert_response(response, next_state="start", data=data, message=message)
+
+ def test_list_delivery_package_picking_qty_superior(self):
+ self._create_package_type()
+ self.menu.sudo().write(
+ {
+ "pick_pack_same_time": True,
+ "default_pack_pickings_action": "package_type",
+ }
+ )
+
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[:1], self.bin2)
+ self._set_dest_package_and_done(move_lines[1:], self.bin1)
+ move_lines.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ # The first bin to process is bin1 we should therefore scan the bin 1
+ # to pack and put in pack
+ picking = move_lines[-1].picking_id
+ picking.carrier_id = self.carrier
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ lines = picking.move_line_ids.filtered(
+ lambda ml: ml.result_package_id.is_internal
+ ).sorted(key=lambda ml: ml.result_package_id.name)
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+
+ data = self.data.select_package(picking, lines)
+ self.assert_response(
+ response,
+ next_state="select_package",
+ data=data,
+ )
+ line = first(picking.move_line_ids)
+ line.qty_done = line.reserved_qty + 1
+ # Delivery is already done
+ response = self.service.dispatch(
+ "list_delivery_package_types",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": lines.ids,
+ },
+ )
+ message = {
+ "message_type": "warning",
+ "body": "The quantity scanned for one or more lines "
+ "cannot be higher than the maximum allowed. (%s : %s > %s)"
+ % (line.product_id.name, line.qty_done, line.reserved_qty),
+ }
+ data = self.data.select_package(picking, lines.sorted())
+ # data = self.data.pack_picking(next_picking)
+ self.assert_response(
+ response, next_state="select_package", data=data, message=message
+ )
+
+ def test_pack_package_type(self):
+ self._create_package_type()
+ self.menu.sudo().write(
+ {
+ "pick_pack_same_time": True,
+ "default_pack_pickings_action": "package_type",
+ }
+ )
+
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[:1], self.bin2)
+ self._set_dest_package_and_done(move_lines[1:], self.bin1)
+ move_lines.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ # The first bin to process is bin1 we should therefore scan the bin 1
+ # to pack and put in pack
+ picking = move_lines[-1].picking_id
+ picking.carrier_id = self.carrier
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ lines = picking.move_line_ids.filtered(
+ lambda ml: ml.result_package_id.is_internal
+ ).sorted(key=lambda ml: ml.result_package_id.name)
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+
+ data = self.data.select_package(picking, lines)
+ self.assert_response(
+ response,
+ next_state="select_package",
+ data=data,
+ )
+ # We use new pack
+ response = self.service.dispatch(
+ "list_delivery_package_types",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": lines.ids,
+ },
+ )
+ data = {}
+ data["selected_lines_for_packing"] = self.data.move_lines(lines)
+ data["packaging"] = self.data.delivery_packaging_list(self.package_types)
+ data["picking"] = self.data.picking(picking)
+ self.assert_response(
+ response,
+ next_state="select_delivery_packaging",
+ data=data,
+ )
+
+ response = self.service.dispatch(
+ "put_in_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": picking.move_line_ids.ids,
+ "package_type_id": self.package_type.id,
+ },
+ )
+ message = self.service.msg_store.stock_picking_packed_successfully(picking)
+ next_picking = self.batch.picking_ids.filtered(
+ lambda p: p.is_shopfloor_packing_todo
+ )
+ data = data = self.data.pack_picking(next_picking)
+
+ self.assert_response(
+ response, next_state="pack_picking_scan_pack", data=data, message=message
+ )
+
+ def test_pack_package_type_scan(self):
+ self._create_package_type()
+ self.menu.sudo().write(
+ {
+ "pick_pack_same_time": True,
+ "default_pack_pickings_action": "package_type",
+ }
+ )
+
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[:1], self.bin2)
+ self._set_dest_package_and_done(move_lines[1:], self.bin1)
+ move_lines.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ # The first bin to process is bin1 we should therefore scan the bin 1
+ # to pack and put in pack
+ picking = move_lines[-1].picking_id
+ picking.carrier_id = self.carrier
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ lines = picking.move_line_ids.filtered(
+ lambda ml: ml.result_package_id.is_internal
+ ).sorted(key=lambda ml: ml.result_package_id.name)
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+
+ data = self.data.select_package(picking, lines)
+ self.assert_response(
+ response,
+ next_state="select_package",
+ data=data,
+ )
+
+ # we scan the package type
+ response = self.service.dispatch(
+ "scan_package_action",
+ params={
+ "picking_id": picking.id,
+ "selected_line_ids": lines.ids,
+ "barcode": "BOX-5",
+ },
+ )
+ message = self.service.msg_store.stock_picking_packed_successfully(picking)
+ next_picking = first(
+ self.batch.picking_ids.filtered(lambda p: p.is_shopfloor_packing_todo)
+ )
+ data = self.data.pack_picking(next_picking)
+ self.assert_response(
+ response, next_state="pack_picking_scan_pack", message=message, data=data
+ )
+
+ def test_pack_package_type_no_picking(self):
+ self._create_package_type()
+ self.menu.sudo().write(
+ {
+ "pick_pack_same_time": True,
+ "default_pack_pickings_action": "package_type",
+ }
+ )
+
+ move_lines = self.move_lines
+ self._set_dest_package_and_done(move_lines[:1], self.bin2)
+ self._set_dest_package_and_done(move_lines[1:], self.bin1)
+ move_lines.write({"location_dest_id": self.packing_location.id})
+ response = self.service.dispatch(
+ "prepare_unload", params={"picking_batch_id": self.batch.id}
+ )
+ # The first bin to process is bin1 we should therefore scan the bin 1
+ # to pack and put in pack
+ picking = move_lines[-1].picking_id
+ picking.carrier_id = self.carrier
+ data = self.data.pack_picking(picking)
+ self.assert_response(
+ response,
+ next_state="pack_picking_scan_pack",
+ data=data,
+ )
+ lines = picking.move_line_ids.filtered(
+ lambda ml: ml.result_package_id.is_internal
+ ).sorted(key=lambda ml: ml.result_package_id.name)
+ # we scan the pack
+ response = self.service.dispatch(
+ "scan_packing_to_pack",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "barcode": self.bin1.name,
+ },
+ )
+
+ data = self.data.select_package(picking, lines)
+ self.assert_response(
+ response,
+ next_state="select_package",
+ data=data,
+ )
+
+ # Another action validated the picking
+ picking._action_done()
+
+ # We use new pack
+ response = self.service.dispatch(
+ "list_delivery_package_types",
+ params={
+ "picking_batch_id": self.batch.id,
+ "picking_id": picking.id,
+ "selected_line_ids": lines.ids,
+ },
+ )
+ data = {}
+ data["packaging"] = self.data.delivery_packaging_list(self.package_types)
+ data["picking"] = self.data.picking(picking)
+ message = {"message_type": "info", "body": "Operation already processed."}
+ data = {}
+ self.assert_response(response, next_state="start", data=data, message=message)
diff --git a/shopfloor_packing/tests/test_cluster_picking_unload.py b/shopfloor_packing/tests/test_cluster_picking_unload.py
new file mode 100644
index 00000000000..e81895089bb
--- /dev/null
+++ b/shopfloor_packing/tests/test_cluster_picking_unload.py
@@ -0,0 +1,50 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo.addons.shopfloor.tests.test_cluster_picking_unload import (
+ ClusterPickingPrepareUnloadCase,
+ ClusterPickingSetDestinationAllCase,
+ ClusterPickingUnloadScanDestinationCase,
+ ClusterPickingUnloadScanPackCase,
+ ClusterPickingUnloadSplitCase,
+)
+
+
+class ClusterPickingPrepareUnloadCase2(ClusterPickingPrepareUnloadCase):
+ """
+ Ensure that the normal unload process is preserved if the pack_pickings option.
+
+ is not activated on the menu (default)
+ """
+
+
+class ClusterPickingSetDestinationAllCase2(ClusterPickingSetDestinationAllCase):
+ """
+ Ensure that the normal unload process is preserved if the pack_pickings option.
+
+ is not activated on the menu (default)
+ """
+
+
+class ClusterPickingUnloadSplitCase2(ClusterPickingUnloadSplitCase):
+ """
+ Ensure that the normal unload process is preserved if the pack_pickings option.
+
+ is not activated on the menu (default)
+ """
+
+
+class ClusterPickingUnloadScanPackCase2(ClusterPickingUnloadScanPackCase):
+ """
+ Ensure that the normal unload process is preserved if the pack_pickings option.
+
+ is not activated on the menu (default)
+ """
+
+
+class ClusterPickingUnloadScanDestinationCase2(ClusterPickingUnloadScanDestinationCase):
+ """
+ Ensure that the normal unload process is preserved if the pack_pickings option.
+
+ is not activated on the menu (default)
+ """
diff --git a/shopfloor_packing/views/shopfloor_menu.xml b/shopfloor_packing/views/shopfloor_menu.xml
new file mode 100644
index 00000000000..d251ba72d14
--- /dev/null
+++ b/shopfloor_packing/views/shopfloor_menu.xml
@@ -0,0 +1,24 @@
+
+
+Shopfloor Packing
+ + +
In a two-step delivery process (or more), packing is a major task. +It is essential that the picking scenario helps operators to put products from +the same order into packages, when collecting multiple orders at the same time.
+This module adds a new configuration option to the “cluster picking” scenario, +enabling the packing of pickings into packages. +When this option is activated, the operator will be prompted to pack the +products of the same picking. +In the background, a package will be created and set as the destination for +the stock move lines.
+Table of contents
+
+
+-
+
- Usage +
- Bug Tracker +
- Credits + +
+
+Usage
+Go to the “cluster picking” scenario and check “Pack pickings”.
+
+
+Bug Tracker
+Bugs are tracked on GitHub Issues. +In case of trouble, please check there if your issue has already been reported. +If you spotted it first, help us to smash it by providing a detailed and welcomed +feedback.
+Do not contact contributors directly about support or help with technical issues.
+
+
+Credits
+
+
+Authors
+-
+
- ACSONE SA/NV +
+
+Contributors
+-
+
- Souheil Bejaoui <souheil.bejaoui@acsone.eu> +
- Denis Roussel <denis.roussel@acsone.eu> +
- Jacques-Étienne Baudoux <je@bcim.be> +
+
+
+
+Maintainers
+This module is maintained by the OCA.
+ +
+
+OCA, or the Odoo Community Association, is a nonprofit organization whose +mission is to support the collaborative development of Odoo features and +promote its widespread use.
+This module is part of the OCA/wms project on GitHub.
+You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
+