@things-factory/warehouse-base 4.0.0-alpha.8 → 4.0.0-beta.2

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

@@ -0,0 +1,745 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, EntityManager, Equal, getRepository, Not, Repository, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getPartnersCompanyBizplaces, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Product, ProductBundleSetting } from '@things-factory/product-base'
+import { Setting } from '@things-factory/setting-base'
+import { buildQuery, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
+
+import { INVENTORY_STATUS } from '../../constants'
+import { InventoryChange } from '../inventory-change/inventory-change'
+import { Inventory } from './inventory'
+import { InventoryBundleGroupDetail, InventoryList } from './inventory-types'
+
+@Resolver(Inventory)
+export class InventoryQuery {
+  @Directive('@privilege(category: "inventory", privilege: "query")')
+  @Query(returns => InventoryList)
+  async inventories(
+    @Ctx() context: any,
+    @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[]
+  ): Promise<InventoryList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const productFilters = filters.find(x => x.name == 'product_info')
+    filters = filters.filter(x => x.name != 'product_info')
+    const params = { filters, pagination }
+
+    if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
+      params.filters.push({
+        name: 'bizplace',
+        operator: 'in',
+        value: await getPermittedBizplaceIds(domain, user),
+        relation: true
+      })
+    }
+
+    const remainOnlyParam: { name: string; operator: string; value: boolean } = 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: { name: string; operator: string; value: boolean } = 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 qb: SelectQueryBuilder<Inventory> = getRepository(Inventory).createQueryBuilder('iv')
+    buildQuery(qb, params, context)
+
+    qb.leftJoinAndSelect('iv.domain', 'domain')
+      .leftJoinAndSelect('iv.bizplace', 'bizplace')
+      .leftJoinAndSelect('iv.product', 'product')
+      .leftJoinAndSelect('iv.warehouse', 'warehouse')
+      .leftJoinAndSelect('iv.location', 'location')
+      .leftJoinAndSelect('iv.creator', 'creator')
+      .leftJoinAndSelect('iv.updater', 'updater')
+
+    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')
+    }
+
+    if (productFilters) {
+      let productFilterValue = `%${productFilters.value.toLowerCase()}%`
+      qb.andWhere(qb => {
+        const subQuery = qb
+          .subQuery()
+          .select()
+          .from(Product, `products`)
+          .where(`products.id = iv.product_id`)
+          .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 })
+            })
+          )
+          .getQuery()
+        return `EXISTS ${subQuery}`
+      })
+    }
+
+    if (sortings?.length !== 0) {
+      const arrChildSortData = ['bizplace', 'product', 'location', 'warehouse', 'zone']
+      const sort = (sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'iv.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        {}
+      )
+      qb.orderBy(sort)
+    }
+
+    if (locationSortingRules?.length > 0) {
+      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
+        qb.addOrderBy(`location.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+      })
+    }
+
+    let [items, total] = await qb.getManyAndCount()
+
+    items = await Promise.all(
+      items.map(async (item: Inventory) => {
+        let inventoryChangeCount = await getRepository(InventoryChange).count({
+          where: { inventory: item.id }
+        })
+
+        const selectedQty = item.lockedQty ? item.lockedQty : 0
+        const selectedUomValue = item.lockedUomValue ? item.lockedUomValue : 0
+
+        return {
+          ...item,
+          changeCount: inventoryChangeCount,
+          remainQty: item.qty - selectedQty,
+          remainUomValue: item.uomValue - selectedUomValue
+        }
+      })
+    )
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query")')
+  @Query(returns => Inventory)
+  async inventory(@Arg('palletId') palletId: string, @Ctx() context: any): Promise<Inventory> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(Inventory).findOne({
+      where: { domain: domain, palletId },
+      relations: ['domain', 'bizplace', 'product', 'location', 'warehouse', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query")')
+  @Query(returns => Inventory)
+  async inventoryByPallet(@Arg('palletId') palletId: string, @Ctx() context: any): Promise<Inventory> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(Inventory).findOne({
+      where: { domain, palletId, status: Not(Equal(INVENTORY_STATUS.TERMINATED)) },
+      relations: ['domain', 'bizplace', 'product', 'location', 'warehouse', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "query")')
+  @Directive('@transaction')
+  @Query(returns => InventoryList)
+  async inventoriesByProduct(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryList> {
+    try {
+      const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = 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')
+
+      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"."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 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")`
+      }
+
+      await tx.query(
+        `
+        create temp table temp_inv_history AS 
+        (
+          SELECT "Product"."id" AS "id", "Product"."sku" AS "sku", "Product"."name" AS "name", "Product"."type" AS "type", "Product"."description" AS "description", 
+          "Product"."weight" AS "weight", "ProductRef"."name" AS "productRefName", 
+          "ProductRef"."description" AS "productRefDesciption", "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"
+          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"
+          WHERE "Inventory"."qty" >= 0
+          AND "Inventory"."domain_id" = $1
+          ${bizplaceQuery}
+          ${productQuery}
+          GROUP BY "Product"."id", "ProductRef"."id", "Bizplace"."id", "ProductDetailBizplaceSetting"."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,
+              description: item.description,
+              type: item.type,
+              weight: item.weight,
+              productRef: { name: item.productRefName, description: item.productRefDesciption },
+              bizplace: { name: item.bizplaceName },
+              minQty: item.minQty,
+              maxQty: item.maxQty
+            },
+            averageUnitCost: item.averageUnitCost,
+            qty: item.qty
+          }
+        }),
+        total: total[0].count
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Directive('@transaction')
+  @Query(returns => InventoryList)
+  async inventoriesByStratege(
+    @Arg('worksheetId') worksheetId: string,
+    @Arg('batchId') batchId: string,
+    @Arg('bizplaceId') bizplaceId: string,
+    @Arg('productName') productName: string,
+    @Arg('productSku') productSku: string,
+    @Arg('packingType') packingType: string,
+    @Arg('pickingStrategy') pickingStrategy: string,
+    @Arg('locationSortingRules', type => [Sorting]) locationSortingRules: Sorting[],
+    @Ctx() context: any
+  ): Promise<InventoryList> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, 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, pickingStrategy, locationSortingRules },
+      tx
+    )
+  }
+
+  @Directive('@transaction')
+  @Query(returns => Boolean)
+  async checkProductIdenticality(
+    @Arg('palletA') palletA: string,
+    @Arg('palletB') palletB: string,
+    @Ctx() context: any
+  ): Promise<Boolean> {
+    const { tx }: { tx: EntityManager } = context.state
+    const invRepo: Repository<Inventory> = tx.getRepository(Inventory)
+    const invA: Inventory = await invRepo.findOne({
+      where: { domain: context.state.domain, palletId: palletA, status: INVENTORY_STATUS.STORED },
+      relations: ['product']
+    })
+
+    const invB: Inventory = await invRepo.findOne({
+      where: { domain: context.state.domain, 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: any
+  ) {
+    const invRepo: Repository<Inventory> = getRepository(Inventory)
+    const invA: Inventory = await invRepo.findOne({
+      where: { domain: context.state.domain, palletId: palletA, cartonId: cartonA, status: INVENTORY_STATUS.STORED },
+      relations: ['product']
+    })
+
+    const invB: Inventory = await invRepo.findOne({
+      where: {
+        domain: context.state.domain,
+        packingType: invA.packingType,
+        packingSize: invA.packingSize,
+        product: invA.product,
+        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: any
+  ): Promise<Boolean> {
+    const invRepo: Repository<Inventory> = getRepository(Inventory)
+    const bizRepo: Repository<Bizplace> = getRepository(Bizplace)
+
+    const inventory: Inventory = await invRepo.findOne({
+      where: { domain: context.state.domain, 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")')
+  @Query(returns => InventoryBundleGroupDetail)
+  async inventoriesByBundle(
+    @Ctx() context: any,
+    @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 }: { domain: Domain; user: 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: { name: string; operator: string; value: boolean } = 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: { name: string; operator: string; value: boolean } = 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: 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 }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() inventory: Inventory) {
+    return await getRepository(Domain).findOne(inventory.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() inventory: Inventory) {
+    return await getRepository(User).findOne(inventory.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() inventory: Inventory) {
+    return await getRepository(User).findOne(inventory.creatorId)
+  }
+}
+
+export async function inventoriesByStrategy(
+  { worksheetId, batchId, bizplaceId, productName, productSku, packingType, pickingStrategy, locationSortingRules },
+  trxMgr: EntityManager
+) {
+  const qb = await trxMgr.getRepository(Inventory).createQueryBuilder('INV')
+  qb.leftJoinAndSelect('INV.product', 'PROD')
+    .leftJoinAndSelect('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"."status" = :status', { status: 'STORED' })
+    .setParameters({
+      productName,
+      productSku,
+      packingType
+    })
+
+  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) => {
+          idx === 0
+            ? qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+            : 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) => {
+          idx === 0
+            ? qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+            : qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+        })
+      }
+      break
+
+    case 'FEFO':
+      qb.orderBy('"INV"."expiration_date"', 'ASC')
+      if (locationSortingRules?.length > 0) {
+        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
+          idx === 0
+            ? qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+            : qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+        })
+      }
+      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
+    default:
+      qb.orderBy('"INV"."created_at"', 'ASC')
+
+      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 }
+}