@things-factory/sales-base 4.3.651 → 4.3.653

package/dist-server/utils/inventory-util.js

@@ -0,0 +1,1098 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._composeTargetInventories = exports.switchLocationStatus = exports.InventoryUtil = void 0;
+const typeorm_1 = require("typeorm");
+const biz_base_1 = require("@things-factory/biz-base");
+const product_base_1 = require("@things-factory/product-base");
+const setting_base_1 = require("@things-factory/setting-base");
+const warehouse_base_1 = require("@things-factory/warehouse-base");
+const constants_1 = require("../constants");
+const errors_1 = require("../errors");
+const service_1 = require("../service");
+exports.InventoryUtil = {
+    /**
+     * Get all available product belonging to list of bizplaces
+     * @param {[Object]} bizplaces
+     * @param {Object} params
+     * @param {Object} context
+     * @param {Object} trxMgr
+     * @returns { object } {items, total}
+     */
+    async bizplaceProductInventory(bizplaces, params, context, trxMgr) {
+        try {
+            let filters = params.filters;
+            const { domain } = context.state;
+            const { bizplaceIds, productWhereClause, bundleWhereClause, whereClause, batchBundle, productDetailWhereClause } = await getConditions(bizplaces, filters, trxMgr, false);
+            let productFilter = filters.find(itm => itm.name == 'productName');
+            let inventoryBizplaceFilter = filters.find(itm => itm.name == 'bizplaceId');
+            let deletedAt = filters.find(filter => filter.name == 'deleted_at');
+            let queryStrings = `
+        CREATE TEMP TABLE temp_inventory_product_group ON COMMIT DROP AS (
+          SELECT * FROM (
+            WITH oi as (
+              SELECT
+                SUM(oi.release_qty) AS release_qty,
+                SUM(oi.release_uom_value) AS release_uom_value,
+                oi.batch_id,
+                oi.batch_id_ref,
+                oi.product_id,
+                p.name AS product_name,
+                oi.packing_type,
+                oi.packing_size,
+                oi.uom
+              FROM
+                order_inventories oi
+              LEFT JOIN
+                products p
+              ON
+                oi.product_id = p.id
+              WHERE
+                (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
+                AND oi.batch_id NOTNULL
+                AND oi.product_id NOTNULL
+                AND oi.packing_type NOTNULL
+                AND oi.packing_size NOTNULL
+                AND oi.inventory_id IS NULL
+              GROUP BY
+                oi.batch_id,
+                oi.batch_id_ref,
+                oi.product_id,
+                oi.packing_type,
+                oi.packing_size,
+                oi.uom,
+                p.name
+            )
+            SELECT
+              pd.packing_type AS "packingType",
+              pd.packing_size AS "packingSize",
+              pd.uom AS "uom",
+              concat(p.name, ' (', p.description, ')') AS "productName",
+              coalesce(p.sku, '') AS "productSKU",
+              coalesce(p.brand, '') AS "productBrand",
+              p.id AS "productId",
+              pd.id AS "productDetailId",
+              (
+                CASE WHEN i.lock_inventory is true THEN 0 WHEN (COALESCE(SUM(COALESCE(i.qty, 0)) - GREATEST(SUM(COALESCE(i.locked_qty, 0)), 0) - GREATEST(COALESCE(pds.unassigned_qty, 0), 0) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)),0)) < 0 THEN 0
+                ELSE COALESCE(SUM(COALESCE(i.qty, 0)) - GREATEST(SUM(COALESCE(i.locked_qty, 0)), 0) - GREATEST(COALESCE(pds.unassigned_qty, 0), 0) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)),0) END
+              ) AS "remainQty",
+              (
+                CASE WHEN i.lock_inventory is true THEN 0 WHEN (COALESCE(SUM(COALESCE(i.uom_value, 0)) - GREATEST(SUM(COALESCE(i.locked_uom_value, 0)), 0) - GREATEST(COALESCE(pds.unassigned_uom_value, 0), 0) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)),0)) < 0 THEN 0
+                ELSE COALESCE(SUM(COALESCE(i.uom_value, 0)) - GREATEST(SUM(COALESCE(i.locked_uom_value, 0)), 0) - GREATEST(COALESCE(pds.unassigned_uom_value, 0), 0) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)),0) END
+              ) AS "remainUomValue",
+              (
+                CASE WHEN i.lock_inventory is true THEN concat(0, ' ', pd.uom) WHEN (SUM(COALESCE(i.uom_value, 0)) - GREATEST(SUM(COALESCE(i.locked_uom_value, 0)), 0) - GREATEST(COALESCE(pds.unassigned_uom_value, 0), 0) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0))) < 0 THEN concat(0, ' ', pd.uom)
+                ELSE concat(SUM(COALESCE(i.uom_value, 0)) - GREATEST(SUM(COALESCE(i.locked_uom_value, 0)), 0) - GREATEST(COALESCE(pds.unassigned_uom_value, 0), 0) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', pd.uom) END
+              ) AS "remainUomValueWithUom",
+              COALESCE(SUM(COALESCE(i.transfer_qty, 0)), 0) AS "transferQty",
+              COALESCE(SUM(COALESCE(i.transfer_uom_value, 0)), 0) AS "transferUomValue",
+              'SINGLE' AS "groupType"
+            FROM products p
+            INNER join product_details pd on pd.product_id = p.id
+            LEFT JOIN product_detail_stocks pds on pds.product_detail_id = pd.id
+            LEFT JOIN (
+              SELECT i.* FROM inventories i 
+              INNER JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
+              WHERE l2.type NOT IN ('${warehouse_base_1.LOCATION_TYPE.QUARANTINE}', '${warehouse_base_1.LOCATION_TYPE.RESERVE}', '${warehouse_base_1.LOCATION_TYPE.DAMAGE}')
+              AND i.obsolete = false
+              AND i.domain_id = $1 AND i.status = 'STORED'
+              ${inventoryBizplaceFilter ? `AND i.bizplace_id = '${inventoryBizplaceFilter.value}'` : ``}
+            ) i ON i.product_detail_id = pd.id
+            LEFT JOIN oi ON i.batch_id = oi.batch_id AND p.name = oi.product_name AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
+            LEFT JOIN (
+              SELECT pbs.product_id, SUM(pbs.bundle_qty * src.release_qty) AS bundle_product_release_qty, SUM(pbs.bundle_qty * src.release_uom_value) AS bundle_product_release_uom_value 
+              FROM product_bundle_settings pbs
+              INNER JOIN json_populate_recordset(NULL::order_inventories, '${batchBundle}') src ON src.product_id = pbs.product_bundle_id
+              GROUP BY pbs.product_id
+            ) bp on i.product_id = bp.product_id
+            WHERE i.bizplace_id IN (${bizplaceIds})
+            AND i.lock_inventory is not true
+            AND case when i.expiration_date is not null and p.min_outbound_shelf_life is not null then CURRENT_DATE < i.expiration_date - p.min_outbound_shelf_life else true end
+              ${productDetailWhereClause}
+              ${productFilter
+                ? `AND (
+                lower(p.sku) ilike '${productFilter.value}'
+                OR lower(p.name) ilike '${productFilter.value}'
+                OR lower(p.description) ilike '${productFilter.value}'
+              )
+            `
+                : ``}
+              ${deletedAt && deletedAt.value == true ? `AND  pd.deleted_at isnull` : ``}
+            GROUP BY
+              i.lock_inventory,
+              p.id,
+              pd.id,
+              pd.packing_type,
+              pd.packing_size,
+              pd.uom,
+              pds.unassigned_qty,
+              pds.unassigned_uom_value
+            UNION 
+            SELECT packing_type, packing_size,'UNIT' AS "uom", name AS "productName", sku AS "productSKU", '-' AS "productBrand", id AS "productId", pbs.product_detail_id AS "productDetailId",
+            COALESCE(MIN(FLOOR(pbs."availableQty")),0) AS "remainQty", 
+            COALESCE(MIN(FLOOR(pbs."availableUomValue")),0) AS "remainUomValue", 
+            CONCAT(COALESCE(MIN(FLOOR(pbs."availableUomValue")),0),' UNIT') AS "remainUomValueWithUom", 
+            COALESCE(MIN(FLOOR(pbs."transferQty")),0) AS "transferQty", 
+            COALESCE(MIN(FLOOR(pbs."transferUomValue")),0) AS "transferUomValue", 
+            'BUNDLE' AS "groupType"
+            FROM product_bundles pb
+            LEFT JOIN (
+              SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
+              (
+                CASE WHEN ((SUM(COALESCE(i2.qty, 0)) - GREATEST(SUM(COALESCE(i2.locked_qty, 0)), 0) - GREATEST(COALESCE(pds2.unassigned_qty, 0), 0) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty)) < 0 THEN 0
+                ELSE (SUM(COALESCE(i2.qty, 0)) - GREATEST(SUM(COALESCE(i2.locked_qty, 0)), 0) - GREATEST(COALESCE(pds2.unassigned_qty, 0), 0) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) END
+              ) AS "availableQty",
+              (
+                CASE WHEN ((SUM(COALESCE(i2.uom_value, 0)) - GREATEST(SUM(COALESCE(i2.locked_uom_value, 0)), 0) - GREATEST(COALESCE(pds2.unassigned_uom_value, 0), 0) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)) < 0 THEN 0
+                ELSE (SUM(COALESCE(i2.uom_value, 0)) - GREATEST(SUM(COALESCE(i2.locked_uom_value, 0)), 0) - GREATEST(COALESCE(pds2.unassigned_uom_value, 0), 0) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty) END
+              ) AS "availableUomValue",
+              (SUM(COALESCE(i2.transfer_qty, 0)) / min(pbs.bundle_qty)) AS "transferQty",
+              (SUM(COALESCE(i2.transfer_uom_value, 0)) / min(pbs.bundle_qty)) AS "transferUomValue",
+              pbs.product_detail_id
+              FROM product_bundle_settings pbs 
+              LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id AND i2.domain_id = $1 AND i2.status = 'STORED'
+              LEFT JOIN product_detail_stocks pds2 ON pds2.product_detail_id = pbs.product_detail_id
+              INNER JOIN locations l2 ON i2.location_id = l2.id                
+              LEFT JOIN oi ON oi.product_id = i2.product_id
+              WHERE l2.type NOT IN ('${warehouse_base_1.LOCATION_TYPE.QUARANTINE}', '${warehouse_base_1.LOCATION_TYPE.RESERVE}', '${warehouse_base_1.LOCATION_TYPE.DAMAGE}')
+              and i2.obsolete = false
+              ${inventoryBizplaceFilter ? `AND i2.bizplace_id = '${inventoryBizplaceFilter.value}'` : ``}
+              GROUP BY 
+                pbs.product_id, 
+                pbs.product_bundle_id,
+                pbs.product_detail_id,
+                pds2.unassigned_qty,
+                pds2.unassigned_uom_value
+            ) pbs ON pbs.product_bundle_id = pb.id
+            ${bundleWhereClause}
+            AND pb.bizplace_id IN (${bizplaceIds}) 
+            ${productFilter
+                ? `AND (
+              lower(pb.sku) ilike '${productFilter.value}'
+              OR lower(pb.name) ilike '${productFilter.value}'
+              OR lower(pb.description) ilike '${productFilter.value}'
+              )
+            `
+                : ``}
+            GROUP BY 
+              pb.packing_type, 
+              pb.packing_size, 
+              pb.name, 
+              pb.sku, 
+              pb.id,
+              pbs.product_detail_id
+          )
+          AS inv_prod_grp 
+          ${whereClause}
+          order by "productSKU", "productName"
+        )
+      `;
+            await trxMgr.query(queryStrings, [domain.id]);
+            const [{ total }] = await trxMgr.query(`select count(*) as total from temp_inventory_product_group`);
+            let items = [];
+            if (params === null || params === void 0 ? void 0 : params.pagination) {
+                items = await trxMgr.query(`select * from temp_inventory_product_group OFFSET $1 LIMIT $2`, [
+                    (params.pagination.page - 1) * params.pagination.limit,
+                    params.pagination.limit
+                ]);
+            }
+            else {
+                items = await trxMgr.query(`select * from temp_inventory_product_group`);
+            }
+            await trxMgr.query(`drop table temp_inventory_product_group`);
+            return { items, total };
+        }
+        catch (error) {
+            throw error;
+        }
+    },
+    /**
+     * Get all available product belonging to list of bizplaces
+     * @param {[Object]} bizplaces
+     * @param {Object} params
+     * @param {Object} context
+     * @param {Object} trxMgr
+     * @returns { object } {items, total}
+     */
+    async bizplaceInventoryProductGroup(bizplaces, params, context, trxMgr) {
+        var _a;
+        try {
+            let filters = params.filters;
+            const { domain } = context.state;
+            const { bizplaceIds, productWhereClause, bundleWhereClause, whereClause, batchBundle } = await getConditions(bizplaces, filters, trxMgr);
+            let cycleCountFilter = (_a = filters.find(filter => filter.name == 'cycleCount')) === null || _a === void 0 ? void 0 : _a.value;
+            const _groupType = filters.find(res => res.name == 'groupType');
+            let queryStrings = `
+        CREATE TEMP TABLE temp_inventory_product_group AS (
+          SELECT * FROM (
+              SELECT
+                  i.batch_id AS "batchId",
+                  i.batch_id_ref AS "batchIdRef",
+                  i.packing_type AS "packingType",
+                  i.packing_size AS "packingSize",
+                  i.uom AS "uom",
+                  CONCAT(p.name, ' (', p.description, ')') AS "productName",
+                  COALESCE(p.sku, '') AS "productSKU",
+                  COALESCE(p.brand, '') AS "productBrand",
+                  p.id AS "productId",
+                  p.is_inventory_decimal AS "isInventoryDecimal",
+                  i.product_detail_id AS "productDetailId",
+                  SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) - SUM(COALESCE(pds.unassigned_qty, 0)) AS "remainQty",
+                  SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0)) AS "remainUomValue",
+                  SUM(COALESCE(i.locked_qty, 0)) AS "lockedQty",
+                  CONCAT(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0)), ' ', i.uom) AS "remainUomValueWithUom",
+                  'SINGLE' AS "groupType",
+                  SUM(COALESCE(pds.unassigned_qty, 0)) AS "unassignedQty"
+              FROM inventories i
+              LEFT JOIN products p ON i.product_id = p.id
+              LEFT JOIN product_detail_stocks pds ON pds.product_detail_id = i.product_detail_id
+              LEFT JOIN (
+                  SELECT
+                      pbs.product_id,
+                      SUM(pbs.bundle_qty * src.release_qty) AS bundle_product_release_qty,
+                      SUM(pbs.bundle_qty * src.release_uom_value) AS bundle_product_release_uom_value 
+                  FROM product_bundle_settings pbs
+                  INNER JOIN json_populate_recordset(NULL::order_inventories,'${batchBundle}') src ON src.product_id = pbs.product_bundle_id
+                  GROUP BY pbs.product_id
+              ) bp ON i.product_id = bp.product_id
+              LEFT JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
+              WHERE i.domain_id = $1
+              AND l2.type NOT IN ('${warehouse_base_1.LOCATION_TYPE.QUARANTINE}', '${warehouse_base_1.LOCATION_TYPE.RESERVE}', '${warehouse_base_1.LOCATION_TYPE.DAMAGE}')
+              AND i.obsolete = false
+              AND i.transfer_qty <= 0
+              AND i.transfer_uom_value <= 0
+              AND i.lock_inventory is not true
+              AND CASE WHEN i.expiration_date IS NOT NULL AND p.min_outbound_shelf_life IS NOT NULL THEN CURRENT_DATE < i.expiration_date - p.min_outbound_shelf_life ELSE true END
+               ${cycleCountFilter
+                ? `AND i.id NOT IN (
+                    SELECT DISTINCT(ici.inventory_id) FROM worksheets w
+                    INNER JOIN worksheet_details wd ON wd.worksheet_id = w.id
+                    INNER JOIN inventory_check_items ici ON wd.target_inventory_check_item_id = ici.id
+                    WHERE w.type IN ('CYCLE_COUNT','CYCLE_COUNT_RECHECK')
+                    AND w.status != 'DONE'
+                    AND w.bizplace_id IN (${bizplaceIds})
+                    AND w.domain_id = '${domain.id}'
+                    )`
+                : `AND true`}
+              ${productWhereClause}
+              GROUP BY
+                  i.product_detail_id,
+                  i.batch_id,
+                  i.batch_id_ref,
+                  p.id,
+                  i.packing_type,
+                  i.packing_size,
+                  i.uom
+              UNION
+              SELECT
+                  'BUNDLE' AS "batchId",
+                  NULL AS "batchIdRef",
+                  pb.packing_type,
+                  pb.packing_size,
+                  'UNIT' AS "uom",
+                  pb.name AS "productName",
+                  pb.sku AS "productSKU",
+                  'brand' AS "productBrand",
+                  id AS "productId",
+                  false AS "isInventoryDecimal",
+                  pbs.product_detail_id AS "productDetailId",
+                  MIN(FLOOR(pbs."availableQty")) AS "remainQty", 
+                  MIN(FLOOR(pbs."availableUomValue")) AS "remainUomValue", 
+                  MIN(FLOOR(pbs."releaseQty")) AS "lockedQty", 
+                  CONCAT(MIN(FLOOR(pbs."availableUomValue")), ' UNIT') AS "remainUomValueWithUom",
+                  'BUNDLE' AS "groupType",
+                  0 AS "unassignedQty"
+              FROM product_bundles pb
+              INNER JOIN (
+                  SELECT
+                      pbs.product_id,
+                      pbs.product_bundle_id,
+                      MIN(pbs.bundle_qty),
+                      (SUM(COALESCE(i2.qty, 0)) - GREATEST(SUM(COALESCE(i2.locked_qty, 0)), 0)) / MIN(pbs.bundle_qty) AS "availableQty",
+                      (SUM(COALESCE(i2.uom_value, 0)) - GREATEST(SUM(COALESCE(i2.locked_uom_value, 0)), 0)) / MIN(pbs.bundle_qty)  AS "availableUomValue",
+                      (SUM(COALESCE(i2.locked_qty, 0))) / min(pbs.bundle_qty) AS "releaseQty",
+                      pbs.product_detail_id
+                  FROM product_bundle_settings pbs 
+                  LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id 
+                  AND i2.domain_id = $1
+                  AND i2.bizplace_id IN (${bizplaceIds})
+                  AND i2.status = 'STORED'
+                  GROUP BY pbs.product_id, pbs.product_bundle_id, pbs.product_detail_id
+              ) pbs ON pbs.product_bundle_id = pb.id
+              ${bundleWhereClause}
+              GROUP BY pb.packing_type, pb.packing_size, pb.name, pb.sku, pb.id, pbs.product_detail_id
+          ) AS inv_prod_grp
+          ${whereClause}
+        )
+      `;
+            let filterGroupTypeQuery;
+            if (_groupType) {
+                if (_groupType.value === 'SINGLE') {
+                    filterGroupTypeQuery = `where "groupType"= 'SINGLE' `;
+                }
+                else {
+                    filterGroupTypeQuery = `where "groupType"= 'BUNDLE' `;
+                }
+            }
+            let sortingArr = params.sortings || [];
+            let sortedBy = [];
+            if (sortingArr.length > 0) {
+                sortingArr.forEach(element => {
+                    if (element.desc) {
+                        sortedBy.push(`"${element.name}" DESC `);
+                    }
+                    else {
+                        sortedBy.push(`"${element.name}" `);
+                    }
+                });
+            }
+            await trxMgr.query(queryStrings, [domain.id]);
+            const [{ total }] = await trxMgr.query(`select count(*) as total from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''}`);
+            let items = [];
+            if (params === null || params === void 0 ? void 0 : params.pagination) {
+                items = await trxMgr.query(`select * from temp_inventory_product_group  ${filterGroupTypeQuery ? filterGroupTypeQuery : ''} ${sortingArr.length > 0 ? ' Order by ' + sortedBy.toString() : ''} OFFSET $1 LIMIT $2`, [(params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]);
+            }
+            await trxMgr.query(`drop table temp_inventory_product_group`);
+            return { items, total };
+        }
+        catch (error) {
+            throw error;
+        }
+    },
+    async bizplaceInventoryProductGroupImport(bizplaces, params, context, trxMgr) {
+        try {
+            let filters = params.filters;
+            const { domain } = context.state;
+            const { bizplaceIds, productWhereClause, bundleWhereClause, whereClause, batchBundle } = await getConditions(bizplaces, filters, trxMgr);
+            let queryStrings = `
+        CREATE TEMP TABLE temp_inventory_product_group AS (
+          SELECT * FROM (
+              SELECT
+                  i.batch_id AS "batchId",
+                  i.batch_id_ref AS "batchIdRef",
+                  i.packing_type AS "packingType",
+                  i.packing_size AS "packingSize",
+                  i.uom AS "uom",
+                  CONCAT(p.name, ' (', p.description, ')') AS "productName",
+                  COALESCE(p.sku, '') AS "productSKU",
+                  COALESCE(p.brand, '') AS "productBrand",
+                  p.id AS "productId",
+                  p.is_inventory_decimal AS "isInventoryDecimal",
+                  i.product_detail_id AS "productDetailId",
+                  p.picking_strategy AS "pickingStrategy",
+                  i.created_at AS "createdAt", 
+                  i.expiration_date AS "expirationDate", 
+                  i.manufacture_date AS "manufactureDate", 
+                  l2.name AS "name",  
+                  l2.zone AS "zone", 
+                  l2.row AS "row", 
+                  l2.column AS "column", 
+                  l2.shelf AS "shelf", 
+                  SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) - SUM(COALESCE(pds.unassigned_qty, 0)) AS "remainQty",
+                  SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0)) AS "remainUomValue",
+                  SUM(COALESCE(i.locked_qty, 0)) AS "lockedQty",
+                  CONCAT(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0)), ' ', i.uom) AS "remainUomValueWithUom",
+                  SUM(COALESCE(pds.unassigned_qty, 0)) AS "unassignedQty"
+              FROM inventories i
+              LEFT JOIN products p ON i.product_id = p.id
+              LEFT JOIN product_detail_stocks pds ON pds.product_detail_id = i.product_detail_id
+              LEFT JOIN (
+                  SELECT
+                      pbs.product_id,
+                      SUM(pbs.bundle_qty * src.release_qty) AS bundle_product_release_qty,
+                      SUM(pbs.bundle_qty * src.release_uom_value) AS bundle_product_release_uom_value 
+                  FROM product_bundle_settings pbs
+                  INNER JOIN json_populate_recordset(NULL::order_inventories,'${batchBundle}') src ON src.product_id = pbs.product_bundle_id
+                  GROUP BY pbs.product_id
+              ) bp ON i.product_id = bp.product_id
+              LEFT JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
+              WHERE i.domain_id = $1
+              AND l2.type NOT IN ('${warehouse_base_1.LOCATION_TYPE.QUARANTINE}', '${warehouse_base_1.LOCATION_TYPE.RESERVE}', '${warehouse_base_1.LOCATION_TYPE.DAMAGE}')
+              AND i.obsolete = false
+              AND i.transfer_qty <= 0
+              AND i.transfer_uom_value <= 0
+              AND i.lock_inventory is not true
+              AND CASE WHEN i.expiration_date IS NOT NULL AND p.min_outbound_shelf_life IS NOT NULL THEN CURRENT_DATE < i.expiration_date - p.min_outbound_shelf_life ELSE true END
+              ${productWhereClause}
+              GROUP BY
+                  i.product_detail_id,
+                  i.batch_id,
+                  i.batch_id_ref,
+                  p.id,
+                  i.packing_type,
+                  i.packing_size,
+                  i.uom,
+                  i.created_at, 
+                  i.expiration_date, 
+                  i.manufacture_date,
+                  l2.name,
+                  l2.zone, 
+                  l2.row, 
+                  l2.column, 
+                  l2.shelf 
+              UNION
+              SELECT
+                  'BUNDLE' AS "batchId",
+                  NULL AS "batchIdRef",
+                  pb.packing_type,
+                  pb.packing_size,
+                  'UNIT' AS "uom",
+                  pb.name AS "productName",
+                  pb.sku AS "productSKU",
+                  'brand' AS "productBrand",
+                  id AS "productId",
+                  false AS "isInventoryDecimal",
+                  pbs.product_detail_id AS "productDetailId",
+                  NULL AS "pickingStrategy",
+                  NULL AS "createdAt",
+                  NULL AS "expirationDate", 
+                  NULL AS "manufactureDate",
+                  NULL AS "name",
+                  NULL AS "zone",
+                  NULL AS "row",
+                  NULL AS "column",
+                  NULL AS "shelf",
+                  MIN(FLOOR(pbs."availableQty")) AS "remainQty", 
+                  MIN(FLOOR(pbs."availableUomValue")) AS "remainUomValue", 
+                  MIN(FLOOR(pbs."releaseQty")) AS "lockedQty", 
+                  CONCAT(MIN(FLOOR(pbs."availableUomValue")), ' UNIT') AS "remainUomValueWithUom",
+                  0 AS "unassignedQty"
+              FROM product_bundles pb
+              INNER JOIN (
+                  SELECT
+                      pbs.product_id,
+                      pbs.product_bundle_id,
+                      MIN(pbs.bundle_qty),
+                      (SUM(COALESCE(i2.qty, 0)) - GREATEST(SUM(COALESCE(i2.locked_qty, 0)), 0)) / MIN(pbs.bundle_qty) AS "availableQty",
+                      (SUM(COALESCE(i2.uom_value, 0)) - GREATEST(SUM(COALESCE(i2.locked_uom_value, 0)), 0)) / MIN(pbs.bundle_qty)  AS "availableUomValue",
+                      (SUM(COALESCE(i2.locked_qty, 0))) / min(pbs.bundle_qty) AS "releaseQty",
+                      pbs.product_detail_id
+                  FROM product_bundle_settings pbs 
+                  LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id 
+                  AND i2.domain_id = $1
+                  AND i2.bizplace_id IN (${bizplaceIds})
+                  AND i2.status = 'STORED'
+                  GROUP BY pbs.product_id, pbs.product_bundle_id, pbs.product_detail_id
+              ) pbs ON pbs.product_bundle_id = pb.id
+              ${bundleWhereClause}
+              GROUP BY pb.packing_type, pb.packing_size, pb.name, pb.sku, pb.id, pbs.product_detail_id
+          ) AS inv_prod_grp
+          ${whereClause}
+        )
+      `;
+            const inventoryAssignmentSetting = await trxMgr.getRepository(setting_base_1.Setting).findOne({
+                where: { domain, name: 'rule-for-inventory-assignment' }
+            });
+            const getLocationSortingClause = (inventoryAssignmentSetting) => {
+                let locationSortingRules = [];
+                if (inventoryAssignmentSetting) {
+                    try {
+                        let locationSetting = JSON.parse(inventoryAssignmentSetting.value);
+                        for (const key in locationSetting) {
+                            locationSortingRules.push({ name: key, desc: locationSetting[key] !== 'ASC' });
+                        }
+                    }
+                    catch (error) {
+                        console.error('Invalid JSON in inventoryAssignmentSetting:', error);
+                    }
+                }
+                if (locationSortingRules.length) {
+                    return locationSortingRules
+                        .map(rule => `
+            CASE
+              WHEN "pickingStrategy" = 'LOCATION' THEN "${rule.name}"
+            END ${rule.desc ? 'DESC' : 'ASC'}
+          `)
+                        .join(',\n');
+                }
+                return `
+          CASE
+            WHEN "pickingStrategy" = 'LOCATION' THEN "name"
+          END ASC
+        `;
+            };
+            await trxMgr.query(queryStrings, [domain.id]);
+            const total = 0;
+            let items = [];
+            if (!(params === null || params === void 0 ? void 0 : params.pagination)) {
+                const orderByClause = `
+              ORDER BY
+          ${getLocationSortingClause(inventoryAssignmentSetting)},
+          CASE
+              WHEN "pickingStrategy" = 'LIFO' THEN "createdAt"
+              ELSE NULL
+          END DESC,
+          CASE
+              WHEN "pickingStrategy" = 'FIFO' THEN "createdAt"
+              WHEN "pickingStrategy" = 'FEFO' THEN "expirationDate"
+              WHEN "pickingStrategy" = 'FMFO' THEN "manufactureDate"
+              ELSE "createdAt"
+          END ASC,
+          -- Add this secondary sort for when primary sort values are equal
+          CASE
+              WHEN "pickingStrategy" = 'FEFO' THEN "createdAt"
+              WHEN "pickingStrategy" = 'FMFO' THEN "createdAt"
+              ELSE NULL
+          END ASC
+          `;
+                items = await trxMgr.query(`select * from temp_inventory_product_group  ${orderByClause}`);
+            }
+            await trxMgr.query(`drop table temp_inventory_product_group`);
+            return { items, total };
+        }
+        catch (error) {
+            throw error;
+        }
+    },
+    async inventoryProductGroupOpenAPI(bizplaces, params, context, trxMgr) {
+        try {
+            let filters = params.filters;
+            const { domain } = context.state;
+            const { apiWhereClause } = await getConditions(bizplaces, filters, trxMgr);
+            let queryStrings = `
+      CREATE TEMP TABLE temp_inventory_product_group_open_api AS (
+        SELECT * FROM (
+          WITH oi as (
+            SELECT
+              SUM(oi.release_qty) AS release_qty,
+              SUM(oi.release_uom_value) AS release_uom_value,
+              oi.product_id,
+              p.name AS product_name,
+              oi.packing_type,
+              oi.packing_size,
+              oi.uom
+            FROM
+              order_inventories oi
+            LEFT JOIN
+              products p
+            ON
+              oi.product_id = p.id
+            WHERE
+              (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
+              AND oi.product_id NOTNULL
+              AND oi.packing_type NOTNULL
+              AND oi.packing_size NOTNULL
+              AND oi.inventory_id IS NULL
+            GROUP BY
+              oi.product_id,
+              oi.packing_type,
+              oi.packing_size,
+              oi.uom,
+              p.name
+          )
+          SELECT
+            i.packing_type AS "packingType",
+            i.packing_size AS "packingSize",
+            i.uom AS "uom",
+            concat(p.name, ' (', p.description, ')') AS "productName",
+            coalesce(p.sku, '') AS "productSKU",
+            coalesce(p.brand, '') AS "productBrand",
+            p.id AS "productId",
+            SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) AS "remainQty",
+            SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) AS "remainUomValue",
+            SUM(COALESCE(i.qty, 0)) AS "totalQty",
+            SUM(COALESCE(i.uom_value, 0)) AS "totalUomValue",
+            SUM(COALESCE(i.locked_qty, 0)) + MAX(COALESCE(oi.release_qty, 0)) AS "totalLockedQty",
+            SUM(COALESCE(i.locked_uom_value, 0)) + MAX(COALESCE(oi.release_uom_value, 0)) AS "totalLockedUomValue",
+            concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)), ' ', i.uom) AS "remainUomValueWithUom"
+          FROM inventories i
+          LEFT JOIN products p ON i.product_id = p.id
+          LEFT JOIN oi ON p.name = oi.product_name AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
+          LEFT JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
+          WHERE i.domain_id = $1
+          AND l2.type NOT IN ('${warehouse_base_1.LOCATION_TYPE.QUARANTINE}', '${warehouse_base_1.LOCATION_TYPE.RESERVE}')
+          AND i.obsolete = false
+          AND case when i.expiration_date is not null and p.min_outbound_shelf_life is not null then CURRENT_DATE < i.expiration_date - p.min_outbound_shelf_life else true end
+          ${apiWhereClause}
+          GROUP BY
+          p.id,
+          i.packing_type,
+          i.packing_size,
+          i.uom
+        )
+        AS inv_prod_grp
+      )
+    `;
+            await trxMgr.query(queryStrings, [domain.id]);
+            const [{ total }] = await trxMgr.query(`select count(*) as total from temp_inventory_product_group_open_api`);
+            let items = [];
+            if (params === null || params === void 0 ? void 0 : params.pagination) {
+                items = await trxMgr.query(`select * from temp_inventory_product_group_open_api OFFSET $1 LIMIT $2`, [
+                    (params.pagination.page - 1) * params.pagination.limit,
+                    params.pagination.limit
+                ]);
+            }
+            else {
+                items = await trxMgr.query(`select * from temp_inventory_product_group_open_api`);
+            }
+            await trxMgr.query(`drop table temp_inventory_product_group_open_api`);
+            return { items, total };
+        }
+        catch (error) {
+            throw error;
+        }
+    },
+    /**
+     * Validate warehouse partners product quantity
+     * @param {Object} warehouseDomain -
+     * @param {Object} partnerBizplace - {id}
+     * @param {Object} orderInventories - [{id, qty}]
+     * @param {Object} context
+     * @param {Object} trxMgr
+     */
+    async validateWarehousePartnersProductsQuantity(warehouseDomain, partnerBizplace, orderInventories, context, trxMgr) {
+        let validOrderInventories = orderInventories.filter(oi => (oi === null || oi === void 0 ? void 0 : oi.isError) !== true);
+        if (!validOrderInventories.length) {
+            return;
+        }
+        let json_oi = JSON.stringify(validOrderInventories.map(x => {
+            return {
+                product_detail_id: x.productDetail.id,
+                batch_id: x.batchId.replace(/'/g, `''`),
+                release_qty: x.releaseQty,
+                uom: x.uom
+            };
+        }));
+        let resultQb = await trxMgr.query(`
+      select joi.product_detail_id as "productDetailId", joi.batch_id as "batchId", joi.uom as "uom", joi.release_qty as "releaseQty",
+      sum(i.qty - coalesce(i.locked_qty,0)) - coalesce(
+      (
+        select sum(oi.release_qty) from order_inventories oi 
+        where (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
+        and oi.inventory_id IS null
+        and oi.product_detail_id = joi.product_detail_id
+        and oi.batch_id = joi.batch_id
+        and oi.uom = joi.uom
+        and oi.domain_id = $1
+        and oi.bizplace_id = $2
+      ),0) as "availableQty",
+      sum(i.uom_value - coalesce(i.locked_uom_value ,0)) - coalesce(
+      (
+        select sum(oi.release_uom_value) from order_inventories oi 
+        where (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
+        and oi.inventory_id IS null
+        and oi.product_detail_id = joi.product_detail_id
+        and oi.batch_id = joi.batch_id
+        and oi.uom = joi.uom
+        and oi.domain_id = $1
+        and oi.bizplace_id = $2
+      ),0) as "availableUomValue"
+      from json_populate_recordset(NULL::order_inventories,'${json_oi}') joi
+      left join inventories i on joi.product_detail_id = i.product_detail_id 
+      and joi.batch_id = i.batch_id
+      and i.status ='STORED'
+      and i.lock_inventory is not true
+      and joi.uom = i.uom
+      and i.domain_id = $1
+      and i.bizplace_id = $2
+      group by joi.product_detail_id, joi.batch_id, joi.packing_type, joi.release_qty, joi.uom
+    `, [warehouseDomain.id, partnerBizplace.id]);
+        resultQb.forEach(itm => {
+            if (parseFloat(itm.releaseQty) > parseFloat(itm.availableQty)) {
+                throw new errors_1.ValidationError(Object.assign(Object.assign({}, errors_1.ValidationError.ERROR_CODES.RELEASE_QTY_OVER_LIMIT), { detail: { data: JSON.stringify(resultQb) } }));
+            }
+        });
+    },
+    async checkPalletDuplication(palletId, warehouseDomain, trxMgr) {
+        const duplicatedPalletCnt = await trxMgr.getRepository(warehouse_base_1.Inventory).count({
+            domain: warehouseDomain,
+            palletId,
+            status: (0, typeorm_1.Not)((0, typeorm_1.Equal)(warehouse_base_1.INVENTORY_STATUS.TERMINATED))
+        });
+        if (duplicatedPalletCnt)
+            throw new Error(palletId + ` exists`);
+        const duplicatedReusablePalletCnt = await trxMgr.getRepository(warehouse_base_1.Pallet).count({
+            where: {
+                domain: warehouseDomain,
+                name: palletId
+            }
+        });
+        if (duplicatedReusablePalletCnt)
+            throw new Error(palletId + ` exists`);
+    },
+    /**
+     * To pre-assign inventories automatically for orderInventories in Release Goods
+     * @param product
+     * @param orderInventory
+     * @param packingType
+     * @param locationSortingRules
+     * @param customerBizplace
+     * @param domain
+     * @param trxMgr
+     * @returns orderInventories
+     */
+    async autoAssignInventoryForRelease(orderInventory, product, productDetail, locationSortingRules = [], customerBizplace, domain, trxMgr, batchId, preferLocation = null, recall = null, cartonId, expirationDate) {
+        let strictProduct = 'false';
+        if (!(customerBizplace === null || customerBizplace === void 0 ? void 0 : customerBizplace.domain)) {
+            let bizplace = await trxMgr.getRepository(biz_base_1.Bizplace).findOne({
+                where: { id: customerBizplace.id },
+                relations: ['domain']
+            });
+            customerBizplace.domain = bizplace.domain;
+        }
+        const strictProductSelectionSetting = await trxMgr.getRepository(setting_base_1.Setting).findOne({
+            where: { domain, category: 'id-rule', name: 'strict-product-selection' }
+        });
+        if (strictProductSelectionSetting)
+            strictProduct = strictProductSelectionSetting.value;
+        const partnerStrictProductSelectionSetting = await trxMgr.getRepository(setting_base_1.PartnerSetting).findOne({
+            where: { setting: strictProductSelectionSetting, domain, partnerDomain: customerBizplace === null || customerBizplace === void 0 ? void 0 : customerBizplace.domain }
+        });
+        if (partnerStrictProductSelectionSetting)
+            strictProduct = partnerStrictProductSelectionSetting.value;
+        let locationTypes = [warehouse_base_1.LOCATION_TYPE.QUARANTINE, warehouse_base_1.LOCATION_TYPE.RESERVE];
+        if (recall === false) {
+            locationTypes.push(warehouse_base_1.LOCATION_TYPE.DAMAGE);
+        }
+        let qb = trxMgr.getRepository(warehouse_base_1.Inventory).createQueryBuilder('iv');
+        qb.innerJoinAndSelect('iv.location', 'loc')
+            .innerJoin('warehouse_inventory_assignment_rankings', 'wiar', '"wiar"."location_type" = "loc"."type"')
+            .innerJoin('iv.product', 'p')
+            .andWhere('"iv"."domain_id" = :domainId')
+            .andWhere('"iv"."bizplace_id" = :bizplaceId')
+            .andWhere('"iv"."status" = :status')
+            .andWhere('"iv"."qty" - COALESCE("iv"."locked_qty", 0) > 0')
+            .andWhere('"loc"."type" NOT IN (:...locationTypes)')
+            .andWhere('"iv"."obsolete" = false')
+            .andWhere('"iv"."transfer_qty" <= 0')
+            .andWhere('"iv"."transfer_uom_value" <= 0')
+            .andWhere('"iv"."product_id" = :productId')
+            .andWhere('case when "iv"."expiration_date" is not null and "p"."min_outbound_shelf_life" is not null then CURRENT_DATE < "iv"."expiration_date" - "p"."min_outbound_shelf_life" else true end')
+            .setParameters({
+            domainId: domain.id,
+            bizplaceId: customerBizplace.id,
+            productId: product.id,
+            status: warehouse_base_1.INVENTORY_STATUS.STORED,
+            locationTypes
+        });
+        if (batchId) {
+            qb.andWhere('"iv"."batch_id" = :batchId', { batchId });
+        }
+        if (cartonId) {
+            qb.andWhere('"iv"."carton_id" = :cartonId', { cartonId });
+        }
+        if (expirationDate) {
+            qb.andWhere('"iv"."expiration_date" = :expirationDate', { expirationDate });
+        }
+        if (preferLocation) {
+            qb.andWhere('"loc"."type" = :preferLocation', { preferLocation });
+        }
+        if (strictProduct == 'true' || preferLocation == 'STORAGE') {
+            qb.andWhere('"iv"."product_detail_id" = :productDetailId', { productDetailId: productDetail.id });
+        }
+        else {
+            qb.andWhere('"iv"."packing_type" = :packingType', { packingType: orderInventory.packingType })
+                .andWhere('"iv"."packing_size" = :packingSize', { packingSize: orderInventory.packingSize })
+                .andWhere('"iv"."uom" = :uom', { uom: orderInventory.uom });
+        }
+        let locationSorting = function (qb, locationSortingRules) {
+            if (locationSortingRules === null || locationSortingRules === void 0 ? void 0 : locationSortingRules.length) {
+                locationSortingRules.forEach((rule, idx) => {
+                    idx === 0
+                        ? qb.addOrderBy(`loc.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+                        : qb.addOrderBy(`loc.${rule.name}`, rule.desc ? 'DESC' : 'ASC');
+                });
+            }
+            else {
+                qb.addOrderBy('"loc"."name"', 'ASC');
+                qb.addOrderBy('"iv"."created_at"', 'ASC');
+            }
+            return qb;
+        };
+        qb.addOrderBy('"wiar"."rank"', 'ASC');
+        switch (product === null || product === void 0 ? void 0 : product.pickingStrategy) {
+            case 'FIFO':
+                qb.addOrderBy('"iv"."created_at"', 'ASC');
+                qb = locationSorting(qb, locationSortingRules);
+                break;
+            case 'LIFO':
+                qb.addOrderBy('"iv"."created_at"', 'DESC');
+                qb = locationSorting(qb, locationSortingRules);
+                break;
+            case 'FEFO':
+                qb.addOrderBy('"iv"."expiration_date"', 'ASC');
+                qb.addOrderBy('"iv"."created_at"', 'ASC');
+                qb = locationSorting(qb, locationSortingRules);
+                break;
+            case 'FMFO':
+                qb.addOrderBy('"iv"."manufacture_date"', 'ASC');
+                qb.addOrderBy('"iv"."created_at"', 'ASC');
+                qb = locationSorting(qb, locationSortingRules);
+                break;
+            case 'LOCATION':
+                qb = locationSorting(qb, locationSortingRules);
+                break;
+            default:
+                qb.addOrderBy('"iv"."created_at"', 'ASC');
+                qb = locationSorting(qb, locationSortingRules);
+                break;
+        }
+        let inventories = await qb.getMany();
+        if (!(inventories === null || inventories === void 0 ? void 0 : inventories.length))
+            throw new Error(`no inventories found for ${product.sku}`);
+        inventories = inventories.map(inventory => {
+            return Object.assign(Object.assign({}, inventory), { remainQty: inventory.qty - ((inventory === null || inventory === void 0 ? void 0 : inventory.lockedQty) || 0), remainUomValue: inventory.uomValue - ((inventory === null || inventory === void 0 ? void 0 : inventory.lockedUomValue) || 0) });
+        });
+        return _composeTargetInventories(product, productDetail, orderInventory, inventories);
+    },
+    /**
+     * @summary Do transaction on inventory record
+     * @description It will update inventory after set a temp (domain, updater)
+     * and then generate inventory history based on current changes
+     */
+    async transactionInventory(inventory, referenceOrder, changedQty, changedWeight, transactionType, user, trxMgr) {
+        if (inventory.id) {
+            inventory = await updateInventory(inventory, trxMgr);
+        }
+        else {
+            inventory = await createInventory(inventory, trxMgr);
+        }
+        await (0, warehouse_base_1.generateInventoryHistory)(inventory, referenceOrder, transactionType, changedQty, changedWeight, user, trxMgr);
+        return inventory;
+    }
+};
+async function getConditions(bizplaces, filters, trxMgr, hasRemainingQty = true) {
+    var _a;
+    let bizplaceIds = bizplaces.map((bizplace) => `'${bizplace.id}'`).join();
+    let productWhereClause = `
+    AND i.status = 'STORED'
+    AND i.bizplace_id IN (${bizplaceIds})
+  `;
+    let apiWhereClause = `
+    AND i.bizplace_id IN (${bizplaceIds})
+  `;
+    let bundleWhereClause = `
+    WHERE pb.status = 'ACTIVATED'
+  `;
+    // Find the showAllInventory filter
+    const showAllInventoryFilter = filters.find(filter => filter.name === 'showAllInventory');
+    const showAllInventory = showAllInventoryFilter ? showAllInventoryFilter.value : false;
+    // Set the whereClause based on the showAllInventory value
+    let whereClause = showAllInventory ? ` WHERE 1 = 1 ` : hasRemainingQty ? ` WHERE "remainQty" > 0 ` : ` WHERE 1 = 1 `;
+    let productDetailWhereClause = ``;
+    let batchBundle;
+    if (filters === null || filters === void 0 ? void 0 : filters.length) {
+        await Promise.all(filters.map(async (filter) => {
+            const name = filter.name;
+            const operator = filter.operator.toLowerCase();
+            let value = filter.value;
+            let flatValue;
+            switch (name) {
+                case 'productId':
+                    if (operator == 'in')
+                        flatValue = value.flat();
+                    whereClause += `AND "productId" ${operator === 'in' ? 'IN' : 'NOT IN'} (${flatValue
+                        .map(itm => {
+                        return `'${itm}'`;
+                    })
+                        .join(',')})`;
+                    break;
+                case 'productBundleId':
+                    if (operator == 'in')
+                        whereClause += `AND "productId" ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
+                            .map(itm => {
+                            return `'${itm}'`;
+                        })
+                            .join(',')})`;
+                    break;
+                case 'batchId':
+                    let batchId = `${value}`;
+                    whereClause += `AND LOWER("batchId") LIKE '${batchId.replace(`'`, `''`).toLowerCase()}'`;
+                    break;
+                case 'batchIdRef':
+                    whereClause += `AND LOWER("batchIdRef") LIKE '${value.toLowerCase()}'`;
+                    break;
+                case 'productBrand':
+                    whereClause += `AND LOWER("productBrand") LIKE '${value.toLowerCase()}'`;
+                    break;
+                case 'productSKU':
+                    whereClause += `AND LOWER("productSKU") LIKE '${value.toLowerCase()}'`;
+                case 'productName':
+                    const products = await trxMgr.getRepository(product_base_1.Product).find({
+                        select: ['id'],
+                        where: [
+                            {
+                                bizplace: (0, typeorm_1.In)(bizplaces.map((bizplace) => bizplace.id)),
+                                name: (0, typeorm_1.Raw)((alias) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`)
+                            },
+                            {
+                                bizplace: (0, typeorm_1.In)(bizplaces.map((bizplace) => bizplace.id)),
+                                sku: (0, typeorm_1.Raw)((alias) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`)
+                            },
+                            {
+                                bizplace: (0, typeorm_1.In)(bizplaces.map((bizplace) => bizplace.id)),
+                                description: (0, typeorm_1.Raw)((alias) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`)
+                            }
+                        ]
+                    });
+                    const productIds = products
+                        .map((product) => product.id)
+                        .map((id) => `'${id}'`)
+                        .join();
+                    if (productIds.length) {
+                        productWhereClause += `AND i.product_id IN (${productIds})`;
+                    }
+                    else {
+                        productWhereClause += `AND i.product_id ISNULL`;
+                    }
+                    // filter product bundle as product info
+                    const productBundles = await trxMgr.getRepository(product_base_1.ProductBundle).find({
+                        select: ['id'],
+                        where: [
+                            {
+                                bizplace: (0, typeorm_1.In)(bizplaces.map((bizplace) => bizplace.id)),
+                                name: (0, typeorm_1.Raw)((alias) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`)
+                            },
+                            {
+                                bizplace: (0, typeorm_1.In)(bizplaces.map((bizplace) => bizplace.id)),
+                                sku: (0, typeorm_1.Raw)((alias) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`)
+                            },
+                            {
+                                bizplace: (0, typeorm_1.In)(bizplaces.map((bizplace) => bizplace.id)),
+                                description: (0, typeorm_1.Raw)((alias) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`)
+                            }
+                        ]
+                    });
+                    const productBundleIds = productBundles
+                        .map((bundle) => bundle.id)
+                        .map((id) => `'${id}'`)
+                        .join();
+                    if (productBundleIds.length) {
+                        bundleWhereClause += `AND pb.id IN (${productBundleIds})`;
+                    }
+                    else {
+                        bundleWhereClause += `AND pb.id ISNULL`;
+                    }
+                    break;
+                case 'packingType':
+                    whereClause += `AND LOWER("packingType") LIKE '${value.toLowerCase()}'`;
+                    break;
+                case 'showBundle':
+                    whereClause += `AND LOWER("groupType") LIKE 'bundle'`;
+                    break;
+                case 'hideBundle':
+                    whereClause += `AND LOWER("groupType") LIKE 'single'`;
+                    break;
+                case 'batch_product':
+                    productWhereClause += `
+              AND (i.batch_id, p.id, i.packing_type, i.packing_size) ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
+                        .map((v) => `('${v.batchId.replace(`'`, `''`)}', '${v.productId}', '${v.packingType}', '${v.packingSize}')`)
+                        .join()})
+            `;
+                    break;
+                case 'batch_bundle':
+                    bundleWhereClause += `
+              ${bundleWhereClause == '' ? 'WHERE' : 'AND'} pb.id ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
+                        .map((v) => `('${v.productId}')`)
+                        .join()})
+            `;
+                    break;
+                case 'product':
+                    productDetailWhereClause += `
+              AND (pd.product_id, pd.packing_type, pd.packing_size, pd.uom) ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
+                        .map((v) => `('${v.productId}', '${v.packingType}', '${v.packingSize}', '${v.uom}')`)
+                        .join()})
+            `;
+                    break;
+            }
+        }));
+        batchBundle = JSON.stringify(((_a = filters
+            .find(filter => filter.name === 'batch_bundle')) === null || _a === void 0 ? void 0 : _a.value.map(itm => {
+            return {
+                product_id: itm.productId,
+                release_qty: (itm === null || itm === void 0 ? void 0 : itm.releaseQty) || 0,
+                release_uom_value: (itm === null || itm === void 0 ? void 0 : itm.releaseUomValue) || 0
+            };
+        })) || []);
+    }
+    return {
+        bizplaceIds,
+        productWhereClause,
+        apiWhereClause,
+        bundleWhereClause,
+        whereClause,
+        batchBundle,
+        productDetailWhereClause
+    };
+}
+async function createInventory(inventory, trxMgr) {
+    return await trxMgr.getRepository(warehouse_base_1.Inventory).save(inventory);
+}
+/**
+ * @summary Update inventory record
+ * @description It will update inventory after set a stamp (domain, updater)
+ * The special point of this function is that this changes won't generate inventory history
+ * If you want to generate inventory history automatically you would better to use transactionInventory function
+ */
+async function updateInventory(inventory, trxMgr) {
+    if (!inventory.id)
+        throw new Error(`Target doesn't have ID`);
+    return await trxMgr.getRepository(warehouse_base_1.Inventory).save(inventory);
+}
+/**
+ * @description: Check location emptiness and update status of location
+ * @param domain
+ * @param location
+ * @param updater
+ * @param trxMgr
+ */
+async function switchLocationStatus(domain, location, updater, trxMgr) {
+    const invRepo = (trxMgr === null || trxMgr === void 0 ? void 0 : trxMgr.getRepository(warehouse_base_1.Inventory)) || (0, typeorm_1.getRepository)(warehouse_base_1.Inventory);
+    const locationRepo = (trxMgr === null || trxMgr === void 0 ? void 0 : trxMgr.getRepository(warehouse_base_1.Location)) || (0, typeorm_1.getRepository)(warehouse_base_1.Location);
+    const allocatedItemsCnt = await invRepo.count({
+        domain,
+        status: warehouse_base_1.INVENTORY_STATUS.STORED,
+        location
+    });
+    if (!allocatedItemsCnt && location.status !== warehouse_base_1.LOCATION_STATUS.EMPTY) {
+        location = await locationRepo.save(Object.assign(Object.assign({}, location), { status: warehouse_base_1.LOCATION_STATUS.EMPTY, updater }));
+    }
+    else if (allocatedItemsCnt && location.status === warehouse_base_1.LOCATION_STATUS.EMPTY) {
+        location = await locationRepo.save(Object.assign(Object.assign({}, location), { status: warehouse_base_1.LOCATION_STATUS.OCCUPIED, updater }));
+    }
+    return location;
+}
+exports.switchLocationStatus = switchLocationStatus;
+function _composeTargetInventories(product, productDetail, record, inventories) {
+    let leftReleaseQty = record.releaseQty;
+    let leftReleaseUomValue = record.releaseUomValue;
+    let compReleaseQty = 0;
+    let compReleaseUomValue = 0;
+    let totalInventoryQty = inventories.reduce((total, inventory) => total + inventory.remainQty, 0);
+    if (!product)
+        product = productDetail.product;
+    if (totalInventoryQty < record.releaseQty) {
+        throw new Error(`invalid release qty for ${product === null || product === void 0 ? void 0 : product.sku}`);
+    }
+    let orderInventories = [];
+    let idx = 0;
+    while (compReleaseQty < record.releaseQty) {
+        const inventory = inventories[idx];
+        const { packingType, packingSize, batchId, batchIdRef, uom } = inventory;
+        let orderInventory = new service_1.OrderInventory();
+        if (inventory.remainQty > leftReleaseQty) {
+            const uomValuePerQty = Math.round((inventory.remainUomValue / inventory.remainQty) * 1000) / 1000;
+            compReleaseQty += leftReleaseQty;
+            compReleaseUomValue += leftReleaseUomValue;
+            orderInventory = Object.assign(Object.assign({}, orderInventory), { releaseQty: leftReleaseQty, releaseUomValue: Math.round(leftReleaseQty * uomValuePerQty * 1000) / 1000 });
+        }
+        else {
+            compReleaseQty += inventory.remainQty;
+            compReleaseUomValue += inventory.remainUomValue;
+            leftReleaseQty -= inventory.remainQty;
+            leftReleaseUomValue -= inventory.remainUomValue;
+            orderInventory = Object.assign(Object.assign({}, orderInventory), { releaseQty: inventory.remainQty, releaseUomValue: inventory.remainUomValue });
+        }
+        orderInventories.push(Object.assign(Object.assign(Object.assign({}, record), orderInventory), { inventory,
+            packingType,
+            packingSize,
+            batchId,
+            batchIdRef,
+            uom,
+            product,
+            productDetail, type: constants_1.ORDER_TYPES.RELEASE_OF_GOODS }));
+        idx++;
+    }
+    return orderInventories;
+}
+exports._composeTargetInventories = _composeTargetInventories;
+//# sourceMappingURL=inventory-util.js.map