[ADD] sale purchase: added barcode scanning in product catalog

 Automatically hit adds quantity 1 when a product is found via barcode scan
 (no manual intervention)
Show toaster message 'No product found with this barcode number' if no match is
 found
Increment quantity on existing order line if the same product is scanned
multiple times
Ensure all scanned products are sorted and shown on the first page

Author: kdes-odoo

sales_order_barcode/__manifest__.py

@@ -0,0 +1,16 @@
+{
+    "name": "Sale Order Barcode Scanning",
+    "version": "1.0",
+    "category": "Sales",
+    "summary": "Adds products to SO from catalog via barcode scanning.",
+    "author": "Kalpan Desai",
+    "depends": ["sale_management", "web", "product"],
+    "license": "LGPL-3",
+    "assets": {
+        "web.assets_backend": [
+            "sales_order_barcode/static/src/**/*"
+        ]
+    },
+    "installable": True,
+    "application": True,
+}

sales_order_barcode/static/src/barcodescanner_controller.js

@@ -0,0 +1,145 @@
+import { patch } from "@web/core/utils/patch";
+import { ProductCatalogKanbanController } from "@product/product_catalog/kanban_controller";
+import { rpc } from "@web/core/network/rpc";
+import { useService } from "@web/core/utils/hooks";
+import { onMounted, onWillUnmount } from "@odoo/owl";
+
+patch(ProductCatalogKanbanController.prototype, {
+    /**
+     * @override
+     */
+    setup() {
+        super.setup();
+        this.orm = useService("orm");
+        this.notification = useService("notification");
+        this.orderId = this.props.context.order_id;
+        // The resModel of the order
+        this.orderResModel = this.props.context.product_catalog_order_model;
+
+        // Properties for keyboard-based barcode scanning
+        this.lastInputTime = 0;
+        this.barcodeBuffer = "";
+
+        // Bind the keydown handler to this component instance
+        this._onKeyDown = this._onKeyDown.bind(this);
+
+        // Add and remove the event listener when the component is mounted and unmounted.
+        onMounted(() => {
+            document.addEventListener("keydown", this._onKeyDown);
+        });
+
+        onWillUnmount(() => {
+            document.removeEventListener("keydown", this._onKeyDown);
+        });
+    },
+
+    /**
+     * Handles the 'keydown' event to capture barcode scans from a keyboard/scanner.
+     *
+     * @param {KeyboardEvent} ev
+     */
+    async _onKeyDown(ev) {
+        // Ignore key events if they originate from an input, textarea, or select element
+        // to avoid interfering with user typing.
+        const targetTagName = ev.target.tagName;
+        if (targetTagName === 'INPUT' || targetTagName === 'TEXTAREA' || targetTagName === 'SELECT') {
+            return;
+        }
+
+        const currentTime = new Date().getTime();
+        // If the last keypress was more than 500ms ago, reset the buffer.
+        // This prevents accidental concatenation of different barcodes.
+        if (currentTime - this.lastInputTime > 500) {
+            this.barcodeBuffer = "";
+        }
+
+        // If the 'Enter' key is pressed, process the buffered input as a barcode.
+        if (ev.key === "Enter") {
+            if (this.barcodeBuffer.length > 1) {
+                this._processBarcode(this.barcodeBuffer);
+                this.barcodeBuffer = ""; // Reset buffer after processing
+            }
+        } else if (ev.key.length === 1) {
+            // Append the character to our buffer if it's a single character key.
+            this.barcodeBuffer += ev.key;
+        }
+
+        // Update the timestamp of the last keypress.
+        this.lastInputTime = currentTime;
+    },
+
+    /**
+     * Processes the scanned barcode to find the corresponding product and update the order.
+     *
+     * @param {string} scannedBarcode The barcode string to process.
+     */
+    async _processBarcode(scannedBarcode) {
+        // An order must be selected to add products.
+        if (!this.orderId) {
+            this.notification.add("Please select an order first.", { type: "warning" });
+            return;
+        }
+
+        try {
+            // Search for a product with the scanned barcode.
+            const products = await this.orm.searchRead(
+                "product.product",
+                [["barcode", "=", scannedBarcode]],
+                ["id", "name"]
+            );
+
+            if (!products.length) {
+                this.notification.add("No product found for this barcode.", { type: "warning" });
+                return;
+            }
+
+            const product = products[0];
+
+            let orderLineModel, quantityField;
+            // Determine the correct model and field names based on the order type.
+            if (this.orderResModel === "sale.order") {
+                orderLineModel = "sale.order.line";
+                quantityField = "product_uom_qty";
+            } else if (this.orderResModel === "purchase.order") {
+                orderLineModel = "purchase.order.line";
+                quantityField = "product_qty";
+            } else {
+                // Log an error if the order model is not supported.
+                console.error("Unsupported order model for barcode scanning:", this.orderResModel);
+                this.notification.add("Barcode scanning is not supported for this document type.", { type: "danger" });
+                return;
+            }
+
+            // Check if there is an existing order line for this product.
+            const existingOrderLines = await this.orm.searchRead(
+                orderLineModel,
+                [["order_id", "=", this.orderId], ["product_id", "=", product.id]],
+                ["id", quantityField]
+            );
+
+            // If a line exists, increment its quantity; otherwise, set quantity to 1.
+            const updatedQuantity = existingOrderLines.length ? existingOrderLines[0][quantityField] + 1 : 1;
+
+            // Call the backend to create or update the order line.
+            await rpc("/product/catalog/update_order_line_info", {
+                res_model: this.orderResModel,
+                order_id: this.orderId,
+                product_id: product.id,
+                quantity: updatedQuantity,
+            });
+
+            // Notify the user of the successful addition.
+            this.notification.add(
+                `Added ${product.name} (Qty: ${updatedQuantity})`,
+                { type: "success" }
+            );
+
+            // Reload the view to show the updated order line information.
+            this.model.load();
+
+        } catch (error) {
+            console.error("Error processing barcode scan:", error);
+            this.notification.add("An error occurred while processing the barcode.", { type: "danger" });
+        }
+    },
+});

sales_order_barcode/static/src/kanban_model.js

@@ -0,0 +1,82 @@
+/** @odoo-module **/
+
+import { rpc } from "@web/core/network/rpc";
+import { ProductCatalogKanbanModel } from "@product/product_catalog/kanban_model";
+import { getFieldsSpec } from "@web/model/relational_model/utils";
+
+export class BarcodeProductCatalogKanbanModel extends ProductCatalogKanbanModel {
+
+    // async _loadData(params) {
+    //     const result = await super._loadData(...arguments);
+    //     // Only when not mono-record and no grouping
+    //     if (!params.isMonoRecord && !params.groupBy.length) {
+    //         const orderLines = await rpc("/product/catalog/order_lines_info", super._getorderLinesParams(params, result.records.map((rec) => rec.id)));
+    //         for (const record of result.records) {
+    //             record.productCatalogData = orderLines[record.id];
+    //         }
+    //         // === SORT: Move products with higher ordered quantity to top ===
+    //         result.records.sort((a, b) => {
+    //             const qtyA = (a.productCatalogData && a.productCatalogData.quantity) || 0;
+    //             const qtyB = (b.productCatalogData && b.productCatalogData.quantity) || 0;
+    //             // Descending by quantity, then by id for stability
+    //             if (qtyB === qtyA) return a.id - b.id;
+    //             return qtyB - qtyA;
+    //         });
+    //     }
+    //     return result;
+    // }
+
+
+    async _loadUngroupedList(config) {
+        const allProducts = await this.orm.search(config.resModel, config.domain);
+
+        if (!allProducts.length) {
+            return { records: [], length: 0 };
+        }
+
+        let orderLines = {};
+        const scanned = [], unscanned = [];
+
+        if (config.context.order_id && config.context.product_catalog_order_model) {
+            orderLines = await rpc("/product/catalog/order_lines_info", {
+                order_id: config.context.order_id,
+                product_ids: allProducts,
+                res_model: config.context.product_catalog_order_model,
+            });
+
+            for (const id of allProducts) {
+                const qty = (orderLines[id]?.quantity) || 0;
+                if (qty > 0) scanned.push(id);
+                else unscanned.push(id);
+            }
+
+
+            scanned.sort((a, b) =>
+                (orderLines[b]?.quantity || 0) - (orderLines[a]?.quantity || 0)
+            );
+        } else {
+            unscanned.push(...allProducts);
+        }
+
+        const sortedProductIds = [...scanned, ...unscanned];
+        const paginatedProductIds = sortedProductIds.slice(config.offset, config.offset + config.limit);
+
+        const kwargs = {
+            specification: getFieldsSpec(config.activeFields, config.fields, config.context),
+        };
+
+        const result = await this.orm.webSearchRead(config.resModel, [["id", "in", paginatedProductIds]], kwargs);
+
+        result.records.sort((a, b) => {
+            const qtyA = orderLines[a.id]?.quantity || 0;
+            const qtyB = orderLines[b.id]?.quantity || 0;
+            return qtyB - qtyA || a.id - b.id;
+        });
+
+        return {
+            length: allProducts.length,
+            records: result.records,
+        };
+    }
+
+}

sales_order_barcode/static/src/kanban_view.js

@@ -0,0 +1,11 @@
+import { registry } from "@web/core/registry";
+import { productCatalogKanbanView } from "@product/product_catalog/kanban_view";
+import { BarcodeProductCatalogKanbanModel } from "./kanban_model";
+
+export const BarcodeProductCatalogKanbanView = {
+    ...productCatalogKanbanView,
+    Model: BarcodeProductCatalogKanbanModel,
+};
+
+registry.category("views").remove("product_kanban_catalog");
+registry.category("views").add("product_kanban_catalog", BarcodeProductCatalogKanbanView);

sales_order_barcode1/__init__.py

@@ -0,0 +1 @@
+from . import models

sales_order_barcode1/__manifest__.py

@@ -0,0 +1,18 @@
+{
+    "name": "Sale Order Barcode Scanning",
+    "version": "1.0",
+    "summary": "Adds products to SO from catalog via barcode scanning.",
+    "author": "Kalpan Desai",
+    "depends": ["sale_management", "web", "product", "base"],
+    "license": "LGPL-3",
+    "assets": {
+        "web.assets_backend": [
+            "sales_order_barcode1/static/src/barcode_handler.js",
+        ],
+    },
+    "data": [
+        "views/sale_order_view.xml",
+    ],
+    "installable": True,
+    "application": True,
+}

sales_order_barcode1/models/__init__.py

@@ -0,0 +1 @@
+from . import sales_order

sales_order_barcode1/models/sales_order.py

@@ -0,0 +1,44 @@
+from odoo import api, models
+
+
+class SaleOrder(models.Model):
+    _inherit = 'sale.order'
+
+    @api.model
+    def add_product_by_barcode(self, barcode, order_id):
+        # print("function called by %s %s",barcode,order_id)
+
+        """Finds a product by barcode and adds/updates it in the given SO."""
+        if not barcode or not order_id:
+            return {'warning': 'Barcode or Order ID not provided.'}
+
+        order = self.browse(order_id)
+        product = self.env['product.product'].search(
+            [('barcode', '=', barcode)], limit=1
+        )
+
+        if not product:
+            # Request: Raise toaster "No product found..."
+            return {'warning': ('No product found with this barcode: %s') % barcode}
+
+        existing_line = self.env['sale.order.line'].search([
+            ('order_id', '=', order.id),
+            ('product_id', '=', product.id)
+        ], limit=1)
+
+        # Request: If scanning the same product, increase the qty
+        if existing_line:
+            existing_line.product_uom_qty += 1
+        # Request: Hit the 'add' button with qty 1
+        else:
+            self.env['sale.order.line'].create({
+                'order_id': order.id,
+                'product_id': product.id,
+                'product_uom_qty': 1,
+            })
+
+        # Return product info to highlight the card in the UI
+        return {
+            'product_id': product.id,
+            'product_name': product.name,
+        }