@things-factory/sales-base 8.0.2 → 8.0.5

package/server/utils/inventory-util.ts

@@ -1,1155 +0,0 @@
-import { EntityManager, Equal, In, Not, Raw, Repository, SelectQueryBuilder } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Product, ProductBundle } from '@things-factory/product-base'
-import { Domain, Filter, getRepository, ListParam } from '@things-factory/shell'
-import {
-  Inventory,
-  INVENTORY_STATUS,
-  InventoryHistory,
-  InventoryNoGenerator,
-  Location,
-  LOCATION_STATUS,
-  LOCATION_TYPE,
-  Pallet
-} from '@things-factory/warehouse-base'
-
-import { ORDER_TYPES } from '../constants'
-import { ValidationError } from '../errors'
-import {
-  ArrivalNotice,
-  DeliveryOrder,
-  InventoryCheck,
-  OrderInventory,
-  ReleaseGood,
-  ReturnOrder,
-  ReverseKittingOrder,
-  VasOrder
-} from '../service'
-
-export type ReferenceOrderType =
-  | ArrivalNotice
-  | ReleaseGood
-  | VasOrder
-  | InventoryCheck
-  | DeliveryOrder
-  | ReturnOrder
-  | ReverseKittingOrder
-
-export const 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: Bizplace[],
-    params: ListParam,
-    context: ResolverContext,
-    trxMgr: EntityManager
-  ) {
-    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 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",
-              COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)),0) AS "remainQty",
-              COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)),0) AS "remainUomValue",
-              concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', pd.uom) AS "remainUomValueWithUom",
-              'SINGLE' AS "groupType"
-            FROM products p
-            INNER join product_details pd on pd.product_id = p.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 ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
-              AND i.domain_id = $1 AND i.status = 'STORED'
-              ${inventoryBizplaceFilter ? `AND i.bizplace_id = '${inventoryBizplaceFilter.value}'` : ``}
-            ) i ON i.product_id = pd.product_id
-            AND i.packing_type = pd.packing_type 
-            and i.packing_size = pd.packing_size 
-            and i.uom = pd.uom 
-            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 p.bizplace_id IN (${bizplaceIds})
-              ${productDetailWhereClause}
-              ${
-                productFilter
-                  ? `AND (
-                lower(p.sku) ilike '${productFilter.value}'
-                OR lower(p.name) ilike '${productFilter.value}'
-                OR lower(p.description) ilike '${productFilter.value}'
-              )
-            `
-                  : ``
-              }
-            GROUP BY
-              p.id,
-              pd.packing_type,
-              pd.packing_size,
-              pd.uom
-            UNION 
-            SELECT packing_type, packing_size,'UNIT' AS "uom", name AS "productName", sku AS "productSKU", '-' AS "productBrand", id AS "productId",
-            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", 
-            'BUNDLE' AS "groupType"
-            FROM product_bundles pb
-            LEFT JOIN (
-              SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
-              (SUM(COALESCE(i2.qty, 0)) - SUM(COALESCE(i2.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
-              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue"
-              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'
-              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 ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
-              ${inventoryBizplaceFilter ? `AND i2.bizplace_id = '${inventoryBizplaceFilter.value}'` : ``}
-              GROUP BY 
-                pbs.product_id, 
-                pbs.product_bundle_id
-            ) 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
-          )
-          AS inv_prod_grp 
-          ${whereClause}
-          order by "productSKU", "productName"
-        )
-      `
-
-      await trxMgr.query(queryStrings, [domain.id])
-
-      const [{ total }]: any = await trxMgr.query(`select count(*) as total from temp_inventory_product_group`)
-      let items: any[] = []
-
-      if (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`)
-      }
-
-      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: Bizplace[],
-    params: ListParam,
-    context: ResolverContext,
-    trxMgr: EntityManager
-  ) {
-    try {
-      let filters = params.filters
-      const { domain } = context.state
-
-      const { bizplaceIds, productWhereClause, bundleWhereClause, whereClause, batchBundle } = await getConditions(
-        bizplaces,
-        filters,
-        trxMgr
-      )
-
-      const _groupType = filters.find(res => res.name == 'groupType')
-
-      let queryStrings = `
-        CREATE TEMP TABLE temp_inventory_product_group AS (
-          SELECT * FROM (
-            WITH oi as (
-              SELECT
-                round(cast(SUM(oi.release_qty) as numeric), 3) AS release_qty,
-                round(cast(SUM(oi.release_uom_value) as numeric), 3) 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
-              i.batch_id AS "batchId",
-              i.batch_id_ref AS "batchIdRef",
-              i.packing_type AS "packingType",
-              i.packing_size AS "packingSize",
-              i.pallet_id as "palletId",
-              i.created_at as "createdAt",
-              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",
-              ROUND(cast(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) as numeric), 3) AS "remainQty",
-              ROUND(cast(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) as numeric), 3) AS "remainUomValue",
-              concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', i.uom) AS "remainUomValueWithUom",
-              'SINGLE' AS "groupType",
-              i.expiration_date as "expirationDate"
-            FROM
-              inventories i
-              LEFT JOIN products p ON i.product_id = p.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 locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_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
-            WHERE i.domain_id = $1
-            AND l2.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
-            ${productWhereClause}
-            GROUP BY
-            i.batch_id,
-            i.batch_id_ref,
-            p.id,
-            i.packing_type,
-            i.packing_size,
-            i.expiration_date,
-            i.pallet_id,
-            i.created_at,
-            i.uom
-            UNION 
-            SELECT 'BUNDLE' AS "batchId", null as "batchIdRef", packing_type, packing_size, null AS "palletId", null AS "createdAt", 'UNIT' AS "uom", name AS "productName", sku AS "productSKU", 'brand' AS "productBrand", id AS "productId",
-            MIN(FLOOR(pbs."availableQty")) AS "remainQty", 
-            MIN(FLOOR(pbs."availableUomValue")) AS "remainUomValue", 
-            CONCAT(MIN(FLOOR(pbs."availableUomValue")),' UNIT') AS "remainUomValueWithUom",
-            'BUNDLE' AS "groupType",
-            pbs."expirationDate" as "expirationDate"
-            FROM product_bundles pb
-            INNER JOIN (
-              SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
-              (SUM(COALESCE(i2.qty, 0)) - SUM(COALESCE(i2.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
-              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue", i2.expiration_date as "expirationDate"
-              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'
-              LEFT JOIN oi ON oi.product_id = i2.product_id
-              GROUP BY pbs.product_id, pbs.product_bundle_id, i2.expiration_date
-            ) pbs ON pbs.product_bundle_id = pb.id
-            ${bundleWhereClause}
-            GROUP BY pb.packing_type, pb.packing_size, pb.name, pb.sku, pb.id, pbs."expirationDate"
-          )
-          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 }]: any = await trxMgr.query(
-        `select count(*) as total from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''}`
-      )
-      let items: any[] = []
-
-      if (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]
-        )
-      } else {
-        items = await trxMgr.query(
-          `select * from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''} ${
-            sortingArr.length > 0 ? ' Order by ' + sortedBy.toString() : ''
-          }`
-        )
-      }
-
-      await trxMgr.query(`drop table temp_inventory_product_group`)
-
-      return { items, total }
-    } catch (error) {
-      throw error
-    }
-  },
-
-  async inventoryProductGroupOpenAPI(
-    bizplaces: Bizplace[],
-    params: ListParam,
-    context: ResolverContext,
-    trxMgr: EntityManager
-  ) {
-    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 ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
-          ${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 }]: any = await trxMgr.query(`select count(*) as total from temp_inventory_product_group_open_api`)
-      let items: any[] = []
-
-      if (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: Domain,
-    partnerBizplace: Bizplace,
-    orderInventories: OrderInventory[],
-    context: any,
-    trxMgr?: EntityManager
-  ): Promise<void> {
-    let json_oi = JSON.stringify(
-      orderInventories.map(x => {
-        return {
-          product_id: x.product.id,
-          batch_id: x.batchId,
-          packing_type: x.packingType,
-          release_qty: x.releaseQty,
-          uom: x.uom
-        }
-      })
-    )
-
-    let resultQb = await trxMgr.query(
-      `
-      select joi.product_id as "productId", joi.batch_id as "batchId", joi.packing_type as "packingType", joi.uom as "uom", joi.release_qty as "releaseQty",
-      ROUND(cast(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_id = joi.product_id
-        and oi.batch_id = joi.batch_id
-        and oi.packing_type = joi.packing_type
-        and oi.uom = joi.uom
-        and oi.domain_id = $1
-        and oi.bizplace_id = $2
-      ),0) as numeric), 3) as "availableQty",
-      ROUND(cast(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_id = joi.product_id
-        and oi.batch_id = joi.batch_id
-        and oi.packing_type = joi.packing_type
-        and oi.uom = joi.uom
-        and oi.domain_id = $1
-        and oi.bizplace_id = $2
-      ),0) as numeric), 3) as "availableUomValue"
-      from json_populate_recordset(NULL::order_inventories,'${json_oi}') joi
-      left join inventories i on joi.product_id = i.product_id 
-      and joi.batch_id = i.batch_id
-      and joi.packing_type = i.packing_type and i.status ='STORED'
-      and joi.uom = i.uom
-      and i.domain_id = $1
-      and i.bizplace_id = $2
-      group by joi.product_id, joi.batch_id, joi.packing_type, joi.release_qty, joi.uom
-    `,
-      [warehouseDomain.id, partnerBizplace.id]
-    )
-
-    resultQb.forEach(itm => {
-      if (itm.releaseQty > itm.availableQty) {
-        throw new ValidationError({
-          ...ValidationError.ERROR_CODES.RELEASE_QTY_OVER_LIMIT,
-          detail: { data: JSON.stringify(resultQb) }
-        })
-      }
-    })
-  },
-
-  async checkPalletDuplication(palletId: string, warehouseDomain: Domain, trxMgr: EntityManager): Promise<void> {
-    const duplicatedPalletCnt: number = await trxMgr.getRepository(Inventory).countBy({
-      domain: { id: warehouseDomain.id },
-      palletId,
-      status: Not(Equal(INVENTORY_STATUS.TERMINATED))
-    })
-
-    if (duplicatedPalletCnt) throw new Error(palletId + ` exists`)
-
-    const duplicatedReusablePalletCnt: number = await trxMgr.getRepository(Pallet).count({
-      where: {
-        domain: { id: warehouseDomain.id },
-        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(
-    product: Product,
-    orderInventory: OrderInventory,
-    packingType: string,
-    locationSortingRules: any = [],
-    customerBizplace: Bizplace,
-    domain: Domain,
-    trxMgr: EntityManager,
-    batchId?: string
-  ): Promise<OrderInventory[]> {
-    let qb: SelectQueryBuilder<Inventory> = trxMgr.getRepository(Inventory).createQueryBuilder('iv')
-    qb.leftJoinAndSelect('iv.location', 'loc')
-      .andWhere('"iv"."domain_id" = :domainId')
-      .andWhere('"iv"."bizplace_id" = :bizplaceId')
-      .andWhere('"iv"."packing_type" = :packingType')
-      .andWhere('"iv"."product_id" = :productId')
-      .andWhere('"iv"."status" = :status')
-      .andWhere('"iv"."qty" - COALESCE("iv"."locked_qty", 0) > 0')
-      .andWhere('"loc"."type" NOT IN (:...locationTypes)')
-      .setParameters({
-        domainId: domain.id,
-        bizplaceId: customerBizplace.id,
-        packingType: packingType,
-        productId: product.id,
-        status: INVENTORY_STATUS.STORED,
-        locationTypes: [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
-      })
-
-    if (batchId) {
-      qb.andWhere('"iv"."batch_id" = :batchId', { batchId: batchId })
-    }
-
-    let locationSorting = function (qb: SelectQueryBuilder<Inventory>, locationSortingRules) {
-      if (locationSortingRules?.length) {
-        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
-          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
-    }
-
-    switch (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: Inventory[] = await qb.getMany()
-    if (!inventories?.length) throw new Error(`no inventories found for ${product.sku}`)
-
-    inventories = inventories.map(inventory => {
-      return {
-        ...inventory,
-        remainQty: inventory.qty - (inventory?.lockedQty || 0),
-        remainUomValue: inventory.uomValue - (inventory?.lockedUomValue || 0)
-      }
-    })
-
-    return _composeTargetInventories(product, 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: Inventory,
-    referenceOrder: ReferenceOrderType,
-    changedQty: number,
-    changedWeight: number,
-    transactionType: string,
-    user: User,
-    trxMgr: EntityManager
-  ): Promise<Inventory> {
-    if (inventory.id) {
-      inventory = (await updateInventory(inventory, trxMgr)) as any
-    } else {
-      inventory = (await createInventory(inventory, trxMgr)) as any
-    }
-
-    await generateInventoryHistory(inventory, referenceOrder, transactionType, changedQty, changedWeight, user, trxMgr)
-
-    return inventory
-  }
-}
-
-interface Conditions {
-  bizplaceIds: string
-  productWhereClause: string
-  bundleWhereClause: string
-  whereClause: string
-  batchBundle: string
-  apiWhereClause: string
-  productDetailWhereClause: string
-}
-
-async function getConditions(
-  bizplaces: Bizplace[],
-  filters: Filter[],
-  trxMgr: EntityManager,
-  hasRemainingQty: Boolean = true
-): Promise<Conditions> {
-  let bizplaceIds = bizplaces.map((bizplace: 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'
-  `
-
-  let whereClause = hasRemainingQty ? ` WHERE "remainQty" > 0` : ` WHERE 1 = 1`
-
-  let productDetailWhereClause = ``
-
-  let batchBundle: string
-  if (filters?.length) {
-    await Promise.all(
-      filters.map(async (filter: { name: string; operator: string; value: any }) => {
-        const name = filter.name
-        const operator = filter.operator.toLowerCase()
-        let value = filter.value
-
-        switch (name) {
-          case 'productId':
-            if (operator == 'in')
-              whereClause += `AND "productId" ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
-                .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':
-            whereClause += `AND LOWER("batchId") LIKE '${value.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: Product[] = await trxMgr.getRepository(Product).find({
-              select: ['id'],
-              where: [
-                {
-                  bizplace: In(bizplaces.map((bizplace: Bizplace) => bizplace.id)),
-                  name: Raw(
-                    (alias: string) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`
-                  )
-                },
-                {
-                  bizplace: In(bizplaces.map((bizplace: Bizplace) => bizplace.id)),
-                  sku: Raw(
-                    (alias: string) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`
-                  )
-                },
-                {
-                  bizplace: In(bizplaces.map((bizplace: Bizplace) => bizplace.id)),
-                  description: Raw(
-                    (alias: string) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`
-                  )
-                }
-              ]
-            })
-
-            const productIds: string = products
-              .map((product: Product) => product.id)
-              .map((id: string) => `'${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: ProductBundle[] = await trxMgr.getRepository(ProductBundle).find({
-              select: ['id'],
-              where: [
-                {
-                  bizplace: In(bizplaces.map((bizplace: Bizplace) => bizplace.id)),
-                  name: Raw(
-                    (alias: string) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`
-                  )
-                },
-                {
-                  bizplace: In(bizplaces.map((bizplace: Bizplace) => bizplace.id)),
-                  sku: Raw(
-                    (alias: string) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`
-                  )
-                },
-                {
-                  bizplace: In(bizplaces.map((bizplace: Bizplace) => bizplace.id)),
-                  description: Raw(
-                    (alias: string) => `LOWER(${alias}) LIKE '${value.toLowerCase().trim().replace(/'/g, "''")}'`
-                  )
-                }
-              ]
-            })
-
-            const productBundleIds: string = productBundles
-              .map((bundle: ProductBundle) => bundle.id)
-              .map((id: string) => `'${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: { batchId: string; productId: string; packingType: string; packingSize: string }) =>
-                    `('${v.batchId}', '${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: { productId: string }) => `('${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: { productId: string; packingType: string; packingSize: string; uom: string }) =>
-                    `('${v.productId}', '${v.packingType}', '${v.packingSize}', '${v.uom}')`
-                )
-                .join()})
-            `
-            break
-        }
-      })
-    )
-
-    batchBundle = JSON.stringify(
-      filters
-        .find(filter => filter.name === 'batch_bundle')
-        ?.value.map(itm => {
-          return {
-            product_id: itm.productId,
-            release_qty: itm?.releaseQty || 0,
-            release_uom_value: itm?.releaseUomValue || 0
-          }
-        }) || []
-    )
-  }
-
-  return {
-    bizplaceIds,
-    productWhereClause,
-    apiWhereClause,
-    bundleWhereClause,
-    whereClause,
-    batchBundle,
-    productDetailWhereClause
-  }
-}
-
-async function createInventory(
-  inventory: Partial<Inventory> | Partial<Inventory>[],
-  trxMgr: EntityManager
-): Promise<Inventory | Inventory[]> {
-  return await trxMgr.getRepository(Inventory).save(inventory as 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: Partial<Inventory> | Partial<Inventory>[],
-  trxMgr: EntityManager
-): Promise<Partial<Inventory> | Partial<Inventory>[]> {
-  if (!(inventory as any).id) throw new Error(`Target doesn't have ID`)
-  return await trxMgr.getRepository(Inventory).save(inventory as Inventory)
-}
-
-async function generateInventoryHistory(
-  inventory: Inventory,
-  refOrder: any,
-  transactionType: string,
-  qty: number,
-  uomValue: number,
-  user: User,
-  trxMgr?: EntityManager
-): Promise<InventoryHistory> {
-  const invHistoryRepo: Repository<InventoryHistory> =
-    trxMgr?.getRepository(InventoryHistory) || getRepository(InventoryHistory)
-  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
-
-  if (!inventory?.id) throw new Error(`Can't find out ID of inventory.`)
-  if (!refOrder?.id || !refOrder.name) throw new Error(`Can't find out ID or Name of Reference Order`)
-  if (
-    !inventory?.domain ||
-    !inventory?.bizplace ||
-    !inventory?.product?.id ||
-    !inventory?.warehouse?.id ||
-    !inventory?.location?.id
-  ) {
-    inventory = await invRepo.findOne({
-      where: { id: inventory.id },
-      relations: ['domain', 'bizplace', 'product', 'warehouse', 'location']
-    })
-  }
-
-  const domain: Domain = inventory.domain
-  const location: Location = inventory.location
-
-  const seq: number = await invHistoryRepo.countBy({
-    domain: { id: inventory.domain.id },
-    palletId: inventory.palletId
-  })
-  let openingQty: number = 0
-  let openingUomValue: number = 0
-
-  if (seq) {
-    const lastInvHistory: InventoryHistory = await invHistoryRepo.findOneBy({
-      domain: { id: inventory.domain.id },
-      palletId: inventory.palletId,
-      seq: seq - 1
-    })
-    openingQty = lastInvHistory.openingQty + lastInvHistory.qty
-    openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
-  }
-
-  let inventoryHistory: InventoryHistory = new InventoryHistory()
-  inventoryHistory.name = InventoryNoGenerator.inventoryHistoryName()
-  inventoryHistory.description = inventory.description
-  inventoryHistory.seq = seq
-  inventoryHistory.palletId = inventory.palletId
-  inventoryHistory.cartonId = inventory.cartonId
-  inventoryHistory.batchId = inventory.batchId
-  inventoryHistory.batchIdRef = inventory.batchIdRef
-  inventoryHistory.status = inventory.status
-  inventoryHistory.transactionType = transactionType
-  inventoryHistory.refOrderId = refOrder?.id || null
-  inventoryHistory.orderNo = refOrder?.name || null
-  inventoryHistory.orderRefNo = refOrder?.refNo || null
-  inventoryHistory.inventory = inventory
-  inventoryHistory.product = inventory.product
-  inventoryHistory.reusablePallet = inventory.reusablePallet
-  inventoryHistory.zone = inventory.zone
-  inventoryHistory.warehouse = inventory.warehouse
-  inventoryHistory.location = inventory.location
-  inventoryHistory.expirationDate = inventory.expirationDate
-  inventoryHistory.packingType = inventory.packingType
-  inventoryHistory.packingSize = inventory.packingSize
-  inventoryHistory.uom = inventory.uom
-  inventoryHistory.qty = qty
-  inventoryHistory.openingQty = openingQty
-  inventoryHistory.uomValue = uomValue
-  inventoryHistory.openingUomValue = openingUomValue
-  inventoryHistory.unitCost = inventory.unitCost
-  inventoryHistory.domain = inventory.domain
-  inventoryHistory.bizplace = inventory.bizplace
-  inventoryHistory.creator = user
-  inventoryHistory.updater = user
-
-  inventoryHistory = await invHistoryRepo.save(inventoryHistory)
-
-  if (inventory.lastSeq !== seq) {
-    await invRepo.save({
-      ...inventory,
-      lastSeq: inventoryHistory.seq,
-      updater: user
-    })
-  }
-
-  await switchLocationStatus(domain, location, user, trxMgr)
-  return inventoryHistory
-}
-
-/**
- * @description: Check location emptiness and update status of location
- * @param domain
- * @param location
- * @param updater
- * @param trxMgr
- */
-export async function switchLocationStatus(
-  domain: Domain,
-  location: Location,
-  updater: User,
-  trxMgr?: EntityManager
-): Promise<Location> {
-  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
-  const locationRepo: Repository<Location> = trxMgr?.getRepository(Location) || getRepository(Location)
-  const allocatedItemsCnt: number = await invRepo.countBy({
-    domain: { id: domain.id },
-    status: INVENTORY_STATUS.STORED,
-    location: { id: location.id }
-  })
-
-  if (!allocatedItemsCnt && location.status !== LOCATION_STATUS.EMPTY) {
-    location = await locationRepo.save({
-      ...location,
-      status: LOCATION_STATUS.EMPTY,
-      updater
-    })
-  } else if (allocatedItemsCnt && location.status === LOCATION_STATUS.EMPTY) {
-    location = await locationRepo.save({
-      ...location,
-      status: LOCATION_STATUS.OCCUPIED,
-      updater
-    })
-  }
-
-  return location
-}
-
-export function _composeTargetInventories(product: Product, record: any, inventories: Inventory[]): OrderInventory[] {
-  let leftReleaseQty: number = record.releaseQty
-  let leftReleaseUomValue: number = record.releaseUomValue
-  let compReleaseQty: number = 0
-  let compReleaseUomValue: number = 0
-  let totalInventoryQty: number = inventories.reduce((total, inventory) => total + inventory.remainQty, 0)
-
-  if (totalInventoryQty < record.releaseQty) {
-    throw new Error(`invalid release qty for ${product?.sku}`)
-  }
-
-  let orderInventories: Partial<OrderInventory[]> = []
-  let idx = 0
-  while (compReleaseQty < record.releaseQty) {
-    const inventory = inventories[idx]
-    const {
-      packingType,
-      packingSize,
-      batchId,
-      batchIdRef,
-      uom
-    }: { packingType: string; packingSize: number; batchId: string; batchIdRef: string; uom: string } = inventory
-
-    let orderInventory: OrderInventory = new OrderInventory()
-
-    if (inventory.remainQty > leftReleaseQty) {
-      const uomValuePerQty: number = Math.round((inventory.remainUomValue / inventory.remainQty) * 100) / 100
-
-      compReleaseQty += leftReleaseQty
-      compReleaseUomValue += leftReleaseUomValue
-
-      orderInventory = {
-        ...orderInventory,
-        releaseQty: leftReleaseQty,
-        releaseUomValue: Math.round(leftReleaseQty * uomValuePerQty * 100) / 100
-      }
-    } else {
-      compReleaseQty += inventory.remainQty
-      compReleaseUomValue += inventory.remainUomValue
-      leftReleaseQty -= inventory.remainQty
-      leftReleaseUomValue -= inventory.remainUomValue
-
-      orderInventory = {
-        ...orderInventory,
-        releaseQty: inventory.remainQty,
-        releaseUomValue: inventory.remainUomValue
-      }
-    }
-
-    orderInventories.push({
-      ...orderInventory,
-      inventory,
-      packingType,
-      packingSize,
-      batchId,
-      batchIdRef,
-      uom,
-      product,
-      type: ORDER_TYPES.RELEASE_OF_GOODS
-    })
-
-    idx++
-  }
-
-  return orderInventories
-}