@things-factory/sales-base 4.3.651 → 4.3.652

package/dist-server/controllers/ecommerce/powrup-controller.js

@@ -0,0 +1,690 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePackageId = exports.createSofOrderPackageItem = exports.createSofOrderPackage = exports.createConsignmentWithMultipackage = exports.splitOrderConsignment = exports.sortingProduct = exports.createOrderConsignment = exports.PowrupController = void 0;
+const typeorm_1 = require("typeorm");
+const uuid_1 = require("uuid");
+const biz_base_1 = require("@things-factory/biz-base");
+const env_1 = require("@things-factory/env");
+const integration_powrup_1 = require("@things-factory/integration-powrup");
+const warehouse_base_1 = require("@things-factory/warehouse-base");
+const constants_1 = require("../../constants");
+const order_package_item_1 = require("../../service/order-package-item/order-package-item");
+const order_package_1 = require("../../service/order-package/order-package");
+const release_good_1 = require("../../service/release-good/release-good");
+const utils_1 = require("../../utils");
+const datetime_util_1 = require("../../utils/datetime-util");
+const order_consignment_1 = require("../../service/order-consignment/order-consignment");
+const { PerformanceObserver, performance } = require('node:perf_hooks');
+class PowrupController {
+    async packOrder(powrup, releaseGood, domain, user, trxMgr) {
+        var _a;
+        let roUpdateFields = null;
+        const updateRO = async (releaseGoodId, roUpdateFields, trxMgr) => {
+            try {
+                if (roUpdateFields) {
+                    const result = await trxMgr.getRepository(release_good_1.ReleaseGood).save({ id: releaseGoodId }, roUpdateFields);
+                }
+            }
+            catch (e) {
+                env_1.logger.error(e);
+            }
+        };
+        try {
+            const orderProducts = releaseGood.orderProducts;
+            const orderInformation = { refOrderId: releaseGood.refOrderId };
+            const lmdOption = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.lmdOption;
+            if ((releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.lastMarketPackCall) &&
+                datetime_util_1.DateTimeDifference.timeDifferenceInSeconds(releaseGood.lastMarketPackCall, new Date()) <= 5) {
+                return;
+            }
+            // capture update fields
+            roUpdateFields = {
+                lastMarketPackCall: new Date()
+            };
+            // non-sof orders will trigger packOrder - create consignment - order package
+            if (!lmdOption) {
+                performance.mark(`start:${releaseGood.refOrderId}`);
+                const orderPack = await integration_powrup_1.PowrupAPI.packOrder(powrup, Object.assign(Object.assign({}, orderInformation), { context: { state: { domain: domain || null, user: user || null } } }));
+                performance.mark(`end:${releaseGood.refOrderId}`);
+                if (orderPack === null || orderPack === void 0 ? void 0 : orderPack.packages) {
+                    const packages = orderPack.packages;
+                    await Promise.all(packages.map(async (pkg) => {
+                        const items = pkg.items;
+                        let orderConsignment = await createOrderConsignment(trxMgr, releaseGood, user);
+                        let savedOrderPackage = await this.createOrderPackage(trxMgr, releaseGood, orderConsignment, user, pkg);
+                        const orderPackageItems = await this.createOrderPackageItems(orderProducts, savedOrderPackage, items, user, false, releaseGood);
+                        await trxMgr.getRepository(order_package_item_1.OrderPackageItem).save(orderPackageItems);
+                    }));
+                    const unassignedOrderProducts = orderProducts.filter(op => {
+                        return (op.releaseQty > 0 ||
+                            !packages.some(pkg => pkg.items.some(itm => itm.refCode === op.productDetail.refCode)));
+                    });
+                    if ((unassignedOrderProducts === null || unassignedOrderProducts === void 0 ? void 0 : unassignedOrderProducts.length) > 0)
+                        await this.unassignedOrderProducts(unassignedOrderProducts, releaseGood, user, trxMgr);
+                    roUpdateFields = {
+                        packageId: packages[0].packageId,
+                        marketPackCallSuccess: new Date(),
+                        lastMarketPackCall: new Date(),
+                        updatedAt: new Date()
+                    };
+                }
+                await updateRO(releaseGood.id, roUpdateFields, trxMgr);
+            }
+            else {
+                //sof orders will create consignment - order package - trigger packOrder
+                let newReleaseGood;
+                let orderPackages = [];
+                const isMps = (_a = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.lastMileDelivery) === null || _a === void 0 ? void 0 : _a.mps;
+                const orderInformation = { refOrderId: releaseGood.refOrderId, isSof: true };
+                if (isMps) {
+                    newReleaseGood = await splitOrderConsignment(trxMgr, releaseGood, user);
+                    orderPackages = newReleaseGood.orderPackages;
+                    releaseGood.orderPackages = orderPackages;
+                }
+                else {
+                    //create package like normal non sof orders
+                    let orderConsignment = await createOrderConsignment(trxMgr, releaseGood, user);
+                    let savedOrderPackage = await this.createOrderPackage(trxMgr, releaseGood, orderConsignment, user);
+                    let orderPackageItems = await createSofOrderPackageItem(trxMgr, [], savedOrderPackage, releaseGood);
+                    savedOrderPackage.orderPackageItems = orderPackageItems;
+                    orderPackages.push(savedOrderPackage);
+                    releaseGood.orderPackages = orderPackages;
+                    newReleaseGood = releaseGood;
+                }
+                const packages = orderPackages.map(op => {
+                    const items = op.orderPackageItems.map(opi => {
+                        return {
+                            universalIdentifier: opi.productDetail.refCode,
+                            sku: opi.orderProduct.product.sku,
+                            quantity: opi.releaseQty
+                        };
+                    });
+                    return {
+                        packageId: op.id,
+                        items: items
+                    };
+                });
+                performance.mark(`start:${newReleaseGood === null || newReleaseGood === void 0 ? void 0 : newReleaseGood.refOrderId}`);
+                const orderPack = await integration_powrup_1.PowrupAPI.packOrder(powrup, Object.assign(Object.assign({}, orderInformation), { packages, context: { state: { domain: domain || null, user: user || null } } }));
+                performance.mark(`end:${newReleaseGood.refOrderId}`);
+                if (orderPack === null || orderPack === void 0 ? void 0 : orderPack.packages) {
+                    roUpdateFields = {
+                        marketPackCallSuccess: new Date(),
+                        lastMarketPackCall: new Date(),
+                        updatedAt: new Date()
+                    };
+                    let packages = orderPack.packages;
+                    await updatePackageId(packages, releaseGood, trxMgr);
+                }
+            }
+        }
+        catch (error) {
+            performance.mark(`end:${releaseGood.refOrderId}`);
+            roUpdateFields = {
+                packOrderFail: true
+            };
+            env_1.logger.error(`powrup-controller[packOrder]: ${error}`);
+        }
+        finally {
+            let perf = performance.measure(`powrupPackOrder: ${releaseGood.refOrderId}`, `start:${releaseGood.refOrderId}`, `end:${releaseGood.refOrderId}`);
+            console.info(perf.toJSON());
+        }
+        return releaseGood;
+    }
+    async updateStock(inventories, customerDomain, user, trxMgr) {
+        if (trxMgr) {
+            await this.updateStockFunction(inventories, customerDomain, user, trxMgr);
+        }
+        else {
+            await (0, typeorm_1.getConnection)().transaction(async (tx) => {
+                await this.updateStockFunction(inventories, customerDomain, user, tx);
+            });
+        }
+    }
+    async initiateShipment(powrup, releaseGood, domain, user, trxMgr) {
+        try {
+            let orderPackageRepo = trxMgr ? trxMgr.getRepository(order_package_1.OrderPackage) : (0, typeorm_1.getRepository)(order_package_1.OrderPackage);
+            let releaseGoodRepo = trxMgr ? trxMgr.getRepository(release_good_1.ReleaseGood) : (0, typeorm_1.getRepository)(release_good_1.ReleaseGood);
+            let orderPackages = await orderPackageRepo.find({
+                where: { releaseGood, packageId: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) },
+                relations: ['releaseGood', 'releaseGood.lastMileDelivery']
+            });
+            if (orderPackages === null || orderPackages === void 0 ? void 0 : orderPackages.length) {
+                await Promise.all(orderPackages
+                    .filter(op => (op === null || op === void 0 ? void 0 : op.marketRtsCallSuccess) == undefined)
+                    .map(async (op) => {
+                    var _a, _b;
+                    if (!(op === null || op === void 0 ? void 0 : op.packageId))
+                        throw new Error('Order package id is not found');
+                    if (op.lmdOption && !(op === null || op === void 0 ? void 0 : op.parcelId))
+                        return;
+                    let orderInformation = {
+                        refOrderId: releaseGood.refOrderId,
+                        packageId: op.packageId,
+                        platform: releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.platformCode
+                    };
+                    if ((_a = op === null || op === void 0 ? void 0 : op.releaseGood) === null || _a === void 0 ? void 0 : _a.lmdOption) {
+                        orderInformation = Object.assign(Object.assign({}, orderInformation), { awb: op.airwayBill, trackingNo: op.trackingNo, lmdOption: (_b = op === null || op === void 0 ? void 0 : op.releaseGood) === null || _b === void 0 ? void 0 : _b.lmdOption, shipperName: op.releaseGood.lastMileDelivery.platform });
+                    }
+                    performance.mark(`start:${releaseGood.refOrderId} - ${op.packageId}`);
+                    try {
+                        await integration_powrup_1.PowrupAPI.initiateShipment(powrup, Object.assign(Object.assign({}, orderInformation), { context: { state: { domain, user } } }));
+                        await orderPackageRepo.update({ id: op.id }, { marketRtsCallSuccess: new Date() });
+                        performance.mark(`end:${releaseGood.refOrderId} - ${op.packageId}`);
+                    }
+                    catch (error) {
+                        performance.mark(`end:${releaseGood.refOrderId} - ${op.packageId}`);
+                        env_1.logger.error(`powrup-controller[initiateShipment]: ${JSON.stringify(Object.assign(Object.assign({}, orderInformation), { context: { state: { domain: domain || null, user: user || null } }, error: error }))}`);
+                    }
+                    finally {
+                        let perf = performance.measure(`powrupInitiateShipment: ${releaseGood.refOrderId} - ${op.packageId}`, `start:${releaseGood.refOrderId} - ${op.packageId}`, `end:${releaseGood.refOrderId} - ${op.packageId}`);
+                        console.info(perf.toJSON());
+                    }
+                }));
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async fetchDocument(powrup, releaseGood, domain, user, trxMgr) {
+        if (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.lmdOption) {
+            return;
+        }
+        try {
+            let orderPackages = await ((trxMgr === null || trxMgr === void 0 ? void 0 : trxMgr.getRepository(order_package_1.OrderPackage)) || (0, typeorm_1.getRepository)(order_package_1.OrderPackage)).find({ where: { releaseGood } });
+            if (orderPackages === null || orderPackages === void 0 ? void 0 : orderPackages.length) {
+                await Promise.all(orderPackages.map(async (op) => {
+                    if (!(op === null || op === void 0 ? void 0 : op.packageId))
+                        throw new Error('Order package id is not found');
+                    const orderInformation = {
+                        refOrderId: releaseGood.refOrderId,
+                        packageId: op.packageId
+                    };
+                    performance.mark(`start:${releaseGood.refOrderId} - ${op.packageId}`);
+                    try {
+                        const { trackingNo, transporter, printLabels } = await integration_powrup_1.PowrupAPI.fetchDocument(powrup, Object.assign(Object.assign({}, orderInformation), { context: { state: { domain: domain || null, user: user || null } } }));
+                        performance.mark(`end:${releaseGood.refOrderId} - ${op.packageId}`);
+                        let updateInfo;
+                        if (printLabels === null || printLabels === void 0 ? void 0 : printLabels.length) {
+                            printLabels.map(pl => {
+                                updateInfo = Object.assign(Object.assign({}, updateInfo), { airwayBill: pl.awbUrl });
+                            });
+                            updateInfo = Object.assign(Object.assign({}, updateInfo), { trackingNo: trackingNo, transporter: transporter, updater: user });
+                            await ((trxMgr === null || trxMgr === void 0 ? void 0 : trxMgr.getRepository(order_package_1.OrderPackage)) || (0, typeorm_1.getRepository)(order_package_1.OrderPackage)).update({ id: op.id }, Object.assign({}, updateInfo));
+                        }
+                    }
+                    catch (error) {
+                        performance.mark(`end:${releaseGood.refOrderId} - ${op.packageId}`);
+                    }
+                    finally {
+                        let perf = performance.measure(`powrupFetchDocument: ${releaseGood.refOrderId} - ${op.packageId}`, `start:${releaseGood.refOrderId} - ${op.packageId}`, `end:${releaseGood.refOrderId} - ${op.packageId}`);
+                        console.info(perf.toJSON());
+                    }
+                }));
+                releaseGood = await ((trxMgr === null || trxMgr === void 0 ? void 0 : trxMgr.getRepository(release_good_1.ReleaseGood)) || (0, typeorm_1.getRepository)(release_good_1.ReleaseGood)).findOne({
+                    id: releaseGood.id
+                });
+            }
+            return releaseGood;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async updateStockFunction(inventories, customerDomain, user, trxMgr) {
+        const bizplace = await trxMgr.getRepository(biz_base_1.Bizplace).findOne({ domain: customerDomain });
+        const powrup = await trxMgr
+            .getRepository(integration_powrup_1.Powrup)
+            .findOne({ where: { platform: integration_powrup_1.Platform.POWRUP, active: true } });
+        if (powrup) {
+            for (let inventory of inventories) {
+                try {
+                    let product = inventory.product;
+                    const productDetail = inventory.productDetail;
+                    const warehouseDomainId = inventory.domainId;
+                    let qb = trxMgr.getRepository(warehouse_base_1.Inventory).createQueryBuilder('inv');
+                    qb.leftJoinAndSelect('inv.location', 'loc')
+                        .andWhere('"inv"."domain_id" = :domainId')
+                        .andWhere('"inv"."bizplace_id" = :bizplaceId')
+                        .andWhere('"inv"."product_id" = :productId')
+                        .andWhere('"inv"."product_detail_id" = :productDetailId')
+                        .andWhere('"inv"."status" = :status')
+                        .andWhere('"loc"."type" NOT IN (:...locationTypes)')
+                        .setParameters({
+                        domainId: warehouseDomainId,
+                        bizplaceId: bizplace.id,
+                        productId: product.id,
+                        productDetailId: productDetail.id,
+                        status: warehouse_base_1.INVENTORY_STATUS.STORED,
+                        locationTypes: [warehouse_base_1.LOCATION_TYPE.QUARANTINE]
+                    });
+                    let foundInventories = await qb.getMany();
+                    let inventoryTotalQty = 0;
+                    let inventoryTotalLockedQty = 0;
+                    let inventoryBufferQty = 0;
+                    foundInventories.forEach((inventory) => {
+                        const { qty, lockedQty } = inventory;
+                        inventoryTotalQty += qty;
+                        inventoryTotalLockedQty += lockedQty;
+                        if (inventory.location.type === warehouse_base_1.LOCATION_TYPE.RESERVE) {
+                            inventoryBufferQty += qty;
+                        }
+                    });
+                    const productDetailStock = await trxMgr
+                        .getRepository(warehouse_base_1.ProductDetailStock)
+                        .findOne({ productDetail });
+                    const powrupInvs = [
+                        {
+                            refCode: productDetail.refCode,
+                            stock: {
+                                quantityTotal: inventoryTotalQty || 0,
+                                quantityReserved: inventoryTotalLockedQty + (productDetailStock.unassignedQty || 0) || 0,
+                                quantityBuffer: 0
+                            }
+                        }
+                    ];
+                    await integration_powrup_1.PowrupAPI.updateStock(powrup, {
+                        context: { state: { domain: customerDomain || null, user: user || user } },
+                        warehouseDomainId,
+                        powrupInvs
+                    });
+                }
+                catch (e) {
+                    console.log(e);
+                }
+            }
+        }
+    }
+    //create orderPackage for non-sof / sof- non mps orders
+    async createOrderPackage(tx, releaseGood, orderConsignment, user, pkg) {
+        try {
+            const orderPackage = {
+                id: (0, uuid_1.v4)(),
+                name: utils_1.OrderNoGenerator.orderPackage(),
+                packageId: pkg ? pkg.packageId : null,
+                status: constants_1.ORDER_STATUS.PROCESSING,
+                releaseGood,
+                orderConsignment,
+                domain: releaseGood.domain,
+                bizplace: releaseGood.bizplace,
+                creator: user.id,
+                updater: user.id,
+                originalPackResponse: pkg ? JSON.stringify(pkg) : null
+            };
+            let savedOrderPackage = await tx.getRepository(order_package_1.OrderPackage).save(orderPackage);
+            return savedOrderPackage;
+        }
+        catch (e) {
+            env_1.logger.error(`[lmd-create-order-consignment]: ${e} `);
+        }
+    }
+    async createOrderPackageItems(orderProducts, orderPackage, items, user, unassignedItems, releaseGood) {
+        try {
+            const processedItems = items.map(itm => {
+                var _a;
+                const { refCode, qty, productDetail, releaseQty } = itm;
+                if (!refCode && !unassignedItems) {
+                    throw new Error(`universalIdentifier missing`);
+                }
+                const idx = orderProducts.findIndex(op => { var _a, _b; return ((_a = op.productDetail) === null || _a === void 0 ? void 0 : _a.refCode) === refCode || ((_b = op.productDetail) === null || _b === void 0 ? void 0 : _b.refCode) === (productDetail === null || productDetail === void 0 ? void 0 : productDetail.refCode); });
+                const matchedOrderProduct = idx !== -1 ? Object.assign({}, orderProducts[idx]) : undefined;
+                if (!matchedOrderProduct || matchedOrderProduct.releaseQty <= 0) {
+                    return null; // No matched product or no remaining quantity to release
+                }
+                const matchedOrderPackageItem = (_a = orderPackage === null || orderPackage === void 0 ? void 0 : orderPackage.orderPackageItems) === null || _a === void 0 ? void 0 : _a.find(itm => itm.orderProductId === matchedOrderProduct.id);
+                const commonProperties = {
+                    orderProduct: matchedOrderProduct,
+                    status: constants_1.ORDER_STATUS.PROCESSING,
+                    orderPackage: orderPackage,
+                    domain: releaseGood.domain,
+                    bizplace: releaseGood.bizplace,
+                    creator: user.id,
+                    updater: user.id,
+                    productDetail: matchedOrderProduct.productDetail
+                };
+                let result = {};
+                if (matchedOrderPackageItem) {
+                    result = Object.assign(Object.assign({}, commonProperties), { id: matchedOrderPackageItem.id, name: matchedOrderPackageItem.name, releaseQty: (matchedOrderPackageItem.releaseQty || 0) + (releaseQty || 0) });
+                }
+                else {
+                    orderProducts[idx].releaseQty = (orderProducts[idx].releaseQty || 0) - (qty || 0);
+                    result = Object.assign(Object.assign({}, commonProperties), { name: utils_1.OrderNoGenerator.orderPackageItem(), releaseQty: releaseQty
+                            ? releaseQty
+                            : qty > matchedOrderProduct.releaseQty
+                                ? matchedOrderProduct.releaseQty
+                                : qty });
+                }
+                return result;
+            });
+            return processedItems.filter(item => item != null);
+        }
+        catch (e) {
+            env_1.logger.error(`unable-to-create-opi-powrup: ${e}`);
+        }
+    }
+    async unassignedOrderProducts(unassignedOrderProducts, releaseGood, user, trxMgr) {
+        const orderPackages = await trxMgr.getRepository(order_package_1.OrderPackage).find({
+            where: { releaseGood: releaseGood.id },
+            relations: ['orderPackageItems']
+        });
+        let selectedOrderPackage = orderPackages.reduce((minOrderPackage, currentOrderPackage) => {
+            return (currentOrderPackage === null || currentOrderPackage === void 0 ? void 0 : currentOrderPackage.orderPackageItems.length) < (minOrderPackage === null || minOrderPackage === void 0 ? void 0 : minOrderPackage.orderPackageItems.length)
+                ? currentOrderPackage
+                : minOrderPackage;
+        }, orderPackages[0]);
+        const unassignedPackageItems = await this.createOrderPackageItems(unassignedOrderProducts, selectedOrderPackage, unassignedOrderProducts, user, true, releaseGood);
+        await trxMgr.getRepository(order_package_item_1.OrderPackageItem).save(unassignedPackageItems);
+    }
+}
+exports.PowrupController = PowrupController;
+async function createOrderConsignment(tx, releaseGood, user, orderCons) {
+    var _a;
+    try {
+        const orderConsignment = {
+            id: (0, uuid_1.v4)(),
+            name: utils_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
+        };
+        return tx.getRepository(order_consignment_1.OrderConsignment).save(orderConsignment);
+    }
+    catch (e) {
+        env_1.logger.error(`[lmd-create-order-consignment]: ${e} `);
+    }
+}
+exports.createOrderConsignment = createOrderConsignment;
+async function sortingProduct(orderProducts) {
+    try {
+        const sortedMatchedOrderProducts = 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 sortedMatchedOrderProducts;
+    }
+    catch (e) {
+        env_1.logger.error(`[lmd-sort-product]: ${e} `);
+    }
+}
+exports.sortingProduct = sortingProduct;
+async function splitOrderConsignment(tx, releaseGood, user) {
+    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 products according to the packingType
+        let sortItems = 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: utils_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: constants_1.ORDER_STATUS.PROCESSING,
+                releaseGood,
+                domain: releaseGood.domain,
+                bizplace: releaseGood.bizplace,
+                creator: user,
+                updater: user,
+                orderPackageItems: [
+                    {
+                        id: (0, uuid_1.v4)(),
+                        name: utils_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);
+            }
+        };
+        sortItems.forEach(item => {
+            let productDetail = item.productDetail;
+            if (productDetail.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: utils_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: utils_1.OrderNoGenerator.orderPackageItem(),
+                            releaseQty: op.releaseQty,
+                            orderProduct: 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);
+                    }
+                }
+            }
+        }
+        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);
+        return newReleaseGood;
+    }
+    catch (e) {
+        env_1.logger.error(e);
+    }
+}
+exports.splitOrderConsignment = splitOrderConsignment;
+async function createConsignmentWithMultipackage(tx, orderConsList, releaseGood, user) {
+    try {
+        let newOrderPackages = [];
+        let newOrderConsignments = [];
+        for (const orderCons of orderConsList) {
+            const savedOrderConsignment = await createOrderConsignment(tx, releaseGood, user, orderCons);
+            for (const currentPackage of orderCons.orderPackages) {
+                const savedOrderPackage = await createSofOrderPackage(tx, currentPackage, releaseGood, user, savedOrderConsignment);
+                const orderPackageItems = await createSofOrderPackageItem(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 createSofOrderPackage(tx, orderPackageData, releaseGood, user, orderConsignment) {
+    try {
+        const orderPackage = {
+            id: (0, uuid_1.v4)(),
+            name: utils_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: constants_1.ORDER_STATUS.PROCESSING,
+            releaseGood,
+            domain: releaseGood.domain,
+            bizplace: releaseGood.bizplace,
+            creator: user,
+            updater: user,
+            orderConsignment
+        };
+        return tx.getRepository(order_package_1.OrderPackage).save(orderPackage);
+    }
+    catch (e) {
+        env_1.logger.error(`[lmd-create-order-package]: ${e} `);
+    }
+}
+exports.createSofOrderPackage = createSofOrderPackage;
+async function createSofOrderPackageItem(tx, orderPackageItemsData, savedOrderPackage, releaseGood) {
+    try {
+        const orderPackageItems = (orderPackageItemsData.length > 0 ? orderPackageItemsData : releaseGood.orderProducts).map(item => {
+            const isOrderPackageItemData = orderPackageItemsData.length > 0;
+            const id = isOrderPackageItemData ? item.id : (0, uuid_1.v4)();
+            const name = isOrderPackageItemData ? item.name : utils_1.OrderNoGenerator.orderPackageItem();
+            const orderProduct = isOrderPackageItemData ? item.orderProduct : item;
+            const releaseQty = isOrderPackageItemData ? item.releaseQty : item.releaseQty;
+            return {
+                id,
+                name,
+                orderProduct,
+                status: constants_1.ORDER_STATUS.PROCESSING,
+                releaseQty,
+                orderPackage: savedOrderPackage,
+                domain: releaseGood.domain,
+                bizplace: releaseGood.bizplace,
+                creator: releaseGood.creator,
+                updater: releaseGood.updater,
+                productDetail: isOrderPackageItemData ? item.productDetail : item.productDetail
+            };
+        });
+        let savedOrderPackageItems = await tx.getRepository(order_package_item_1.OrderPackageItem).save(orderPackageItems);
+        return savedOrderPackageItems;
+    }
+    catch (e) {
+        env_1.logger.error(`[lmd-create-order-package]: ${e} `);
+    }
+}
+exports.createSofOrderPackageItem = createSofOrderPackageItem;
+async function updatePackageId(packages, releaseGood, trxMgr) {
+    try {
+        //open new transactiion - same transaction will cause blocking
+        await (0, typeorm_1.getConnection)().transaction(async (tx2) => {
+            const orderPackages = await tx2.getRepository(order_package_1.OrderPackage).find({
+                where: { releaseGood: { id: releaseGood.id } },
+                relations: ['releaseGood']
+            });
+            for (let orderPackage of orderPackages) {
+                let matchedPackage = packages.find(p => {
+                    return p.orderPackageId == orderPackage.id;
+                });
+                if (matchedPackage) {
+                    await tx2.getRepository(order_package_1.OrderPackage).update({ id: orderPackage.id }, {
+                        packageId: matchedPackage.packageId
+                    });
+                }
+            }
+            let rg = await tx2.getRepository(release_good_1.ReleaseGood).findOne({ id: releaseGood.id });
+            if (rg) {
+                await tx2.getRepository(release_good_1.ReleaseGood).update({ id: releaseGood.id }, {
+                    marketPackCallSuccess: new Date(),
+                    lastMarketPackCall: new Date(),
+                    updatedAt: new Date()
+                });
+            }
+        });
+    }
+    catch (e) {
+        env_1.logger.error('unable-to-update-package-id-mps');
+    }
+}
+exports.updatePackageId = updatePackageId;
+//# sourceMappingURL=powrup-controller.js.map