@things-factory/warehouse-base 8.0.0-beta.9 → 8.0.0

package/server/service/inventory/inventory-query.ts

@@ -0,0 +1,1259 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, EntityManager, Equal, Not, OrderByCondition, Repository, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getPartnersCompanyBizplaces, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { Product, ProductBundleSetting } from '@things-factory/product-base'
+import { Setting } from '@things-factory/setting-base'
+import {
+  buildQuery,
+  Domain,
+  Filter,
+  getQueryBuilderFromListParams,
+  getRepository,
+  ListParam,
+  Pagination,
+  Sorting
+} from '@things-factory/shell'
+
+import { INVENTORY_STATUS, LOCATION_TYPE } from '../../constants'
+import { InventoryChange } from '../inventory-change/inventory-change'
+import { Inventory } from './inventory'
+import { InventoryBundleGroupDetail, InventoryList } from './inventory-types'
+
+@Resolver(Inventory)
+export class InventoryQuery {
+  /**
+   * Combined single query resolver to perform extraction of data with or without pagination
+   * @param context
+   * @param filters
+   * @param pagination
+   * @param sortings
+   * @param locationSortingRules
+   * @param exportItem
+   * @returns
+   */
+  @Directive('@privilege(category: "inventory", privilege: "query", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Query(returns => InventoryList)
+  async inventories(
+    @Ctx() context: ResolverContext,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[],
+    @Arg('locationSortingRules', type => [Sorting], { nullable: true }) locationSortingRules?: Sorting[],
+    @Arg('exportItem', type => Boolean, { nullable: true }) exportItem?: Boolean
+  ): Promise<InventoryList> {
+    const { domain, user, tx } = context.state
+    const { page, limit } = pagination || {}
+
+    try {
+      //Define special filters
+      const productFilters = filters.find((filter: any) => filter.name == 'productInfo')
+      const remainOnlyParam = filters.find((filter: any) => filter.name == 'remainOnly')
+      const bizplace = filters.find((filter: any) => filter.name === 'bizplace')
+
+      filters = filters.filter(x => ['productInfo', 'remainOnly'].indexOf(x.name) < 0)
+
+      const params = { filters, pagination }
+
+      const remainOnly: boolean = remainOnlyParam?.value || false
+
+      const qb: SelectQueryBuilder<Inventory> = getQueryBuilderFromListParams({
+        repository: tx.getRepository(Inventory),
+        params,
+        domain,
+        alias: 'inventory',
+        searchables: ['warehouse', 'product', 'batchId', 'location', 'palletId', 'lot']
+      })
+
+      qb.leftJoinAndSelect('inventory.bizplace', 'bizplace')
+        .leftJoinAndSelect('inventory.product', 'product')
+        .leftJoinAndSelect('product.productDetails', 'productDetail', 'productDetail.id = inventory.product_detail_id')
+        .leftJoinAndSelect('inventory.warehouse', 'warehouse')
+        .leftJoinAndSelect('inventory.location', 'location')
+        .leftJoinAndSelect('inventory.creator', 'creator')
+        .leftJoinAndSelect('inventory.updater', 'updater')
+
+      if (!bizplace) {
+        const bizplaces = await getPermittedBizplaceIds(domain, user)
+
+        qb.andWhere(
+          new Brackets(qb => {
+            qb.orWhere('inventory.bizplace_id IN (:...bizplaces)', { bizplaces })
+          })
+        )
+      }
+
+      // To get aggregated serial number in csv and total number of stored serial number
+      qb.leftJoinAndSelect(
+        subQuery => {
+          return subQuery
+            .select('inventoryItems.inventory_id', 'inventory_item_inventory_id')
+            .addSelect(`SUM(case when "inventoryItems"."status" = 'STORED' then 1 else 0 end)`, 'inventory_item_count')
+            .addSelect(`string_agg(inventoryItems.serial_number, ', ')`, 'serial_numbers')
+            .from('inventory_items', 'inventoryItems')
+            .where(`inventoryItems.domain_id = :domainId`, { domainId: domain.id })
+            .andWhere(`inventoryItems.status = :ivicStatus`, { ivicStatus: INVENTORY_STATUS.STORED })
+            .groupBy('inventoryItems.inventory_id')
+        },
+        'inventoryItems',
+        '"inventoryItems"."inventory_item_inventory_id" = "inventory"."id"'
+      )
+
+      // To get inventory with remaining qty
+      if (remainOnly) {
+        qb.andWhere('inventory.qty > 0')
+          .andWhere('CASE WHEN inventory.lockedQty IS NULL THEN 0 ELSE inventory.lockedQty END >= 0')
+          .andWhere('inventory.qty - CASE WHEN inventory.lockedQty IS NULL THEN 0 ELSE inventory.lockedQty END > 0')
+      }
+
+      // Filter based on multiple product parameters and allow to search in csv format
+      if (productFilters) {
+        let productFilterValue = `%${productFilters.value.toLowerCase()}%`
+        qb.andWhere(qb => {
+          const subQuery = qb
+            .subQuery()
+            .select()
+            .from(Product, `products`)
+            .where(`products.id = Inventory.product_id`) // @chrislim Does the uppercase I in Inventory affect? I can see the rest are in lowercase i
+            .andWhere(
+              new Brackets(qb => {
+                qb.where('Lower(products.sku) LIKE :productInfo', { productInfo: productFilterValue })
+                  .orWhere('Lower(products.name) LIKE :productInfo', { productInfo: productFilterValue })
+                  .orWhere('Lower(products.description) LIKE :productInfo', { productInfo: productFilterValue })
+                  .orWhere('Lower(products.brand) LIKE :productInfo', { productInfo: productFilterValue })
+              })
+            )
+            .getQuery()
+          return `EXISTS ${subQuery}`
+        })
+      }
+
+      // Apply sorting based on child data
+      if (sortings?.length !== 0) {
+        const arrChildSortData = ['bizplace', 'product', 'location', 'warehouse', 'zone']
+        const sort: OrderByCondition = (sortings || []).reduce(
+          (acc, sort) => ({
+            ...acc,
+            [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'inventory.' + sort.name]: sort.desc
+              ? 'DESC'
+              : 'ASC'
+          }),
+          {}
+        )
+        qb.orderBy(sort)
+      }
+
+      if (locationSortingRules?.length > 0) {
+        locationSortingRules.forEach(rule => {
+          qb.addOrderBy(`location.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+        })
+      }
+
+      // Fetch all row for exporting
+      if (exportItem != true && page && limit) {
+        qb.offset((page - 1) * limit).limit(limit)
+      }
+
+      let items = (await qb.getRawMany()).map(item => {
+        return {
+          ...new Inventory(item),
+          serialNumbers: item.serial_numbers
+        }
+      })
+      let total = await qb.getCount()
+
+      return {
+        items,
+        total
+      }
+    } catch (error) {
+      logger.error(`inventory-query[inventories]`, error)
+      throw error
+    }
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Inventory)
+  async inventory(@Arg('palletId') palletId: string, @Ctx() context: ResolverContext): Promise<Inventory> {
+    const { domain } = context.state
+
+    return await getRepository(Inventory).findOne({
+      where: { domain: { id: domain.id }, palletId },
+      relations: ['domain', 'bizplace', 'product', 'location', 'warehouse', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Inventory)
+  async inventoryById(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Inventory> {
+    const { domain } = context.state
+
+    return await getRepository(Inventory).findOne({
+      where: { domain: { id: domain.id }, id },
+      relations: ['domain', 'bizplace', 'product', 'location', 'warehouse', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Inventory)
+  async inventoryByPallet(@Arg('palletId') palletId: string, @Ctx() context: ResolverContext): Promise<Inventory> {
+    const { domain } = context.state
+
+    return await getRepository(Inventory).findOne({
+      where: { domain: { id: domain.id }, palletId, status: Not(Equal(INVENTORY_STATUS.TERMINATED)) },
+      relations: ['domain', 'bizplace', 'product', 'location', 'warehouse', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => InventoryList)
+  async renewInventoriesGroupByProduct(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(Inventory),
+      params,
+      alias: 'i',
+      domain,
+      searchables: ['productName', 'productSKU'],
+      filtersMap: {
+        productName: {
+          relationColumn: 'product',
+          columnName: 'name'
+        },
+        productSKU: {
+          relationColumn: 'product',
+          columnName: 'sku'
+        }
+      }
+    })
+
+    queryBuilder
+      .select('product.id', 'productId')
+      .addSelect('product.name', 'productName')
+      .addSelect('product.sku', 'productSKU')
+      .addSelect('product.type', 'productType')
+      .addSelect('product.primaryValue', 'primaryValue')
+      .addSelect('product.primaryUnit', 'primaryUnit')
+      .addSelect('product.auxUnit1', 'auxUnit1')
+      .addSelect('product.minQty', 'minQty')
+      .addSelect('product.maxQty', 'maxQty')
+      .addSelect('i.product_color', 'productColor')
+      .addSelect('i.product_quality', 'productQuality')
+      .addSelect('i.work_category', 'workCategory')
+      .addSelect('i.packing_type', 'packingType')
+      .addSelect('COALESCE(SUM(i.qty), 0)', 'qty')
+      .addSelect('COALESCE(SUM(i.locked_qty), 0)', 'lockedQty')
+      .addSelect('COALESCE(SUM(i.uom_value), 0)', 'uomValue')
+      .addSelect('COALESCE(SUM(i.locked_uom_value), 0)', 'lockedUomValue')
+      .innerJoin('i.product', 'product', 'product.deleted_at IS NULL')
+      .andWhere('i.status = :status', { status: INVENTORY_STATUS.STORED })
+      .andWhere('i.expiration_date >= now()')
+      .andWhere('product.domain_id = :domain', { domain: domain.id })
+      .groupBy('product.id')
+      .addGroupBy('i.product_color')
+      .addGroupBy('i.product_quality')
+      .addGroupBy('i.packing_type')
+      .addGroupBy('i.work_category')
+
+    queryBuilder.orderBy('product.sku', 'ASC')
+
+    const items = await queryBuilder.getRawMany()
+    return { items, total: items.length }
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Query(returns => InventoryList)
+  async inventoriesByProduct(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryList> {
+    try {
+      const { domain, user, tx } = context.state
+      let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
+      const partnersCompanyBizplaces: Bizplace[] = await getPartnersCompanyBizplaces(domain, user)
+
+      const page = params.pagination.page
+      const limit = params.pagination.limit
+
+      let bizplaceFilter = params.filters.find(filter => filter.name == 'bizplace')
+      let productFilter = params.filters.find(filter => filter.name == 'product')
+      let packingTypeFilter = params.filters.find(filter => filter.name == 'packingType')
+      let availableStockFilter = params.filters.find(filter => filter.name == 'availableStock')
+      let lowStockFilter = params.filters.find(filter => filter.name == 'lowStock')
+      let overStockFilter = params.filters.find(filter => filter.name == 'overStock')
+      let quarantineStockFilter = params.filters.find(filter => filter.name == 'quarantineStock')
+      let reserveStockFilter = params.filters.find(filter => filter.name == 'reserveStock')
+      let productTypeFilter = params.filters.find(filter => filter.name == 'type')
+
+      if (bizplaceFilter) {
+        const bizplaceQueryBuilder: SelectQueryBuilder<Bizplace> = getRepository(Bizplace).createQueryBuilder('b')
+        bizplaceQueryBuilder
+          .innerJoin('companies', 'c2', ' c2.domain_id = b.domain_id')
+          .innerJoin('bizplaces', 'b2', 'b2.company_id = c2.id')
+          .where('b2.id = :bizplaceId', { bizplaceId: bizplaceFilter.value })
+
+        let bizplaceList = await bizplaceQueryBuilder.getMany()
+
+        permittedBizplaceIds = [
+          ...permittedBizplaceIds.filter(itm => itm == bizplaceFilter.value),
+          ...bizplaceList.map(bz => bz.id),
+          ...partnersCompanyBizplaces.map(biz => biz.id)
+        ]
+      }
+
+      let bizplaceQuery = ''
+      if (permittedBizplaceIds.length > 0) {
+        bizplaceQuery = `AND EXISTS (
+          SELECT * FROM (VALUES ${permittedBizplaceIds.map(id => `('${id}')`).join(',')})
+          AS bizFilter(bizplace_id)
+          WHERE bizFilter.bizplace_id::uuid = "Inventory"."bizplace_id"
+        )`
+      } else {
+        bizplaceQuery = `1 = 0`
+      }
+
+      let productQuery = ''
+      if (productFilter) {
+        let productValue = productFilter.value
+          .toLowerCase()
+          .split(',')
+          .map(prod => {
+            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+          })
+          .join(',')
+        productQuery = `AND (
+          Lower("Product"."name") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("Product"."sku") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("Product"."brand") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("Product"."description") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("ProductRef"."name") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("ProductRef"."sku") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("ProductRef"."description") LIKE ANY(ARRAY[${productValue}])
+        )`
+      }
+
+      if (productTypeFilter) {
+        let productTypeValue = productTypeFilter.value
+          .toLowerCase()
+          .split(',')
+          .map(prod => {
+            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+          })
+          .join(',')
+        productQuery =
+          productQuery +
+          ` AND (
+          Lower("Product"."type") LIKE ANY(ARRAY[${productTypeValue}])
+        )`
+      }
+
+      let qtyStockQuery = ''
+
+      let availableStockQuery = ''
+
+      if (reserveStockFilter?.value) {
+        qtyStockQuery += `\nAND SUM("reserveQty") > 0`
+      }
+
+      if (quarantineStockFilter?.value) {
+        qtyStockQuery += `\nAND SUM("quarantineQty") > 0`
+      }
+
+      if (availableStockFilter?.value) {
+        qtyStockQuery += ` AND SUM("availableQty") > 0`
+      }
+
+      if (availableStockFilter?.value) {
+        availableStockQuery = ` AND SUM("Inventory"."qty") > 0`
+      }
+
+      if (availableStockFilter?.value && quarantineStockFilter?.value) {
+        qtyStockQuery = ''
+        qtyStockQuery += `\nAND (SUM("availableQty") > 0 \n OR SUM("quarantineQty") > 0)`
+      }
+
+      if (availableStockFilter?.value && reserveStockFilter?.value) {
+        qtyStockQuery = ''
+        qtyStockQuery += `\nAND (SUM("availableQty") > 0 \n OR SUM("reserveQty") > 0)`
+      }
+
+      if (quarantineStockFilter?.value && reserveStockFilter?.value) {
+        qtyStockQuery = ''
+        qtyStockQuery += `\nAND (SUM("quarantineQty") > 0 \n OR SUM("reserveQty") > 0)`
+      }
+
+      let inventoryQuery = ''
+      if (packingTypeFilter) {
+        let packingTypeValue = packingTypeFilter.value
+          .toLowerCase()
+          .split(',')
+          .map(prod => {
+            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+          })
+          .join(',')
+
+        inventoryQuery =
+          inventoryQuery +
+          ` AND (
+          Lower("Inventory"."packing_type") LIKE ANY(ARRAY[${packingTypeValue}])
+        )`
+      }
+
+      let thresholdQuery = ''
+      if (lowStockFilter?.value && overStockFilter?.value) {
+        throw new Error('invalid filter combination')
+      } else if (lowStockFilter?.value && !overStockFilter?.value) {
+        thresholdQuery = `AND SUM(COALESCE("minQty", 0)) > SUM("availableQty")`
+      } else if (!lowStockFilter?.value && overStockFilter?.value) {
+        thresholdQuery = `AND SUM(COALESCE("maxQty", 0)) > 0 AND SUM(COALESCE("maxQty", 0)) < SUM("availableQty")`
+      }
+
+      await tx.query(
+        `
+        CREATE TEMP TABLE order_inventories_by_products AS (
+          SELECT "product_id", "packing_type", sum("release_qty") AS "total_release_qty" FROM order_inventories oi 
+          WHERE "type" = 'RELEASE_OF_GOODS'
+          AND "domain_id" = $1
+          AND "inventory_id" ISNULL
+          AND "status" IN ('PENDING','PENDING_RECEIVE','PENDING_WORKSHEET','READY_TO_PICK'/*, 'PENDING_SPLIT' kiv sebab kalau pending split, ada yang dah assign tapi belum delete*/)
+          GROUP BY "product_id", "packing_type"
+        )`,
+        [domain.id]
+      )
+
+      await tx.query(
+        `
+        create temp table temp_inv_history AS 
+        (
+          SELECT "Product"."id" AS "id", "Product"."sku" AS "sku", "Product"."brand" AS "brand", "Product"."name" AS "name", "Product"."type" AS "type", "Product"."description" AS "description", 
+          "Inventory"."packing_type" AS "packingType",
+          "Product"."weight" AS "weight", "ProductRef"."id" AS "productRefId", 
+          "ProductRef"."description" AS "productRefDesciption", "Bizplace"."id" AS "bizplaceId", "Bizplace"."name" AS "bizplaceName", SUM("Inventory"."qty") AS "qty" ,
+          CASE WHEN SUM("Inventory"."qty") > 0 THEN SUM(COALESCE("Inventory"."unit_cost", 0) * "Inventory"."qty")/ SUM("Inventory"."qty") ELSE 0 END AS "averageUnitCost",
+          COALESCE("ProductDetailBizplaceSetting"."min_qty", "Product"."min_qty",0) AS "minQty", 
+          COALESCE("ProductDetailBizplaceSetting"."max_qty", "Product"."max_qty",0) AS "maxQty",
+          CASE WHEN "Location"."type" NOT IN ('${LOCATION_TYPE.QUARANTINE}','${LOCATION_TYPE.RESERVE}') 
+          THEN 
+          CASE WHEN SUM("Inventory"."qty") > 0 
+          THEN SUM("Inventory"."qty")-SUM(COALESCE("Inventory"."locked_qty", 0) + COALESCE("OrderInventoriesByProduct"."total_release_qty", 0))
+          ELSE 0 END
+          ELSE 0 END AS "availableQty",
+          SUM(COALESCE("Inventory"."locked_qty", 0) + COALESCE("OrderInventoriesByProduct"."total_release_qty", 0)) AS "releaseQty",
+          CASE WHEN "Location"."type" = '${LOCATION_TYPE.QUARANTINE}' 
+          THEN 
+          CASE WHEN SUM("Inventory"."qty") > 0 
+          THEN SUM("Inventory"."qty")-SUM(COALESCE("Inventory"."locked_qty", 0) + COALESCE("OrderInventoriesByProduct"."total_release_qty", 0))
+          ELSE 0 END
+          ELSE 0 END AS "quarantineQty",
+          CASE WHEN "Location"."type" = '${LOCATION_TYPE.RESERVE}' 
+          THEN 
+          CASE WHEN SUM("Inventory"."qty") > 0 
+          THEN SUM("Inventory"."qty")-SUM(COALESCE("Inventory"."locked_qty", 0) + COALESCE("OrderInventoriesByProduct"."total_release_qty", 0))
+          ELSE 0 END
+          ELSE 0 END AS "reserveQty",
+          CASE WHEN "Location"."type" = '${LOCATION_TYPE.BIN}' THEN SUM("Inventory"."qty") ELSE 0 END AS "binQty"
+          FROM "inventories" "Inventory" 
+          LEFT JOIN "products" "Product" ON "Product"."id"="Inventory"."product_id" 
+          LEFT JOIN "product_details" "ProductDetails" ON "ProductDetails"."product_id" = "Product"."id" 
+            AND "ProductDetails"."is_default"
+          LEFT JOIN "product_detail_bizplace_settings" "ProductDetailBizplaceSetting" ON "ProductDetailBizplaceSetting"."product_detail_id" = "ProductDetails"."id" 
+            AND "ProductDetailBizplaceSetting"."domain_id" = "Inventory"."domain_id"
+          LEFT JOIN "products" "ProductRef" ON "ProductRef"."id"="Product"."product_ref_id" 
+          INNER JOIN "bizplaces" "Bizplace" ON "Bizplace"."id"="Inventory"."bizplace_id"
+          INNER JOIN "locations" "Location" ON "Location"."id" = "Inventory"."location_id"
+          LEFT JOIN "order_inventories_by_products" "OrderInventoriesByProduct" 
+          ON "OrderInventoriesByProduct"."product_id" = "Inventory"."product_id"
+          AND "OrderInventoriesByProduct"."packing_type" = "Inventory"."packing_type"
+          WHERE "Inventory"."qty" >= 0
+          AND "Inventory"."status" <> 'MISSING'
+          AND "Inventory"."domain_id" = $1
+          ${bizplaceQuery}
+          ${productQuery}
+          GROUP BY "Product"."id", "Bizplace"."id", "ProductDetailBizplaceSetting"."id", "Inventory"."packing_type", "Location"."type", "ProductRef"."id"
+          HAVING 1 = 1
+          ${availableStockQuery}
+        )`,
+        [domain.id]
+      )
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE grouped_inventories_product AS (
+            SELECT "id", "sku", "brand", "name", "description",
+             "packingType", "bizplaceId", "bizplaceName", sum("averageUnitCost") AS "averageUnitCost",
+		              sum("minQty") AS "minQty", sum("maxQty") AS "maxQty", 
+		              sum("availableQty") AS "availableQty", 
+		              sum("quarantineQty") AS "quarantineQty",
+		              sum("reserveQty") AS "reserveQty", 
+		              sum("releaseQty") AS "releaseQty",
+		              sum("availableQty" + "quarantineQty"  + "releaseQty" +  "reserveQty" - "binQty") AS "warehouseQty" 
+	            FROM temp_inv_history
+	            GROUP BY "id", "sku", "brand", "name", "description", "packingType", "bizplaceId", "bizplaceName"
+	            HAVING 1=1  
+            ${qtyStockQuery}
+            ${thresholdQuery}
+          )
+        `
+      )
+      const results: any = await tx.query(
+        `
+          SELECT * FROM grouped_inventories_product
+          ORDER BY "bizplaceName", "sku"
+          OFFSET $1 LIMIT $2
+        `,
+        [(page - 1) * limit, limit]
+      )
+
+      const total: any = await tx.query(`SELECT COUNT(*) FROM grouped_inventories_product`)
+
+      await tx.query(`drop table temp_inv_history, order_inventories_by_products, grouped_inventories_product`)
+
+      return {
+        items: results.map((item: any) => {
+          return {
+            product: {
+              id: item.id,
+              name: item.name,
+              sku: item.sku,
+              brand: item.brand,
+              description: item.description,
+              minQty: item.minQty,
+              maxQty: item.maxQty
+            },
+            bizplace: {
+              id: item.bizplaceId,
+              name: item.bizplaceName
+            },
+            packingType: item.packingType,
+            averageUnitCost: item.averageUnitCost,
+            availableQty: item.availableQty,
+            releaseQty: item.releaseQty,
+            quarantineQty: item.quarantineQty,
+            reserveQty: item.reserveQty,
+            warehouseQty: item.warehouseQty
+          }
+        }),
+        total: total[0].count
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Directive('@transaction')
+  @Query(returns => InventoryList)
+  async inventoriesByStrategy(
+    @Ctx() context: ResolverContext,
+    @Arg('worksheetId') worksheetId: string,
+    @Arg('batchId') batchId: string,
+    @Arg('productName') productName: string,
+    @Arg('productSku') productSku: string,
+    @Arg('packingType') packingType: string,
+    @Arg('packingSize') packingSize: number,
+    @Arg('uom') uom: string,
+    @Arg('pickingStrategy') pickingStrategy: string,
+    @Arg('locationSortingRules', type => [Sorting], { nullable: true }) locationSortingRules?: Sorting[],
+    @Arg('bizplaceId', { nullable: true }) bizplaceId?: string
+  ): Promise<InventoryList> {
+    const { domain, tx } = context.state
+
+    const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain: { id: domain.id }, name: 'rule-for-inventory-assignment' }
+    })
+
+    if (!locationSortingRules && inventoryAssignmentSetting) {
+      locationSortingRules = []
+      let locationSetting = JSON.parse(inventoryAssignmentSetting.value)
+      for (const key in locationSetting) {
+        locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
+      }
+    }
+
+    return inventoriesByStrategy(
+      {
+        worksheetId,
+        batchId,
+        bizplaceId,
+        productName,
+        productSku,
+        packingType,
+        packingSize,
+        uom,
+        pickingStrategy,
+        locationSortingRules
+      },
+      tx
+    )
+  }
+
+  @Directive('@transaction')
+  @Query(returns => Boolean)
+  async checkProductIdenticality(
+    @Arg('palletA') palletA: string,
+    @Arg('palletB') palletB: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { tx } = context.state
+    const invRepo: Repository<Inventory> = tx.getRepository(Inventory)
+    const invA: Inventory = await invRepo.findOne({
+      where: { domain: { id: context.state.domain.id }, palletId: palletA, status: INVENTORY_STATUS.STORED },
+      relations: ['product']
+    })
+
+    const invB: Inventory = await invRepo.findOne({
+      where: { domain: { id: context.state.domain.id }, palletId: palletB, status: INVENTORY_STATUS.STORED },
+      relations: ['product']
+    })
+
+    return (
+      invA?.batchId === invB?.batchId &&
+      invA?.product?.id === invB?.product?.id &&
+      invA?.packingType === invB?.packingType
+    )
+  }
+
+  @Query(returns => Boolean)
+  async checkCartonIdenticality(
+    @Arg('cartonA') cartonA: string,
+    @Arg('palletA') palletA: string,
+    @Arg('cartonB') cartonB: string,
+    @Ctx() context: ResolverContext
+  ) {
+    const invRepo: Repository<Inventory> = getRepository(Inventory)
+    const invA: Inventory = await invRepo.findOne({
+      where: {
+        domain: { id: context.state.domain.id },
+        palletId: palletA,
+        cartonId: cartonA,
+        status: INVENTORY_STATUS.STORED
+      },
+      relations: ['product']
+    })
+
+    const invB: Inventory = await invRepo.findOne({
+      where: {
+        domain: { id: context.state.domain.id },
+        packingType: invA.packingType,
+        packingSize: invA.packingSize,
+        product: { id: invA.product.id },
+        cartonId: cartonB,
+        status: INVENTORY_STATUS.STORED
+      },
+      relations: ['product']
+    })
+
+    return (
+      invA?.expirationDate === invB?.expirationDate &&
+      invA?.product?.id === invB?.product?.id &&
+      invA?.packingType === invB?.packingType &&
+      invA?.packingSize === invB?.packingSize
+    )
+  }
+
+  @Query(returns => Boolean)
+  async checkInventoryOwner(
+    @Arg('palletId') palletId: string,
+    @Arg('bizplaceName') bizplaceName: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const invRepo: Repository<Inventory> = getRepository(Inventory)
+    const bizRepo: Repository<Bizplace> = getRepository(Bizplace)
+
+    const inventory: Inventory = await invRepo.findOne({
+      where: { domain: { id: context.state.domain.id }, palletId, status: INVENTORY_STATUS.STORED },
+      relations: ['bizplace']
+    })
+
+    if (!inventory) throw new Error('This inventory status is not stored.')
+
+    const ownerBizplace: Bizplace = await bizRepo.findOne({
+      where: { name: bizplaceName }
+    })
+
+    const foundBizplace: Bizplace = inventory.bizplace
+
+    return Boolean(ownerBizplace.id === foundBizplace.id)
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => InventoryBundleGroupDetail)
+  async inventoriesByBundle(
+    @Ctx() context: ResolverContext,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<InventoryBundleGroupDetail> {
+    const { domain, user } = context.state
+
+    const params = { filters, pagination }
+
+    const productBundleId = params.filters.filter(x => x.name === 'productBundleId')[0].value
+    if (!productBundleId) {
+      throw new Error('params product bundle is missing')
+    }
+
+    const bundleReleaseQty: number = params.filters.filter(x => x.name === 'bundleReleaseQty')[0].value
+
+    // remove productBundleId and bundleReleaseQty from params.filters
+    params.filters = params.filters.filter(x => x.name !== 'productBundleId' && x.name !== 'bundleReleaseQty')
+
+    if (!params.filters.find((filter: any) => filter.name === 'bizplace_id')) {
+      params.filters.push({
+        name: 'bizplace_id',
+        operator: 'in',
+        value: await getPermittedBizplaceIds(domain, user),
+        relation: true
+      })
+    }
+
+    const remainOnlyParam = params?.filters?.find(
+      (f: { name: string; operator: string; value: any }) => f.name === 'remainOnly'
+    )
+
+    let remainOnly: boolean = false
+    if (typeof remainOnlyParam?.value !== 'undefined') {
+      remainOnly = remainOnlyParam.value
+      params.filters = params.filters.filter(
+        (f: { name: string; operator: string; value: any }) => f.name !== 'remainOnly'
+      )
+    }
+
+    const unlockOnlyParam = params?.filters?.find(
+      (f: { name: string; operator: string; value: any }) => f.name === 'unlockOnly'
+    )
+
+    let unlockOnly: boolean = false
+    if (typeof unlockOnlyParam?.value !== 'undefined') {
+      unlockOnly = unlockOnlyParam.value
+      params.filters = params.filters.filter(
+        (f: { name: string; operator: string; value: any }) => f.name !== 'unlockOnly'
+      )
+    }
+
+    const productBundleSettings: ProductBundleSetting[] = await getRepository(ProductBundleSetting).find({
+      where: { productBundle: { id: productBundleId } },
+      relations: ['product', 'productBundle']
+    })
+
+    if (!productBundleSettings.length) {
+      throw new Error('product bundle settings is not found')
+    }
+
+    const qb: SelectQueryBuilder<Inventory> = getRepository(Inventory).createQueryBuilder('iv')
+    buildQuery(qb, params, context)
+
+    qb.select('iv.product_id', 'productId')
+      .addSelect('iv.batch_id', 'batchId')
+      .addSelect('iv.batch_id_ref', 'batchIdRef')
+      .addSelect('iv.packing_type', 'packingType')
+      .addSelect('SUM(iv.qty)', 'qty')
+      .addSelect('SUM(iv.locked_qty)', 'lockedQty')
+      .addSelect('SUM(iv.uom_value)', 'uomValue')
+      .addSelect('SUM(iv.locked_uom_value)', 'lockedUomValue')
+      .addSelect('prd.sku', 'productSku')
+      .addSelect('prd.name', 'productName')
+      .addSelect('prd.description', 'productDescription')
+      .addSelect('prd.type', 'productType')
+      .addSelect('prd.primary_unit', 'uom')
+      .leftJoin('iv.product', 'prd')
+
+    if (remainOnly) {
+      qb.andWhere('iv.qty > 0')
+        .andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END >= 0')
+        .andWhere('iv.qty - CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END > 0')
+    }
+
+    if (unlockOnly) {
+      qb.andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END = 0')
+    }
+
+    qb.andWhere('iv.product_id IN (:...productIds)', {
+      productIds: productBundleSettings.map(productBundle => productBundle.product.id)
+    })
+      .groupBy('iv.product_id')
+      .addGroupBy('iv.batch_id')
+      .addGroupBy('iv.batch_id_ref')
+      .addGroupBy('iv.packing_type')
+      .addGroupBy('prd.sku')
+      .addGroupBy('prd.name')
+      .addGroupBy('prd.description')
+      .addGroupBy('prd.type')
+      .addOrderBy('prd.name')
+      .addGroupBy('prd.primary_unit')
+      .addOrderBy('iv.batch_id')
+
+    let bundleGroup = await qb.getRawMany()
+
+    bundleGroup = bundleGroup.map((item: any) => {
+      return {
+        ...item,
+        bundleId: productBundleId,
+        remainQty: item.qty - (item.lockedQty ? item.lockedQty : 0),
+        remainUomValue: item.uomValue - (item.lockedUomValue ? item.lockedUomValue : 0),
+        uom: item.uom,
+        bundleQty: productBundleSettings.filter(pbs => pbs.product.id === item.productId)[0].bundleQty
+      }
+    })
+
+    const bundleSetting = productBundleSettings.map(pbs => {
+      return {
+        id: pbs.id,
+        productId: pbs.product.id,
+        bundleId: pbs.productBundle.id,
+        bundleQty: pbs.bundleQty,
+        releaseQty: bundleReleaseQty * pbs.bundleQty,
+        productReleaseQty: 0,
+        productReleaseUomValue: 0
+      }
+    })
+
+    /** ************************ **/
+    bundleGroup = bundleGroup
+      .map(group => {
+        const uomValue = group.remainUomValue / group.remainQty
+
+        bundleSetting.forEach(setting => {
+          let assigned = false
+          let releaseQty = 0
+          let releaseUomValue = 0
+
+          if (group.productId === setting.productId) {
+            if (setting.productReleaseQty < setting.releaseQty) {
+              assigned = true
+              const leftQty = setting.releaseQty - setting.productReleaseQty
+              releaseQty = leftQty > group.remainQty ? group.remainQty : leftQty
+              releaseUomValue = Math.round(releaseQty * uomValue * 100) / 100
+              setting.productReleaseQty += releaseQty
+              setting.productReleaseUomValue += releaseUomValue
+            }
+
+            group.assigned = assigned
+            group.releaseQty = releaseQty
+            group.releaseUomValue = releaseUomValue
+            group.releaseUomValueWithUom = `${releaseUomValue} ${group.uom}`
+          }
+        })
+
+        return group
+      })
+      .filter(group => group.assigned)
+    /** ************************ **/
+
+    return { bundleGroup, bundleSetting }
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Query(returns => InventoryList)
+  async inventoriesGroupByProduct(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryList> {
+    try {
+      const { domain, user, tx } = context.state
+      let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
+      const partnersCompanyBizplaces: Bizplace[] = await getPartnersCompanyBizplaces(domain, user)
+
+      const page = params.pagination.page
+      const limit = params.pagination.limit
+
+      let bizplaceFilter = params.filters.find(filter => filter.name == 'bizplace')
+      let productFilter = params.filters.find(filter => filter.name == 'product')
+      let productTypeFilter = params.filters.find(filter => filter.name == 'type')
+      let availableStockFilter = params.filters.find(filter => filter.name == 'availableStock')
+      let lowStockFilter = params.filters.find(filter => filter.name == 'lowStock')
+      let overStockFilter = params.filters.find(filter => filter.name == 'overStock')
+      let warehouseNameFilter = params.filters.find(filter => filter.name == 'warehouseName')
+      let unexpiredOnlyFilter = params.filters.find(filter => filter.name === 'unexpiredOnly')
+
+      if (bizplaceFilter) {
+        const bizplaceQueryBuilder: SelectQueryBuilder<Bizplace> = getRepository(Bizplace).createQueryBuilder('b')
+        bizplaceQueryBuilder
+          .innerJoin('companies', 'c2', ' c2.domain_id = b.domain_id')
+          .innerJoin('bizplaces', 'b2', 'b2.company_id = c2.id')
+          .where('b2.id = :bizplaceId', { bizplaceId: bizplaceFilter.value })
+
+        let bizplaceList = await bizplaceQueryBuilder.getMany()
+
+        permittedBizplaceIds = [
+          ...permittedBizplaceIds.filter(itm => itm == bizplaceFilter.value),
+          ...bizplaceList.map(bz => bz.id),
+          ...partnersCompanyBizplaces.map(biz => biz.id)
+        ]
+      }
+
+      let bizplaceQuery = ''
+      if (permittedBizplaceIds.length > 0) {
+        bizplaceQuery = `AND EXISTS (
+          SELECT * FROM (VALUES ${permittedBizplaceIds.map(id => `('${id}')`).join(',')})
+          AS bizFilter(bizplace_id)
+          WHERE bizFilter.bizplace_id::uuid = "Inventory"."bizplace_id"
+        )`
+      } else {
+        bizplaceQuery = `1 = 0`
+      }
+
+      let productQuery = ''
+      if (productFilter) {
+        let productValue = productFilter.value
+          .toLowerCase()
+          .split(',')
+          .map(prod => {
+            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+          })
+          .join(',')
+        productQuery = `AND (
+          Lower("Product"."name") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("Product"."sku") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("Product"."brand") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("Product"."description") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("ProductRef"."name") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("ProductRef"."sku") LIKE ANY(ARRAY[${productValue}])
+          OR Lower("ProductRef"."description") LIKE ANY(ARRAY[${productValue}])
+        )`
+      }
+
+      if (productTypeFilter) {
+        let productTypeValue = productTypeFilter.value
+          .toLowerCase()
+          .split(',')
+          .map(prod => {
+            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+          })
+          .join(',')
+        productQuery =
+          productQuery +
+          ` AND (
+          Lower("Product"."type") LIKE ANY(ARRAY[${productTypeValue}])
+        )`
+      }
+
+      let availableStockQuery = ''
+      if (availableStockFilter?.value) {
+        availableStockQuery = ` AND SUM("Inventory"."qty") > 0`
+      }
+
+      let unexpiredOnlyQuery = ''
+      if (unexpiredOnlyFilter?.value) {
+        unexpiredOnlyQuery = 'AND "Inventory"."expiration_date" >= CURRENT_DATE'
+      }
+
+      let thresholdQuery = ''
+      if (lowStockFilter?.value) {
+        thresholdQuery = `AND COALESCE("ProductDetailBizplaceSetting"."min_qty", "Product"."min_qty",0) > SUM("Inventory"."qty")`
+      }
+
+      if (overStockFilter?.value) {
+        thresholdQuery = `AND COALESCE("ProductDetailBizplaceSetting"."max_qty", "Product"."max_qty",0)  > 0 AND 
+          COALESCE("ProductDetailBizplaceSetting"."max_qty", "Product"."max_qty",0)  < SUM("Inventory"."qty")`
+      }
+
+      let warehouseQuery = ''
+      if (warehouseNameFilter?.value) {
+        warehouseQuery = `AND "Warehouse"."name" like '%${warehouseNameFilter.value}%'`
+      }
+
+      await tx.query(
+        `
+        create temp table temp_inv_history AS 
+        (
+          SELECT "Product"."id" AS "id", "Product"."sku" AS "sku", "Product"."brand" AS "brand", "Product"."name" AS "name", "Product"."type" AS "type", "Product"."description" AS "description", "Product"."primary_unit" AS "primaryUnit",
+          "Product"."weight" AS "weight", "ProductRef"."id" AS "productRefId", 
+          "ProductRef"."description" AS "productRefDesciption", "Bizplace"."id" AS "bizplaceId", "Bizplace"."name" AS "bizplaceName", SUM("Inventory"."qty") AS "qty" , SUM("Inventory"."uom_value") AS "uomValue",
+          "Warehouse"."id" AS "warehouseId", "Warehouse"."name" AS "warehouseName",
+          CASE WHEN SUM("Inventory"."qty") > 0 THEN SUM(COALESCE("Inventory"."unit_cost", 0) * "Inventory"."qty")/ SUM("Inventory"."qty") ELSE 0 END AS "averageUnitCost",
+          COALESCE("ProductDetailBizplaceSetting"."min_qty", "Product"."min_qty",0) AS "minQty", 
+          COALESCE("ProductDetailBizplaceSetting"."max_qty", "Product"."max_qty",0) AS "maxQty"
+          FROM "inventories" "Inventory" 
+          LEFT JOIN "warehouses" "Warehouse" ON "Warehouse"."id"="Inventory"."warehouse_id"
+          LEFT JOIN "products" "Product" ON "Product"."id"="Inventory"."product_id" 
+          LEFT JOIN "product_details" "ProductDetails" ON "ProductDetails"."product_id" = "Product"."id" 
+            AND "ProductDetails"."is_default"
+          LEFT JOIN "product_detail_bizplace_settings" "ProductDetailBizplaceSetting" ON "ProductDetailBizplaceSetting"."product_detail_id" = "ProductDetails"."id" 
+            AND "ProductDetailBizplaceSetting"."domain_id" = "Inventory"."domain_id"
+          LEFT JOIN "products" "ProductRef" ON "ProductRef"."id"="Product"."product_ref_id" 
+          INNER JOIN "bizplaces" "Bizplace" ON "Bizplace"."id"="Inventory"."bizplace_id"
+          WHERE "Inventory"."qty" >= 0
+          AND "Inventory"."domain_id" = $1
+          ${bizplaceQuery}
+          ${productQuery}
+          ${warehouseQuery}
+          ${unexpiredOnlyQuery}
+          GROUP BY "Product"."id", "ProductRef"."id", "Bizplace"."id", "ProductDetailBizplaceSetting"."id", "Warehouse"."id"
+          HAVING 1 = 1
+          ${availableStockQuery}
+          ${thresholdQuery}
+        )`,
+        [domain.id]
+      )
+
+      const results: any = await tx.query(
+        `
+          SELECT * FROM temp_inv_history
+          ORDER BY "bizplaceName", "sku" 
+          OFFSET $1 LIMIT $2
+        `,
+        [(page - 1) * limit, limit]
+      )
+
+      const total: any = await tx.query(`SELECT COUNT(*) FROM temp_inv_history`)
+
+      tx.query(`drop table temp_inv_history`)
+
+      return {
+        items: results.map((item: any) => {
+          return {
+            product: {
+              id: item.id,
+              name: item.name,
+              sku: item.sku,
+              brand: item.brand,
+              description: item.description,
+              type: item.type,
+              weight: item.weight,
+              productRefId: item.productRefId,
+              bizplaceId: item.bizplaceId,
+              minQty: item.minQty,
+              maxQty: item.maxQty,
+              primaryUnit: item.primaryUnit
+            },
+            warehouse: {
+              id: item.warehouseId,
+              name: item.warehouseName
+            },
+            averageUnitCost: item.averageUnitCost,
+            qty: item.qty,
+            uomValue: item.uomValue
+          }
+        }),
+        total: total[0].count
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() inventory: Inventory): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: inventory.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() inventory: Inventory): Promise<User> {
+    return await getRepository(User).findOneBy({ id: inventory.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() inventory: Inventory): Promise<User> {
+    return await getRepository(User).findOneBy({ id: inventory.creatorId })
+  }
+
+  /*
+    move changeCount to @FieldResolver so that system don't have
+    to keep searching for this when user does not request for it 
+  */
+  @FieldResolver(type => Number)
+  async changeCount(@Root() inventory: Inventory): Promise<Number> {
+    return await getRepository(InventoryChange).count({
+      where: { inventory: { id: inventory.id } }
+    })
+  }
+
+  /*
+    "purchaseOrderNo", "orderProductRemark" and "arrivalNoticeRefNo"
+    are purely for Getha's lot label. @farishelmi added these here to
+    avoid logic changes in @inventories query
+  */
+  @FieldResolver(type => String)
+  async purchaseOrderNo(@Root() inventory: Inventory): Promise<String> {
+    if (!inventory.refOrderId) return ''
+
+    let items: any = await getRepository(Inventory).query(`
+      SELECT po.name as "purchaseOrderNo" FROM arrival_notices an
+      LEFT JOIN purchase_orders po
+      ON an.purchase_order_id = po.id
+      WHERE an.id = '${inventory.refOrderId}'
+      LIMIT 1
+    `)
+
+    return items[0]?.purchaseOrderNo || ''
+  }
+
+  @FieldResolver(type => String)
+  async orderProductRemark(@Root() inventory: Inventory): Promise<String> {
+    if (!inventory.orderProductId) return ''
+
+    let items: any = await getRepository(Inventory).query(`
+      SELECT op.remark as "orderProductRemark" FROM order_products op
+      WHERE op.id = '${inventory.orderProductId}'
+      LIMIT 1
+    `)
+
+    return items[0]?.orderProductRemark || ''
+  }
+
+  @FieldResolver(type => String)
+  async arrivalNoticeRefNo(@Root() inventory: Inventory): Promise<String> {
+    if (!inventory.refOrderId) return ''
+
+    let items: any = await getRepository(Inventory).query(`
+      SELECT an.ref_no as "arrivalNoticeRefNo" FROM arrival_notices an
+      WHERE an.id = '${inventory.refOrderId}'
+      LIMIT 1
+    `)
+
+    return items[0]?.arrivalNoticeRefNo || ''
+  }
+
+  @FieldResolver(type => String)
+  async arrivalNoticeNo(@Root() inventory: Inventory): Promise<String> {
+    if (!inventory.refOrderId) return ''
+
+    let items: any = await getRepository(Inventory).query(`
+      SELECT an.name as "arrivalNoticeNo" FROM arrival_notices an
+      WHERE an.id = '${inventory.refOrderId}'
+      LIMIT 1
+    `)
+
+    return items[0]?.arrivalNoticeNo || ''
+  }
+}
+
+export async function inventoriesByStrategy(
+  {
+    worksheetId,
+    batchId,
+    bizplaceId,
+    productName,
+    productSku,
+    packingType,
+    packingSize,
+    uom,
+    pickingStrategy,
+    locationSortingRules
+  },
+  trxMgr: EntityManager
+) {
+  const qb = await trxMgr.getRepository(Inventory).createQueryBuilder('INV')
+  qb.innerJoinAndSelect('INV.product', 'PROD')
+    .innerJoinAndSelect('INV.location', 'LOC')
+    .addSelect(subQuery =>
+      subQuery
+        .select('COALESCE(SUM(release_qty), 0)', 'releaseQty')
+        .from('order_inventories', 'OI')
+        .where('"OI"."inventory_id" = "INV"."id"')
+        .andWhere("\"OI\".\"status\" IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')")
+        .andWhere('"OI"."ref_worksheet_id" <> :worksheetId', { worksheetId: worksheetId })
+    )
+    .addSelect(subQuery =>
+      subQuery
+        .select('COALESCE(SUM(release_uom_value), 0)', 'releaseUomValue')
+        .from('order_inventories', 'OI')
+        .where('"OI"."inventory_id" = "INV"."id"')
+        .andWhere("\"OI\".\"status\" IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')")
+        .andWhere('"OI"."ref_worksheet_id" <> :worksheetId', { worksheetId: worksheetId })
+    )
+    .andWhere('"PROD"."name" = :productName')
+    .andWhere('"PROD"."sku" = :productSku')
+    .andWhere('"INV"."packing_type" = :packingType')
+    .andWhere('"INV"."packing_size" = :packingSize')
+    .andWhere('"INV"."uom" = :uom')
+    .andWhere('"INV"."status" = :status', { status: 'STORED' })
+    .andWhere('"LOC"."type" NOT IN (:...locationTypes)', {
+      locationTypes: [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
+    })
+    .setParameters({
+      productName,
+      productSku,
+      packingType,
+      packingSize,
+      uom
+    })
+
+  if (batchId !== '') {
+    qb.andWhere('"INV"."batch_id" = :batchId', { batchId })
+  }
+
+  if (bizplaceId) {
+    qb.andWhere('"INV"."bizplace_id" = :bizplaceId', { bizplaceId: bizplaceId })
+  }
+
+  switch (pickingStrategy.toUpperCase()) {
+    case 'FIFO':
+      qb.orderBy('"INV"."created_at"', 'ASC')
+      if (locationSortingRules?.length > 0) {
+        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
+          qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+        })
+      }
+      break
+
+    case 'LIFO':
+      qb.orderBy('"INV"."created_at"', 'DESC')
+      if (locationSortingRules?.length > 0) {
+        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
+          qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+        })
+      }
+      break
+
+    case 'FEFO':
+      qb.orderBy('"INV"."expiration_date"', 'ASC')
+      qb.addOrderBy('"INV"."created_at"', 'ASC')
+      if (locationSortingRules?.length > 0) {
+        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
+          qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+        })
+      }
+      break
+
+    case 'FMFO':
+      qb.orderBy('"INV"."manufacture_date"', 'ASC')
+      qb.addOrderBy('"INV"."created_at"', 'ASC')
+      if (locationSortingRules?.length > 0) {
+        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
+          qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+        })
+      }
+      break
+
+    case 'LOCATION':
+      if (locationSortingRules?.length > 0) {
+        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
+          idx === 0
+            ? qb.orderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+            : qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+        })
+      } else qb.orderBy('"LOC"."name"', 'DESC')
+      break
+  }
+
+  const { entities, raw } = await qb.getRawAndEntities()
+  const items = entities
+    .map((inv: Inventory, idx: number) => {
+      const qty: number = inv?.qty > 0 ? inv.qty : 0
+      const uomValue: number = inv?.uomValue > 0 ? inv.uomValue : 0
+      const lockedQty: number = inv.lockedQty || 0
+      const lockedUomValue: number = inv.lockedUomValue || 0
+      const releaseQty: number = parseInt(raw[idx].releaseQty) || 0
+      const releaseUomValue: number = parseFloat(raw[idx].releaseUomValue) || 0
+
+      return {
+        ...inv,
+        qty: qty - lockedQty - releaseQty,
+        uomValue: uomValue - lockedUomValue - releaseUomValue
+      }
+    })
+    .filter((inv: Inventory) => inv.qty)
+
+  const total: number = await qb.getCount()
+  return { items, total }
+}