odoo-addon-stock-barcodes 16.0.1.1.0.10__py3-none-any.whl → 16.0.2.0.0.1__py3-none-any.whl

odoo/addons/stock_barcodes/static/src/views/{kanban_renderer.esm.js → kanban/kanban_renderer.esm.js}

@@ -2,14 +2,14 @@
 /* Copyright 2022 Tecnativa - Alexandre D. Díaz
  * License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). */
 
+import {onPatched, useEffect, useRef} from "@odoo/owl";
+import {useBus, useService} from "@web/core/utils/hooks";
 import {KanbanRenderer} from "@web/views/kanban/kanban_renderer";
-import {isAllowedBarcodeModel} from "../utils/barcodes_models_utils.esm";
+import {isAllowedBarcodeModel} from "../../utils/barcodes_models_utils.esm";
 import {patch} from "@web/core/utils/patch";
-import {useBus} from "@web/core/utils/hooks";
 import {useHotkey} from "@web/core/hotkeys/hotkey_hook";
-import {useRef} from "@odoo/owl";
 
-patch(KanbanRenderer.prototype, "add hotkey", {
+patch(KanbanRenderer.prototype, "stock_barcodes.KanbanRenderer", {
     setup() {
         const rootRef = useRef("root");
         useHotkey(
@@ -40,6 +40,34 @@ patch(KanbanRenderer.prototype, "add hotkey", {
         );
 
         this._super(...arguments);
+        this.ormService = useService("orm");
+        this.action = useService("action");
+        const busService = useService("bus_service");
+        this.enableCurrentOperation = 0;
+        const handleNotification = ({detail: notifications}) => {
+            if (notifications && notifications.length > 0) {
+                notifications.forEach((notif) => {
+                    const {payload, type} = notif;
+                    if (type === "enable_operations" && payload) {
+                        this.enableCurrentOperation = payload.id;
+                    }
+                });
+            }
+        };
+        useEffect(() => {
+            busService.addChannel("stock_barcodes_kanban_update");
+            busService.addEventListener("notification", handleNotification);
+            return () => {
+                busService.deleteChannel("stock_barcodes_kanban_update");
+                busService.removeEventListener("notification", handleNotification);
+            };
+        });
+
+        onPatched(() => {
+            $("div.oe_kanban_operations-" + this.enableCurrentOperation).removeClass(
+                "d-none"
+            );
+        });
 
         if (isAllowedBarcodeModel(this.props.list.resModel)) {
             if (this.env.searchModel) {
@@ -63,6 +91,36 @@ patch(KanbanRenderer.prototype, "add hotkey", {
                 });
             }
         }
+
+        this.showMessageScanProductPackage =
+            this.props.list.resModel === "stock.picking";
+    },
+
+    getNextCard(direction, iCard, cards, iGroup, isGrouped) {
+        let nextCard = null;
+        switch (direction) {
+            case "down":
+                nextCard = iCard < cards[iGroup].length - 1 && cards[iGroup][iCard + 1];
+                break;
+            case "up":
+                nextCard = iCard > 0 && cards[iGroup][iCard - 1];
+                break;
+            case "right":
+                if (isGrouped) {
+                    nextCard = iGroup < cards.length - 1 && cards[iGroup + 1][0];
+                } else {
+                    nextCard = iCard < cards[0].length - 1 && cards[0][iCard + 1];
+                }
+                break;
+            case "left":
+                if (isGrouped) {
+                    nextCard = iGroup > 0 && cards[iGroup - 1][0];
+                } else {
+                    nextCard = iCard > 0 && cards[0][iCard - 1];
+                }
+                break;
+        }
+        return nextCard;
     },
 
     // eslint-disable-next-line complexity
@@ -77,6 +135,8 @@ patch(KanbanRenderer.prototype, "add hotkey", {
      *
      * @param {Node} area
      * @param {String} direction
+     *
+     * @returns {String/Boolean}
      */
     focusNextCard(area, direction) {
         const {isGrouped} = this.props.list;
@@ -117,33 +177,24 @@ patch(KanbanRenderer.prototype, "add hotkey", {
             iGroup = 0;
         }
         // Find next card to focus
-        let nextCard = null;
-        switch (direction) {
-            case "down":
-                nextCard = iCard < cards[iGroup].length - 1 && cards[iGroup][iCard + 1];
-                break;
-            case "up":
-                nextCard = iCard > 0 && cards[iGroup][iCard - 1];
-                break;
-            case "right":
-                if (isGrouped) {
-                    nextCard = iGroup < cards.length - 1 && cards[iGroup + 1][0];
-                } else {
-                    nextCard = iCard < cards[0].length - 1 && cards[0][iCard + 1];
-                }
-                break;
-            case "left":
-                if (isGrouped) {
-                    nextCard = iGroup > 0 && cards[iGroup - 1][0];
-                } else {
-                    nextCard = iCard > 0 && cards[0][iCard - 1];
-                }
-                break;
-        }
+        const nextCard = this.getNextCard(direction, iCard, cards, iGroup, isGrouped);
 
         if (nextCard && nextCard instanceof HTMLElement) {
             nextCard.focus();
             return true;
         }
     },
+
+    async openBarcodeScanner() {
+        if (this.showMessageScanProductPackage) {
+            const action = await this.ormService.call(
+                "stock.picking",
+                "action_barcode_scan",
+                [false, false]
+            );
+            this.action.doAction(action);
+        }
+    },
 });
+
+KanbanRenderer.template = "stock_barcodes.BarcodeKanbanRenderer";

odoo/addons/stock_barcodes/static/src/views/kanban/kanban_view.esm.js

@@ -0,0 +1,8 @@
+/** @odoo-module */
+
+import {kanbanView} from "@web/views/kanban/kanban_view";
+import {registry} from "@web/core/registry";
+
+registry.category("views").add("stock_barcodes_kanban", {
+    ...kanbanView,
+});

odoo/addons/stock_barcodes/static/src/views/kanban/stock_barcodes_kanban.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<templates xml:space="preserve">
+
+    <t
+        t-name="stock_barcodes.BarcodeKanbanRenderer"
+        t-inherit="web.KanbanRenderer"
+        owl="1"
+    >
+        <xpath expr="//div[hasclass('o_kanban_renderer')]" position="before">
+            <div
+                t-if="showMessageScanProductPackage"
+                class="o_kanban_stock_barcodes text-white w-100 mt-1 mb-1 d-flex align-items-center justify-content-center bg-dark"
+            >
+                <span t-if="packageEnabled">Scan a <b>transfer</b>, a <b
+                    >product</b> or a <b>lot</b> to filter your records</span>
+                <span t-else="">Scan a <b>transfer</b> or a <b
+                    >product</b> to filter your records</span>
+                <button
+                    class="o_stock_mobile_barcode btn"
+                    t-on-click="openBarcodeScanner"
+                >
+                    <i class="fa fa-barcode" />
+                </button>
+            </div>
+        </xpath>
+    </t>
+
+</templates>

odoo/addons/stock_barcodes/static/src/views/views.esm.js

@@ -7,6 +7,7 @@ import {getVisibleElements, isVisible} from "@web/core/utils/ui";
 import {FormController} from "@web/views/form/form_controller";
 import {KanbanController} from "@web/views/kanban/kanban_controller";
 import {ListController} from "@web/views/list/list_controller";
+import {_t} from "@web/core/l10n/translation";
 import {isAllowedBarcodeModel} from "../utils/barcodes_models_utils.esm";
 import {patch} from "@web/core/utils/patch";
 import {useEffect} from "@odoo/owl";
@@ -94,7 +95,7 @@ function setupView() {
         } else if (ev.keyCode === 123 || ev.keyCode === 115) {
             // F12 or F4
             await actionService.doAction(
-                "stock_barcodes.action_stock_barcodes_action",
+                "stock_barcodes.action_stock_barcodes_action_client",
                 {
                     name: "Barcode wizard menu",
                     res_model: "wiz.stock.barcodes.read.picking",
@@ -109,8 +110,8 @@ function setupView() {
             notifications.forEach((notif) => {
                 const {payload, type} = notif;
                 if (
-                    (this.model.root.resModel == payload.res_model) &
-                    (this.model.root.resId == payload.res_id)
+                    (this.model.root.resModel === payload.res_model) &
+                    (this.model.root.resId === payload.res_id)
                 ) {
                     if (type === "stock_barcodes_sound") {
                         if (payload.sound === "ko") {
@@ -118,8 +119,7 @@ function setupView() {
                         } else {
                             this.$sound_ok[0].play();
                         }
-                    }
-                    if (type === "stock_barcodes_focus") {
+                    } else if (type === "stock_barcodes_focus") {
                         requestIdleCallback(() => {
                             const input = document.querySelector(
                                 `[name=${payload.field_name}] input`
@@ -128,8 +128,7 @@ function setupView() {
                                 input.focus();
                             }
                         });
-                    }
-                    if (type === "stock_barcodes_notify") {
+                    } else if (type === "stock_barcodes_notify") {
                         notification.add(notif.payload.message, {
                             title: notif.payload.title,
                             type: notif.payload.type,
@@ -137,6 +136,35 @@ function setupView() {
                         });
                     }
                 }
+
+                if (type === "stock_barcodes_edit_manual") {
+                    if (payload.manual_entry) {
+                        this.env.bus.trigger("enableFormEditBarcode");
+                    } else if (!payload.manual_entry) {
+                        this.env.bus.trigger("disableFormEditBarcode");
+                    }
+                } else if (type === "actions_barcode") {
+                    if (payload.valid_picking) {
+                        notification.add(_t("The transfer has been validated"), {
+                            type: "success",
+                        });
+                    } else if (payload.apply_inventory) {
+                        actionService.doAction(
+                            "stock_barcodes.action_stock_barcodes_action_client"
+                        );
+                        notification.add(
+                            _t("The inventory adjustment has been validated"),
+                            {
+                                type: "success",
+                            }
+                        );
+                    }
+                } else if (type === "actions_barcode_notification") {
+                    notification.add(_t(payload.message), {
+                        type: payload.message_type,
+                        sticky: payload.sticky,
+                    });
+                }
             });
         }
     };

odoo/addons/stock_barcodes/static/src/widgets/boolean_toggle.esm.js

@@ -3,9 +3,25 @@
  * License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). */
 
 import {BooleanToggleField} from "@web/views/fields/boolean_toggle/boolean_toggle_field";
+import {onMounted} from "@odoo/owl";
 import {registry} from "@web/core/registry";
+import {useBus} from "@web/core/utils/hooks";
 
 class BarcodeBooleanToggleField extends BooleanToggleField {
+    setup() {
+        super.setup();
+        onMounted(() => {
+            this.enableFormEdit(this.props.value, true);
+        });
+
+        useBus(this.env.bus, "enableFormEditBarcode", () =>
+            this.enableFormEdit(true, true)
+        );
+        useBus(this.env.bus, "disableFormEditBarcode", () =>
+            this.enableFormEdit(false, true)
+        );
+    }
+
     /*
     This is needed because, whenever we click the checkbox to enter data
     manually, the checkbox will be focused causing that when we scan the
@@ -20,6 +36,36 @@ class BarcodeBooleanToggleField extends BooleanToggleField {
         requestIdleCallback(() => {
             document.activeElement.blur();
         });
+        this.enableFormEdit(newValue);
+    }
+
+    enableFormEdit(newValue, editAction = false) {
+        // Enable edit form
+        if (this.props.name === "manual_entry" || editAction) {
+            const $form_edit = $("div.oe_stock_barcordes_content > div.scan_fields");
+            const $div_inventory_quant_ids = $("div[name='inventory_quant_ids']").find(
+                "div.o_kanban_renderer"
+            );
+            if ($form_edit.length > 0) {
+                if (newValue) {
+                    $form_edit.removeClass("d-none");
+                    $div_inventory_quant_ids.addClass("inventory_quant_ids_with_form");
+                    $div_inventory_quant_ids.removeClass(
+                        "inventory_quant_ids_without_form"
+                    );
+                } else {
+                    $form_edit.addClass("d-none");
+                    $div_inventory_quant_ids.removeClass(
+                        "inventory_quant_ids_with_form"
+                    );
+                    $div_inventory_quant_ids.addClass(
+                        "inventory_quant_ids_without_form"
+                    );
+                }
+            } else {
+                $div_inventory_quant_ids.addClass("inventory_quant_ids_without_form");
+            }
+        }
     }
 }
 

odoo/addons/stock_barcodes/tests/common.py

@@ -21,9 +21,12 @@ class TestCommonStockBarcodes(TransactionCase):
         cls.Product = cls.env["product.product"]
         cls.ProductPackaging = cls.env["product.packaging"]
         cls.WizScanReadPicking = cls.env["wiz.stock.barcodes.read.picking"]
+        cls.WizScanReadInventory = cls.env["wiz.stock.barcodes.read.inventory"]
+        cls.WizCandidatePicking = cls.env["wiz.candidate.picking"]
         cls.StockProductionLot = cls.env["stock.lot"]
         cls.StockPicking = cls.env["stock.picking"]
         cls.StockQuant = cls.env["stock.quant"]
+        cls.StockBarcodeAction = cls.env["stock.barcodes.action"]
 
         cls.company = cls.env.company
 
@@ -103,6 +106,28 @@ class TestCommonStockBarcodes(TransactionCase):
         cls.wiz_scan = cls.WizScanReadPicking.create(
             {"option_group_id": cls.option_group.id, "step": 1}
         )
+        cls.wiz_scan_read_inventory = cls.WizScanReadInventory.create(
+            {"option_group_id": cls.option_group.id, "step": 1}
+        )
+
+        cls.wiz_scan_candidate_picking = cls.WizCandidatePicking.create(
+            {"wiz_barcode_id": cls.wiz_scan.id}
+        )
+
+        # Barcode actions
+        cls.barcode_action_valid = cls.StockBarcodeAction.create(
+            {
+                "name": "Barcode action valid",
+                "action_window_id": cls.env.ref("stock.stock_picking_type_action").id,
+                "context": "{'search_default_barcode_options': 1}",
+            }
+        )
+
+        cls.barcode_action_invalid = cls.StockBarcodeAction.create(
+            {
+                "name": "Barcode action valid",
+            }
+        )
 
     @classmethod
     def _create_barcode_option_group(cls):

odoo/addons/stock_barcodes/tests/test_stock_barcodes.py

@@ -1,8 +1,13 @@
 # Copyright 2108-2019 Sergio Teruel <sergio.teruel@tecnativa.com>
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
 
+import re
+
+from odoo.exceptions import ValidationError
 from odoo.tests.common import tagged
 
+from odoo.addons.stock_barcodes.models.stock_barcodes_action import FIELDS_NAME, REGEX
+
 from .common import TestCommonStockBarcodes
 
 
@@ -42,7 +47,7 @@ class TestStockBarcodes(TestCommonStockBarcodes):
         self.wiz_scan.manual_entry = True
         self.wiz_scan.action_clean_values()
         self.action_barcode_scanned(self.wiz_scan, "5420008510489")
-        self.assertEqual(self.wiz_scan.packaging_qty, 0.0)
+        self.assertEqual(self.wiz_scan.packaging_qty, 1.0)
         self.wiz_scan.packaging_qty = 3.0
         self.wiz_scan.onchange_packaging_qty()
         self.assertEqual(self.wiz_scan.product_qty, 15.0)
@@ -75,3 +80,62 @@ class TestStockBarcodes(TestCommonStockBarcodes):
         self.action_barcode_scanned(self.wiz_scan, "8411822222568")
         self.wiz_scan.action_clean_lot()
         self.assertFalse(self.wiz_scan.lot_id)
+
+    def test_barcode_action(self):
+        self.assertTrue(self.barcode_action_valid.action_window_id)
+        self.assertEqual(bool(self.barcode_action_invalid.action_window_id), False)
+
+    def test_action_back(self):
+        result = self.wiz_scan.action_back()
+        self.assertIn("name", result)
+        self.assertIn("type", result)
+        self.assertIn("res_model", result)
+        self.assertEqual(result["type"], "ir.actions.act_window")
+
+    def test_barcode_context_action(self):
+        context = self.barcode_action_valid.context
+        self.assertTrue(bool(re.match(REGEX.get("context", ""), context)))
+        self.assertGreater(len(context), 0)
+        context = context.strip("{}").split(",")
+        field_values = context[0].split(":")
+        self.assertGreater(len(field_values), 1)
+        field_name = field_values[0].split("search_default_")
+        self.assertGreater(len(field_name), 1)
+        field_value_format = field_values[1].replace("'", "").strip()
+        self.assertTrue(field_value_format.isdigit())
+        self.assertEqual(field_values[0].strip("'"), "search_default_barcode_options")
+        self.assertTrue(len(field_values[0].split("search_default_")), 2)
+        self.assertEqual(self.barcode_action_invalid._count_elements(), 0)
+        self.barcode_action_invalid.context = False
+        with self.assertRaises(TypeError):
+            self.barcode_action_invalid._compute_count_elements()
+        self.barcode_action_invalid.context = "{}"
+        self.assertFalse("search_default_" in self.barcode_action_invalid.context)
+
+        self.assertEqual(self.barcode_action_invalid._count_elements(), 0)
+        self.barcode_action_valid.context = "{'search_default_code': 1}"
+        self.assertEqual(self.barcode_action_valid._count_elements(), 6)
+        field_value_name = (
+            self.barcode_action_valid.context.strip("{}").split(",")[0].split(":")
+        )
+        field_name = field_value_name[0].split("search_default_")[1].strip("'")
+        self.assertTrue("search_default_" in self.barcode_action_valid.context)
+        self.assertFalse(
+            hasattr(
+                self.barcode_action_valid.action_window_id.res_model,
+                FIELDS_NAME.get(field_name, field_name),
+            )
+        )
+        field_values = field_value_name[1].strip()
+        self.assertTrue(field_values.isdigit())
+
+        with self.assertRaises(IndexError):
+            self.barcode_action_invalid.context = "{'search_default_'}"
+            self.assertEqual(self.barcode_action_invalid._count_elements(), 0)
+        with self.assertRaises(ValidationError):
+            self.StockBarcodeAction.create(
+                {
+                    "name": "Barcode action invalid with space",
+                    "context": "{'search_default_code': 'incoming'}  ",
+                }
+            )

odoo/addons/stock_barcodes/tests/test_stock_barcodes_picking.py

@@ -1,5 +1,6 @@
 # Copyright 2108-2019 Sergio Teruel <sergio.teruel@tecnativa.com>
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+from odoo.exceptions import MissingError, UserError
 from odoo.tests.common import tagged
 
 from .common import TestCommonStockBarcodes
@@ -140,7 +141,10 @@ class TestStockBarcodesPicking(TestCommonStockBarcodes):
         )
 
     def test_picking_wizard_scan_product(self):
-        wiz_scan_picking = self.wiz_scan_picking.with_context(force_create_move=True)
+        # self.wiz_scan_picking.manual_entry = True
+        wiz_scan_picking = self.wiz_scan_picking.with_context(
+            force_create_move=True, no_increase_qty_done=True
+        )
         self.action_barcode_scanned(wiz_scan_picking, "8480000723208")
         sml = self.picking_in_01.move_line_ids.filtered(
             lambda x: x.product_id == self.product_wo_tracking
@@ -166,9 +170,9 @@ class TestStockBarcodesPicking(TestCommonStockBarcodes):
         self.assertEqual(sml.qty_done, 1.0)
         self.action_barcode_scanned(wiz_scan_picking, "8433281006850")
         stock_move = sml.move_id
-        self.assertEqual(sum(stock_move.move_line_ids.mapped("qty_done")), 2.0)
+        self.assertEqual(sum(stock_move.move_line_ids.mapped("qty_done")), 1.0)
         self.action_barcode_scanned(wiz_scan_picking, "8411822222568")
-        self.assertEqual(sum(stock_move.move_line_ids.mapped("qty_done")), 3.0)
+        self.assertEqual(sum(stock_move.move_line_ids.mapped("qty_done")), 1.0)
         self.assertEqual(
             self.wiz_scan_picking.message,
             "8411822222568 (Scan Product, Packaging, Lot / Serial)",
@@ -176,10 +180,12 @@ class TestStockBarcodesPicking(TestCommonStockBarcodes):
         # Scan a package
         self.action_barcode_scanned(wiz_scan_picking, "5420008510489")
         # Package of 5 product units. Already three unit exists
-        self.assertEqual(sum(stock_move.move_line_ids.mapped("qty_done")), 8.0)
+        self.assertEqual(sum(stock_move.move_line_ids.mapped("qty_done")), 5.0)
 
     def test_picking_wizard_scan_product_manual_entry(self):
-        wiz_scan_picking = self.wiz_scan_picking.with_context(force_create_move=True)
+        wiz_scan_picking = self.wiz_scan_picking.with_context(
+            force_create_move=True, no_increase_qty_done=True
+        )
         wiz_scan_picking.manual_entry = True
         self.action_barcode_scanned(wiz_scan_picking, "8480000723208")
         sml = self.picking_in_01.move_line_ids.filtered(
@@ -203,8 +209,10 @@ class TestStockBarcodesPicking(TestCommonStockBarcodes):
         self.wiz_scan_picking.lot_id = self.lot_1
         self.wiz_scan_picking.product_qty = 2
 
-        self.wiz_scan_picking.with_context(force_create_move=True).action_confirm()
-        self.assertEqual(len(self.wiz_scan_picking.candidate_picking_ids), 2)
+        self.wiz_scan_picking.with_context(
+            force_create_move=True, no_increase_qty_done=True
+        ).action_confirm()
+        self.assertEqual(len(self.wiz_scan_picking.candidate_picking_ids[0:2]), 2)
         # Lock first picking
         candidate = self.wiz_scan_picking.candidate_picking_ids.filtered(
             lambda c: c.picking_id == self.picking_out_01
@@ -215,21 +223,27 @@ class TestStockBarcodesPicking(TestCommonStockBarcodes):
         candidate_wiz.with_context(force_create_move=True).action_lock_picking()
         self.assertEqual(self.picking_out_01.move_ids.quantity_done, 2)
         self.wiz_scan_picking.product_qty = 2
-        self.wiz_scan_picking.with_context(force_create_move=True).action_confirm()
-        self.assertEqual(self.picking_out_01.move_ids.quantity_done, 4)
+        self.wiz_scan_picking.with_context(
+            force_create_move=True, no_increase_qty_done=True
+        ).action_confirm()
+        self.assertEqual(self.picking_out_01.move_ids.quantity_done, 2)
 
         # Picking out 3 is in confirmed state, so until confirmed moves has
         # not been activated candidate pickings is 2
         picking_out_3.action_confirm()
         candidate_wiz.action_unlock_picking()
         self.wiz_scan_picking.product_qty = 2
-        self.wiz_scan_picking.with_context(force_create_move=True).action_confirm()
-        self.assertEqual(len(self.wiz_scan_picking.candidate_picking_ids), 2)
+        self.wiz_scan_picking.with_context(
+            force_create_move=True, no_increase_qty_done=True
+        ).action_confirm()
+        self.assertEqual(len(self.wiz_scan_picking.candidate_picking_ids[0:2]), 2)
         candidate_wiz.action_unlock_picking()
         self.wiz_scan_picking.product_qty = 2
         self.wiz_scan_picking.option_group_id.confirmed_moves = True
-        self.wiz_scan_picking.with_context(force_create_move=True).action_confirm()
-        self.assertEqual(len(self.wiz_scan_picking.candidate_picking_ids), 3)
+        self.wiz_scan_picking.with_context(
+            force_create_move=True, no_increase_qty_done=True
+        ).action_confirm()
+        self.assertEqual(len(self.wiz_scan_picking.candidate_picking_ids[0:3]), 3)
 
     def test_picking_wizard_scan_product_auto_lot(self):
         # Prepare more data
@@ -453,3 +467,73 @@ class TestStockBarcodesPicking(TestCommonStockBarcodes):
                 ],
             }
         )
+
+    def test_stock_picking_validate(self):
+        self.picking_in_01.state = False
+        with self.assertRaises(UserError):
+            self.picking_in_01.with_context(
+                stock_barcodes_validate_picking=True
+            ).button_validate()
+
+    def test_barcode_read_picking(self):
+        self.picking_in_01.state = "done"
+        self.wiz_scan_picking._compute_enable_add_product()
+        self.assertFalse(self.wiz_scan_picking.enable_add_product)
+
+        self.wiz_scan_picking.show_detailed_operations = False
+        self.wiz_scan_picking.action_show_detailed_operations()
+        self.assertTrue(self.wiz_scan_picking.action_show_detailed_operations)
+
+        self.wiz_scan_picking.action_show_detailed_operations()
+        self.assertFalse(self.wiz_scan_picking.show_detailed_operations)
+
+    def test_barcode_read_inventory(self):
+        context = {
+            "params": {
+                "model": "wiz.stock.barcodes.read.inventory",
+                "id": self.quant_lot_1.id,
+            }
+        }
+        with self.assertRaises(MissingError):
+            self.quant_lot_1.with_context(
+                **context
+            ).action_barcode_inventory_quant_unlink()
+        context = {
+            "params": {
+                "model": self.wiz_scan_read_inventory._name,
+                "id": self.wiz_scan_read_inventory.id,
+            }
+        }
+        self.quant_lot_1.with_context(**context).action_barcode_inventory_quant_unlink()
+        self.assertIsNone(
+            self.quant_lot_1.with_context(
+                **context
+            ).action_barcode_inventory_quant_unlink()
+        )
+        self.assertIsNone(self.quant_lot_1.enable_current_operations())
+        self.assertIsNone(self.quant_lot_1.action_barcode_inventory_quant_edit())
+        with self.assertRaises(ValueError):
+            self.quant_lot_1.write({"inventory_quantity": "test"})
+            self.quant_lot_1.operation_quantities_rest()
+            self.quant_lot_1.operation_quantities()
+        self.assertEqual(
+            type(self.picking_in_01.picking_type_id.get_action_picking_tree_ready()),
+            dict,
+        )
+        self.assertEqual(
+            type(
+                self.picking_in_01.picking_type_id.with_context(
+                    **{"operations_mode": True}
+                ).get_action_picking_tree_ready()
+            ),
+            dict,
+        )
+        self.assertIsNone(self.wiz_scan_candidate_picking._compute_picking_quantity())
+        self.assertIsNone(self.wiz_scan_candidate_picking._compute_is_pending())
+        self.assertEqual(
+            self.wiz_scan_candidate_picking._get_picking_to_validate()._name,
+            self.picking_in_01._name,
+        )
+        self.assertEqual(
+            type(self.wiz_scan_candidate_picking.action_validate_picking()), tuple
+        )