@things-factory/operato-hub 4.3.744 → 4.3.745

package/dist-server/routers/api/restful-apis/v1/warehouse/update-release-order-details.js

@@ -1,12 +1,47 @@
 "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 });
 const typeorm_1 = require("typeorm");
+const uuid_1 = require("uuid");
 const api_1 = require("@things-factory/api");
 const biz_base_1 = require("@things-factory/biz-base");
+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 worksheet_base_1 = require("@things-factory/worksheet-base");
 const middlewares_1 = require("../middlewares");
 const error_util_1 = require("../utils/error-util");
 const debug = require('debug')('things-factory:operato-hub:restful-api:v1:update-release-order-details');
+// Allowed statuses for updates (order information only)
+const ALLOWED_STATUSES_FOR_INFO_UPDATE = [
+    sales_base_1.ORDER_STATUS.PENDING,
+    sales_base_1.ORDER_STATUS.PENDING_RECEIVE,
+    sales_base_1.ORDER_STATUS.PENDING_WORKSHEET,
+    sales_base_1.ORDER_STATUS.READY_TO_PICK,
+    sales_base_1.ORDER_STATUS.PICKING,
+    sales_base_1.ORDER_STATUS.READY_TO_LOAD,
+    sales_base_1.ORDER_STATUS.LOADING,
+    sales_base_1.ORDER_STATUS.READY_TO_PACK,
+    sales_base_1.ORDER_STATUS.PACKING
+];
+// Allowed statuses for order product updates
+const ALLOWED_STATUSES_FOR_PRODUCT_UPDATE = [
+    sales_base_1.ORDER_STATUS.PENDING,
+    sales_base_1.ORDER_STATUS.PENDING_RECEIVE,
+    sales_base_1.ORDER_STATUS.PENDING_WORKSHEET,
+    sales_base_1.ORDER_STATUS.READY_TO_PICK
+];
 api_1.restfulApiRouter.post('/v1/warehouse/update-release-order-details', middlewares_1.businessMiddleware, middlewares_1.validationMiddleware, middlewares_1.loggingMiddleware, async (context, next) => {
     try {
         const { domain } = context.state;
@@ -18,11 +53,12 @@ api_1.restfulApiRouter.post('/v1/warehouse/update-release-order-details', middle
                 throw new error_util_1.ApiError('E04', 'warehouse id not found');
             let patch = {};
             patch.releaseGood = bodyReq.releaseGood;
+            patch.orderProducts = bodyReq.orderProducts || [];
             if (bodyReq === null || bodyReq === void 0 ? void 0 : bodyReq.shippingOrder)
                 patch.shippingOrder = bodyReq.shippingOrder;
             else
                 patch.shippingOrder = null;
-            context.body = await updateReleaseGoodDetails(tx, domain, patch, user);
+            context.body = await updateReleaseGoodDetails(tx, domain, patch, user, context);
         });
     }
     catch (e) {
@@ -32,36 +68,42 @@ api_1.restfulApiRouter.post('/v1/warehouse/update-release-order-details', middle
             (0, error_util_1.throwInternalServerError)(context, e);
     }
 });
-async function updateReleaseGoodDetails(tx, domain, patch, user) {
-    let { releaseGood, shippingOrder } = patch;
-    let status = [sales_base_1.ORDER_STATUS.DONE, sales_base_1.ORDER_STATUS.CANCELLED, sales_base_1.ORDER_STATUS.REJECTED];
+async function updateReleaseGoodDetails(tx, domain, patch, user, context) {
+    let { releaseGood, shippingOrder, orderProducts: inputOrderProducts } = patch;
     // Build where clause: prioritize refOrderId over roId
     let whereClause = { domain };
     const refOrderId = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.refOrderId;
     const hasRefOrderId = refOrderId != null && refOrderId !== '';
+    const roId = releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.roId;
     if (hasRefOrderId) {
         whereClause.refOrderId = refOrderId;
     }
-    else if (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.roId) {
-        whereClause.id = releaseGood.roId;
+    else if (roId) {
+        whereClause.id = roId;
     }
     else {
         throw new error_util_1.ApiError('E04', 'release order: roId or refOrderId is required');
     }
     let foundReleaseGood = await tx.getRepository(sales_base_1.ReleaseGood).findOne({
         where: whereClause,
-        relations: ['shippingOrder']
+        relations: ['bizplace', 'shippingOrder', 'orderProducts', 'orderProducts.product', 'orderProducts.productDetail']
     });
     if (!foundReleaseGood) {
-        const searchId = hasRefOrderId
-            ? `refOrderId: ${refOrderId}`
-            : `roId: ${releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.roId}`;
+        const searchId = hasRefOrderId ? `refOrderId: ${refOrderId}` : `roId: ${roId}`;
         throw new error_util_1.ApiError('E04', `release order: ${searchId}`);
     }
-    if (status.indexOf(foundReleaseGood.status) !== -1) {
-        throw new error_util_1.ApiError('E04', `release order status: ${foundReleaseGood.status}`);
+    // Validate status for order information updates
+    const releaseGoodStatus = foundReleaseGood.status;
+    if (!ALLOWED_STATUSES_FOR_INFO_UPDATE.includes(releaseGoodStatus)) {
+        throw new error_util_1.ApiError('E04', `Release order status "${releaseGoodStatus}" does not allow updates. Allowed statuses: ${ALLOWED_STATUSES_FOR_INFO_UPDATE.join(', ')}`);
+    }
+    // Validate status for order product updates
+    if (inputOrderProducts && inputOrderProducts.length > 0) {
+        if (!ALLOWED_STATUSES_FOR_PRODUCT_UPDATE.includes(releaseGoodStatus)) {
+            throw new error_util_1.ApiError('E04', `Order product updates are not allowed when release order status is "${releaseGoodStatus}". Order products can only be updated when status is: ${ALLOWED_STATUSES_FOR_PRODUCT_UPDATE.join(', ')}`);
+        }
     }
-    // case to update existing shippingOrder
+    // Update shipping order if provided
     if (shippingOrder !== null) {
         shippingOrder.remark = shippingOrder.exportRemark;
         shippingOrder.containerClosureDateTime = shippingOrder.containerClosureDate
@@ -69,15 +111,900 @@ async function updateReleaseGoodDetails(tx, domain, patch, user) {
             : null;
         delete shippingOrder.exportRemark;
     }
-    if (foundReleaseGood.shippingOrder && shippingOrder) {
-        await tx.getRepository(sales_base_1.ShippingOrder).update(foundReleaseGood.shippingOrder.id, shippingOrder);
+    const releaseGoodEntityForShipping = foundReleaseGood;
+    const foundShippingOrder = releaseGoodEntityForShipping.shippingOrder;
+    if (foundShippingOrder && shippingOrder) {
+        await tx.getRepository(sales_base_1.ShippingOrder).update(foundShippingOrder.id, shippingOrder);
     }
-    // case for new shippingOrder
-    else if (!foundReleaseGood.shippingOrder && shippingOrder) {
+    else if (!foundShippingOrder && shippingOrder) {
         let newShippingOrder = await tx.getRepository(sales_base_1.ShippingOrder).save(Object.assign(Object.assign({}, shippingOrder), { name: sales_base_1.OrderNoGenerator.shippingOrder(), domain, bizplace: await (0, biz_base_1.getMyBizplace)(domain, user), status: sales_base_1.ORDER_STATUS.PENDING, creator: user, updater: user }));
         releaseGood.shippingOrder = newShippingOrder;
     }
-    foundReleaseGood = await tx.getRepository(sales_base_1.ReleaseGood).save(Object.assign(Object.assign(Object.assign({}, foundReleaseGood), releaseGood), { remark: (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.remark) ? releaseGood.remark : null }));
-    return foundReleaseGood;
+    // Update order products if provided
+    if (inputOrderProducts && inputOrderProducts.length > 0) {
+        await updateOrderProducts(tx, foundReleaseGood, inputOrderProducts, domain, user, context);
+    }
+    // Update release good fields
+    const updateData = {
+        remark: (releaseGood === null || releaseGood === void 0 ? void 0 : releaseGood.remark) ? releaseGood.remark : null,
+        updater: user
+    };
+    const releaseGoodPatch = releaseGood;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.refNo) !== undefined)
+        updateData.refNo = releaseGoodPatch.refNo;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.refNo2) !== undefined)
+        updateData.refNo2 = releaseGoodPatch.refNo2;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.refNo3) !== undefined)
+        updateData.refNo3 = releaseGoodPatch.refNo3;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.description) !== undefined)
+        updateData.description = releaseGoodPatch.description;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.truckNo) !== undefined)
+        updateData.truckNo = releaseGoodPatch.truckNo;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.collectionOrderNo) !== undefined)
+        updateData.collectionOrderNo = releaseGoodPatch.collectionOrderNo;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.releaseDate) !== undefined)
+        updateData.releaseDate = releaseGoodPatch.releaseDate;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.ownTransport) !== undefined)
+        updateData.ownTransport = releaseGoodPatch.ownTransport;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.exportOption) !== undefined)
+        updateData.exportOption = releaseGoodPatch.exportOption;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.packingOption) !== undefined)
+        updateData.packingOption = releaseGoodPatch.packingOption;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.courierOption) !== undefined)
+        updateData.courierOption = releaseGoodPatch.courierOption;
+    if ((releaseGoodPatch === null || releaseGoodPatch === void 0 ? void 0 : releaseGoodPatch.shippingOrder) !== undefined)
+        updateData.shippingOrder = releaseGoodPatch.shippingOrder;
+    const releaseGoodEntityForUpdate = foundReleaseGood;
+    // Exclude orderProducts relation to prevent TypeORM from syncing and clearing foreign keys
+    const { orderProducts, orderInventories, deliveryOrders } = releaseGoodEntityForUpdate, releaseGoodWithoutRelations = __rest(releaseGoodEntityForUpdate, ["orderProducts", "orderInventories", "deliveryOrders"]);
+    await tx.getRepository(sales_base_1.ReleaseGood).save(Object.assign(Object.assign({}, releaseGoodWithoutRelations), updateData));
+    // Fetch updated release good with relations for response
+    // Query order products separately to ensure we get all of them including newly added ones
+    const releaseGoodId = foundReleaseGood.id;
+    // Fetch release good basic info
+    const updatedReleaseGood = await tx.getRepository(sales_base_1.ReleaseGood).findOne({
+        where: { id: releaseGoodId },
+        relations: ['shippingOrder']
+    });
+    if (!updatedReleaseGood) {
+        throw new error_util_1.ApiError('E04', 'Failed to retrieve updated release order');
+    }
+    // Fetch all order products separately to ensure we get newly added ones
+    const allOrderProducts = await tx.getRepository(sales_base_1.OrderProduct).find({
+        where: { releaseGood: { id: releaseGoodId } },
+        relations: ['product', 'productDetail']
+    });
+    // Attach order products to release good
+    updatedReleaseGood.orderProducts = allOrderProducts;
+    const releaseGoodForResponse = updatedReleaseGood;
+    // Format response - only include necessary fields
+    const resultOrderProducts = (releaseGoodForResponse.orderProducts || []).map((op) => {
+        var _a, _b, _c;
+        return ({
+            id: op.id,
+            product: {
+                sku: ((_a = op.product) === null || _a === void 0 ? void 0 : _a.sku) || null,
+                name: ((_b = op.product) === null || _b === void 0 ? void 0 : _b.name) || null
+            },
+            productDetail: {
+                refCode: ((_c = op.productDetail) === null || _c === void 0 ? void 0 : _c.refCode) || null
+            },
+            batchId: op.batchId,
+            packingType: op.packingType,
+            packingSize: op.packingSize,
+            releaseQty: op.releaseQty,
+            releaseUomValue: op.releaseUomValue,
+            uom: op.uom,
+            refItemId: op.refItemId || null,
+            unitPrice: op.unitPrice || null,
+            remark: op.remark || null,
+            status: op.status
+        });
+    });
+    const shippingOrderData = releaseGoodForResponse.shippingOrder
+        ? {
+            id: releaseGoodForResponse.shippingOrder.id,
+            name: releaseGoodForResponse.shippingOrder.name,
+            status: releaseGoodForResponse.shippingOrder.status
+        }
+        : null;
+    const data = {
+        id: releaseGoodForResponse.id,
+        roNo: releaseGoodForResponse.name,
+        refOrderId: releaseGoodForResponse.refOrderId,
+        refNo: releaseGoodForResponse.refNo,
+        refNo2: releaseGoodForResponse.refNo2,
+        refNo3: releaseGoodForResponse.refNo3,
+        description: releaseGoodForResponse.description,
+        truckNo: releaseGoodForResponse.truckNo,
+        collectionOrderNo: releaseGoodForResponse.collectionOrderNo,
+        releaseDate: releaseGoodForResponse.releaseDate,
+        ownTransport: releaseGoodForResponse.ownTransport,
+        exportOption: releaseGoodForResponse.exportOption,
+        packingOption: releaseGoodForResponse.packingOption,
+        courierOption: releaseGoodForResponse.courierOption,
+        status: releaseGoodForResponse.status,
+        remark: releaseGoodForResponse.remark,
+        orderProducts: resultOrderProducts,
+        shippingOrder: shippingOrderData
+    };
+    return {
+        responseCode: '200',
+        message: 'success',
+        data
+    };
+}
+async function updateOrderProducts(tx, releaseGood, inputOrderProducts, domain, user, context) {
+    // Get existing order products with their order inventories
+    const existingOrderProducts = await tx.getRepository(sales_base_1.OrderProduct).find({
+        where: { releaseGood },
+        relations: ['product', 'productDetail', 'orderInventories', 'orderInventories.inventory']
+    });
+    // Determine hasOrderInventories by checking if releaseGood has any orderInventories
+    // Check directly on releaseGood by counting orderInventories
+    const orderInventoriesCount = await tx.getRepository(sales_base_1.OrderInventory).count({
+        where: { releaseGood }
+    });
+    const hasOrderInventories = orderInventoriesCount > 0;
+    // Process removals first
+    const orderProductIdsToRemove = [];
+    const orderProductsToUpdate = [];
+    const orderProductsToAdd = [];
+    for (const orderProductReq of inputOrderProducts) {
+        if (orderProductReq._action === 'remove') {
+            const matchingOP = findMatchingOrderProduct(existingOrderProducts, orderProductReq);
+            if (!matchingOP) {
+                throw new error_util_1.ApiError('E04', `Order product not found for removal. Provide id, sku, refCode, batchId, packingType, or refItemId to identify the item.`);
+            }
+            orderProductIdsToRemove.push(matchingOP.id);
+            continue;
+        }
+        // Try to find existing order product for update
+        const matchingOP = findMatchingOrderProduct(existingOrderProducts, orderProductReq);
+        if (matchingOP) {
+            orderProductsToUpdate.push({ existing: matchingOP, request: orderProductReq });
+        }
+        else {
+            orderProductsToAdd.push(orderProductReq);
+        }
+    }
+    // Validate: Prevent removing all products from the order
+    // If removing products would leave the order with zero products, throw an error
+    const existingProductCount = existingOrderProducts.length;
+    const productsToRemoveCount = orderProductIdsToRemove.length;
+    const productsToAddCount = orderProductsToAdd.length;
+    const remainingProductCount = existingProductCount - productsToRemoveCount + productsToAddCount;
+    if (remainingProductCount <= 0) {
+        throw new error_util_1.ApiError('E04', 'Cannot remove all products from the release order. Please use the cancellation API to cancel the entire order instead of removing the final item(s).');
+    }
+    // Remove order products
+    if (orderProductIdsToRemove.length > 0) {
+        await removeOrderProducts(tx, orderProductIdsToRemove, hasOrderInventories);
+    }
+    // Update existing order products
+    for (const { existing, request } of orderProductsToUpdate) {
+        await updateExistingOrderProduct(tx, existing, request, releaseGood, domain, user, context, hasOrderInventories);
+    }
+    // Add new order products
+    for (const orderProductReq of orderProductsToAdd) {
+        await addNewOrderProduct(tx, orderProductReq, releaseGood, domain, user, context, hasOrderInventories);
+    }
+}
+function findMatchingOrderProduct(existingOrderProducts, orderProductReq) {
+    var _a, _b, _c;
+    // First try by ID if provided
+    if (orderProductReq.id) {
+        const found = existingOrderProducts.find(op => op.id === orderProductReq.id);
+        if (found)
+            return found;
+    }
+    // Extract matching fields
+    const sku = ((_a = orderProductReq.product) === null || _a === void 0 ? void 0 : _a.sku) || orderProductReq.sku;
+    const refCode = ((_b = orderProductReq.product) === null || _b === void 0 ? void 0 : _b.refCode) || ((_c = orderProductReq.productDetail) === null || _c === void 0 ? void 0 : _c.refCode) || orderProductReq.refCode;
+    const batchId = orderProductReq.batchId;
+    const packingType = orderProductReq.packingType;
+    const refItemId = orderProductReq.refItemId;
+    // Need at least one matching field (besides id)
+    if (!sku && !refCode && !batchId && !packingType && !refItemId) {
+        return null;
+    }
+    // Match by provided fields (all provided fields must match)
+    return (existingOrderProducts.find(op => {
+        var _a, _b;
+        const matchesSku = !sku || ((_a = op.product) === null || _a === void 0 ? void 0 : _a.sku) === sku;
+        const matchesRefCode = !refCode || ((_b = op.productDetail) === null || _b === void 0 ? void 0 : _b.refCode) === refCode;
+        const matchesBatchId = !batchId || op.batchId === batchId;
+        const matchesPackingType = !packingType || op.packingType === packingType;
+        const matchesRefItemId = !refItemId || op.refItemId === refItemId;
+        return matchesSku && matchesRefCode && matchesBatchId && matchesPackingType && matchesRefItemId;
+    }) || null);
+}
+async function removeOrderProducts(tx, orderProductIds, hasOrderInventories) {
+    var _a;
+    for (const orderProductId of orderProductIds) {
+        const orderProduct = await tx.getRepository(sales_base_1.OrderProduct).findOne({
+            where: { id: orderProductId },
+            relations: ['orderInventories', 'orderInventories.inventory']
+        });
+        if (!orderProduct)
+            continue;
+        const orderProductEntity = orderProduct;
+        const orderInventories = (orderProductEntity.orderInventories || []);
+        const releaseQty = orderProductEntity.releaseQty || 0;
+        const releaseUomValue = orderProductEntity.releaseUomValue || 0;
+        if (hasOrderInventories && orderInventories.length > 0) {
+            // Release locked quantities from inventories
+            for (const orderInventory of orderInventories) {
+                const inventory = orderInventory.inventory;
+                if (inventory) {
+                    const oiReleaseQty = orderInventory.releaseQty || 0;
+                    const oiReleaseUomValue = orderInventory.releaseUomValue || 0;
+                    const inventoryEntity = inventory;
+                    await tx
+                        .getRepository(warehouse_base_1.Inventory)
+                        .createQueryBuilder()
+                        .update(warehouse_base_1.Inventory)
+                        .set({
+                        lockedQty: () => `COALESCE(locked_qty, 0) - ${oiReleaseQty}`,
+                        lockedUomValue: () => `COALESCE(locked_uom_value, 0) - ${oiReleaseUomValue}`,
+                        updater: orderProductEntity.updater
+                    })
+                        .where('id = :id', { id: inventoryEntity.id })
+                        .execute();
+                }
+            }
+            // Delete order inventories
+            // First, delete any worksheet details that reference these order inventories
+            const oiIds = orderInventories.map(oi => oi.id).filter((id) => !!id);
+            if (oiIds.length > 0) {
+                // Find and delete worksheet details that reference the order inventories to be deleted
+                // Join with OrderInventory to find worksheet details by order inventory IDs
+                const worksheetDetailsToDelete = await tx
+                    .getRepository(worksheet_base_1.WorksheetDetail)
+                    .createQueryBuilder('wsd')
+                    .innerJoin('wsd.targetInventory', 'oi')
+                    .where('oi.id IN (:...oiIds)', { oiIds })
+                    .andWhere('wsd.domain = :domainId', {
+                    domainId: ((_a = orderProductEntity.domain) === null || _a === void 0 ? void 0 : _a.id) || orderProductEntity.domainId
+                })
+                    .getMany();
+                if (worksheetDetailsToDelete.length > 0) {
+                    const worksheetDetailIds = worksheetDetailsToDelete.map(wsd => wsd.id);
+                    await tx.getRepository(worksheet_base_1.WorksheetDetail).delete(worksheetDetailIds);
+                }
+                // Now delete the order inventories
+                await tx.getRepository(sales_base_1.OrderInventory).delete(oiIds);
+            }
+        }
+        else {
+            // Update ProductDetailStock unassigned quantities
+            const productDetail = orderProductEntity.productDetail;
+            if (productDetail && productDetail.id) {
+                await tx
+                    .getRepository(warehouse_base_1.ProductDetailStock)
+                    .createQueryBuilder()
+                    .update(warehouse_base_1.ProductDetailStock)
+                    .set({
+                    unassignedQty: () => `"unassigned_qty" - ${releaseQty}`,
+                    unassignedUomValue: () => `"unassigned_uom_value" - ${releaseUomValue}`
+                })
+                    .where({ productDetail: productDetail.id })
+                    .execute();
+            }
+        }
+        // Delete order product
+        await tx.getRepository(sales_base_1.OrderProduct).delete(orderProductId);
+    }
+}
+async function updateExistingOrderProduct(tx, existing, request, releaseGood, domain, user, context, hasOrderInventories) {
+    var _a, _b, _c, _d, _e;
+    const newQty = request.releaseQty !== undefined ? request.releaseQty : request.qty;
+    if (newQty === undefined) {
+        // No quantity change, just update other fields if provided
+        const updateData = { updater: user };
+        if (request.remark !== undefined)
+            updateData.remark = request.remark;
+        if (request.unitPrice !== undefined)
+            updateData.unitPrice = request.unitPrice;
+        await tx.getRepository(sales_base_1.OrderProduct).update(existing.id, updateData);
+        return;
+    }
+    if (newQty <= 0) {
+        throw new error_util_1.ApiError('E01', 'releaseQty must be greater than 0');
+    }
+    const qtyDiff = newQty - existing.releaseQty;
+    const uomValueDiff = (newQty - existing.releaseQty) * (((_a = existing.productDetail) === null || _a === void 0 ? void 0 : _a.uomValue) || 1);
+    // Validate decimal places for non-decimal products
+    if (!((_b = existing.product) === null || _b === void 0 ? void 0 : _b.isInventoryDecimal) && newQty % 1 !== 0) {
+        throw new error_util_1.ApiError('E01', `releaseQty must be an integer for product ${(_c = existing.product) === null || _c === void 0 ? void 0 : _c.sku}`);
+    }
+    // Round to 3 decimal places
+    const roundedNewQty = ((_d = existing.product) === null || _d === void 0 ? void 0 : _d.isInventoryDecimal) ? Math.round(newQty * 1000) / 1000 : Math.round(newQty);
+    const roundedNewUomValue = roundedNewQty * (((_e = existing.productDetail) === null || _e === void 0 ? void 0 : _e.uomValue) || 1);
+    if (hasOrderInventories) {
+        // Update order inventories
+        await updateOrderInventoriesForQtyChange(tx, existing, qtyDiff, uomValueDiff, roundedNewQty, roundedNewUomValue, user, releaseGood, domain);
+    }
+    else {
+        // Update ProductDetailStock
+        await tx
+            .getRepository(warehouse_base_1.ProductDetailStock)
+            .createQueryBuilder()
+            .update(warehouse_base_1.ProductDetailStock)
+            .set({
+            unassignedQty: () => `"unassigned_qty" + ${qtyDiff}`,
+            unassignedUomValue: () => `"unassigned_uom_value" + ${uomValueDiff}`
+        })
+            .where({ productDetail: existing.productDetail.id })
+            .execute();
+    }
+    // Update order product
+    const updateData = {
+        releaseQty: roundedNewQty,
+        releaseUomValue: roundedNewUomValue,
+        updater: user
+    };
+    if (request.remark !== undefined)
+        updateData.remark = request.remark;
+    if (request.unitPrice !== undefined)
+        updateData.unitPrice = request.unitPrice;
+    await tx.getRepository(sales_base_1.OrderProduct).update(existing.id, updateData);
+}
+async function updateOrderInventoriesForQtyChange(tx, orderProduct, qtyDiff, uomValueDiff, newQty, newUomValue, user, releaseGood, domain) {
+    const existingOrderInventories = (await tx.getRepository(sales_base_1.OrderInventory).find({
+        where: { orderProduct },
+        relations: ['inventory']
+    }));
+    if (qtyDiff > 0) {
+        // Increase: assign more inventory
+        await assignAdditionalInventory(tx, orderProduct, qtyDiff, uomValueDiff, user, releaseGood, domain);
+    }
+    else if (qtyDiff < 0) {
+        // Decrease: select latest order inventories and deduct from them
+        const reductionQty = Math.abs(qtyDiff);
+        const reductionUomValue = Math.abs(uomValueDiff);
+        // Sort order inventories by creation date (latest first)
+        const sortedOrderInventories = [...existingOrderInventories].sort((a, b) => {
+            const dateA = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+            const dateB = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+            return dateB - dateA; // Latest first
+        });
+        let remainingReductionQty = reductionQty;
+        let remainingReductionUomValue = reductionUomValue;
+        const orderInventoriesToDelete = [];
+        for (const oi of sortedOrderInventories) {
+            if (remainingReductionQty <= 0 && remainingReductionUomValue <= 0) {
+                break;
+            }
+            const oiReleaseQty = oi.releaseQty || 0;
+            const oiReleaseUomValue = oi.releaseUomValue || 0;
+            // Calculate how much to deduct from this order inventory
+            const deductQty = Math.min(remainingReductionQty, oiReleaseQty);
+            const deductUomValue = Math.min(remainingReductionUomValue, oiReleaseUomValue);
+            const inventory = oi.inventory;
+            if (inventory) {
+                // Release locked quantities from inventory
+                await tx
+                    .getRepository(warehouse_base_1.Inventory)
+                    .createQueryBuilder()
+                    .update(warehouse_base_1.Inventory)
+                    .set({
+                    lockedQty: () => `COALESCE(locked_qty, 0) - ${deductQty}`,
+                    lockedUomValue: () => `COALESCE(locked_uom_value, 0) - ${deductUomValue}`,
+                    updater: user
+                })
+                    .where('id = :id', { id: inventory.id })
+                    .execute();
+            }
+            const newOiQty = oiReleaseQty - deductQty;
+            const newOiUomValue = oiReleaseUomValue - deductUomValue;
+            if (newOiQty <= 0 || newOiUomValue <= 0) {
+                // Mark this order inventory for deletion
+                orderInventoriesToDelete.push(oi.id);
+            }
+            else {
+                // Update order inventory with remaining quantity
+                await tx.getRepository(sales_base_1.OrderInventory).update(oi.id, {
+                    releaseQty: newOiQty,
+                    releaseUomValue: newOiUomValue,
+                    updater: user
+                });
+            }
+            remainingReductionQty -= deductQty;
+            remainingReductionUomValue -= deductUomValue;
+        }
+        // Delete order inventories that are fully consumed
+        if (orderInventoriesToDelete.length > 0) {
+            // Find and delete worksheet details that reference these order inventories
+            const worksheetDetailsToDelete = await tx
+                .getRepository(worksheet_base_1.WorksheetDetail)
+                .createQueryBuilder('wsd')
+                .innerJoin('wsd.targetInventory', 'oi')
+                .where('oi.id IN (:...oiIds)', { oiIds: orderInventoriesToDelete })
+                .andWhere('wsd.domain = :domainId', { domainId: domain.id })
+                .getMany();
+            if (worksheetDetailsToDelete.length > 0) {
+                const worksheetDetailIds = worksheetDetailsToDelete.map(wsd => wsd.id);
+                await tx.getRepository(worksheet_base_1.WorksheetDetail).delete(worksheetDetailIds);
+            }
+            // Now delete the order inventories
+            await tx.getRepository(sales_base_1.OrderInventory).delete(orderInventoriesToDelete);
+        }
+    }
+    // Update order product totals
+    const remainingOrderInventories = (await tx.getRepository(sales_base_1.OrderInventory).find({
+        where: { orderProduct }
+    }));
+    const totalReleaseQty = remainingOrderInventories.reduce((sum, oi) => sum + (oi.releaseQty || 0), 0);
+    const totalReleaseUomValue = remainingOrderInventories.reduce((sum, oi) => sum + (oi.releaseUomValue || 0), 0);
+    await tx.getRepository(sales_base_1.OrderProduct).update(orderProduct.id, {
+        releaseQty: totalReleaseQty,
+        releaseUomValue: totalReleaseUomValue,
+        updater: user
+    });
+}
+async function assignAdditionalInventory(tx, orderProduct, qtyDiff, uomValueDiff, user, releaseGood, domain) {
+    var _a;
+    // Get customer bizplace from releaseGood (it's already loaded)
+    // If not loaded, fetch it using bizplaceId
+    let customerBizplace = releaseGood.bizplace;
+    if (!customerBizplace && releaseGood.bizplaceId) {
+        customerBizplace = await tx.getRepository(biz_base_1.Bizplace).findOne({
+            where: { id: releaseGood.bizplaceId }
+        });
+    }
+    if (!customerBizplace) {
+        throw new error_util_1.ApiError('E04', 'Customer bizplace not found for release order');
+    }
+    // Get release shelf life override from contact point (deliverTo)
+    let releaseShelfLifeOverride = null;
+    if (releaseGood.deliverToId) {
+        const deliverToContactPoint = await tx
+            .getRepository(biz_base_1.ContactPoint)
+            .findOne({ where: { id: releaseGood.deliverToId } });
+        if ((deliverToContactPoint === null || deliverToContactPoint === void 0 ? void 0 : deliverToContactPoint.releaseShelfLife) != null && deliverToContactPoint.releaseShelfLife !== 0) {
+            releaseShelfLifeOverride = deliverToContactPoint.releaseShelfLife;
+        }
+    }
+    // Get picking product setting
+    const pickingProductSetting = await tx.getRepository(setting_base_1.Setting).findOne({
+        where: { domain, name: 'rule-for-picking-product' }
+    });
+    // Determine orderInventory status based on releaseGood status
+    let orderInventoryStatus;
+    switch (releaseGood.status) {
+        case sales_base_1.ORDER_STATUS.PENDING:
+            orderInventoryStatus = sales_base_1.ORDER_INVENTORY_STATUS.PENDING;
+            break;
+        case sales_base_1.ORDER_STATUS.PENDING_RECEIVE:
+            orderInventoryStatus = sales_base_1.ORDER_INVENTORY_STATUS.PENDING_RECEIVE;
+            break;
+        case sales_base_1.ORDER_STATUS.PENDING_WORKSHEET:
+            orderInventoryStatus = sales_base_1.ORDER_INVENTORY_STATUS.PENDING_WORKSHEET;
+            break;
+        case sales_base_1.ORDER_STATUS.READY_TO_PICK:
+            orderInventoryStatus = sales_base_1.ORDER_INVENTORY_STATUS.READY_TO_PICK;
+            break;
+        default:
+            // Default to PENDING_WORKSHEET for other statuses
+            orderInventoryStatus = sales_base_1.ORDER_INVENTORY_STATUS.PENDING_WORKSHEET;
+    }
+    // Ensure product is loaded
+    if (!orderProduct.product) {
+        orderProduct.product = await tx.getRepository(product_base_1.Product).findOne({
+            where: { id: orderProduct.productId }
+        });
+    }
+    const product = orderProduct.product;
+    if (!product) {
+        throw new error_util_1.ApiError('E04', 'Product not found for order product');
+    }
+    // Determine picking strategy sortings
+    let sortings = [];
+    switch (product.pickingStrategy) {
+        case 'LIFO':
+            sortings.push({ name: 'iv.created_at', desc: true });
+            if (pickingProductSetting === null || pickingProductSetting === void 0 ? void 0 : pickingProductSetting.value) {
+                for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+                    sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false });
+                }
+            }
+            else {
+                sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false });
+            }
+            break;
+        case 'FEFO':
+            sortings.push({ name: 'iv.expiration_date', desc: false }, { name: 'iv.created_at', desc: false });
+            if (pickingProductSetting === null || pickingProductSetting === void 0 ? void 0 : pickingProductSetting.value) {
+                for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+                    sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false });
+                }
+            }
+            else {
+                sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false });
+            }
+            break;
+        case 'FMFO':
+            sortings.push({ name: 'iv.manufacture_date', desc: false }, { name: 'iv.created_at', desc: false });
+            if (pickingProductSetting === null || pickingProductSetting === void 0 ? void 0 : pickingProductSetting.value) {
+                for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+                    sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false });
+                }
+            }
+            else {
+                sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false });
+            }
+            break;
+        case 'LOCATION':
+            if (pickingProductSetting === null || pickingProductSetting === void 0 ? void 0 : pickingProductSetting.value) {
+                for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+                    sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false });
+                }
+            }
+            else {
+                sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false });
+            }
+            break;
+        // Every other case includes 'FIFO' will be applicable for this case
+        default:
+            sortings.push({ name: 'iv.created_at', desc: false });
+            if (pickingProductSetting === null || pickingProductSetting === void 0 ? void 0 : pickingProductSetting.value) {
+                for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+                    sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false });
+                }
+            }
+            else {
+                sortings.push({ name: 'loc.name', desc: false });
+                sortings.push({ name: 'iv.pallet_id', desc: false });
+            }
+            break;
+    }
+    let queryFilters = [];
+    let queryStrings = queryFilters.reduce((acc, itm, idx, arr) => {
+        acc.values.push(itm.filters);
+        switch (itm === null || itm === void 0 ? void 0 : itm.operator) {
+            case 'notin':
+            case 'in':
+                acc.query.push(`${itm.query} ${itm.operator == 'notin' ? 'NOT IN' : 'IN'} (${itm.filters
+                    .map((itm, idx) => {
+                    return `$${acc.values.length + 1}`;
+                })
+                    .join(',')})`);
+                break;
+            default:
+                acc.query.push(`${itm.query} ${(itm === null || itm === void 0 ? void 0 : itm.operator) ? itm.operator : '='} $${acc.values.length + 1}`);
+                break;
+        }
+        acc.query.push(`${itm.query} ${(itm === null || itm === void 0 ? void 0 : itm.operator) ? itm.operator : '='} $${acc.values.length + 1}`);
+        return acc;
+    }, {
+        query: [],
+        values: []
+    });
+    let sortQuery = sortings
+        .map(itm => {
+        return `${itm.name} ${itm.desc ? 'DESC' : 'ASC'}`;
+    })
+        .join(`,`);
+    // Ensure productDetail is loaded for uom
+    if (!orderProduct.productDetail) {
+        orderProduct.productDetail = await tx.getRepository(product_base_1.ProductDetail).findOne({
+            where: { id: orderProduct.productDetailId }
+        });
+    }
+    const productDetail = orderProduct.productDetail;
+    const uom = (productDetail && productDetail.uom) || product.uom || 'UN';
+    let params = [
+        user.id,
+        domain.id,
+        customerBizplace.id,
+        orderProduct.packingType,
+        orderProduct.packingSize,
+        product.id,
+        warehouse_base_1.INVENTORY_STATUS.STORED,
+        warehouse_base_1.LOCATION_TYPE.QUARANTINE,
+        warehouse_base_1.LOCATION_TYPE.RESERVE,
+        warehouse_base_1.LOCATION_TYPE.STORAGE
+    ];
+    let batchId = orderProduct.batchId && orderProduct.batchId !== '-' ? String(orderProduct.batchId).trim() : null;
+    if (batchId)
+        params.push(batchId);
+    params = [...params, ...queryStrings.values];
+    // Handle warehouse code filtering
+    const warehouseCode = orderProduct.warehouseCode;
+    const warehouseNameFilter = warehouseCode ? `AND w.name = $${params.length + 1}` : '';
+    if (warehouseCode) {
+        params.push(String(warehouseCode).trim());
+    }
+    // Add release shelf life override parameter
+    const releaseShelfLifeParamIndex = params.length + 1;
+    params.push(releaseShelfLifeOverride);
+    // Build the sophisticated SQL query with window functions
+    let query = `
+    update inventories tgt set locked_qty = coalesce(locked_qty,0) + src.reserve_qty, 
+    locked_uom_value = coalesce(locked_uom_value,0) + src.reserve_uom_value,
+    updated_at = NOW(),
+    updater_id = $1
+    from (
+      select "id", "pallet_id","carton_id", "batch_id", "batch_id_ref", "unit", "uom", "packing_type", "packing_size", "manufacture_year",
+      "reserve_qty", (("uom_value"/"qty") * "reserve_qty") as "reserve_uom_value" from (	
+        select "sort_seq", "id", "pallet_id", "batch_id", "batch_id_ref", "unit", "uom", "packing_type", "packing_size", "manufacture_year", "carton_id", "uom_value", "locked_uom_value", "qty", "locked_qty", "created_at", 
+        "release_qty", "release_uom_value", lock_amount, 
+        case when "lock_amount" < 0 then "available_qty" else "available_qty" - "lock_amount" end as "reserve_qty"
+        from (
+          select *,
+          (
+            case when (qty - greatest(locked_qty, 0) - greatest(unassigned_qty, 0)) < 0 then 0
+            else qty - greatest(locked_qty, 0) - greatest(unassigned_qty, 0) end
+          ) as available_qty,
+          sum(qty - locked_qty - release_qty - unassigned_qty) over (order by sort_seq asc rows between unbounded preceding and current row) as lock_amount
+          from (
+            SELECT 0 as sort_seq, null as id, null as pallet_id, null as batch_id, null as batch_id_ref, 
+            null as unit, '${uom}' as uom, '${orderProduct.packingType}' as packing_type, '${orderProduct.packingSize}' as packing_size,
+            null as manufacture_year, null as carton_id, 0 as uom_value, 0 as locked_uom_value, 0 as qty, 0 as locked_qty, 0 as unassigned_uom_value, 0 as unassigned_qty, null as created_at,
+            ${qtyDiff}::numeric as release_qty, ${uomValueDiff}::numeric as release_uom_value
+            UNION
+            (
+              SELECT ROW_NUMBER() OVER(PARTITION BY iv.domain_id ORDER BY wiar.rank ${sortQuery ? ', ' + sortQuery : ''}) as sort_seq, 
+              iv.id, iv.pallet_id, iv.batch_id, iv.batch_id_ref, 
+              iv.unit, iv.uom, iv.packing_type, iv.packing_size, 
+              iv.manufacture_year, iv.carton_id, iv.uom_value, 
+              coalesce(iv.locked_uom_value,0) as locked_uom_value, iv.qty, greatest(coalesce(iv.locked_qty,0),0) as locked_qty, coalesce(pds.unassigned_uom_value,0) as unassigned_uom_value, greatest(coalesce(pds.unassigned_qty,0),0) as unassigned_qty, 
+              iv.created_at, 0 as release_qty, 0 as release_uom_value
+              FROM "inventories" "iv" 
+              LEFT JOIN "product_detail_stocks" "pds" ON "pds"."product_detail_id" = "iv"."product_detail_id"
+              INNER JOIN "locations" "loc" ON "loc"."id"="iv"."location_id" 
+              INNER JOIN "warehouses" "w" ON "w"."id" = "loc"."warehouse_id"
+              INNER JOIN "products" "p" ON "p"."id"="iv"."product_id" 
+              INNER JOIN "warehouse_inventory_assignment_rankings" "wiar" ON "wiar"."location_type"="loc"."type"
+              WHERE case when coalesce("iv"."locked_qty",0) < 0 then 0 else ("iv"."qty" - coalesce("iv"."locked_qty",0)) end > 0 AND 
+               "iv"."domain_id" = $2 AND "iv"."bizplace_id" = $3 AND "iv"."packing_type" = $4 AND "iv"."packing_size" = $5 AND  "iv"."product_id" = $6 AND "iv"."status" = $7 AND "loc"."type" NOT IN ($8, $9, $10)
+               AND ${batchId ? `"iv"."batch_id" = $11` : `1=1`}
+              ${warehouseNameFilter}
+              AND "iv"."obsolete" = false AND (
+                "iv"."expiration_date" IS NULL
+                OR
+                CASE
+                  WHEN $${releaseShelfLifeParamIndex}::integer IS NOT NULL AND $${releaseShelfLifeParamIndex}::integer > 0 THEN
+                    CURRENT_DATE < ("iv"."expiration_date" - $${releaseShelfLifeParamIndex}::integer)
+                  WHEN "p"."min_outbound_shelf_life" IS NOT NULL AND "p"."min_outbound_shelf_life" > 0 THEN
+                    CURRENT_DATE < ("iv"."expiration_date" - "p"."min_outbound_shelf_life")
+                  ELSE
+                    TRUE
+                END
+              )
+              ${queryStrings.query.length > 0 ? `AND ${queryStrings.query.join(' AND ')}` : ''}
+              ORDER BY wiar.rank ${sortQuery ? ', ' + sortQuery : ''}
+            )
+          ) dt1
+        ) dt2 where case when "lock_amount" < 0 then "available_qty" else "available_qty" - "lock_amount" end > 0		
+      ) dt3 where sort_seq > 0
+    ) src where src.id = tgt.id
+    returning 
+      tgt."id", tgt."qty", tgt."pallet_id", tgt."carton_id", tgt."batch_id", tgt."batch_id_ref", tgt."unit", 
+      tgt."uom", tgt."packing_type", tgt."packing_size", tgt."manufacture_year", 
+      tgt."locked_qty", tgt."uom_value", tgt."locked_uom_value", src."reserve_qty", src."reserve_uom_value";`;
+    let updatedInventories = await tx.getRepository(warehouse_base_1.Inventory).query(query, params);
+    let totalAssigned = ((_a = updatedInventories[0]) === null || _a === void 0 ? void 0 : _a.reduce((acc, inv) => {
+        return acc + inv.reserve_qty;
+    }, 0)) || 0;
+    // For non-decimal products, round the values before comparison
+    let roundedQtyDiff = qtyDiff;
+    if (!product.isInventoryDecimal) {
+        roundedQtyDiff = Math.round(qtyDiff);
+        totalAssigned = Math.round(totalAssigned);
+    }
+    else {
+        // For decimal products, round to 3 decimal places
+        roundedQtyDiff = Math.round(qtyDiff * 1000) / 1000;
+        totalAssigned = Math.round(totalAssigned * 1000) / 1000;
+    }
+    if (Math.abs(roundedQtyDiff - totalAssigned) > 0.001) {
+        // Using small epsilon for float comparison
+        throw new error_util_1.ApiError('E01', 'INSUFFICIENT_STOCK');
+    }
+    // Create order inventory records for each assigned inventory
+    if (updatedInventories[0] && updatedInventories[0].length > 0) {
+        // Ensure releaseGood.id is available (required for TypeORM relation)
+        if (!releaseGood.id) {
+            throw new error_util_1.ApiError('E04', 'Release good ID is required for order inventory');
+        }
+        // Ensure orderProduct.id is available (required for TypeORM relation)
+        if (!orderProduct.id) {
+            throw new error_util_1.ApiError('E04', 'Order product ID is required for order inventory');
+        }
+        // Get existing order inventories for this order product to check for duplicates
+        const existingOrderInventories = await tx.getRepository(sales_base_1.OrderInventory).find({
+            where: { orderProduct },
+            relations: ['inventory']
+        });
+        // Check if worksheets exist for this release good
+        const existingWorksheets = await tx.getRepository(worksheet_base_1.Worksheet).find({
+            where: {
+                releaseGood: { id: releaseGood.id },
+                type: worksheet_base_1.WORKSHEET_TYPE.PICKING,
+                status: (0, typeorm_1.In)([worksheet_base_1.WORKSHEET_STATUS.DEACTIVATED])
+            },
+            relations: ['bizplace']
+        });
+        const newOrderInventories = [];
+        for (const inv of updatedInventories[0]) {
+            // Check if an order inventory already exists for this inventory ID
+            const existingOI = existingOrderInventories.find((oi) => oi.inventory && oi.inventory.id === inv.id);
+            let savedOrderInventory;
+            if (existingOI) {
+                // Update existing order inventory
+                const updatedReleaseQty = (existingOI.releaseQty || 0) + inv.reserve_qty;
+                const updatedReleaseUomValue = (existingOI.releaseUomValue || 0) + inv.reserve_uom_value;
+                await tx.getRepository(sales_base_1.OrderInventory).update(existingOI.id, {
+                    releaseQty: updatedReleaseQty,
+                    releaseUomValue: updatedReleaseUomValue,
+                    updater: user
+                });
+                // Reload to get updated entity
+                savedOrderInventory = (await tx.getRepository(sales_base_1.OrderInventory).findOne({
+                    where: { id: existingOI.id },
+                    relations: ['inventory']
+                }));
+            }
+            else {
+                // Create new order inventory
+                savedOrderInventory = await tx.getRepository(sales_base_1.OrderInventory).save(Object.assign(new sales_base_1.OrderInventory(), {
+                    name: (0, uuid_1.v4)(),
+                    domain: domain,
+                    bizplace: customerBizplace,
+                    releaseGood: releaseGood,
+                    releaseGoodId: releaseGood.id,
+                    orderProduct: orderProduct,
+                    orderProductId: orderProduct.id,
+                    product: product,
+                    productDetail: productDetail,
+                    inventory: { id: inv.id },
+                    packingType: inv.packing_type,
+                    packingSize: inv.packing_size,
+                    batchId: inv.batch_id,
+                    releaseQty: inv.reserve_qty,
+                    releaseUomValue: inv.reserve_uom_value,
+                    uom: inv.uom,
+                    type: sales_base_1.ORDER_TYPES.RELEASE_OF_GOODS,
+                    status: orderInventoryStatus,
+                    creator: user,
+                    updater: user
+                }));
+                newOrderInventories.push(savedOrderInventory);
+            }
+        }
+        // Create worksheet details for newly created order inventories if worksheets exist
+        if (existingWorksheets.length > 0 && newOrderInventories.length > 0) {
+            for (const worksheet of existingWorksheets) {
+                const worksheetDetails = newOrderInventories.map((oi) => ({
+                    domain: domain,
+                    bizplace: worksheet.bizplace || customerBizplace,
+                    worksheet: worksheet,
+                    name: worksheet_base_1.WorksheetNoGenerator.pickingDetail(),
+                    type: worksheet_base_1.WORKSHEET_TYPE.PICKING,
+                    status: worksheet_base_1.WORKSHEET_STATUS.DEACTIVATED,
+                    targetInventory: oi,
+                    creator: user,
+                    updater: user
+                }));
+                await tx.getRepository(worksheet_base_1.WorksheetDetail).save(worksheetDetails);
+            }
+        }
+    }
+}
+async function addNewOrderProduct(tx, orderProductReq, releaseGood, domain, user, context, hasOrderInventories) {
+    var _a, _b, _c;
+    const sku = ((_a = orderProductReq.product) === null || _a === void 0 ? void 0 : _a.sku) || orderProductReq.sku;
+    const refCode = ((_b = orderProductReq.product) === null || _b === void 0 ? void 0 : _b.refCode) || orderProductReq.refCode;
+    const packingType = orderProductReq.packingType;
+    const packingSize = orderProductReq.packingSize;
+    const releaseQty = orderProductReq.releaseQty !== undefined ? orderProductReq.releaseQty : orderProductReq.qty;
+    const refItemId = ((_c = orderProductReq.product) === null || _c === void 0 ? void 0 : _c.refItemId) || orderProductReq.refItemId || null;
+    if (!sku && !refCode) {
+        throw new error_util_1.ApiError('E01', 'sku or refCode is required for new items');
+    }
+    if (!releaseQty || releaseQty <= 0) {
+        throw new error_util_1.ApiError('E01', 'releaseQty must be greater than 0');
+    }
+    // Ensure releaseGood has an ID (required for TypeORM relation)
+    if (!releaseGood.id) {
+        throw new error_util_1.ApiError('E04', 'Release good ID is required');
+    }
+    // Get company bizplace for product lookup
+    const customerCompanyBizplace = await (0, biz_base_1.getCompanyBizplace)(null, null, releaseGood.bizplaceId, tx);
+    // Find product detail
+    const qb = tx
+        .getRepository(product_base_1.ProductDetail)
+        .createQueryBuilder('pd')
+        .innerJoinAndSelect('pd.product', 'prod')
+        .where('prod.bizplace_id = :bizplaceId', { bizplaceId: customerCompanyBizplace.id })
+        .andWhere('pd.deleted_at IS NULL');
+    if (refCode) {
+        qb.andWhere('pd.ref_code = :refCode', { refCode });
+    }
+    if (sku) {
+        qb.andWhere('prod.sku = :sku', { sku });
+    }
+    if (packingType) {
+        qb.andWhere('pd.packing_type = :packingType', { packingType });
+    }
+    if (packingSize) {
+        qb.andWhere('pd.packing_size = :packingSize', { packingSize });
+    }
+    if (!refCode && !packingType && !packingSize) {
+        qb.andWhere('pd.is_default = :isDefault', { isDefault: true });
+    }
+    const productDetail = await qb.getOne();
+    if (!productDetail) {
+        throw new error_util_1.ApiError('E04', `Product not found: ${sku || refCode}`);
+    }
+    // Validate decimal places
+    if (!productDetail.product.isInventoryDecimal && releaseQty % 1 !== 0) {
+        throw new error_util_1.ApiError('E01', `releaseQty must be an integer for product ${sku || refCode}`);
+    }
+    // Round to 3 decimal places
+    const roundedReleaseQty = productDetail.product.isInventoryDecimal
+        ? Math.round(releaseQty * 1000) / 1000
+        : Math.round(releaseQty);
+    const releaseUomValue = roundedReleaseQty * (productDetail.uomValue || 1);
+    // Ensure bizplace is loaded - fetch it if not already loaded
+    let bizplace = releaseGood.bizplace;
+    if (!bizplace && releaseGood.bizplaceId) {
+        bizplace = await tx.getRepository(biz_base_1.Bizplace).findOne({ where: { id: releaseGood.bizplaceId } });
+        if (!bizplace) {
+            throw new error_util_1.ApiError('E04', 'Bizplace not found for release order');
+        }
+    }
+    else if (!bizplace) {
+        throw new error_util_1.ApiError('E04', 'Bizplace is required for order product');
+    }
+    const repo = tx.getRepository(sales_base_1.OrderProduct);
+    const created = repo.create({
+        name: `OP-` + (0, uuid_1.v4)(),
+        // Use relation stubs (IDs only) to force FK persistence
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        releaseGood: { id: releaseGood.id },
+        releaseGoodId: releaseGood.id,
+        product: { id: productDetail.product.id },
+        productDetail: { id: productDetail.id },
+        packingType: productDetail.packingType,
+        packingSize: packingSize || productDetail.packingSize,
+        batchId: orderProductReq.batchId || '',
+        refItemId: refItemId,
+        releaseQty: roundedReleaseQty,
+        releaseUomValue: releaseUomValue,
+        uom: productDetail.uom,
+        uomValue: productDetail.uomValue,
+        packQty: 0,
+        actualPackQty: 0,
+        palletQty: 0,
+        actualPalletQty: 0,
+        type: sales_base_1.ORDER_TYPES.RELEASE_OF_GOODS,
+        status: sales_base_1.ORDER_PRODUCT_STATUS.ASSIGNED,
+        unitPrice: orderProductReq.unitPrice || null,
+        remark: orderProductReq.remark || null,
+        creator: user,
+        updater: user
+    });
+    const newOrderProduct = await repo.save(created);
+    if (hasOrderInventories) {
+        // Assign inventory - pass releaseGood so status can be determined
+        await assignAdditionalInventory(tx, newOrderProduct, roundedReleaseQty, releaseUomValue, user, releaseGood, domain);
+    }
+    else {
+        // Update ProductDetailStock
+        await tx
+            .getRepository(warehouse_base_1.ProductDetailStock)
+            .createQueryBuilder()
+            .update(warehouse_base_1.ProductDetailStock)
+            .set({
+            unassignedQty: () => `"unassigned_qty" + ${roundedReleaseQty}`,
+            unassignedUomValue: () => `"unassigned_uom_value" + ${releaseUomValue}`
+        })
+            .where({ productDetail: productDetail.id })
+            .execute();
+    }
 }
 //# sourceMappingURL=update-release-order-details.js.map