@things-factory/worksheet-base 4.3.651 → 4.3.652

package/dist-server/controllers/outbound/picking-worksheet-controller.js

@@ -0,0 +1,2489 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortingProduct = exports.createConsignmentWithMultipackage = exports.createConsignmentPackageItem = exports.createConsignmentPackage = exports.createOrderConsignment = exports.splitOrderConsignment = exports.createOrderPackageAndItems = exports.PickingWorksheetController = void 0;
+const typeorm_1 = require("typeorm");
+const uuid_1 = require("uuid");
+const auth_base_1 = require("@things-factory/auth-base");
+const env_1 = require("@things-factory/env");
+const id_rule_base_1 = require("@things-factory/id-rule-base");
+const integration_powrup_1 = require("@things-factory/integration-powrup");
+const product_base_1 = require("@things-factory/product-base");
+const sales_base_1 = require("@things-factory/sales-base");
+const setting_base_1 = require("@things-factory/setting-base");
+const warehouse_base_1 = require("@things-factory/warehouse-base");
+const integration_base_1 = require("@things-factory/integration-base");
+const constants_1 = require("../../constants");
+const entities_1 = require("../../entities");
+const utils_1 = require("../../utils");
+const vas_worksheet_controller_1 = require("../vas/vas-worksheet-controller");
+class PickingWorksheetController extends vas_worksheet_controller_1.VasWorksheetController {
+    async generatePickingWorksheet(releaseGoodNo, currentStatus = null) {
+        let releaseGood = await this.findRefOrder(sales_base_1.ReleaseGood, {
+            domain: this.domain,
+            name: releaseGoodNo,
+            status: sales_base_1.ORDER_STATUS.PENDING_WORKSHEET
+        }, ['orderInventories', 'orderInventories.inventory', 'orderVass']);
+        const orderInventories = releaseGood.orderInventories;
+        //const orderVASs: OrderVas[] = releaseGood.orderVass
+        let worksheet = await this.createWorksheet(releaseGood, constants_1.WORKSHEET_TYPE.PICKING);
+        if ((orderInventories === null || orderInventories === void 0 ? void 0 : orderInventories.length) > 0) {
+            let validOrderInventories = orderInventories.filter((oi) => oi.status !== 'CANCELLED');
+            if (validOrderInventories.every((oi) => { var _a; return (_a = oi.inventory) === null || _a === void 0 ? void 0 : _a.id; }) || releaseGood.crossDocking) {
+                worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, constants_1.WORKSHEET_TYPE.PICKING, validOrderInventories // Only non-cancelled ones
+                );
+            }
+            orderInventories.forEach((oi) => {
+                var _a;
+                if (oi.status === sales_base_1.ORDER_INVENTORY_STATUS.CANCELLED)
+                    return;
+                oi.status =
+                    oi.crossDocking || ((_a = oi.inventory) === null || _a === void 0 ? void 0 : _a.id)
+                        ? sales_base_1.ORDER_INVENTORY_STATUS.READY_TO_PICK
+                        : sales_base_1.ORDER_INVENTORY_STATUS.PENDING_SPLIT;
+                oi.updater = this.user;
+            });
+            await this.updateOrderTargets(orderInventories);
+        }
+        // if (orderVASs?.length > 0) {
+        //   await this.generateVasWorksheet(releaseGood)
+        // }
+        releaseGood.status = sales_base_1.ORDER_STATUS.READY_TO_PICK;
+        releaseGood.updater = this.user;
+        await this.updateRefOrder(releaseGood, null, currentStatus);
+        return worksheet;
+    }
+    async generateBatchPickingWorksheet(releaseGoodWithBiz) {
+        let worksheets = [];
+        for (let i = 0; i < releaseGoodWithBiz.length; i++) {
+            let releaseGoodNos = releaseGoodWithBiz[i].map(itm => itm.releaseGoodNo);
+            let releaseGoods = await this.trxMgr.getRepository(sales_base_1.ReleaseGood).find({
+                where: { domain: this.domain, name: (0, typeorm_1.In)(releaseGoodNos), status: sales_base_1.ORDER_STATUS.PENDING_WORKSHEET },
+                relations: [
+                    'orderProducts',
+                    'orderProducts.product',
+                    'orderInventories',
+                    'orderInventories.inventory',
+                    'bizplace',
+                    'bizplace.domain'
+                ]
+            });
+            let orderInventories = [];
+            releaseGoods.map((releaseGood) => {
+                const foundOIs = releaseGood.orderInventories;
+                foundOIs.map((oi) => {
+                    orderInventories.push(oi);
+                });
+            });
+            const worksheetPickingAssignment = await this.trxMgr.getRepository(setting_base_1.Setting).findOne({
+                where: { domain: this.domain, category: 'id-rule', name: 'enable-worksheet-picking-activation-assignment' }
+            });
+            const worksheetSetting = await this.trxMgr.getRepository(setting_base_1.Setting).findOne({
+                where: {
+                    domain: this.domain,
+                    name: constants_1.TASK_NUMBER_SETTING_KEY.TASK_NO_RULE
+                }
+            });
+            if (!worksheetSetting)
+                throw new Error(this.ERROR_MSG.FIND.NO_RESULT('task number rule'));
+            let worksheet = new entities_1.Worksheet();
+            worksheet.name = utils_1.WorksheetNoGenerator.generate(constants_1.WORKSHEET_TYPE.BATCH_PICKING);
+            worksheet.type = constants_1.WORKSHEET_TYPE.BATCH_PICKING;
+            worksheet.taskNo = await (0, id_rule_base_1.generateId)({
+                domain: this.domain,
+                type: constants_1.TASK_NUMBER_RULE_TYPE.TASK_NO,
+                seed: {}
+            });
+            worksheet.status = constants_1.WORKSHEET_STATUS.DEACTIVATED;
+            worksheet.bizplace = releaseGoodWithBiz[i][0].bizplaceId;
+            worksheet.domain = this.domain;
+            worksheet.creator = this.user;
+            worksheet.updater = this.user;
+            worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).save(worksheet);
+            if ((orderInventories === null || orderInventories === void 0 ? void 0 : orderInventories.length) > 0) {
+                if (orderInventories.some((oi) => { var _a; return (_a = oi.inventory) === null || _a === void 0 ? void 0 : _a.id; })) {
+                    const hasInventoryOIs = orderInventories.filter((orderInventory) => orderInventory.inventory !== null || orderInventory.status !== 'CANCELLED');
+                    worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, constants_1.WORKSHEET_TYPE.BATCH_PICKING, hasInventoryOIs);
+                }
+                orderInventories.forEach((oi) => {
+                    var _a;
+                    if (oi.status !== sales_base_1.ORDER_INVENTORY_STATUS.CANCELLED) {
+                        oi.refWorksheetId = worksheet.id;
+                        oi.status = ((_a = oi.inventory) === null || _a === void 0 ? void 0 : _a.id) ? sales_base_1.ORDER_INVENTORY_STATUS.READY_TO_PICK : sales_base_1.ORDER_INVENTORY_STATUS.PENDING_SPLIT;
+                        oi.updater = this.user;
+                    }
+                });
+                await this.updateOrderTargets(orderInventories);
+            }
+            else {
+                let orderProducts = [];
+                releaseGoods.map((releaseGood) => {
+                    const foundOPs = releaseGood.orderProducts;
+                    foundOPs
+                        .filter((op) => op.status !== sales_base_1.ORDER_PRODUCT_STATUS.CANCELLED)
+                        .forEach((op) => {
+                        orderProducts.push(op);
+                    });
+                });
+                if (worksheetPickingAssignment && (orderProducts === null || orderProducts === void 0 ? void 0 : orderProducts.length) > 0) {
+                    worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, constants_1.WORKSHEET_TYPE.BATCH_PICKING, orderProducts);
+                }
+            }
+            releaseGoods = releaseGoods.map((releaseGood) => {
+                return Object.assign(Object.assign({}, releaseGood), { status: sales_base_1.ORDER_STATUS.READY_TO_PICK, updater: this.user });
+            });
+            await this.trxMgr.getRepository(sales_base_1.ReleaseGood).save(releaseGoods);
+            worksheets.push(worksheet);
+        }
+        return worksheets;
+    }
+    async generateBatchPickingWorksheetDetail(worksheet, targetInventory) {
+        // Create worksheet details
+        return await this.createWorksheetDetails(worksheet, constants_1.WORKSHEET_TYPE.BATCH_PICKING, [targetInventory]);
+    }
+    async generatePickingWorksheetDetail(worksheet, targetInventory) {
+        // Create worksheet details
+        return await this.createWorksheetDetails(worksheet, constants_1.WORKSHEET_TYPE.PICKING, [targetInventory]);
+    }
+    async activatePicking(worksheetNo) {
+        var _a, _b;
+        let worksheet = await this.findActivatableWorksheet(worksheetNo, constants_1.WORKSHEET_TYPE.PICKING, [
+            'releaseGood',
+            'releaseGood.bizplace',
+            'releaseGood.domain',
+            'releaseGood.lastMileDelivery',
+            'releaseGood.bizplace.domain',
+            'domain',
+            'bizplace',
+            'bizplace.domain',
+            'bizplace.company',
+            'bizplace.company.domain',
+            'worksheetDetails',
+            'worksheetDetails.targetInventory',
+            'worksheetDetails.targetInventory.product'
+        ]);
+        let worksheetDetails;
+        let orderProducts = await this.trxMgr.getRepository(sales_base_1.OrderProduct).find({
+            where: { releaseGood: worksheet.releaseGood },
+            relations: [
+                'product',
+                'productDetail',
+                'productDetail.product',
+                'productBundle',
+                'productBundle.productBundleSettings',
+                'productBundle.productBundleSettings.productDetail'
+            ]
+        });
+        let orderPackages = await this.trxMgr.getRepository(sales_base_1.OrderPackage).find({
+            where: { releaseGood: worksheet.releaseGood },
+            relations: [
+                'orderPackageItems',
+                'orderPackageItems.productDetail',
+                'orderPackageItems.orderProduct',
+                'orderPackageItems.orderProduct.product',
+                'orderPackageItems.orderProduct.productDetail'
+            ]
+        });
+        let orderConsignments = await this.trxMgr.getRepository(sales_base_1.OrderConsignment).find({
+            where: { releaseGood: worksheet.releaseGood },
+            relations: [
+                'orderPackages',
+                'orderPackages.orderPackageItems',
+                'orderPackages.orderPackageItems.orderProduct',
+                'orderPackages.orderPackageItems.orderProduct.product',
+                'orderPackages.orderPackageItems.orderProduct.productDetail'
+            ]
+        });
+        worksheet.releaseGood = Object.assign(Object.assign({}, worksheet.releaseGood), { orderProducts, orderPackages, orderConsignments });
+        let releaseGood = Object.assign(new sales_base_1.ReleaseGood(), worksheet.releaseGood);
+        let newReleaseGood;
+        // assign inventory if unassigned
+        if (!releaseGood.assignedInventory) {
+            worksheetDetails = await this.assignInventoriesForUnassignedOrder(worksheet);
+            worksheet.worksheetDetails = worksheetDetails;
+            releaseGood.assignedInventory = true;
+        }
+        else {
+            worksheetDetails = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED');
+            const targetInventories = worksheetDetails.map((wsd) => {
+                let targetInventory = wsd.targetInventory;
+                targetInventory.status = sales_base_1.ORDER_INVENTORY_STATUS.PICKING;
+                targetInventory.updater = this.user;
+                return targetInventory;
+            });
+            this.updateOrderTargets(targetInventories);
+        }
+        releaseGood.status = sales_base_1.ORDER_STATUS.PICKING;
+        releaseGood.updater = this.user;
+        this.updateRefOrder(releaseGood);
+        (0, integration_base_1.webhookHandler)(releaseGood, releaseGood.bizplace, integration_base_1.WebhookEventsEnum.PickingStarted);
+        worksheet = await this.activateWorksheet(worksheet, worksheetDetails, []);
+        // VAS will be activated after PICKING is completed
+        // try {
+        //   const vasWorksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.VAS)
+        //   if (vasWorksheet) {
+        //     await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
+        //   }
+        // } catch (e) {}
+        const pendingSplitOIs = await this.trxMgr.getRepository(sales_base_1.OrderInventory).find({
+            where: { domain: this.domain, releaseGood, status: sales_base_1.ORDER_INVENTORY_STATUS.PENDING_SPLIT }
+        });
+        if (pendingSplitOIs === null || pendingSplitOIs === void 0 ? void 0 : pendingSplitOIs.length) {
+            const ids = pendingSplitOIs.map((oi) => oi.id);
+            await this.trxMgr.getRepository(sales_base_1.OrderInventory).delete(ids);
+        }
+        try {
+            // trigger SC pack order asynchronously
+            const orderSource = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.source;
+            switch (orderSource) {
+                //disable temporary to prevent duplicates call
+                case auth_base_1.ApplicationType.SELLERCRAFT:
+                    // getManager().transaction(async txMgr => {
+                    //   const sellercraft: Sellercraft = await txMgr
+                    //     .getRepository(Sellercraft)
+                    //     .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+                    //   if (sellercraft) {
+                    //     const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, this.domain, this.user)
+                    //     if (!releaseGood?.orderPackages?.length) {
+                    //       const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
+                    //         where: { releaseGood },
+                    //         relations: ['product', 'product.productDetails', 'productDetail']
+                    //       })
+                    //       // asynchronously pack order
+                    //       await sellercraftCtrl.packOrder(sellercraft, {
+                    //         ...releaseGood,
+                    //         orderProducts,
+                    //         domain: worksheet.domain
+                    //       })
+                    //     }
+                    //   }
+                    // })
+                    break;
+                case auth_base_1.ApplicationType.POWRUP:
+                    await (0, typeorm_1.getManager)().transaction(async (txMgr) => {
+                        var _a;
+                        const powrup = await txMgr.getRepository(integration_powrup_1.Powrup).findOne({ active: true, platform: 'POWRUP' });
+                        if (powrup) {
+                            const powrupCtrl = new sales_base_1.PowrupController();
+                            if (!((_a = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.orderPackages) === null || _a === void 0 ? void 0 : _a.length)) {
+                                const orderProducts = await txMgr.getRepository(sales_base_1.OrderProduct).find({
+                                    where: { releaseGood },
+                                    relations: ['product', 'productDetail']
+                                });
+                                // asynchronously pack order
+                                newReleaseGood = await powrupCtrl.packOrder(powrup, Object.assign(Object.assign({}, releaseGood), { orderProducts }), worksheet.domain, this.user, txMgr);
+                            }
+                        }
+                    });
+                    break;
+                case auth_base_1.ApplicationType.WEBSPERT:
+                    // Trigger Whole Order Process
+                    sales_base_1.WebspertController.triggerOrderProcesses(releaseGood, this.domain, this.user);
+                    break;
+                default:
+                    if (!((_a = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.orderPackages) === null || _a === void 0 ? void 0 : _a.length)) {
+                        let mps = (_b = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.lastMileDelivery) === null || _b === void 0 ? void 0 : _b.mps;
+                        switch (mps) {
+                            case true:
+                                newReleaseGood = await splitOrderConsignment(this.trxMgr, releaseGood, this.user, this.domain);
+                                break;
+                            case false:
+                            case undefined:
+                                let orderConsignment = await createOrderConsignment(this.trxMgr, {}, releaseGood, this.user);
+                                let orderPackage = {
+                                    name: sales_base_1.OrderNoGenerator.orderPackage(),
+                                    packageId: null,
+                                    trackingNo: null,
+                                    transporter: null,
+                                    airwayBill: (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.airwayBill) || null,
+                                    invoice: releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.invoice,
+                                    status: sales_base_1.ORDER_STATUS.PROCESSING,
+                                    releaseGood,
+                                    domain: releaseGood.domain,
+                                    bizplace: releaseGood.bizplace,
+                                    creator: this.user,
+                                    updater: this.user,
+                                    orderConsignment: orderConsignment
+                                };
+                                newReleaseGood = await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage);
+                                break;
+                        }
+                    }
+                    break;
+            }
+        }
+        catch (error) {
+            env_1.logger.error(`picking-worksheet-controller[activatePicking]: ${error}`);
+        }
+        if (newReleaseGood) {
+            worksheet.releaseGood = newReleaseGood;
+        }
+        return worksheet;
+    }
+    async activateBulkPicking(worksheetNo) {
+        let worksheets = [];
+        try {
+            const worksheetRepo = this.trxMgr.getRepository(entities_1.Worksheet);
+            worksheets = await worksheetRepo
+                .createQueryBuilder('w')
+                .leftJoinAndSelect('w.domain', 'd')
+                .leftJoinAndSelect('w.bizplace', 'b')
+                .leftJoinAndSelect('w.worksheetDetails', 'wd')
+                .leftJoinAndSelect('w.releaseGood', 'rg')
+                .leftJoinAndSelect('rg.domain', 'rgd')
+                .leftJoinAndSelect('rg.lastMileDelivery', 'lmd')
+                .leftJoinAndSelect('rg.orderPackages', 'op')
+                .leftJoinAndSelect('op.orderPackageItems', 'opi')
+                .leftJoinAndSelect('opi.orderProduct', 'op2')
+                .leftJoinAndSelect('op2.product', 'p')
+                .leftJoinAndSelect('op2.productDetail', 'pd')
+                .leftJoinAndSelect('rg.orderConsignments', 'oc')
+                .leftJoinAndSelect('oc.orderPackages', 'ocop')
+                .leftJoinAndSelect('ocop.orderPackageItems', 'ocpi')
+                .leftJoinAndSelect('ocpi.orderProduct', 'ocp2')
+                .leftJoinAndSelect('ocp2.product', 'ocp')
+                .leftJoinAndSelect('ocp2.productDetail', 'ocpd')
+                .leftJoinAndSelect('rg.bizplace', 'rgb')
+                .leftJoinAndSelect('rgb.domain', 'rgbd')
+                .leftJoinAndSelect('b.domain', 'bd')
+                .leftJoinAndSelect('b.company', 'c')
+                .leftJoinAndSelect('c.domain', 'cd')
+                .leftJoinAndSelect('wd.targetInventory', 'ti')
+                .leftJoinAndSelect('ti.product', 'tp')
+                .where('w.name IN (:...worksheetNo)', { worksheetNo: worksheetNo })
+                .andWhere('w.status = :status', { status: constants_1.WORKSHEET_STATUS.DEACTIVATED })
+                .getMany();
+            if (worksheets.length > 50) {
+                throw new Error('Please select maximum 50 worksheets with status deactivated to proceed');
+            }
+            let groupWs = new Map();
+            for (const worksheet of worksheets) {
+                const bizplaceId = worksheet.bizplace.id;
+                const worksheetId = worksheet.id;
+                if (groupWs.has(bizplaceId)) {
+                    groupWs.get(bizplaceId).push(worksheetId);
+                }
+                else {
+                    groupWs.set(bizplaceId, [worksheetId]);
+                }
+            }
+            const groupedWsBiz = [...groupWs.entries()];
+            const updatedWs = await Promise.all(groupedWsBiz.map(async ([bizplaceId, worksheetIds]) => {
+                return await this.activateBulkWorksheets(bizplaceId, worksheetIds);
+            }));
+            worksheets = updatedWs.flat();
+        }
+        catch (error) {
+            throw error;
+        }
+        // finally {
+        //   ActiveWorksheetPickingView.refreshView()
+        // }
+        return worksheets;
+    }
+    async activateBatchPicking(worksheetNo) {
+        let worksheet = await this.findActivatableWorksheet(worksheetNo, constants_1.WORKSHEET_TYPE.BATCH_PICKING, [
+            'worksheetDetails',
+            'worksheetDetails.targetProduct',
+            'worksheetDetails.targetProduct.bizplace',
+            'worksheetDetails.targetProduct.product',
+            'worksheetDetails.targetProduct.productDetail',
+            'worksheetDetails.targetProduct.releaseGood',
+            'worksheetDetails.targetInventory',
+            'worksheetDetails.targetInventory.releaseGood',
+            'worksheetDetails.targetInventory.releaseGood.domain',
+            'worksheetDetails.targetInventory.product',
+            'bizplace',
+            'bizplace.domain',
+            'bizplace.company',
+            'bizplace.company.domain'
+        ]);
+        let worksheetDetails = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED');
+        if (worksheet.worksheetDetails.find(wsd => { var _a, _b; return ((_b = (_a = wsd.targetProduct) === null || _a === void 0 ? void 0 : _a.releaseGood) === null || _b === void 0 ? void 0 : _b.assignedInventory) == false; })) {
+            worksheetDetails = await this.assignInventoriesForUnassignedMergedOrder(worksheet);
+            delete worksheet.worksheetDetails;
+            worksheet = await this.activateWorksheet(worksheet, worksheetDetails, []);
+            await this.trxMgr.getRepository(entities_1.WorksheetDetail).delete({ worksheet, status: 'DEACTIVATED' });
+        }
+        else {
+            const targetInventories = worksheetDetails.map((wsd) => {
+                let targetInventory = wsd.targetInventory;
+                targetInventory.status =
+                    targetInventory.status != 'PENDING_CANCEL' ? sales_base_1.ORDER_INVENTORY_STATUS.PICKING : targetInventory.status;
+                targetInventory.updater = this.user;
+                return targetInventory;
+            });
+            this.updateOrderTargets(targetInventories);
+            worksheet = await this.activateWorksheet(worksheet, worksheetDetails, []);
+        }
+        // retrieve order inventory
+        const pickingOrderInventory = await this.trxMgr.getRepository(sales_base_1.OrderInventory).find({
+            where: { domain: this.domain, refWorksheetId: worksheet.id, status: sales_base_1.ORDER_STATUS.PICKING },
+            relations: ['releaseGood']
+        });
+        const releaseGoodIds = pickingOrderInventory.reduce((data, order) => {
+            const id = order.releaseGood.id;
+            if (!data.includes(id)) {
+                data.push(id);
+            }
+            return data;
+        }, []);
+        let releaseGoods = await this.trxMgr.getRepository(sales_base_1.ReleaseGood).find({
+            where: { id: (0, typeorm_1.In)(releaseGoodIds) },
+            relations: [
+                'domain',
+                'lastMileDelivery',
+                'bizplace',
+                'bizplace.domain',
+                'orderPackages',
+                'orderPackages.orderPackageItems',
+                'orderPackages.orderPackageItems.productDetail',
+                'orderPackages.orderPackageItems.orderProduct',
+                'orderPackages.orderPackageItems.orderProduct.product',
+                'orderPackages.orderPackageItems.orderProduct.productDetail',
+                'orderProducts',
+                'orderProducts.productDetail',
+                'orderProducts.product',
+                'orderConsignments',
+                'orderConsignments.orderPackages',
+                'orderConsignments.orderPackages.orderPackageItems',
+                'orderConsignments.orderPackages.orderPackageItems.orderProduct',
+                'orderConsignments.orderPackages.orderPackageItems.orderProduct.product',
+                'orderConsignments.orderPackages.orderPackageItems.orderProduct.productDetail'
+            ]
+        });
+        pickingOrderInventory.forEach(order => {
+            order.releaseGood = releaseGoods.find(rg => rg.id === order.releaseGood.id);
+        });
+        // let releaseGoodss: ReleaseGood[] = pickingOrderInventory.reduce((data, oi: OrderInventory) => {
+        //   if (!data.find(x => x.id == oi.releaseGood.id)) {
+        //     data.push(oi.releaseGood)
+        //   }
+        //   return data
+        // }, [])
+        // massage data and trigger SC pack order asynchronously
+        if (releaseGoods === null || releaseGoods === void 0 ? void 0 : releaseGoods.length) {
+            releaseGoods = await Promise.all(releaseGoods.map(async (releaseGood) => {
+                var _a, _b;
+                try {
+                    const orderSource = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.source;
+                    switch (orderSource) {
+                        //temporary disable to prevent order-pack call twice
+                        case auth_base_1.ApplicationType.SELLERCRAFT:
+                            // getManager().transaction(async txMgr => {
+                            //   const sellercraft: Sellercraft = await txMgr
+                            //     .getRepository(Sellercraft)
+                            //     .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+                            //   if (sellercraft) {
+                            //     const sellercraftCtrl: SellercraftController = new SellercraftController(
+                            //       txMgr,
+                            //       this.domain,
+                            //       this.user
+                            //     )
+                            //     if (!releaseGood?.orderPackages?.length) {
+                            //       const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
+                            //         where: { releaseGood },
+                            //         relations: ['product', 'product.productDetails', 'productDetail']
+                            //       })
+                            //       // asynchronously pack order
+                            //       await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
+                            //     }
+                            //   }
+                            // })
+                            break;
+                        case auth_base_1.ApplicationType.POWRUP:
+                            await (0, typeorm_1.getManager)().transaction(async (txMgr) => {
+                                var _a;
+                                const powrup = await txMgr.getRepository(integration_powrup_1.Powrup).findOne({ active: true });
+                                if (powrup) {
+                                    const powrupCtrl = new sales_base_1.PowrupController(txMgr, this.domain, this.user);
+                                    if (!((_a = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.orderPackages) === null || _a === void 0 ? void 0 : _a.length)) {
+                                        const orderProducts = await txMgr.getRepository(sales_base_1.OrderProduct).find({
+                                            where: { releaseGood },
+                                            relations: ['product', 'productDetail']
+                                        });
+                                        // asynchronously pack order
+                                        await powrupCtrl.packOrder(powrup, Object.assign(Object.assign({}, releaseGood), { orderProducts }), this.domain, this.user, txMgr);
+                                    }
+                                }
+                            });
+                            break;
+                        case auth_base_1.ApplicationType.WEBSPERT:
+                            // Trigger Whole Order Process
+                            sales_base_1.WebspertController.triggerOrderProcesses(releaseGood, this.domain, this.user);
+                            break;
+                        default:
+                            if (!((_a = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.orderPackages) === null || _a === void 0 ? void 0 : _a.length)) {
+                                let mps = (_b = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.lastMileDelivery) === null || _b === void 0 ? void 0 : _b.mps;
+                                switch (mps) {
+                                    case true:
+                                        await splitOrderConsignment(this.trxMgr, releaseGood, this.user, this.domain);
+                                        break;
+                                    case false:
+                                    case undefined:
+                                        let orderConsignment = await createOrderConsignment(this.trxMgr, {}, releaseGood, this.user);
+                                        let orderPackage = {
+                                            name: sales_base_1.OrderNoGenerator.orderPackage(),
+                                            packageId: null,
+                                            trackingNo: null,
+                                            transporter: null,
+                                            airwayBill: (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.airwayBill) || null,
+                                            invoice: releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.invoice,
+                                            status: sales_base_1.ORDER_STATUS.PROCESSING,
+                                            releaseGood,
+                                            domain: releaseGood.domain,
+                                            bizplace: releaseGood.bizplace,
+                                            creator: this.user,
+                                            updater: this.user,
+                                            orderConsignment: orderConsignment
+                                        };
+                                        await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage);
+                                        break;
+                                }
+                            }
+                            break;
+                    }
+                }
+                catch (error) {
+                    env_1.logger.error(`picking-worksheet-controller[activateBatchPicking]: ${error}`);
+                }
+                return Object.assign(Object.assign({}, releaseGood), { status: releaseGood.status != 'PENDING_CANCEL' ? sales_base_1.ORDER_STATUS.PICKING : releaseGood.status, updater: this.user, assignedInventory: true });
+            }));
+            await Promise.all(releaseGoods.map(rg => this.trxMgr.getRepository(sales_base_1.ReleaseGood).update(rg.id, {
+                status: rg.status,
+                updater: this.user,
+                assignedInventory: true,
+                updatedAt: () => 'CURRENT_TIMESTAMP'
+            })));
+        }
+        for (const releaseGood of releaseGoods) {
+            (0, integration_base_1.webhookHandler)(releaseGood, releaseGood.bizplace, integration_base_1.WebhookEventsEnum.PickingStarted);
+        }
+        return worksheet;
+    }
+    async assignPickingInventories(worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails) {
+        var _a, _b;
+        // 1. Remove prev worksheet details if it's exists
+        const worksheet = await this.findWorksheetByNo(worksheetNo, [
+            'bizplace',
+            'releaseGood',
+            'worksheetDetails'
+        ]);
+        const releaseGood = worksheet.releaseGood;
+        const bizplace = worksheet.bizplace;
+        const prevWorksheetDetails = await this.extractMatchedWorksheetDetails(worksheet.worksheetDetails, batchId, productId, packingType, packingSize);
+        // Delete order inventories
+        if (prevWorksheetDetails === null || prevWorksheetDetails === void 0 ? void 0 : prevWorksheetDetails.length) {
+            const worksheetDetailIds = prevWorksheetDetails.map((wsd) => wsd.id);
+            const prevTargetInventoryIds = prevWorksheetDetails.map((wsd) => wsd.targetInventory.id);
+            await this.trxMgr.getRepository(entities_1.WorksheetDetail).delete(worksheetDetailIds);
+            await this.trxMgr.getRepository(sales_base_1.OrderInventory).delete(prevTargetInventoryIds);
+        }
+        for (let worksheetDetail of worksheetDetails) {
+            if ((_b = (_a = worksheetDetail.targetInventory) === null || _a === void 0 ? void 0 : _a.inventory) === null || _b === void 0 ? void 0 : _b.id) {
+                worksheetDetail = await this.findWorksheetDetail(worksheetDetail, [
+                    'targetInventory',
+                    'targetInventory.inventory'
+                ]);
+            }
+            const targetInventory = worksheetDetail.targetInventory;
+            let inventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).findOne(targetInventory.inventory.id);
+            const product = await this.trxMgr.getRepository(product_base_1.Product).findOne(productId);
+            // Create order inventories
+            let newTargetInventory = Object.assign({}, targetInventory);
+            delete newTargetInventory.id;
+            newTargetInventory.domain = this.domain;
+            newTargetInventory.bizplace = bizplace;
+            newTargetInventory.name = sales_base_1.OrderNoGenerator.orderInventory();
+            newTargetInventory.releaseGood = releaseGood;
+            newTargetInventory.inventory = inventory;
+            newTargetInventory.batchId = batchId;
+            newTargetInventory.product = product;
+            newTargetInventory.packingType = packingType;
+            newTargetInventory.packingSize = packingSize;
+            newTargetInventory.creator = this.user;
+            newTargetInventory.updater = this.user;
+            newTargetInventory = await this.trxMgr.getRepository(sales_base_1.OrderInventory).save(newTargetInventory);
+            // Update locked qty and uomValue of inventory
+            inventory.lockedQty = targetInventory.releaseQty + (inventory.lockedQty || 0);
+            inventory.lockedUomValue = targetInventory.releaseUomValue + (inventory.lockedUomValue || 0);
+            await this.updateInventory(inventory);
+            // Create worksheet details
+            await this.createWorksheetDetails(worksheet, constants_1.WORKSHEET_TYPE.PICKING, [newTargetInventory]);
+        }
+    }
+    async undoPickingAssigment(worksheetNo, batchId, productId, packingType, packingSize) {
+        const worksheet = await this.findWorksheetByNo(worksheetNo, [
+            'worksheetDetails',
+            'worksheetDetails.targetInventory',
+            'worksheetDetails.targetInventory.inventory',
+            'worksheetDetails.targetInventory.product',
+            'worksheetDetails.targetInventory.orderProduct'
+        ]);
+        const worksheetDetails = await this.extractMatchedWorksheetDetails(worksheet.worksheetDetails, batchId, productId, packingType, packingSize, ['targetInventory', 'targetInventory.inventory', 'targetInventory.orderProduct']);
+        let worksheetDetailIds = [];
+        let targetInventoryIds = [];
+        for (const worksheetDetail of worksheetDetails) {
+            worksheetDetailIds.push(worksheetDetail.id);
+            const targetInventory = worksheetDetail.targetInventory;
+            targetInventoryIds.push(targetInventory.id);
+            let inventory = await this.trxMgr
+                .getRepository(warehouse_base_1.Inventory)
+                .findOne({ where: { id: worksheetDetail.targetInventory.inventory.id } });
+            inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty;
+            inventory.lockedUomValue = inventory.lockedUomValue - targetInventory.releaseUomValue;
+            await this.updateInventory(inventory);
+            await this.trxMgr
+                .getRepository(sales_base_1.OrderProduct)
+                .update({ id: targetInventory.orderProduct.id }, { status: sales_base_1.ORDER_PRODUCT_STATUS.PENDING_ASSIGN, updater: this.user });
+        }
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).delete(worksheetDetailIds);
+        await this.trxMgr.getRepository(sales_base_1.OrderInventory).delete(targetInventoryIds);
+        await this.trxMgr.getRepository(sales_base_1.OrderInventory).update({
+            refWorksheetId: worksheet.id,
+            batchId,
+            product: { id: productId },
+            packingType,
+            packingSize,
+            status: sales_base_1.ORDER_INVENTORY_STATUS.COMPLETE_SPLIT
+        }, { status: sales_base_1.ORDER_INVENTORY_STATUS.PENDING_SPLIT, updater: this.user, updatedAt: new Date() });
+    }
+    async scanProductPicking(worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, toteNo, pickedQty = 1) {
+        try {
+            //find existing worksheet detail
+            let worksheetDetailFilters = [
+                { query: 'mawp."worksheetDetailName"', value: worksheetDetailName },
+                { query: 'mawp."domainId"', value: this.domain.id },
+                { query: 'mawp."inventoryCartonId"', value: cartonId }
+                // { query: 'mawp."gtin"', value: productBarcode }
+            ];
+            let worksheetDetailRaw = await this.trxMgr.query(`
+        select * from active_worksheet_picking_views mawp
+        where 1 = 1
+        and
+        ${worksheetDetailFilters
+                .map((data, idx) => {
+                return `${data.query} = $${idx + 1}`;
+            })
+                .join(' AND ')}
+      `, worksheetDetailFilters.map((data, idx) => {
+                return data.value;
+            }));
+            // find directly without going through the materialized view
+            if (worksheetDetailRaw.length < 1) {
+                worksheetDetailRaw = await this.trxMgr.query(`
+          select
+          wd.id AS "worksheetDetailId",
+          wd.name as "worksheetDetailName",
+          w.id as "worksheetId",
+          w.domain_id as "domainId",
+          op.id as "targetProductId",
+          oi.product_id as "productId",
+          oi.product_detail_id as "productDetailId",
+          op.uom_value as "uomValue",
+          pb.id  as "productBarcodeId",
+          pb.gtin,
+          p.is_require_serial_number_scanning_outbound as "productIsRequireSerialNumberScanningOutbound",
+          oi.release_good_id as "releaseGoodId",
+          oi.id as "orderInventoryId",
+          oi.status as "orderInventoryStatus",
+          oi.bizplace_id as "bizplaceId",
+          i.id as "inventoryId",
+          i.carton_id as "inventoryCartonId",
+          i.status as "inventoryStatus",
+          ici.status as "inventoryCheckItemStatus",
+          rg.name as "releaseGoodName",
+          rg.ref_no as "refNo"
+          FROM worksheet_details wd
+          INNER JOIN worksheets w ON wd.worksheet_id = w.id
+          inner JOIN order_inventories oi ON oi.id = wd.target_inventory_id
+          inner JOIN order_products op ON op.id = oi.order_product_id
+          inner join inventories i on i.id = oi.inventory_id
+          inner join release_goods rg on rg.id = oi.release_good_id
+          left join inventory_check_items ici on ici.inventory_id = oi.inventory_id
+          inner join products p on p.id = oi.product_id
+          left join product_bundles pb2 on pb2.id = op.product_bundle_id
+          LEFT JOIN product_barcodes pb ON pb.product_detail_id = oi.product_detail_id 
+          left join product_bundle_settings pbs on pbs.product_bundle_id = pb2.id and pbs.product_id = oi.product_id and pbs.product_detail_id = oi.product_detail_id
+          WHERE w.type::text = 'PICKING'::text AND w.status::text = 'EXECUTING'::text
+          and wd.name = $1 and w.domain_id = $2 and i.carton_id = $3
+          ORDER BY w.domain_id, w.bizplace_id, wd.id
+        `, [worksheetDetailName, this.domain.id, cartonId]);
+            }
+            //validation to check matching worksheet detail based on name
+            if (worksheetDetailRaw.length < 1)
+                throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName));
+            let worksheetDetailInfos = worksheetDetailRaw[0];
+            let targetInventory = await this.trxMgr
+                .getRepository(sales_base_1.OrderInventory)
+                .findOne({ where: { id: worksheetDetailInfos.orderInventoryId } });
+            const inventory = await this.trxMgr
+                .getRepository(warehouse_base_1.Inventory)
+                .findOne({ where: { id: worksheetDetailInfos.inventoryId } });
+            let targetProduct = { id: worksheetDetailInfos.targetProductId };
+            let bizplace = { id: worksheetDetailInfos.bizplaceId };
+            const releaseGood = {
+                id: worksheetDetailInfos.releaseGoodId,
+                name: worksheetDetailInfos.releaseGoodName,
+                refNo: worksheetDetailInfos.refNo
+            };
+            let matchingProduct, pickedUomValue;
+            // // validation to prevent picking if the inventory is involved in cycle count
+            const inventoryCheckStatus = new Set([
+                sales_base_1.INVENTORY_CHECK_ITEM_STATUS.PENDING,
+                sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
+                sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
+                sales_base_1.INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
+                sales_base_1.INVENTORY_CHECK_ITEM_STATUS.MISSING,
+                sales_base_1.INVENTORY_CHECK_ITEM_STATUS.ADDED
+            ]);
+            if (inventoryCheckStatus.has(worksheetDetailInfos.inventoryCheckItemStatus)) {
+                throw new Error(`Inventory currently involved in an ongoing cycle count. Please complete the cycle count to proceed with picking.`);
+            }
+            //validation to prevent duplicated picking
+            if (targetInventory.status != sales_base_1.ORDER_INVENTORY_STATUS.PICKING)
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`));
+            // if (!productBarcodes.find(itm => itm.gtin == productBarcode) && product?.isRequireSerialNumberScanningOutbound) {
+            //   throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+            // }
+            matchingProduct = worksheetDetailRaw.find(x => x.gtin === productBarcode);
+            if (matchingProduct) {
+                pickedUomValue = pickedQty * (matchingProduct.uomValue || 1);
+            }
+            else {
+                matchingProduct = await this.getDirectQty({ id: worksheetDetailInfos.productDetailId }, productBarcode, pickedQty);
+                //validate matching product details based on scanned barcode
+                if (!matchingProduct)
+                    throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode));
+                pickedQty = matchingProduct.qty;
+                pickedUomValue = matchingProduct.uomValue;
+            }
+            // //validation to prevent over release
+            if (!targetInventory)
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `inventory not assigned`));
+            // //validation to prevent over release
+            if (inventory.qty < 1 || pickedQty + ((targetInventory === null || targetInventory === void 0 ? void 0 : targetInventory.pickedQty) || 0) > targetInventory.releaseQty)
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`));
+            targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation);
+            // for required outbound serial number scanning
+            if (worksheetDetailInfos === null || worksheetDetailInfos === void 0 ? void 0 : worksheetDetailInfos.productIsRequireSerialNumberScanningOutbound) {
+                if (!serialNumber || serialNumber == '') {
+                    throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`));
+                }
+                let totalInventoryItems = await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).count({
+                    where: {
+                        inventory: { id: worksheetDetailInfos.inventoryId },
+                        status: (0, typeorm_1.Not)((0, typeorm_1.In)([warehouse_base_1.INVENTORY_STATUS.TERMINATED, warehouse_base_1.INVENTORY_STATUS.PICKED, warehouse_base_1.INVENTORY_STATUS.PACKED]))
+                    }
+                });
+                let foundSerialNumber = await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).findOne({
+                    where: { domain: this.domain, serialNumber: serialNumber, product: { id: worksheetDetailInfos.productId } }
+                });
+                if (foundSerialNumber) {
+                    if (foundSerialNumber.inventoryId !== worksheetDetailInfos.inventoryId) {
+                        throw new Error('Serial Number scanned is in another inventory');
+                    }
+                    if (foundSerialNumber.outboundOrderId) {
+                        let releaseGood = await this.trxMgr
+                            .getRepository(sales_base_1.ReleaseGood)
+                            .findOne({ where: { id: foundSerialNumber.outboundOrderId } });
+                        if (releaseGood) {
+                            throw new Error(`Inventory Item is already picked in ${releaseGood.name}`);
+                        }
+                    }
+                    foundSerialNumber.status = warehouse_base_1.INVENTORY_STATUS.PICKING;
+                    foundSerialNumber.updater = this.user;
+                    foundSerialNumber.outboundOrderId = worksheetDetailInfos.releaseGoodId;
+                    await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).save(foundSerialNumber);
+                }
+                else {
+                    if (totalInventoryItems >= inventory.qty) {
+                        throw new Error('Insufficient inventory quantity to scan new serial number');
+                    }
+                    let inventoryItem = new warehouse_base_1.InventoryItem();
+                    inventoryItem.name = warehouse_base_1.InventoryNoGenerator.inventoryItemName();
+                    inventoryItem.serialNumber = serialNumber;
+                    inventoryItem.status = warehouse_base_1.INVENTORY_STATUS.PICKING;
+                    inventoryItem.outboundOrderId = worksheetDetailInfos.releaseGoodId;
+                    inventoryItem.source = warehouse_base_1.INVENTORY_ITEM_SOURCE.OUTBOUND;
+                    inventoryItem.product = { id: worksheetDetailInfos.productId };
+                    inventoryItem.productDetail = { id: worksheetDetailInfos.productDetailId };
+                    inventoryItem.inventory = { id: worksheetDetailInfos.inventoryId };
+                    inventoryItem.domain = this.domain;
+                    await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).save(inventoryItem);
+                }
+            }
+            // for tote scanning
+            if (toteNo) {
+                await this.toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace);
+            }
+            // temporarily override with separate logic to handle transaction to speed up function
+            // await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
+            const releaseQty = targetInventory.releaseQty;
+            targetInventory.pickedQty = ((targetInventory === null || targetInventory === void 0 ? void 0 : targetInventory.pickedQty) || 0) + pickedQty;
+            let updateOiObj = {
+                pickedQty: () => `"picked_qty" + ${pickedQty}`,
+                updatedAt: new Date(),
+                updater: this.user,
+                pickedBy: this.user.name,
+                pickedByUser: this.user,
+                pickedAt: new Date(),
+                status: () => `case when release_qty = "picked_qty" + ${pickedQty} then '${sales_base_1.ORDER_INVENTORY_STATUS.PICKED}' else status end`
+            };
+            if (targetInventory.binLocation) {
+                updateOiObj['binLocation'] = targetInventory.binLocation;
+            }
+            await this.trxMgr
+                .getRepository(sales_base_1.OrderInventory)
+                .createQueryBuilder()
+                .update(sales_base_1.OrderInventory)
+                .set(updateOiObj)
+                .where({ id: targetInventory.id })
+                .andWhere(`picked_qty + :pickedQty <= release_qty`, { pickedQty })
+                .execute();
+            if (targetInventory.pickedQty == releaseQty) {
+                (0, typeorm_1.getConnection)().transaction(async (tx) => {
+                    try {
+                        //update worksheet details only when line item picking complete
+                        await tx
+                            .getRepository(entities_1.WorksheetDetail)
+                            .createQueryBuilder()
+                            .update(entities_1.WorksheetDetail)
+                            .set({
+                            status: constants_1.WORKSHEET_STATUS.DONE,
+                            updater: this.user,
+                            updatedAt: new Date()
+                        })
+                            .where('id = :id', { id: worksheetDetailInfos.worksheetDetailId })
+                            .execute();
+                        let releaseUomValue = Math.trunc((pickedUomValue / pickedQty) * releaseQty * 1000) / 1000;
+                        let updateInvObj = {
+                            qty: () => `"qty" - ${releaseQty}`,
+                            lockedQty: () => `"locked_qty" - ${releaseQty}`,
+                            uomValue: () => `"uom_value" - ${releaseUomValue}`,
+                            lockedUomValue: () => `"locked_uom_value" - ${releaseUomValue}`,
+                            status: () => `case when "qty" - ${releaseQty} <= 0 then '${warehouse_base_1.INVENTORY_STATUS.TERMINATED}' else status end`,
+                            updater: this.user,
+                            updatedAt: new Date()
+                        };
+                        await tx
+                            .getRepository(warehouse_base_1.Inventory)
+                            .createQueryBuilder()
+                            .update(warehouse_base_1.Inventory)
+                            .set(updateInvObj)
+                            .where('id = :id', { id: worksheetDetailInfos.inventoryId })
+                            .returning(['qty'])
+                            .execute();
+                        await (0, warehouse_base_1.generateInventoryHistory)(inventory, releaseGood, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.PICKING, -releaseQty, -releaseUomValue, this.user, tx);
+                        let inventoryItems = await tx
+                            .getRepository(warehouse_base_1.InventoryItem)
+                            .find({ where: { outboundOrderId: worksheetDetailInfos.releaseGoodId } });
+                        if (inventoryItems.length > 0) {
+                            inventoryItems.forEach((itm) => {
+                                itm.status = warehouse_base_1.INVENTORY_STATUS.PICKED;
+                                itm.updater = this.user;
+                            });
+                            await tx.getRepository(warehouse_base_1.InventoryItem).save(inventoryItems);
+                        }
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                });
+            }
+            let worksheetDetail = await this.trxMgr
+                .getRepository(entities_1.WorksheetDetail)
+                .createQueryBuilder('wd')
+                .innerJoin('wd.targetInventory', 'oi')
+                .innerJoinAndSelect('oi.releaseGood', 'rg')
+                .where('wd.id = :id', { id: worksheetDetailInfos.worksheetDetailId })
+                .getOne();
+            return worksheetDetail;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async picking(worksheetDetailName, worksheetType, palletId, locationName, pickedQty, binLocation, serialNumber, toteNo) {
+        try {
+            let worksheetDetail = await this.findExecutableWorksheetDetailByName(worksheetDetailName, worksheetType, [
+                'worksheet',
+                'worksheet.bizplace',
+                'targetInventory',
+                'targetInventory.releaseGood',
+                'targetInventory.orderProduct',
+                'targetInventory.inventory',
+                'targetInventory.inventory.location',
+                'targetInventory.product',
+                'targetInventory.productDetail'
+            ]);
+            const releaseGood = worksheetDetail.targetInventory.releaseGood;
+            let targetInventory = worksheetDetail.targetInventory;
+            const product = targetInventory.product;
+            const productDetail = targetInventory.productDetail;
+            let inventory = targetInventory.inventory;
+            let targetProduct = targetInventory.orderProduct;
+            let bizplace = worksheetDetail.worksheet.bizplace;
+            // validation to prevent picking if the inventory is involved in cycle count
+            let inventoryCheckItem = await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).findOne({
+                where: {
+                    domain: this.domain,
+                    inventory: inventory.id,
+                    status: (0, typeorm_1.In)([
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.PENDING,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.MISSING,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.ADDED
+                    ])
+                }
+            });
+            if (inventoryCheckItem) {
+                throw new Error(`Inventory currently involved in an ongoing cycle count. Please complete the cycle count to proceed with picking.`);
+            }
+            //validation to prevent duplicated picking
+            let oiValidate = await this.trxMgr.getRepository(sales_base_1.OrderInventory).findOne({
+                where: { domain: this.domain, id: targetInventory.id, status: sales_base_1.ORDER_INVENTORY_STATUS.PICKING }
+            });
+            if (!oiValidate)
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`));
+            //validation to prevent over release
+            if (inventory.qty <= 0)
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`));
+            if (inventory.palletId !== palletId && !(product === null || product === void 0 ? void 0 : product.isRequireSerialNumberScanningOutbound))
+                throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId));
+            if (product === null || product === void 0 ? void 0 : product.isRequireSerialNumberScanningOutbound) {
+                if (!serialNumber || serialNumber == '') {
+                    throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`));
+                }
+                let totalInventoryItems = await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).count({
+                    where: {
+                        inventory,
+                        status: (0, typeorm_1.Not)((0, typeorm_1.In)([warehouse_base_1.INVENTORY_STATUS.TERMINATED, warehouse_base_1.INVENTORY_STATUS.PICKED]))
+                    }
+                });
+                let foundSerialNumber = await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).findOne({
+                    where: { domain: this.domain, serialNumber: serialNumber, productDetail },
+                    relations: ['product', 'productDetail', 'inventory']
+                });
+                let scannedPalletIdInventory = await this.trxMgr
+                    .getRepository(warehouse_base_1.Inventory)
+                    .findOne({ where: { domain: this.domain, palletId }, relations: ['productDetail'] });
+                if (foundSerialNumber) {
+                    if (foundSerialNumber.outboundOrderId) {
+                        let releaseGood = await this.trxMgr
+                            .getRepository(sales_base_1.ReleaseGood)
+                            .findOne({ where: { id: foundSerialNumber.outboundOrderId } });
+                        if (releaseGood) {
+                            throw new Error(`Inventory Item is already picked in ${releaseGood.name}`);
+                        }
+                    }
+                    foundSerialNumber.status = warehouse_base_1.INVENTORY_STATUS.PICKING;
+                    foundSerialNumber.updater = this.user;
+                    foundSerialNumber.outboundOrderId = releaseGood.id;
+                    await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).save(foundSerialNumber);
+                }
+                else {
+                    if (totalInventoryItems >= inventory.qty) {
+                        throw new Error('Insufficient inventory quantity to scan new serial number');
+                    }
+                    let inventoryItem = new warehouse_base_1.InventoryItem();
+                    inventoryItem.name = warehouse_base_1.InventoryNoGenerator.inventoryItemName();
+                    inventoryItem.serialNumber = serialNumber;
+                    inventoryItem.status = warehouse_base_1.INVENTORY_STATUS.PICKING;
+                    inventoryItem.source = warehouse_base_1.INVENTORY_ITEM_SOURCE.OUTBOUND;
+                    inventoryItem.outboundOrderId = releaseGood.id;
+                    inventoryItem.product = product;
+                    inventoryItem.productDetail = productDetail;
+                    inventoryItem.inventory = scannedPalletIdInventory;
+                    inventoryItem.domain = this.domain;
+                    foundSerialNumber = await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).save(inventoryItem);
+                }
+                if (inventory.palletId !== palletId) {
+                    let existingOrderInv = await this.trxMgr.getRepository(sales_base_1.OrderInventory).findOne({
+                        where: {
+                            domain: this.domain,
+                            inventory: scannedPalletIdInventory,
+                            releaseGood: releaseGood
+                        }
+                    });
+                    if (existingOrderInv) {
+                        //if replacement order inventory already existed in worksheet detail
+                        await this.serialNumberReplacementForExistingOrderInv(existingOrderInv, targetInventory, worksheetDetail, foundSerialNumber);
+                    }
+                    else if (scannedPalletIdInventory.batchId == inventory.batchId &&
+                        scannedPalletIdInventory.productDetail.id == productDetail.id) {
+                        //if replacement order inventory does not exist
+                        await this.serialNumberReplacement(targetInventory, scannedPalletIdInventory, releaseGood, product, productDetail, worksheetDetail, foundSerialNumber);
+                    }
+                    else {
+                        throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId));
+                    }
+                }
+            }
+            targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation);
+            if (toteNo) {
+                await this.toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace);
+            }
+            await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty);
+            const fromLocation = targetInventory.inventory.location;
+            if (locationName) {
+                const toLocation = await this.trxMgr.getRepository(warehouse_base_1.Location).findOne({
+                    where: { domain: this.domain, name: locationName },
+                    relations: ['warehouse']
+                });
+                if (!toLocation)
+                    throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName));
+                if (fromLocation.id !== toLocation.id) {
+                    inventory.location = toLocation;
+                    inventory.warehouse = toLocation.warehouse;
+                    inventory.zone = toLocation.zone;
+                    inventory = await this.transactionInventory(inventory, releaseGood, 0, 0, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.RELOCATE);
+                }
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async batchPicking(taskNo, worksheetType, palletId, locationName, binLocationName, releaseQty) {
+        const worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne({
+            where: { domain: this.domain, taskNo, type: worksheetType, status: constants_1.WORKSHEET_STATUS.EXECUTING }
+        });
+        const foundInventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).findOne({
+            where: { domain: this.domain, palletId }
+        });
+        const targetInventories = await this.trxMgr.getRepository(sales_base_1.OrderInventory).find({
+            where: {
+                domain: this.domain,
+                refWorksheetId: worksheet.id,
+                status: sales_base_1.ORDER_INVENTORY_STATUS.PICKING,
+                inventory: foundInventory
+            },
+            relations: ['inventory', 'inventory.location', 'releaseGood']
+        });
+        const targetInventoryId = targetInventories.map((oi) => oi.id);
+        let worksheetDetails = await this.trxMgr.getRepository(entities_1.WorksheetDetail).find({
+            where: {
+                domain: this.domain,
+                type: worksheetType,
+                status: constants_1.WORKSHEET_STATUS.EXECUTING,
+                targetInventory: (0, typeorm_1.In)(targetInventoryId)
+            }
+        });
+        const sumOfReleaseQty = targetInventories
+            .map((oi) => oi.releaseQty)
+            .reduce((a, b) => a + b, 0);
+        if (sumOfReleaseQty != releaseQty)
+            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `insufficient picking quantity`));
+        for (var i = 0; i < targetInventories.length; i++) {
+            let targetInventory = targetInventories[i];
+            let inventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).findOne({
+                where: { domain: this.domain, id: targetInventory.inventory.id }
+            });
+            // validation to prevent picking if the inventory is involved in cycle count
+            let inventoryCheckItem = await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).findOne({
+                where: {
+                    domain: this.domain,
+                    inventory: inventory.id,
+                    status: (0, typeorm_1.In)([
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.PENDING,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.MISSING,
+                        sales_base_1.INVENTORY_CHECK_ITEM_STATUS.ADDED
+                    ])
+                }
+            });
+            if (inventoryCheckItem) {
+                throw new Error(`Inventory currently involved in an ongoing cycle count. Please complete the cycle count to proceed with picking.`);
+            }
+            const releaseGood = targetInventory.releaseGood;
+            if (inventory.palletId !== palletId)
+                throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId));
+            const leftQty = inventory.qty - targetInventory.releaseQty;
+            if (leftQty < 0) {
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`));
+            }
+            if (binLocationName) {
+                const binLocation = await this.trxMgr.getRepository(warehouse_base_1.Location).findOne({
+                    where: { domain: this.domain, name: binLocationName, type: warehouse_base_1.LOCATION_TYPE.BIN }
+                });
+                if (!binLocation)
+                    throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`));
+                targetInventory.binLocation = binLocation;
+            }
+            targetInventory.pickedQty = targetInventory.releaseQty;
+            targetInventory.status = sales_base_1.ORDER_INVENTORY_STATUS.PICKED;
+            await this.updateOrderTargets([targetInventory]);
+            let updateInvObj = {
+                qty: () => `"qty" - ${targetInventory.releaseQty}`,
+                lockedQty: () => `"locked_qty" - ${targetInventory.releaseQty}`,
+                uomValue: () => `"uom_value" - ${targetInventory.releaseUomValue}`,
+                lockedUomValue: () => `"locked_uom_value" - ${targetInventory.releaseUomValue}`,
+                updater: this.user,
+                updatedAt: new Date()
+            };
+            await this.trxMgr
+                .getRepository(warehouse_base_1.Inventory)
+                .createQueryBuilder()
+                .update(warehouse_base_1.Inventory)
+                .set(updateInvObj)
+                .where('id = :id', { id: targetInventory.inventory.id })
+                .returning(['qty'])
+                .execute();
+            await (0, warehouse_base_1.generateInventoryHistory)(inventory, releaseGood, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.PICKING, -targetInventory.releaseQty, -targetInventory.releaseUomValue, this.user, this.trxMgr);
+            if (leftQty === 0) {
+                inventory.status = warehouse_base_1.INVENTORY_STATUS.TERMINATED;
+            }
+            const fromLocation = targetInventory.inventory.location;
+            if (locationName) {
+                const toLocation = await this.trxMgr.getRepository(warehouse_base_1.Location).findOne({
+                    where: { domain: this.domain, name: locationName },
+                    relations: ['warehouse']
+                });
+                if (!toLocation)
+                    throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName));
+                if (fromLocation.id !== toLocation.id) {
+                    inventory.location = toLocation;
+                    inventory.warehouse = toLocation.warehouse;
+                    inventory.zone = toLocation.zone;
+                    await this.transactionInventory(inventory, releaseGood, 0, 0, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.RELOCATE);
+                }
+            }
+        }
+        worksheetDetails = worksheetDetails.map((worksheetDetail) => {
+            return Object.assign(Object.assign({}, worksheetDetail), { status: constants_1.WORKSHEET_STATUS.DONE, updater: this.user });
+        });
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetails);
+    }
+    async scanProductBatchPicking(taskNo, worksheetType, cartonId, productBarcode, inventory, binLocationName, pickingQty) {
+        try {
+            console.time(`scanProductBatchPicking:${taskNo}`);
+            const worksheet = await this.trxMgr
+                .getRepository(entities_1.Worksheet)
+                .createQueryBuilder('worksheet')
+                .innerJoinAndSelect('worksheet.worksheetDetails', 'worksheetDetails')
+                .innerJoinAndSelect('worksheetDetails.targetInventory', 'targetInventory')
+                .innerJoinAndSelect('targetInventory.product', 'product')
+                .leftJoinAndSelect('targetInventory.productDetail', 'productDetail')
+                .leftJoinAndSelect('targetInventory.inventory', 'inventory')
+                .leftJoinAndSelect('inventory.location', 'location')
+                .leftJoinAndSelect('targetInventory.releaseGood', 'releaseGood')
+                .where('worksheet.domain_id = :domainId', { domainId: this.domain.id })
+                .andWhere('worksheet.task_no = :taskNo', { taskNo })
+                .andWhere('worksheet.type = :type', { type: worksheetType })
+                .andWhere('worksheet.status = :status', { status: constants_1.WORKSHEET_STATUS.EXECUTING })
+                .getOne();
+            const worksheetDetails = worksheet.worksheetDetails;
+            const productDetail = worksheetDetails
+                .map(wsd => wsd.targetInventory.productDetail)
+                .find(productDetail => productDetail.id === inventory.productDetail.id);
+            const product = productDetail.product;
+            const batchId = inventory.batchId;
+            let pickedQty = pickingQty ? pickingQty : 1;
+            let matchingProduct;
+            const targetInventories = worksheetDetails
+                .map((wsd) => wsd.targetInventory)
+                .filter((targetInventory) => targetInventory.batchId === batchId &&
+                targetInventory.inventory.cartonId === cartonId &&
+                targetInventory.productDetail.id === productDetail.id);
+            matchingProduct = await this.getDirectQty(Object.assign(Object.assign({}, productDetail), { product }), productBarcode, pickedQty);
+            //validate matching product details based on scanned barcode
+            if (!matchingProduct)
+                throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode));
+            pickedQty = matchingProduct.qty;
+            const sumOfReleaseQty = parseFloat(targetInventories
+                .map((oi) => oi.releaseQty)
+                .reduce((a, b) => a + b, 0)
+                .toFixed(3));
+            const sumOfPickedQty = targetInventories.map((oi) => oi.pickedQty).reduce((a, b) => a + b, 0) + pickedQty;
+            if (sumOfPickedQty > sumOfReleaseQty)
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`));
+            for (var i = 0; i < targetInventories.length; i++) {
+                let targetInventory = targetInventories[i];
+                let inventory = targetInventory.inventory;
+                const targetReleaseQty = targetInventory.releaseQty;
+                const targetPickedQty = targetInventory.pickedQty;
+                const releaseGood = targetInventory.releaseGood;
+                if (pickedQty <= 0)
+                    break;
+                // validation to prevent picking if the inventory is involved in cycle count
+                let inventoryCheckItem = await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).findOne({
+                    where: {
+                        domain: this.domain,
+                        inventory: inventory.id,
+                        status: (0, typeorm_1.In)([
+                            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.PENDING,
+                            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
+                            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
+                            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
+                            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.MISSING,
+                            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.ADDED
+                        ])
+                    }
+                });
+                if (inventoryCheckItem) {
+                    throw new Error(`Inventory currently involved in an ongoing cycle count. Please complete the cycle count to proceed with picking.`);
+                }
+                if (targetInventory.status === sales_base_1.ORDER_INVENTORY_STATUS.PICKING &&
+                    targetReleaseQty > targetPickedQty &&
+                    pickedQty > 0) {
+                    let remainingAssignedQty = Math.round((pickedQty - (targetReleaseQty - targetPickedQty)) * 1000) / 1000; // -1, 0, 1
+                    const gapQtyRemaining = Math.round((targetReleaseQty - targetPickedQty) * 1000) / 1000; // > 0
+                    if (binLocationName && !(targetInventory === null || targetInventory === void 0 ? void 0 : targetInventory.binLocation)) {
+                        const binLocation = await this.trxMgr.getRepository(warehouse_base_1.Location).findOne({
+                            where: { domain: this.domain, name: binLocationName, type: warehouse_base_1.LOCATION_TYPE.BIN }
+                        });
+                        if (!binLocation)
+                            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`));
+                        targetInventory.binLocation = binLocation;
+                    }
+                    //  pickedQty = 1, gap = 5 || pickedQty = 12, gap = 5 || pickedQty = 5, gap = 5
+                    targetInventory.pickedQty += pickedQty > gapQtyRemaining ? gapQtyRemaining : pickedQty;
+                    remainingAssignedQty = remainingAssignedQty < 0 ? 0 : remainingAssignedQty;
+                    if (targetInventory.pickedQty == targetReleaseQty) {
+                        const leftQty = inventory.qty - targetInventory.releaseQty;
+                        if (leftQty < 0) {
+                            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`));
+                        }
+                        targetInventory.status = sales_base_1.ORDER_INVENTORY_STATUS.PICKED;
+                        await this.updateOrderTargets([targetInventory]);
+                        let updateInvObj = {
+                            qty: () => `"qty" - ${targetInventory.releaseQty}`,
+                            lockedQty: () => `"locked_qty" - ${targetInventory.releaseQty}`,
+                            uomValue: () => `"uom_value" - ${targetInventory.releaseUomValue}`,
+                            lockedUomValue: () => `"locked_uom_value" - ${targetInventory.releaseUomValue}`,
+                            updater: this.user,
+                            updatedAt: new Date()
+                        };
+                        await this.trxMgr
+                            .getRepository(warehouse_base_1.Inventory)
+                            .createQueryBuilder()
+                            .update(warehouse_base_1.Inventory)
+                            .set(updateInvObj)
+                            .where('id = :id', { id: targetInventory.inventory.id })
+                            .returning(['qty'])
+                            .execute();
+                        await (0, warehouse_base_1.generateInventoryHistory)(inventory, releaseGood, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.PICKING, -targetInventory.releaseQty, -targetInventory.releaseUomValue, this.user, this.trxMgr);
+                        if (leftQty === 0) {
+                            inventory.status = warehouse_base_1.INVENTORY_STATUS.TERMINATED;
+                        }
+                        let worksheetDetail = worksheetDetails.find((wsd) => wsd.targetInventory.id === targetInventory.id);
+                        worksheetDetail.status = constants_1.WORKSHEET_STATUS.DONE;
+                        worksheetDetail.updater = this.user;
+                        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+                    }
+                    else {
+                        await this.updateOrderTargets([targetInventory]);
+                    }
+                    pickedQty = Math.round((pickedQty - (targetReleaseQty - targetPickedQty)) * 1000) / 1000;
+                }
+            }
+        }
+        catch (error) {
+            env_1.logger.error(`picking-worksheet-controller[scanProductBatchPicking]: ${error}`);
+            throw new Error(error);
+        }
+        finally {
+            console.timeEnd(`scanProductBatchPicking:${taskNo}`);
+        }
+    }
+    async completePicking(releaseGood, worksheet, inventories) {
+        const foundNotSealedOrderTote = await this.trxMgr
+            .getRepository(sales_base_1.OrderTote)
+            .findOne({ where: { releaseGood, closedDate: (0, typeorm_1.IsNull)() } });
+        if (foundNotSealedOrderTote) {
+            throw new Error('Please seal the tote(s) before completing');
+        }
+        //check if any inventories is obsolete
+        if (!releaseGood.recall) {
+            let foundObsoleteInventories = await (0, utils_1.isInventoryObsolete)(inventories);
+            if ((foundObsoleteInventories === null || foundObsoleteInventories === void 0 ? void 0 : foundObsoleteInventories.length) > 0) {
+                return foundObsoleteInventories;
+            }
+        }
+        await this.checkRecordValidity(worksheet, { status: constants_1.WORKSHEET_STATUS.EXECUTING });
+        let inventoryItems = await this.trxMgr
+            .getRepository(warehouse_base_1.InventoryItem)
+            .find({ where: { outboundOrderId: releaseGood.id } });
+        if (inventoryItems.length > 0) {
+            inventoryItems.forEach((itm) => {
+                itm.status = warehouse_base_1.INVENTORY_STATUS.TERMINATED;
+                itm.updater = this.user;
+            });
+            await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).save(inventoryItems);
+        }
+        let orderVas = await this.trxMgr
+            .getRepository(sales_base_1.OrderVas)
+            .find({ where: { releaseGood: releaseGood.id } });
+        let orderStatus;
+        if (orderVas && orderVas.some(vas => vas.status === sales_base_1.ORDER_VAS_STATUS.PENDING_APPROVE)) {
+            throw new Error('VAS Order is in PENDING APPROVE. Kindly approve the order to proceed.');
+        }
+        else {
+            if (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.packingOption) {
+                orderStatus = sales_base_1.ORDER_STATUS.READY_TO_PACK;
+            }
+            else if (orderVas.length > 0) {
+                orderStatus = sales_base_1.ORDER_STATUS.VAS;
+            }
+            else {
+                orderStatus = sales_base_1.ORDER_STATUS.LOADING;
+            }
+        }
+        (0, integration_base_1.webhookHandler)(releaseGood, releaseGood.bizplace, integration_base_1.WebhookEventsEnum.PickingCompleted);
+        return await this.completeWorksheet(worksheet, orderStatus);
+    }
+    async completeBatchPicking(taskNo) {
+        let worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne({
+            where: {
+                domain: this.domain,
+                taskNo,
+                type: constants_1.WORKSHEET_TYPE.BATCH_PICKING
+            },
+            relations: [
+                'bizplace',
+                'bizplace.domain',
+                'worksheetDetails',
+                'worksheetDetails.targetInventory',
+                'worksheetDetails.targetInventory.releaseGood',
+                'worksheetDetails.targetInventory.inventory'
+            ]
+        });
+        this.checkRecordValidity(worksheet, { status: constants_1.WORKSHEET_STATUS.EXECUTING });
+        worksheet.status = constants_1.WORKSHEET_STATUS.DONE;
+        worksheet.endedAt = new Date();
+        worksheet.updater = this.user;
+        const worksheetDetails = worksheet.worksheetDetails.filter(wsD => wsD.status != 'MISSING' && wsD.status != 'CANCELLED');
+        worksheetDetails.forEach((wsd) => {
+            wsd.status = constants_1.WORKSHEET_STATUS.DONE;
+            wsd.updater = this.user;
+        });
+        const targetInventories = worksheetDetails.map((wsd) => {
+            let targetInventory = wsd.targetInventory;
+            targetInventory.status = sales_base_1.ORDER_INVENTORY_STATUS.TERMINATED;
+            targetInventory.updater = this.user;
+            return targetInventory;
+        });
+        const inventories = targetInventories.map((ti) => ti.inventory);
+        let isRecall;
+        const releaseGoods = worksheetDetails.map((wsd) => {
+            let releaseGood = wsd.targetInventory.releaseGood;
+            //prevent order from updating status if its in pending cancel
+            if (releaseGood.status == sales_base_1.ORDER_STATUS.PENDING_CANCEL) {
+                return releaseGood;
+            }
+            let orderStatus;
+            if (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.packingOption) {
+                orderStatus = sales_base_1.ORDER_STATUS.READY_TO_PACK;
+            }
+            else {
+                orderStatus = sales_base_1.ORDER_STATUS.READY_TO_SORT;
+            }
+            releaseGood.status = orderStatus;
+            releaseGood.updater = this.user;
+            if (releaseGood.recall) {
+                isRecall = true;
+            }
+            return releaseGood;
+        });
+        //check if any inventories is obsolete
+        if (!isRecall) {
+            let foundObsoleteInventories = await (0, utils_1.isInventoryObsolete)(inventories);
+            if ((foundObsoleteInventories === null || foundObsoleteInventories === void 0 ? void 0 : foundObsoleteInventories.length) > 0) {
+                return foundObsoleteInventories;
+            }
+        }
+        worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).save(worksheet);
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetails);
+        await this.updateOrderTargets(targetInventories);
+        await this.trxMgr.getRepository(sales_base_1.ReleaseGood).save(releaseGoods);
+        for (let releaseGood of releaseGoods) {
+            releaseGood.domain = this.domain;
+            releaseGood.bizplace = worksheet.bizplace;
+            (0, integration_base_1.webhookHandler)(releaseGood, releaseGood.bizplace, integration_base_1.WebhookEventsEnum.PickingCompleted);
+        }
+        return worksheet;
+    }
+    async extractMatchedWorksheetDetails(worksheetDetails, standardBatchId, standardProductId, standardPackingType, standardPackingSize, relations = ['targetInventory', 'targetInventory.product']) {
+        var _a, _b, _c, _d;
+        for (let wsd of worksheetDetails) {
+            if (!((_a = wsd.targetInventory) === null || _a === void 0 ? void 0 : _a.batchId) || !((_c = (_b = wsd.targetInventory) === null || _b === void 0 ? void 0 : _b.product) === null || _c === void 0 ? void 0 : _c.id) || !((_d = wsd.targetInventory) === null || _d === void 0 ? void 0 : _d.packingType)) {
+                wsd = await this.findWorksheetDetail(wsd, ['targetInventory', 'targetInventory.product']);
+            }
+        }
+        worksheetDetails = worksheetDetails.filter((wsd) => wsd.targetInventory.batchId === standardBatchId &&
+            wsd.targetInventory.product.id === standardProductId &&
+            wsd.targetInventory.packingType === standardPackingType &&
+            wsd.targetInventory.packingSize === standardPackingSize);
+        for (let wsd of worksheetDetails) {
+            wsd = await this.findWorksheetDetail(wsd, relations);
+        }
+        return worksheetDetails;
+    }
+    async checkAndSetBinPicking(orderInventory, binLocation) {
+        // bin picking validation
+        if (binLocation) {
+            const foundBinLocation = await this.trxMgr.getRepository(warehouse_base_1.Location).findOne({
+                where: { domain: this.domain, name: binLocation, type: warehouse_base_1.LOCATION_TYPE.BIN }
+            });
+            if (!foundBinLocation)
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`));
+            orderInventory.binLocation = foundBinLocation;
+        }
+        return orderInventory;
+    }
+    async updatePickingTransaction(releaseGood, orderInventory, worksheetDetail, inventory, pickedQty) {
+        var _a;
+        const releaseQty = orderInventory.releaseQty;
+        orderInventory.pickedQty = ((orderInventory === null || orderInventory === void 0 ? void 0 : orderInventory.pickedQty) || 0) + pickedQty;
+        if (orderInventory.pickedQty == releaseQty) {
+            const leftQty = inventory.qty - releaseQty;
+            if (leftQty < 0) {
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`));
+            }
+            orderInventory.status = sales_base_1.ORDER_INVENTORY_STATUS.PICKED;
+            orderInventory.pickedBy = (_a = this.user) === null || _a === void 0 ? void 0 : _a.name;
+            orderInventory.pickedByUser = this.user;
+            orderInventory.pickedAt = new Date();
+            inventory.qty -= orderInventory.releaseQty;
+            inventory.uomValue = Math.round((inventory.uomValue - orderInventory.releaseUomValue) * 100) / 100;
+            inventory.lockedQty = inventory.lockedQty - orderInventory.releaseQty;
+            inventory.lockedUomValue = Math.round((inventory.lockedUomValue - orderInventory.releaseUomValue) * 100) / 100;
+            inventory = await this.transactionInventory(inventory, releaseGood, -orderInventory.releaseQty, -orderInventory.releaseUomValue, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.PICKING);
+            worksheetDetail.status = constants_1.WORKSHEET_STATUS.DONE;
+            worksheetDetail.updater = this.user;
+            await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+            let inventoryItems = await this.trxMgr
+                .getRepository(warehouse_base_1.InventoryItem)
+                .find({ where: { outboundOrderId: releaseGood.id } });
+            if (inventoryItems.length > 0) {
+                inventoryItems.forEach((itm) => {
+                    itm.status = warehouse_base_1.INVENTORY_STATUS.PICKED;
+                    itm.updater = this.user;
+                });
+                await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).save(inventoryItems);
+            }
+            if (leftQty === 0) {
+                inventory.status = warehouse_base_1.INVENTORY_STATUS.TERMINATED;
+            }
+        }
+        await this.updateOrderTargets([orderInventory]);
+        return orderInventory;
+    }
+    async serialNumberReplacementForExistingOrderInv(existingOrderInv, targetInventory, worksheetDetail, foundSerialNumber) {
+        try {
+            //1. update replacement inventory, order inventory, old inventory, old order inventory quantity
+            let newInventory = await this.trxMgr
+                .getRepository(warehouse_base_1.Inventory)
+                .findOne({ where: { domain: this.domain, id: existingOrderInv === null || existingOrderInv === void 0 ? void 0 : existingOrderInv.inventoryId } });
+            let newOrderInventory = await this.trxMgr
+                .getRepository(sales_base_1.OrderInventory)
+                .findOne({ where: { domain: this.domain, id: existingOrderInv === null || existingOrderInv === void 0 ? void 0 : existingOrderInv.id } });
+            let oldInventory = await this.trxMgr
+                .getRepository(warehouse_base_1.Inventory)
+                .findOne({ where: { domain: this.domain, id: targetInventory === null || targetInventory === void 0 ? void 0 : targetInventory.inventory.id } });
+            let oldOrderInventory = await this.trxMgr
+                .getRepository(sales_base_1.OrderInventory)
+                .findOne({ where: { domain: this.domain, id: targetInventory === null || targetInventory === void 0 ? void 0 : targetInventory.id } });
+            //if replacement inventory quantity insufficient
+            if (newInventory.qty - newInventory.lockedQty < targetInventory.releaseQty - targetInventory.pickedQty) {
+                newOrderInventory.releaseQty += newInventory.qty - newInventory.lockedQty;
+                newOrderInventory.releaseUomValue += newInventory.uomValue - newInventory.lockedUomValue;
+                oldOrderInventory.releaseQty -= newOrderInventory.releaseQty;
+                oldOrderInventory.releaseUomValue -= newOrderInventory.releaseUomValue;
+                oldInventory.lockedQty -= newOrderInventory.releaseQty;
+                oldInventory.lockedUomValue -= newOrderInventory.releaseUomValue;
+                newInventory.lockedQty = newInventory.qty;
+                newInventory.lockedUomValue = newInventory.uomValue;
+            }
+            else {
+                newOrderInventory.releaseQty += targetInventory.releaseQty - targetInventory.pickedQty;
+                newOrderInventory.releaseUomValue +=
+                    newOrderInventory.releaseQty * (targetInventory.releaseUomValue / targetInventory.releaseQty);
+                oldOrderInventory.releaseQty = targetInventory.pickedQty;
+                oldOrderInventory.status = sales_base_1.ORDER_INVENTORY_STATUS.PICKED;
+                oldOrderInventory.releaseUomValue =
+                    (targetInventory.releaseUomValue / targetInventory.releaseQty) * oldOrderInventory.releaseQty;
+                oldInventory.lockedQty -= targetInventory.releaseQty - targetInventory.pickedQty;
+                oldInventory.lockedUomValue =
+                    oldInventory.lockedQty * (targetInventory.releaseUomValue / targetInventory.releaseQty);
+                newInventory.lockedQty = newInventory.lockedQty + (targetInventory.releaseQty - targetInventory.pickedQty);
+                newInventory.lockedUomValue =
+                    (targetInventory.releaseUomValue / targetInventory.releaseQty) * newInventory.lockedQty;
+            }
+            newInventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(Object.assign(Object.assign({}, newInventory), { updater: this.user }));
+            newOrderInventory = await this.trxMgr.getRepository(sales_base_1.OrderInventory).save(Object.assign(Object.assign({}, newOrderInventory), { status: warehouse_base_1.INVENTORY_STATUS.PICKING, pickedQty: existingOrderInv.pickedQty++, updater: this.user }));
+            oldInventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(Object.assign(Object.assign({}, oldInventory), { updater: this.user }));
+            foundSerialNumber = await this.trxMgr
+                .getRepository(warehouse_base_1.InventoryItem)
+                .save(Object.assign(Object.assign({}, foundSerialNumber), { inventory: newInventory }));
+            //2. update replacement worksheet detail
+            await this.trxMgr.getRepository(entities_1.WorksheetDetail).update({
+                targetInventory: existingOrderInv
+            }, {
+                status: constants_1.WORKSHEET_STATUS.EXECUTING,
+                updater: this.user
+            });
+            if (oldOrderInventory.releaseQty !== 0) {
+                oldOrderInventory = await this.trxMgr
+                    .getRepository(sales_base_1.OrderInventory)
+                    .save(Object.assign(Object.assign({}, oldOrderInventory), { updater: this.user }));
+                await this.trxMgr.getRepository(entities_1.WorksheetDetail).update({
+                    name: worksheetDetail.name
+                }, {
+                    status: constants_1.WORKSHEET_STATUS.DONE,
+                    updater: this.user
+                });
+            }
+            else {
+                await this.trxMgr.getRepository(entities_1.WorksheetDetail).delete(worksheetDetail.ild);
+                await this.trxMgr.getRepository(sales_base_1.OrderInventory).delete(targetInventory.id);
+            }
+        }
+        catch (e) {
+            env_1.logger.error(`picking-worksheet-controller[serialNumberReplacementForExistingOrderInv]: ${e}`);
+        }
+    }
+    async serialNumberReplacement(targetInventory, scannedPalletIdInventory, releaseGood, product, productDetail, worksheetDetail, foundSerialNumber) {
+        try {
+            //1. create new inventory, new order inventory, update old inventory, old order inventory quantity
+            let newInventory = await this.trxMgr
+                .getRepository(warehouse_base_1.Inventory)
+                .findOne({ where: { id: scannedPalletIdInventory === null || scannedPalletIdInventory === void 0 ? void 0 : scannedPalletIdInventory.id } });
+            let oldInventory = await this.trxMgr
+                .getRepository(warehouse_base_1.Inventory)
+                .findOne({ where: { domain: this.domain, id: targetInventory === null || targetInventory === void 0 ? void 0 : targetInventory.inventory.id } });
+            let oldOrderInventory = await this.trxMgr
+                .getRepository(sales_base_1.OrderInventory)
+                .findOne({ where: { domain: this.domain, id: targetInventory === null || targetInventory === void 0 ? void 0 : targetInventory.id } });
+            let newOrderInventoryReleaseQty = 0;
+            let newOrderInventoryReleaseUomValue = 0;
+            //if replacement inventory quantity insufficient
+            if (newInventory.qty - newInventory.lockedQty < targetInventory.releaseQty - targetInventory.pickedQty) {
+                newOrderInventoryReleaseQty = newInventory.qty - newInventory.lockedQty;
+                newOrderInventoryReleaseUomValue = newInventory.uomValue - newInventory.lockedUomValue;
+                oldOrderInventory.releaseQty -= newOrderInventoryReleaseQty;
+                oldOrderInventory.releaseUomValue -= newOrderInventoryReleaseUomValue;
+                oldInventory.lockedQty -= newOrderInventoryReleaseQty;
+                oldInventory.lockedUomValue -= newOrderInventoryReleaseUomValue;
+                newInventory.lockedQty = newInventory.qty;
+                newInventory.lockedUomValue = newInventory.uomValue;
+            }
+            else {
+                newOrderInventoryReleaseQty = targetInventory.releaseQty - targetInventory.pickedQty;
+                newOrderInventoryReleaseUomValue =
+                    newOrderInventoryReleaseQty * (targetInventory.releaseUomValue / targetInventory.releaseQty);
+                oldOrderInventory.releaseQty = targetInventory.pickedQty;
+                oldOrderInventory.status = sales_base_1.ORDER_INVENTORY_STATUS.PICKED;
+                oldOrderInventory.releaseUomValue =
+                    (targetInventory.releaseUomValue / targetInventory.releaseQty) * oldOrderInventory.releaseQty;
+                oldInventory.lockedQty -= newOrderInventoryReleaseQty;
+                oldInventory.lockedUomValue -= newOrderInventoryReleaseUomValue;
+                newInventory.lockedQty = newInventory.lockedQty + (targetInventory.releaseQty - targetInventory.pickedQty);
+                newInventory.lockedUomValue =
+                    (targetInventory.releaseUomValue / targetInventory.releaseQty) * newInventory.lockedQty;
+            }
+            newInventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(Object.assign(Object.assign({}, newInventory), { updater: this.user }));
+            let newTargetInventory = ((_a) => {
+                var { id } = _a, targetInventory = __rest(_a, ["id"]);
+                return targetInventory;
+            })(targetInventory);
+            let newOrderInventory = await this.trxMgr.getRepository(sales_base_1.OrderInventory).save(Object.assign(Object.assign({}, newTargetInventory), { domain: this.domain, name: sales_base_1.OrderNoGenerator.orderInventory(), releaseGood, releaseQty: newOrderInventoryReleaseQty, releaseUomValue: newOrderInventoryReleaseUomValue, pickedQty: 1, product,
+                productDetail, inventory: scannedPalletIdInventory, creator: this.user, updater: this.user }));
+            oldInventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(Object.assign(Object.assign({}, oldInventory), { updater: this.user }));
+            foundSerialNumber = await this.trxMgr
+                .getRepository(warehouse_base_1.InventoryItem)
+                .save(Object.assign(Object.assign({}, foundSerialNumber), { inventory: newInventory }));
+            //3. create new worksheet detail
+            let NewWorksheetDetail = ((_a) => {
+                var { id } = _a, worksheetDetail = __rest(_a, ["id"]);
+                return worksheetDetail;
+            })(worksheetDetail);
+            await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(Object.assign(Object.assign({}, NewWorksheetDetail), { domain: this.domain, name: utils_1.WorksheetNoGenerator.pickingDetail(), targetInventory: newOrderInventory, status: constants_1.WORKSHEET_STATUS.EXECUTING, creator: this.user, updater: this.user }));
+            //if old order inventory release quantity is 0 then delete
+            if (oldOrderInventory.releaseQty !== 0) {
+                oldOrderInventory = await this.trxMgr
+                    .getRepository(sales_base_1.OrderInventory)
+                    .save(Object.assign(Object.assign({}, oldOrderInventory), { updater: this.user }));
+                //4. update old worksheet detail
+                worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).update({
+                    name: worksheetDetail.name
+                }, {
+                    status: constants_1.WORKSHEET_STATUS.DONE,
+                    updater: this.user
+                });
+            }
+            else {
+                await this.trxMgr.getRepository(entities_1.WorksheetDetail).delete(worksheetDetail.id);
+                await this.trxMgr.getRepository(sales_base_1.OrderInventory).delete(targetInventory.id);
+            }
+        }
+        catch (e) {
+            env_1.logger.error(`picking-worksheet-controller[serialNumberReplacement]: ${e}`);
+        }
+    }
+    async toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace) {
+        //1. find tote
+        let foundTote = await this.trxMgr
+            .getRepository(warehouse_base_1.Tote)
+            .findOne({ where: { bizplace, name: toteNo, deletedAt: (0, typeorm_1.IsNull)() } });
+        if ((foundTote === null || foundTote === void 0 ? void 0 : foundTote.status) == warehouse_base_1.TOTE_STATUS.DAMAGED || (foundTote === null || foundTote === void 0 ? void 0 : foundTote.status) == warehouse_base_1.TOTE_STATUS.DISPATCHED) {
+            foundTote = null;
+        }
+        //2. find order tote
+        let foundOrderTote = await this.trxMgr
+            .getRepository(sales_base_1.OrderTote)
+            .findOne({ where: { domain: this.domain, name: toteNo, releaseGood } });
+        //if order tote not found the create one, if tote not found means it's tote box
+        //create order tote item
+        if (!foundOrderTote) {
+            const orderTote = await this.trxMgr.getRepository(sales_base_1.OrderTote).save({
+                name: toteNo,
+                domain: this.domain,
+                releaseGood,
+                tote: foundTote ? foundTote : null,
+                updater: this.user
+            });
+            const orderToteItem = await this.trxMgr.getRepository(sales_base_1.OrderToteItem).save({
+                domain: this.domain,
+                name: sales_base_1.OrderNoGenerator.orderToteItem(),
+                orderProduct: targetProduct,
+                orderInventory: targetInventory,
+                orderTote,
+                qty: pickedQty,
+                updater: this.user
+            });
+        }
+        else {
+            if (foundOrderTote.closedDate) {
+                throw new Error('Tote has been sealed, please try another tote!');
+            }
+            //if found order tote then check if order tote item exist
+            const foundOrderToteItem = await this.trxMgr.getRepository(sales_base_1.OrderToteItem).findOne({
+                domain: this.domain,
+                orderProduct: targetProduct,
+                orderInventory: targetInventory,
+                orderTote: foundOrderTote
+            });
+            //if not order tote item doesnt exist then create one
+            if (!foundOrderToteItem) {
+                const orderToteItem = await this.trxMgr.getRepository(sales_base_1.OrderToteItem).save({
+                    domain: this.domain,
+                    name: sales_base_1.OrderNoGenerator.orderToteItem(),
+                    orderProduct: targetProduct,
+                    orderInventory: targetInventory,
+                    orderTote: foundOrderTote,
+                    qty: pickedQty,
+                    updater: this.user
+                });
+            }
+            else {
+                //if found order tote item found then add the quantity
+                const orderToteItem = await this.trxMgr.getRepository(sales_base_1.OrderToteItem).save(Object.assign(Object.assign({}, foundOrderToteItem), { qty: foundOrderToteItem.qty + pickedQty }));
+            }
+        }
+    }
+    async undoSerialNumberPicking(worksheetDetailName, inventoryItemId) {
+        const worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).findOne({
+            where: { name: worksheetDetailName, domain: this.domain, status: (0, typeorm_1.Not)((0, typeorm_1.Equal)(constants_1.WORKSHEET_STATUS.DEACTIVATED)) },
+            relations: [
+                'worksheet',
+                'worksheet.releaseGood',
+                'targetInventory',
+                'targetInventory.product',
+                'targetInventory.inventory'
+            ]
+        });
+        let targetInventory = worksheetDetail.targetInventory;
+        let releaseGood = worksheetDetail.worksheet.releaseGood;
+        if (targetInventory.releaseQty == targetInventory.pickedQty &&
+            targetInventory.status == sales_base_1.ORDER_INVENTORY_STATUS.PICKED) {
+            targetInventory.status = warehouse_base_1.INVENTORY_STATUS.PICKING;
+            await this.trxMgr
+                .getRepository(entities_1.WorksheetDetail)
+                .update({ id: worksheetDetail.id }, { status: constants_1.WORKSHEET_STATUS.EXECUTING });
+            targetInventory.inventory.qty += targetInventory.releaseQty;
+            targetInventory.inventory.uomValue =
+                Math.round((targetInventory.inventory.uomValue + targetInventory.releaseUomValue) * 100) / 100;
+            targetInventory.inventory.lockedQty = targetInventory.inventory.lockedQty + targetInventory.releaseQty;
+            targetInventory.inventory.lockedUomValue =
+                Math.round((targetInventory.inventory.lockedUomValue + targetInventory.releaseUomValue) * 100) / 100;
+            await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(targetInventory.inventory);
+        }
+        let InventoryItems = await this.trxMgr
+            .getRepository(warehouse_base_1.InventoryItem)
+            .find({ where: { outboundOrderId: releaseGood.id } });
+        let removeInventoryItem = await this.trxMgr
+            .getRepository(warehouse_base_1.InventoryItem)
+            .findOne({ where: { id: inventoryItemId } });
+        if (InventoryItems.length > 0) {
+            InventoryItems.forEach((itm) => {
+                itm.status = warehouse_base_1.INVENTORY_STATUS.PICKING;
+                itm.updater = this.user;
+            });
+            await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).save(InventoryItems);
+        }
+        if (removeInventoryItem.source == warehouse_base_1.INVENTORY_ITEM_SOURCE.OUTBOUND) {
+            await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).delete(removeInventoryItem.id);
+        }
+        else {
+            await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).update({
+                id: inventoryItemId
+            }, {
+                status: warehouse_base_1.INVENTORY_STATUS.STORED,
+                outboundOrderId: null,
+                updater: this.user
+            });
+        }
+        targetInventory.pickedQty--;
+        targetInventory.updater = this.user;
+        await this.updateOrderTargets([targetInventory]);
+    }
+    async sealTote(sealNo, toteNo, orderNo) {
+        const checkDuplicateSeal = await this.trxMgr.getRepository(sales_base_1.OrderToteSeal).findOne({
+            where: {
+                name: sealNo
+            }
+        });
+        if (checkDuplicateSeal) {
+            throw new Error('Seal has been scanned before');
+        }
+        const releaseGood = await this.trxMgr
+            .getRepository(sales_base_1.ReleaseGood)
+            .findOne({ where: { domain: this.domain, name: orderNo }, relations: ['bizplace', 'bizplace.domain'] });
+        let sealNoSetting = await this.trxMgr.getRepository(setting_base_1.Setting).findOne({
+            where: {
+                domain: releaseGood.bizplace.domain,
+                name: 'minimum-seal-number'
+            }
+        });
+        if (!sealNoSetting) {
+            sealNoSetting = await this.trxMgr.getRepository(setting_base_1.Setting).findOne({
+                where: {
+                    domain: this.domain,
+                    name: 'minimum-seal-number'
+                }
+            });
+        }
+        const foundOrderTote = await this.trxMgr
+            .getRepository(sales_base_1.OrderTote)
+            .findOne({ where: { domain: this.domain, name: toteNo, releaseGood } });
+        if (!foundOrderTote) {
+            throw new Error('Tote not scanned under this order');
+        }
+        let totalOrderToteItems = await this.trxMgr.getRepository(sales_base_1.OrderToteItem).count({
+            where: {
+                orderTote: foundOrderTote
+            }
+        });
+        if (totalOrderToteItems < 1) {
+            throw new Error('Tote carton is empty');
+        }
+        const newToteOrderSeal = await this.trxMgr.getRepository(sales_base_1.OrderToteSeal).save({
+            domain: this.domain,
+            name: sealNo,
+            orderTote: foundOrderTote,
+            updater: this.user
+        });
+        const totalSeal = await this.trxMgr.getRepository(sales_base_1.OrderToteSeal).count({
+            orderTote: foundOrderTote
+        });
+        if (totalSeal >= parseInt((sealNoSetting === null || sealNoSetting === void 0 ? void 0 : sealNoSetting.value) || 0)) {
+            await this.trxMgr.getRepository(sales_base_1.OrderTote).save(Object.assign(Object.assign({}, foundOrderTote), { closedDate: new Date() }));
+        }
+    }
+    async assignInventoriesForUnassignedOrder(worksheet, tx) {
+        var _a, _b;
+        const releaseGood = worksheet.releaseGood;
+        const orderProducts = releaseGood.orderProducts;
+        let finalOrderInventories = [];
+        let newWorksheetDetails = [];
+        const transaction = tx ? tx : this.trxMgr;
+        const inventoryAssignmentSetting = await transaction
+            .getRepository(setting_base_1.Setting)
+            .findOne({ where: { domain: this.domain, name: 'rule-for-inventory-assignment' } });
+        for (let op of orderProducts) {
+            let locationSortingRules = [];
+            if (inventoryAssignmentSetting) {
+                let locationSetting = JSON.parse(inventoryAssignmentSetting.value);
+                for (const key in locationSetting) {
+                    locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true });
+                }
+            }
+            let assignedOrderInventories = await sales_base_1.InventoryUtil.autoAssignInventoryForRelease(op, op.productDetail.product, op.productDetail, locationSortingRules, releaseGood.bizplace, this.domain, transaction, op.batchId);
+            assignedOrderInventories = assignedOrderInventories.map(aoi => {
+                delete aoi.id;
+                return Object.assign(Object.assign({}, aoi), { orderProduct: op, status: sales_base_1.ORDER_INVENTORY_STATUS.PICKING, name: sales_base_1.OrderNoGenerator.orderInventory(), domain: this.domain, bizplace: { id: releaseGood.bizplace.id }, releaseGood });
+            });
+            finalOrderInventories.push(...assignedOrderInventories);
+            await transaction
+                .getRepository(sales_base_1.OrderProduct)
+                .update({ id: op.id }, { status: sales_base_1.ORDER_PRODUCT_STATUS.ASSIGNED, updater: this.user });
+        }
+        for (let oi of finalOrderInventories) {
+            // update inventory locked qty and uom value
+            oi = await transaction.getRepository(sales_base_1.OrderInventory).save(Object.assign({}, oi));
+            await transaction.getRepository(warehouse_base_1.Inventory).update(oi.inventory.id, {
+                lockedQty: (((_a = oi.inventory) === null || _a === void 0 ? void 0 : _a.lockedQty) || 0) + oi.releaseQty,
+                lockedUomValue: (((_b = oi.inventory) === null || _b === void 0 ? void 0 : _b.lockedUomValue) || 0) + oi.releaseUomValue,
+                updater: this.user
+            });
+            await transaction
+                .getRepository(warehouse_base_1.ProductDetailStock)
+                .createQueryBuilder()
+                .update(warehouse_base_1.ProductDetailStock)
+                .set({
+                unassignedQty: () => `"unassigned_qty" - ${oi.releaseQty}`,
+                unassignedUomValue: () => `"unassigned_uom_value" - ${oi.releaseUomValue}`
+            })
+                .where({ productDetail: oi.productDetail.id })
+                .execute();
+            const worksheetDetail = Object.assign(new entities_1.WorksheetDetail(), {
+                domain: this.domain,
+                bizplace: { id: releaseGood.bizplace.id },
+                worksheet,
+                name: utils_1.WorksheetNoGenerator.pickingDetail(),
+                seq: 0,
+                targetInventory: oi,
+                targetProduct: oi.orderProduct,
+                type: constants_1.WORKSHEET_TYPE.PICKING,
+                status: constants_1.WORKSHEET_STATUS.DEACTIVATED,
+                creator: this.user,
+                updater: this.user
+            });
+            newWorksheetDetails.push(worksheetDetail);
+        }
+        newWorksheetDetails = await transaction.getRepository(entities_1.WorksheetDetail).save(newWorksheetDetails);
+        return newWorksheetDetails;
+    }
+    async assignInventoriesForUnassignedMergedOrder(worksheet) {
+        //const releaseGood = worksheet.releaseGood
+        const orderProducts = worksheet.worksheetDetails
+            .filter(itm => itm.targetProduct.releaseGood.assignedInventory == false)
+            .map(wsd => wsd.targetProduct);
+        const releaseGoodIds = [...new Set(orderProducts.map(op => op.releaseGood.id))];
+        let newWorksheetDetails = [];
+        const inventoryAssignmentSetting = await this.trxMgr.getRepository(setting_base_1.Setting).findOne({
+            where: { domain: this.domain, name: 'rule-for-inventory-assignment' }
+        });
+        for (let i = 0; i < orderProducts.length; i++) {
+            let pInventoryList = (0, utils_1.inventoriesByStrategy)(Object.assign(Object.assign({}, orderProducts[i]), { worksheetId: worksheet.id, bizplaceId: worksheet.bizplace.id, locationSortingRules: inventoryAssignmentSetting ? JSON.parse(inventoryAssignmentSetting.value) : false, pickingStrategy: orderProducts[i].product.pickingStrategy }), this.domain, this.trxMgr);
+            let idx = 0;
+            let [inventoryList] = await Promise.all([pInventoryList]);
+            let { releaseQty, releaseUomValue } = orderProducts[i];
+            while (releaseQty > 0 && idx < inventoryList.items.length) {
+                let targetInventory = await this.trxMgr
+                    .getRepository(warehouse_base_1.Inventory)
+                    .findOne({ where: { id: inventoryList.items[idx].id } });
+                let inventoryAvailableQty = targetInventory.qty - ((targetInventory === null || targetInventory === void 0 ? void 0 : targetInventory.lockedQty) || 0);
+                let inventoryAvailableUomValue = targetInventory.uomValue - ((targetInventory === null || targetInventory === void 0 ? void 0 : targetInventory.lockedUomValue) || 0);
+                if (inventoryAvailableQty > 0) {
+                    let allocatedQty = 0, allocatedUomValue = 0;
+                    if (inventoryAvailableQty < releaseQty) {
+                        idx = idx + 1;
+                        allocatedQty = inventoryAvailableQty;
+                        allocatedUomValue = inventoryAvailableUomValue;
+                    }
+                    else {
+                        allocatedQty = releaseQty;
+                        allocatedUomValue = releaseUomValue;
+                    }
+                    releaseQty = releaseQty - allocatedQty;
+                    releaseUomValue = releaseUomValue - allocatedUomValue;
+                    //// Update inventory locked quantity
+                    await this.trxMgr
+                        .getRepository(warehouse_base_1.Inventory)
+                        .createQueryBuilder('inv')
+                        .update(warehouse_base_1.Inventory)
+                        .set({
+                        lockedUomValue: () => `COALESCE(locked_uom_value,0) + ${allocatedUomValue}`,
+                        lockedQty: () => `COALESCE(locked_qty,0) + ${allocatedQty}`
+                    })
+                        .where('id = :id', { id: targetInventory.id })
+                        .execute();
+                    // update product detail stock deduct unassigned qty and unassigned uom value
+                    await this.trxMgr
+                        .getRepository(warehouse_base_1.ProductDetailStock)
+                        .createQueryBuilder()
+                        .update(warehouse_base_1.ProductDetailStock)
+                        .set({
+                        unassignedQty: () => `"unassigned_qty" - ${allocatedQty}`,
+                        unassignedUomValue: () => `"unassigned_uom_value" - ${allocatedUomValue}`
+                    })
+                        .where({ productDetail: orderProducts[i].productDetail.id })
+                        .execute();
+                    // update order product status to ASSIGNED
+                    await this.trxMgr
+                        .getRepository(sales_base_1.OrderProduct)
+                        .update({ id: orderProducts[i].id }, { status: sales_base_1.ORDER_PRODUCT_STATUS.ASSIGNED, updater: this.user });
+                    // Create new order inventory with status -> READY_TO_PICK, type -> RELEASE_OF_GOODS
+                    let newTargetInventory = new sales_base_1.OrderInventory();
+                    newTargetInventory = {
+                        domain: this.domain,
+                        bizplace: orderProducts[i].bizplace,
+                        name: sales_base_1.OrderNoGenerator.orderInventory(),
+                        releaseGood: orderProducts[i].releaseGood,
+                        batchId: targetInventory.batchId,
+                        status: sales_base_1.ORDER_INVENTORY_STATUS.PICKING,
+                        type: sales_base_1.ORDER_TYPES.RELEASE_OF_GOODS,
+                        refWorksheetId: worksheet.id,
+                        product: orderProducts[i].product,
+                        productDetail: orderProducts[i].productDetail,
+                        packingType: orderProducts[i].packingType,
+                        packingSize: parseFloat(orderProducts[i].packingSize),
+                        creator: this.user,
+                        inventory: targetInventory,
+                        releaseQty: allocatedQty,
+                        releaseUomValue: allocatedUomValue,
+                        uom: orderProducts[i].uom,
+                        orderProduct: orderProducts[i]
+                    };
+                    newTargetInventory = await this.trxMgr.getRepository(sales_base_1.OrderInventory).save(newTargetInventory);
+                    if (idx == 0) {
+                        let updatedWorksheetDetail = Object.assign(Object.assign({}, worksheet.worksheetDetails[i]), { targetInventory: newTargetInventory, worksheet, bizplace: worksheet.bizplace, domain: this.domain, updater: this.user, creator: this.user });
+                        await this.trxMgr.getRepository(entities_1.WorksheetDetail).update(worksheet.worksheetDetails[i].id, {
+                            targetInventory: newTargetInventory,
+                            worksheet,
+                            bizplace: worksheet.bizplace,
+                            domain: this.domain,
+                            updater: this.user,
+                            creator: this.user
+                        });
+                        newWorksheetDetails.push(updatedWorksheetDetail);
+                    }
+                    else {
+                        let newWorksheetDetail = Object.assign(Object.assign({}, worksheet.worksheetDetails[i]), { name: utils_1.WorksheetNoGenerator.batchPickingDetail(), targetInventory: newTargetInventory, worksheet, bizplace: worksheet.bizplace, domain: this.domain, updater: this.user, creator: this.user });
+                        delete newWorksheetDetail.id;
+                        newWorksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(newWorksheetDetail);
+                        newWorksheetDetails.push(newWorksheetDetail);
+                    }
+                }
+                else {
+                    idx = idx + 1;
+                }
+            }
+            await this.trxMgr.getRepository(sales_base_1.ReleaseGood).update(releaseGoodIds, { assignedInventory: true });
+        }
+        return newWorksheetDetails;
+    }
+    async activateBulkWorksheets(bizplaceId, worksheetIds) {
+        var _a, _b;
+        const updatedWs = [];
+        try {
+            for (const worksheetId of worksheetIds) {
+                try {
+                    let worksheet;
+                    let releaseGood;
+                    let newReleaseGood;
+                    let domain;
+                    await (0, typeorm_1.getManager)().transaction(async (tx) => {
+                        var _a;
+                        const worksheetRepo = tx.getRepository(entities_1.Worksheet);
+                        worksheet = await worksheetRepo.findOne({
+                            where: { id: worksheetId, bizplace: bizplaceId },
+                            relations: [
+                                'domain',
+                                'bizplace',
+                                'bizplace.company',
+                                'bizplace.company.domain',
+                                'releaseGood',
+                                'releaseGood.bizplace',
+                                'releaseGood.domain',
+                                'releaseGood.lastMileDelivery',
+                                'releaseGood.bizplace.domain',
+                                'worksheetDetails',
+                                'worksheetDetails.targetInventory',
+                                'worksheetDetails.targetInventory.product'
+                            ]
+                        });
+                        let worksheetDetails;
+                        let orderProducts = await tx.getRepository(sales_base_1.OrderProduct).find({
+                            where: { releaseGood: worksheet.releaseGood },
+                            relations: [
+                                'product',
+                                'productDetail',
+                                'productBundle',
+                                'productBundle.productBundleSettings',
+                                'productBundle.productBundleSettings.productDetail',
+                                'productDetail.product'
+                            ]
+                        });
+                        let orderPackages = await tx.getRepository(sales_base_1.OrderPackage).find({
+                            where: { releaseGood: worksheet.releaseGood },
+                            relations: [
+                                'orderPackageItems',
+                                'orderPackageItems.productDetail',
+                                'orderPackageItems.orderProduct',
+                                'orderPackageItems.orderProduct.product',
+                                'orderPackageItems.orderProduct.product.productDetails'
+                            ]
+                        });
+                        let orderConsignments = await tx.getRepository(sales_base_1.OrderConsignment).find({
+                            where: { releaseGood: worksheet.releaseGood },
+                            relations: [
+                                'orderPackages',
+                                'orderPackages.orderPackageItems',
+                                'orderPackages.orderPackageItems.orderProduct',
+                                'orderPackages.orderPackageItems.orderProduct.product',
+                                'orderPackages.orderPackageItems.orderProduct.product.productDetails'
+                            ]
+                        });
+                        worksheet.releaseGood = Object.assign(Object.assign({}, worksheet.releaseGood), { orderProducts, orderPackages, orderConsignments });
+                        if (worksheet.type === constants_1.WORKSHEET_TYPE.PICKING) {
+                            if (((_a = worksheet.releaseGood) === null || _a === void 0 ? void 0 : _a.assignedInventory) == false) {
+                                worksheetDetails = await this.assignInventoriesForUnassignedOrder(worksheet, tx);
+                                worksheet.worksheetDetails = worksheetDetails;
+                                worksheet.releaseGood.assignedInventory = true;
+                            }
+                            else {
+                                worksheetDetails = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED');
+                                const targetInventoryIds = worksheetDetails.map((wsd) => wsd.targetInventory.id);
+                                await tx.getRepository(sales_base_1.OrderInventory).update({ id: (0, typeorm_1.In)(targetInventoryIds) }, {
+                                    status: sales_base_1.ORDER_INVENTORY_STATUS.PICKING,
+                                    updater: this.user
+                                });
+                            }
+                            await tx.getRepository(sales_base_1.ReleaseGood).update({ id: worksheet.releaseGood.id }, {
+                                status: sales_base_1.ORDER_STATUS.PICKING,
+                                updater: this.user,
+                                assignedInventory: true
+                            });
+                        }
+                        else {
+                            worksheetDetails = worksheet.worksheetDetails;
+                        }
+                        worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [], tx);
+                        releaseGood = worksheet.releaseGood;
+                        domain = worksheet.domain;
+                        //updatedWs.push(worksheet)
+                    });
+                    const orderSource = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.source;
+                    switch (orderSource) {
+                        //disable temporary to prevent duplicates call
+                        case auth_base_1.ApplicationType.SELLERCRAFT:
+                            // getManager().transaction(async txMgr => {
+                            //   const sellercraft: Sellercraft = await txMgr
+                            //     .getRepository(Sellercraft)
+                            //     .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+                            //   if (sellercraft) {
+                            //     const sellercraftCtrl: SellercraftController = new SellercraftController(
+                            //       txMgr,
+                            //       this.domain,
+                            //       this.user
+                            //     )
+                            //     if (!releaseGood?.orderPackages?.length) {
+                            //       const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
+                            //         where: { releaseGood },
+                            //         relations: ['product', 'product.productDetails', 'productDetail']
+                            //       })
+                            //       // asynchronously pack order
+                            //       await sellercraftCtrl.packOrder(sellercraft, {
+                            //         ...releaseGood,
+                            //         orderProducts,
+                            //         domain: domain
+                            //       })
+                            //     }
+                            //   }
+                            // })
+                            break;
+                        case auth_base_1.ApplicationType.POWRUP:
+                            await (0, typeorm_1.getManager)().transaction(async (txMgr) => {
+                                var _a;
+                                const powrup = await txMgr.getRepository(integration_powrup_1.Powrup).findOne({ active: true, platform: 'POWRUP' });
+                                if (powrup) {
+                                    const powrupCtrl = new sales_base_1.PowrupController();
+                                    if (!((_a = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.orderPackages) === null || _a === void 0 ? void 0 : _a.length)) {
+                                        const orderProducts = await txMgr.getRepository(sales_base_1.OrderProduct).find({
+                                            where: { releaseGood },
+                                            relations: ['product', 'productDetail']
+                                        });
+                                        // asynchronously pack order
+                                        newReleaseGood = await powrupCtrl.packOrder(powrup, Object.assign(Object.assign({}, releaseGood), { orderProducts }), domain, this.user, txMgr);
+                                    }
+                                }
+                            });
+                            break;
+                        case auth_base_1.ApplicationType.WEBSPERT:
+                            // Trigger Whole Order Process
+                            sales_base_1.WebspertController.triggerOrderProcesses(releaseGood, this.domain, this.user);
+                            break;
+                        case auth_base_1.ApplicationType.MMS:
+                            break;
+                        default:
+                            if (!((_a = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.orderPackages) === null || _a === void 0 ? void 0 : _a.length)) {
+                                let mps = (_b = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.lastMileDelivery) === null || _b === void 0 ? void 0 : _b.mps;
+                                switch (mps) {
+                                    case true:
+                                        newReleaseGood = await splitOrderConsignment(this.trxMgr, releaseGood, this.user, this.domain);
+                                        break;
+                                    case false:
+                                    case undefined:
+                                        let orderConsignment = await createOrderConsignment(this.trxMgr, {}, releaseGood, this.user);
+                                        let orderPackage = {
+                                            name: sales_base_1.OrderNoGenerator.orderPackage(),
+                                            packageId: null,
+                                            trackingNo: null,
+                                            transporter: null,
+                                            airwayBill: (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.airwayBill) || null,
+                                            invoice: releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.invoice,
+                                            status: sales_base_1.ORDER_STATUS.PROCESSING,
+                                            releaseGood,
+                                            domain: releaseGood.domain,
+                                            bizplace: releaseGood.bizplace,
+                                            creator: this.user,
+                                            updater: this.user,
+                                            orderConsignment: orderConsignment
+                                        };
+                                        newReleaseGood = await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage);
+                                        break;
+                                }
+                            }
+                            break;
+                    }
+                    worksheet.releaseGood = newReleaseGood ? newReleaseGood : releaseGood;
+                    updatedWs.push(worksheet);
+                }
+                catch (e) {
+                    env_1.logger.error(`picking-worksheet-controller[activateBulkWorksheets]: ( WorksheetId: ${worksheetId}, Error: ${e})`);
+                }
+            }
+        }
+        catch (e) {
+            console.log(e);
+        }
+        return updatedWs;
+    }
+}
+exports.PickingWorksheetController = PickingWorksheetController;
+async function createOrderPackageAndItems(tx, releaseGood, orderPackage) {
+    try {
+        let savedOrderPackage = await tx.getRepository(sales_base_1.OrderPackage).save(orderPackage);
+        const orderPackageItems = releaseGood.orderProducts
+            .map(op => {
+            if (op.product) {
+                return {
+                    id: (0, uuid_1.v4)(),
+                    name: sales_base_1.OrderNoGenerator.orderPackageItem(),
+                    orderProduct: op,
+                    status: sales_base_1.ORDER_STATUS.PROCESSING,
+                    releaseQty: op.releaseQty,
+                    orderPackage: savedOrderPackage,
+                    domain: releaseGood.domain,
+                    bizplace: releaseGood.bizplace,
+                    creator: releaseGood.creator,
+                    updater: releaseGood.updater,
+                    productDetail: op.productDetail
+                };
+            }
+            else {
+                let productBundle = op.productBundle;
+                return productBundle.productBundleSettings.map(pbs => ({
+                    name: sales_base_1.OrderNoGenerator.orderPackageItem(),
+                    orderProduct: op,
+                    status: sales_base_1.ORDER_STATUS.PROCESSING,
+                    releaseQty: op.releaseQty * pbs.bundleQty,
+                    orderPackage: savedOrderPackage,
+                    domain: releaseGood.domain,
+                    bizplace: releaseGood.bizplace,
+                    creator: releaseGood.creator,
+                    updater: releaseGood.updater,
+                    productDetail: pbs.productDetail
+                }));
+            }
+        })
+            .flat();
+        await tx.getRepository(sales_base_1.OrderPackageItem).save(orderPackageItems);
+        orderPackage.orderPackageItems = orderPackageItems;
+        releaseGood.orderPackages = [orderPackage];
+        return releaseGood;
+    }
+    catch (e) {
+        env_1.logger.error(`error:${e}`);
+    }
+}
+exports.createOrderPackageAndItems = createOrderPackageAndItems;
+async function splitOrderConsignment(tx, releaseGood, user, domain) {
+    try {
+        let currentConsignment = { id: (0, uuid_1.v4)(), totalWeight: 0, orderPackages: [] };
+        let totalConsignments = [];
+        let currOrderProducts = [];
+        let totalConsignmentWeight = 0;
+        let orderProducts = releaseGood.orderProducts;
+        let maxConsignmentWeight = releaseGood.lastMileDelivery.consignmentWeight;
+        //sort product according to packingType
+        let sortOrderProducts = await sortingProduct(orderProducts);
+        //initialise new orderConsignment created
+        const createdNewConsignment = () => ({
+            id: (0, uuid_1.v4)(),
+            totalWeight: 0,
+            orderPackages: []
+        });
+        //push orderPackage & packageItems into consigment
+        const createPackageConsignment = (consignment, packageWeight, releaseGood, orderProduct, releaseQty, user) => {
+            consignment.totalWeight += packageWeight;
+            currentConsignment.orderPackages.push({
+                id: (0, uuid_1.v4)(),
+                name: sales_base_1.OrderNoGenerator.orderPackage(),
+                packageId: null,
+                trackingNo: null,
+                transporter: null,
+                airwayBill: (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.airwayBill) || null,
+                invoice: releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.invoice,
+                status: sales_base_1.ORDER_STATUS.PROCESSING,
+                releaseGood,
+                domain: releaseGood.domain,
+                bizplace: releaseGood.bizplace,
+                creator: user,
+                updater: user,
+                orderPackageItems: [
+                    {
+                        id: (0, uuid_1.v4)(),
+                        name: sales_base_1.OrderNoGenerator.orderPackageItem(),
+                        releaseQty: releaseQty,
+                        orderProduct: orderProduct,
+                        domain: releaseGood.domain,
+                        bizplace: releaseGood.bizplace,
+                        creator: releaseGood.creator,
+                        updater: releaseGood.updater,
+                        productDetail: orderProduct.productDetail
+                    }
+                ]
+            });
+        };
+        const createPackage = op => {
+            let releaseQty = op.productDetail.packingType.toLowerCase() === 'carton' ? 1 : op.releaseQty;
+            let packageWeight = op.productDetail.packingType.toLowerCase() === 'carton'
+                ? op.productDetail.grossWeight
+                : op.productDetail.grossWeight * releaseQty;
+            const isCarton = op.productDetail.packingType.toLowerCase() === 'carton';
+            totalConsignmentWeight += packageWeight;
+            const requiresNewConsignment = totalConsignmentWeight >= maxConsignmentWeight;
+            if (isCarton || op.releaseQty > 1) {
+                if (requiresNewConsignment) {
+                    //push the current consignment to create new consignment
+                    totalConsignments.push(currentConsignment);
+                    //Initialise the totalConsignment weight to the new data
+                    totalConsignmentWeight = packageWeight + 0;
+                    currentConsignment = createdNewConsignment();
+                }
+                createPackageConsignment(currentConsignment, packageWeight, releaseGood, op, releaseQty, user);
+            }
+            else {
+                currOrderProducts.push(op);
+            }
+        };
+        sortOrderProducts.forEach(item => {
+            if (item.packingType.toLowerCase() === 'carton') {
+                for (let i = 0; i < item.releaseQty; i++) {
+                    createPackage(item);
+                }
+            }
+            else {
+                createPackage(item);
+            }
+        });
+        // Add any remaining items to the last orderPackage
+        if (currOrderProducts.length > 0) {
+            let availableConsignment;
+            for (let i = 0; i < currOrderProducts.length; i++) {
+                let op = currOrderProducts[i];
+                let releaseQty = op.releaseQty;
+                let currProductWeight = op.productDetail.grossWeight * op.releaseQty;
+                let lastOrderPackage = currentConsignment.orderPackages[currentConsignment.orderPackages.length - 1];
+                //push the product into last current consignment orderPackage
+                if (currentConsignment.totalWeight + currProductWeight < maxConsignmentWeight) {
+                    if (lastOrderPackage) {
+                        lastOrderPackage.orderPackageItems.push({
+                            id: (0, uuid_1.v4)(),
+                            name: sales_base_1.OrderNoGenerator.orderPackageItem(),
+                            releaseQty: op.releaseQty,
+                            orderProduct: op,
+                            domain: releaseGood.domain,
+                            bizplace: releaseGood.bizplace,
+                            creator: releaseGood.creator,
+                            updater: releaseGood.updater,
+                            productDetail: op.productDetail
+                        });
+                    }
+                    else {
+                        await createPackageConsignment(currentConsignment, currProductWeight, releaseGood, op, releaseQty, user);
+                    }
+                }
+                else {
+                    //push the currentConsignment into list of all the consignments
+                    if (!totalConsignments.some(tc => tc.id === currentConsignment.id)) {
+                        totalConsignments.push(currentConsignment);
+                    }
+                    //find one  order consignment to include the product
+                    availableConsignment = totalConsignments.find(tc => {
+                        tc.totalWeight += currProductWeight < maxConsignmentWeight;
+                    });
+                    if (availableConsignment) {
+                        let lastOrderPackage = availableConsignment.orderPackages[currentConsignment.orderPackages.length - 1];
+                        lastOrderPackage.orderPackageItems.push({
+                            id: (0, uuid_1.v4)(),
+                            name: sales_base_1.OrderNoGenerator.orderPackageItem(),
+                            releaseQty: op.releaseQty,
+                            orderProducts: op,
+                            domain: releaseGood.domain,
+                            bizplace: releaseGood.bizplace,
+                            creator: releaseGood.creator,
+                            updater: releaseGood.updater,
+                            productDetail: op.productDetail
+                        });
+                        //update the totalConsignment data
+                        totalConsignments = totalConsignments.map(tc => {
+                            tc.id === availableConsignment.id ? availableConsignment : tc;
+                        });
+                    }
+                    else {
+                        //create new consignment if no consignment available
+                        currentConsignment = createdNewConsignment();
+                        createPackageConsignment(currentConsignment, currProductWeight, releaseGood, op, releaseQty, user);
+                        totalConsignments.push(currentConsignment);
+                    }
+                }
+            }
+        }
+        //totalConsignments.length < 1 ? totalConsignments.push(currentConsignment) : totalConsignments
+        const existingConsignment = totalConsignments.find(tc => tc.id === currentConsignment.id);
+        if (!existingConsignment) {
+            totalConsignments.push(currentConsignment);
+        }
+        let orderConsignment = totalConsignments;
+        let newReleaseGood = await createConsignmentWithMultipackage(tx, orderConsignment, releaseGood, user, domain);
+        return newReleaseGood;
+    }
+    catch (e) {
+        env_1.logger.error(`[lmd-create-consignment-notes]: ${e} `);
+    }
+}
+exports.splitOrderConsignment = splitOrderConsignment;
+async function createOrderConsignment(tx, orderCons, releaseGood, user) {
+    var _a;
+    try {
+        let orderConsignment = {
+            id: (0, uuid_1.v4)(),
+            name: sales_base_1.OrderNoGenerator.orderConsignment(),
+            noOfPackages: ((_a = orderCons === null || orderCons === void 0 ? void 0 : orderCons.orderPackages) === null || _a === void 0 ? void 0 : _a.length) ? orderCons.orderPackages.length : 1,
+            domain: releaseGood.domain,
+            bizplace: releaseGood.bizplace,
+            releaseGood: releaseGood,
+            orderPackages: [],
+            creator: user,
+            updater: user
+        };
+        orderConsignment = await tx.getRepository(sales_base_1.OrderConsignment).save(orderConsignment);
+        return orderConsignment;
+    }
+    catch (e) {
+        env_1.logger.error(`[lmd-create-order-consignment]: ${e} `);
+    }
+}
+exports.createOrderConsignment = createOrderConsignment;
+async function createConsignmentPackage(tx, orderPackageData, releaseGood, user, orderConsignment) {
+    try {
+        const orderPackage = {
+            id: (0, uuid_1.v4)(),
+            name: sales_base_1.OrderNoGenerator.orderPackage(),
+            packageId: null,
+            trackingNo: null,
+            transporter: null,
+            airwayBill: (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.airwayBill) || null,
+            invoice: releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.invoice,
+            status: sales_base_1.ORDER_STATUS.PROCESSING,
+            releaseGood,
+            domain: releaseGood.domain,
+            bizplace: releaseGood.bizplace,
+            creator: user,
+            updater: user,
+            orderConsignment
+        };
+        return tx.getRepository(sales_base_1.OrderPackage).save(orderPackage);
+    }
+    catch (e) {
+        env_1.logger.error(`[lmd-create-order-package]: ${e} `);
+    }
+}
+exports.createConsignmentPackage = createConsignmentPackage;
+async function createConsignmentPackageItem(tx, orderPackageItemsData, savedOrderPackage, releaseGood) {
+    try {
+        const orderPackageItems = orderPackageItemsData.map(opi => ({
+            id: opi.id,
+            name: opi.name,
+            orderProduct: opi.orderProduct,
+            status: sales_base_1.ORDER_STATUS.PROCESSING,
+            releaseQty: opi.releaseQty,
+            orderPackage: savedOrderPackage,
+            domain: releaseGood.domain,
+            bizplace: releaseGood.bizplace,
+            creator: releaseGood.creator,
+            updater: releaseGood.updater,
+            productDetail: opi.productDetail
+        }));
+        await tx.getRepository(sales_base_1.OrderPackageItem).save(orderPackageItems);
+        return orderPackageItems;
+    }
+    catch (e) {
+        env_1.logger.error(`[lmd-create-order-package]: ${e} `);
+    }
+}
+exports.createConsignmentPackageItem = createConsignmentPackageItem;
+async function createConsignmentWithMultipackage(tx, orderConsList, releaseGood, user, domain) {
+    try {
+        let newOrderPackages = [];
+        let newOrderConsignments = [];
+        for (const orderCons of orderConsList) {
+            const savedOrderConsignment = await createOrderConsignment(tx, orderCons, releaseGood, user);
+            for (const currentPackage of orderCons.orderPackages) {
+                const savedOrderPackage = await createConsignmentPackage(tx, currentPackage, releaseGood, user, savedOrderConsignment);
+                const orderPackageItems = await createConsignmentPackageItem(tx, currentPackage.orderPackageItems, savedOrderPackage, releaseGood);
+                savedOrderPackage.orderPackageItems = orderPackageItems;
+                savedOrderConsignment.orderPackages.push(savedOrderPackage);
+                newOrderPackages.push(savedOrderPackage);
+            }
+            newOrderConsignments.push(savedOrderConsignment);
+        }
+        releaseGood.orderConsignments = newOrderConsignments;
+        releaseGood.orderPackages = newOrderPackages;
+        return releaseGood;
+    }
+    catch (error) {
+        console.error('Error creating consignment with multiple packages:', error);
+        throw error;
+    }
+}
+exports.createConsignmentWithMultipackage = createConsignmentWithMultipackage;
+async function sortingProduct(orderProducts) {
+    try {
+        orderProducts.sort((a, b) => {
+            if (a.product.packingType !== b.product.packingType) {
+                return a.product.packingType < b.product.packingType ? -1 : 1;
+            }
+            if (a.product.sku !== b.product.sku) {
+                return a.product.sku < b.product.sku ? -1 : 1;
+            }
+            return 0;
+        });
+        return orderProducts;
+    }
+    catch (e) {
+        env_1.logger.error(`[lmd-sort-product]: ${e} `);
+    }
+}
+exports.sortingProduct = sortingProduct;
+//# sourceMappingURL=picking-worksheet-controller.js.map