@things-factory/warehouse-base 8.0.2 → 8.0.5

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

@@ -1,1263 +0,0 @@
-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', 'productType'],
-      filtersMap: {
-        productName: {
-          relationColumn: 'product',
-          columnName: 'name'
-        },
-        productSKU: {
-          relationColumn: 'product',
-          columnName: 'sku'
-        },
-        productType: {
-          relationColumn: 'product',
-          columnName: 'type'
-        }
-      }
-    })
-
-    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 }
-}