@things-factory/sales-base 8.0.0-beta.8 → 8.0.0

package/server/service/release-good/release-good-query.ts

@@ -0,0 +1,980 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { EntityManager, In, OrderByCondition, Repository, SelectQueryBuilder } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { checkUserBelongsDomain, User } from '@things-factory/auth-base'
+import { Bizplace, getCompanyBizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { buildQuery, Domain, Filter, getRepository, ListParam, Pagination, Sorting } from '@things-factory/shell'
+import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
+
+import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { ShippingOrder } from '../shipping-order/shipping-order'
+import { ReleaseGood } from './release-good'
+import { NewReleaseGood, ReleasableInventory, ReleasableInventoryList, ReleaseGoodList } from './release-good-types'
+
+@Resolver(ReleaseGood)
+export class ReleaseGoodQuery {
+  @Directive('@privilege(category: "order_customer", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ReleaseGoodList)
+  async releaseGoods(
+    @Ctx() context: ResolverContext,
+    @Args(type => ListParam) params: ListParam
+  ): Promise<ReleaseGoodList> {
+    try {
+      const { domain, user } = context.state
+
+      if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
+        params.filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+      if (fromDateParamIdx >= 0) {
+        let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+        params.filters.splice(fromDateParamIdx, 1)
+
+        params.filters.push({
+          name: 'createdAt',
+          operator: 'gte',
+          value: fromDateVal.toISOString(),
+          relation: false
+        })
+      }
+
+      const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+      if (toDateParamIdx >= 0) {
+        let toDateVal = new Date(params.filters[toDateParamIdx].value)
+        params.filters.splice(toDateParamIdx, 1)
+
+        params.filters.push({
+          name: 'createdAt',
+          operator: 'lt',
+          value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+          relation: false
+        })
+      }
+
+      const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood).createQueryBuilder('rg')
+      buildQuery(qb, params, context)
+      let items: any
+      let total: number
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.leftJoinAndSelect('rg.domain', 'domain')
+      qb.leftJoinAndSelect('rg.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('rg.orderInventories', 'oi')
+      qb.leftJoinAndSelect('rg.orderProducts', 'op')
+      qb.leftJoinAndSelect('oi.inventory', 'inv')
+      qb.leftJoinAndSelect('oi.product', 'prod')
+      qb.leftJoinAndSelect('rg.arrivalNotice', 'an')
+      qb.leftJoinAndSelect('rg.creator', 'creator')
+      qb.leftJoinAndSelect('rg.updater', 'updater')
+      qb.leftJoin(
+        subQuery => {
+          return subQuery
+            .select(`ccd.rank`, 'rank')
+            .addSelect(`ccd.name`, 'status')
+            .from(`common_code_details`, 'ccd')
+            .innerJoin(`ccd.commonCode`, 'cc')
+            .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
+            .andWhere(`cc.name = 'RO_LIST_STATUS'`)
+        },
+        'cc',
+        'cc.status = rg.status'
+      )
+
+      const arrChildSortData = ['bizplace']
+      const sort: OrderByCondition = (params.sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'rg.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      let [itemsRes, totalRes] = await qb.getManyAndCount()
+      items = itemsRes
+      total = totalRes
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ReleaseGood)
+  async releaseGood(
+    @Ctx() context: ResolverContext,
+    @Arg('name', { nullable: true }) name: string,
+    @Arg('trackingNo', { nullable: true }) trackingNo: string
+  ): Promise<ReleaseGood> {
+    const { domain, user } = context.state
+
+    if (name) {
+      return await getRepository(ReleaseGood).findOne({
+        where: {
+          domain: { id: domain.id },
+          name,
+          bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) }
+        },
+        relations: [
+          'domain',
+          'bizplace',
+          'shippingOrder',
+          'arrivalNotice',
+          'orderInventories',
+          'orderInventories.product',
+          'orderInventories.inventory',
+          'orderInventories.inventory.product',
+          'orderVass',
+          'orderVass.vas',
+          'creator',
+          'updater'
+        ]
+      })
+    } else if (trackingNo) {
+      let releaseGood = await getRepository(ReleaseGood).findOne({
+        where: {
+          domain: { id: domain.id },
+          trackingNo,
+          bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) }
+        },
+        relations: ['bizplace']
+      })
+
+      if (!releaseGood) {
+        throw new Error('Tracking No not found in any orders')
+      } else {
+        return releaseGood
+      }
+    }
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Query(returns => ReleaseGood)
+  async releaseGoodDetail(
+    @Ctx() context: ResolverContext,
+    @Arg('refNo', { nullable: true }) refNo?: string,
+    @Arg('name', { nullable: true }) name?: string
+  ): Promise<ReleaseGood> {
+    try {
+      const { domain, tx } = context.state
+      let param: any
+
+      if (name) param = { domain, name }
+      else param = { domain, refNo }
+
+      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: { ...param },
+        relations: [
+          'domain',
+          'bizplace',
+          'shippingOrder',
+          'arrivalNotice',
+          'orderProducts',
+          'orderProducts.product',
+          'orderVass',
+          'orderVass.vas',
+          'orderVass.targetProduct',
+          'orderVass.inventory',
+          'creator',
+          'updater'
+        ]
+      })
+
+      if (releaseGood) {
+        let oiQb: SelectQueryBuilder<OrderInventory> = tx
+          .getRepository(OrderInventory)
+          .createQueryBuilder('oi')
+          .leftJoinAndSelect('oi.inventory', 'inventory')
+          .leftJoinAndSelect('oi.product', 'product')
+          .leftJoinAndSelect('inventory.location', 'location')
+          .where('oi.domain_id = :domainId', { domainId: domain.id })
+          .andWhere('oi.release_good_id = :releaseGoodId', { releaseGoodId: releaseGood.id })
+          .andWhere('oi.status NOT IN (:...orderInventoryStatus)', {
+            orderInventoryStatus: [ORDER_INVENTORY_STATUS.COMPLETE_SPLIT, ORDER_INVENTORY_STATUS.REPLACED]
+          })
+          .orderBy('product.sku', 'ASC')
+
+        let orderInventories: OrderInventory[] = await oiQb.getMany()
+
+        const shippingOrder: ShippingOrder = releaseGood.shippingOrder
+        const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({
+          where: {
+            domain: { id: domain.id },
+            refBy: releaseGood.id,
+            category: ATTACHMENT_TYPE.DELIVERY_ORDER
+          }
+        })
+
+        let invInfos = await Promise.all(
+          orderInventories.map(async (orderInv: OrderInventory) => {
+            if (orderInv?.inventory?.id) {
+              const inventory: Inventory = orderInv.inventory
+              return {
+                id: inventory.id,
+                name: inventory.name,
+                batchId: inventory.batchId,
+                batchIdRef: inventory.batchIdRef,
+                palletId: inventory.palletId,
+                product: orderInv.product,
+                productIdRef: orderInv.product.id,
+                productName: `${orderInv.product.name} (${orderInv.product.description})`,
+                packingType: orderInv.packingType,
+                packingSize: orderInv.packingSize,
+                location: inventory.location,
+                qty: inventory.qty,
+                lockedQty: inventory.lockedQty,
+                lockedUomValue: inventory.lockedUomValue,
+                uom: inventory.uom,
+                uomValue: inventory.uomValue,
+                invStatus: inventory.status,
+                releaseQty: orderInv.releaseQty,
+                releaseUomValue: orderInv.releaseUomValue,
+                status: orderInv.status,
+                refWorksheetId: orderInv.refWorksheetId
+              }
+            }
+          })
+        )
+
+        const result = {
+          ...releaseGood,
+          attachment: foundAttachments,
+          shippingOrderInfo: {
+            containerNo: shippingOrder?.containerNo || '',
+            containerSize: shippingOrder?.containerSize || '',
+            containerLeavingDate: shippingOrder?.containerLeavingDate || '',
+            containerArrivalDate: shippingOrder?.containerArrivalDate || '',
+            containerClosureDate: shippingOrder?.containerClosureDate || '',
+            shipName: shippingOrder?.shipName || '',
+            remark: shippingOrder?.remark || '',
+            remindContainerDeparture: shippingOrder?.remindContainerDeparture || null
+          },
+          inventoryInfos: invInfos
+        }
+
+        return result
+      }
+    } catch (error) {
+      logger.error(`release-good-query[releaseGoodDetail]: ${error}`)
+      throw new Error(error)
+    }
+  }
+
+  @Directive('@privilege(category: "order_warehouse", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ReleaseGoodList)
+  async releaseGoodRequests(
+    @Ctx() context: ResolverContext,
+    @Args(type => ListParam) params: ListParam
+  ): Promise<ReleaseGoodList> {
+    try {
+      console.time('t1')
+      const { domain, user } = context.state
+
+      const statusFilter = params.filters.some(e => e.name === 'status')
+      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
+      const noOfItemsFilter = params.filters.find(param => param.name === 'noOfItems')
+      const skuFilter = params.filters.find(param => param.name === 'sku')
+      const routeId = params.filters.find(param => param.name === 'routeId')
+      const orderRemarkFilter = params.filters.find(param => param.name === 'orderRemark')
+      const manifestedFilter = params.filters.find(param => param.name === 'manifested')
+      const orderInfoFilter = params.filters.find(param => param.name === 'name')
+      const typeFilter = params.filters.find(param => param.name === 'type')?.value
+
+      if (await checkUserBelongsDomain(domain, user)) {
+        if (!statusFilter && !params.filters.some(e => e.name === 'name')) {
+          params.filters.push({
+            name: 'status',
+            operator: 'notin',
+            value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING, ''],
+            relation: false
+          })
+        }
+      }
+
+      if (!bizplaceFilter) {
+        params.filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      if (skuFilter) {
+        params.filters = params.filters.filter(param => param.name !== 'sku')
+      }
+
+      if (orderInfoFilter) {
+        params.filters = params.filters.filter(param => param.name !== 'name')
+      }
+
+      if (routeId) {
+        if (routeId.value == true) {
+          params.filters.find(param => param.name === 'routeId').value = 'null'
+        } else {
+          params.filters.find(param => param.name === 'routeId').operator = 'is_null'
+          params.filters.find(param => param.name === 'routeId').value = null
+        }
+      }
+
+      if (orderRemarkFilter) {
+        const orderRemarkIdx = params.filters.findIndex(param => param.name === 'orderRemark')
+        if (orderRemarkFilter.value == true) {
+          params.filters.splice(orderRemarkIdx, 1)
+          params.filters.push({
+            name: 'remark',
+            operator: 'is_not_null',
+            value: null,
+            relation: false
+          })
+        } else {
+          params.filters.splice(orderRemarkIdx, 1)
+          params.filters.push({
+            name: 'remark',
+            operator: 'is_null',
+            value: null,
+            relation: false
+          })
+        }
+      }
+
+      if (manifestedFilter) {
+        const manifestedIdx = params.filters.findIndex(param => param.name === 'manifested')
+        if (manifestedFilter.value == true) {
+          params.filters.splice(manifestedIdx, 1)
+          params.filters.push({
+            name: 'manifestId',
+            operator: 'is_not_null',
+            value: null,
+            relation: false
+          })
+        } else {
+          params.filters.splice(manifestedIdx, 1)
+          params.filters.push({
+            name: 'manifestId',
+            operator: 'is_null',
+            value: null,
+            relation: false
+          })
+        }
+      }
+
+      const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+      if (fromDateParamIdx >= 0) {
+        let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+        let releaseDateFrom = params.filters.find(param => param.name === 'fromDate')?.value
+        params.filters.splice(fromDateParamIdx, 1)
+
+        params.filters.push({
+          name: typeFilter == 'b2c' ? 'releaseDate' : 'createdAt',
+          operator: 'gte',
+          value: typeFilter == 'b2c' ? releaseDateFrom : fromDateVal.toISOString(),
+          relation: false
+        })
+      }
+
+      const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+      if (toDateParamIdx >= 0) {
+        let toDateVal = new Date(params.filters[toDateParamIdx].value)
+        let releaseDateTo = params.filters.find(param => param.name === 'toDate')?.value
+        params.filters.splice(toDateParamIdx, 1)
+
+        params.filters.push({
+          name: typeFilter == 'b2c' ? 'releaseDate' : 'createdAt',
+          operator: typeFilter == 'b2c' ? 'lte' : 'lt',
+          value:
+            typeFilter == 'b2c' ? releaseDateTo : new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+          relation: false
+        })
+      }
+
+      if (noOfItemsFilter && noOfItemsFilter.value == 1) {
+        params.filters.find(param => param.name === 'noOfItems').operator = 'eq'
+      }
+
+      const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood).createQueryBuilder('rg')
+      buildQuery(qb, params, context)
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.leftJoinAndSelect('rg.domain', 'domain')
+      qb.leftJoinAndSelect('rg.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('rg.arrivalNotice', 'an')
+      qb.leftJoinAndSelect('rg.creator', 'creator')
+      qb.leftJoinAndSelect('rg.updater', 'updater')
+      qb.leftJoinAndSelect('rg.acceptedBy', 'acceptedBy')
+      qb.leftJoinAndSelect('rg.deliverTo', 'deliverTo')
+      qb.leftJoin(
+        subQuery => {
+          return subQuery
+            .select(`ccd.rank`, 'rank')
+            .addSelect(`ccd.name`, 'status')
+            .from(`common_code_details`, 'ccd')
+            .innerJoin(`ccd.commonCode`, 'cc')
+            .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
+            .andWhere(`cc.name = 'RO_REQUESTS_STATUS'`)
+        },
+        'cc',
+        'cc.status = rg.status'
+      )
+
+      if (skuFilter) {
+        let removeSymbol = skuFilter.value
+          .split('')
+          .filter(res => res !== '%')
+          .join('')
+
+        let products = removeSymbol
+          .toLowerCase()
+          .split(',')
+          .map(prod => {
+            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+          })
+          .join(',')
+
+        qb.andWhere(
+          `
+        exists (select * from  order_inventories oi  
+        inner join products p on oi.product_id = p.id
+        inner join inventories i on i.product_id = p.id
+        where oi.release_good_id = rg.id
+        and (lower(p.sku) like any(array[${products}])
+        or lower(p.brand_sku) like any(array[${products}])
+        or lower(p.name) like any(array[${products}])
+        or lower(p.description) like any(array[${products}]))
+        )
+        `
+        )
+      }
+
+      if (orderInfoFilter) {
+        let removeSymbol = orderInfoFilter.value
+          .split('')
+          .filter(res => res !== '%')
+          .join('')
+
+        let orderInfos = removeSymbol
+          .toLowerCase()
+          .split(',')
+          .map(prod => {
+            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+          })
+          .join(',')
+
+        qb.andWhere(`(
+          lower(rg.name) like any(array[${orderInfos}])
+          or lower(rg.ref_no) like any(array[${orderInfos}])
+          or lower(rg.ref_no_2) like any(array[${orderInfos}])
+          or lower(rg.ref_no_3) like any(array[${orderInfos}])
+        )`)
+      }
+
+      const arrChildSortData = ['bizplace', 'creator']
+      const sort: OrderByCondition = (params.sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'rg.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        params.sortings.length < 1 ? { rank: 'ASC', 'rg.createdAt': 'DESC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      let [items, total] = await qb.getManyAndCount()
+
+      items = items
+        .filter(item => {
+          return item.domainId === domain.id
+        })
+        .map(item => {
+          return {
+            ...item,
+            orderRemark: item?.remark ? true : false
+          }
+        })
+      console.timeEnd('t1')
+      return { items, total }
+    } catch (error) {
+      logger.error(`release-good-query[releaseGoodRequests]: ${error}`)
+      throw error
+    }
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ReleasableInventoryList)
+  async releasableInventories(
+    @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<ReleasableInventoryList> {
+    const myBizplace: Bizplace = await getMyBizplace(context.state.domain, context.state.user)
+    const INV_ALIAS = 'INV'
+    const PROD_ALIAS = 'PROD'
+    const GAN_ALIAS = 'GAN'
+    const conditions = filters
+    let {
+      batchId = null,
+      containerNo = null,
+      product = [],
+      packingType = null,
+      inventory = []
+    } = getConditionValues(conditions)
+
+    const SELECT: string = `
+      SELECT
+        ${INV_ALIAS}.batch_id,
+        ${INV_ALIAS}.packing_type,
+        (SUM(COALESCE(${INV_ALIAS}.qty, 0)) - SUM(COALESCE(${INV_ALIAS}.locked_qty, 0))) as remain_qty,
+        (SUM(COALESCE(${INV_ALIAS}.uomValue, 0)) - SUM(COALESCE(${INV_ALIAS}.locked_uom_value, 0))) as remain_uom_value,
+        ${PROD_ALIAS}.id as product_id,
+        ${PROD_ALIAS}.name as product_name,
+        ${GAN_ALIAS}.container_no
+    `
+    const FROM: string = `
+      FROM
+        inventories ${INV_ALIAS}
+      LEFT JOIN
+        products ${PROD_ALIAS}
+      ON
+        ${PROD_ALIAS}.id = ${INV_ALIAS}.product_id
+      LEFT JOIN
+        arrival_notices ${GAN_ALIAS}
+      ON
+        ${GAN_ALIAS}.id = CAST(${INV_ALIAS}.ref_order_id as uuid)
+    `
+
+    const WHERE: string = `
+      WHERE
+        ${INV_ALIAS}.status = 'STORED'
+        AND ${INV_ALIAS}.qty > 0
+        AND ${INV_ALIAS}.bizplace_id = '${myBizplace.id}'
+        ${batchId ? `AND LOWER(${INV_ALIAS}.batch_id) LIKE '%${batchId.toLowerCase()}%'` : ''}
+        ${packingType ? `AND LOWER(${INV_ALIAS}.packing_type) LIKE '%${packingType.toLowerCase()}%'` : ''}
+        ${containerNo ? `AND LOWER(${GAN_ALIAS}.container_no) LIKE '%${containerNo.toLowerCase()}%'` : ''}
+        ${
+          product?.length > 0 && product[0]
+            ? `AND ${PROD_ALIAS}.id IN (${product.map((id: string) => `'${id}'`).join(', ')})`
+            : product[0] === null
+              ? `AND ${PROD_ALIAS}.id isnull`
+              : ''
+        }
+        ${
+          inventory?.length > 0
+            ? `
+              AND (${INV_ALIAS}.batch_id, ${PROD_ALIAS}.id) ${
+                filters.find((filter: { name: string; operator: string; value: any }) => filter.name === 'inventory')
+                  .operator
+              } (
+                ${inventory
+                  .map((inv: { batchId: string; productId: string }) => `('${inv.batchId}', '${inv.productId}')`)
+                  .join(', ')}
+              )
+            `
+            : ''
+        }
+    `
+
+    // ${product?.length > 0 ? `AND ${PROD_ALIAS}.id IN (${product.map((id: string) => id ? `'${id}'` : null).join(', ')})` : ''}
+    const GROUP_BY: string = `
+      GROUP BY
+      ${INV_ALIAS}.batch_id,
+      ${INV_ALIAS}.packing_type,
+      ${GAN_ALIAS}.container_no,
+      ${PROD_ALIAS}.id
+    `
+
+    const OFFSET_LIMIT: string = `
+        OFFSET ${pagination.limit * (pagination.page - 1)}
+        LIMIT ${pagination.limit}
+    `
+
+    const invRepo: Repository<Inventory> = getRepository(Inventory)
+    let items: any[] = await invRepo.query(`
+      ${SELECT} ${FROM} ${WHERE} ${GROUP_BY} ${OFFSET_LIMIT}
+    `)
+    items = items.map((item: any) => {
+      return {
+        batchId: item.batch_id,
+        packingType: item.packing_type,
+        remainQty: item.remain_qty,
+        remainUomValue: item.remain_uom_value,
+        productName: item.product_name,
+        product: {
+          id: item.product_id,
+          name: item.product_name
+        },
+        containerNo: item.container_no
+      }
+    }) as any
+
+    const results: [{ total: number }] = await invRepo.query(`
+      SELECT max(cnt.cnt) as total FROM (
+        SELECT (ROW_NUMBER() OVER()) as cnt ${FROM} ${WHERE} ${GROUP_BY}
+      ) as cnt
+    `)
+
+    return {
+      items,
+      total: Number(results[0].total)
+    }
+  }
+
+  @Directive('@transaction')
+  @Query(returns => [ReleaseGood])
+  async bulkReleaseGoodsAvailableItems(
+    @Ctx() context: ResolverContext,
+    @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
+    @Arg('bizplaceId', type => String) bizplaceId: string
+  ): Promise<ReleaseGood[]> {
+    const { tx } = context.state
+    const availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(rawReleaseGoods, bizplaceId, context, tx)
+
+    return availableItems
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() releaseGood: ReleaseGood): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: releaseGood.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() releaseGood: ReleaseGood): Promise<User> {
+    return await getRepository(User).findOneBy({ id: releaseGood.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() releaseGood: ReleaseGood): Promise<User> {
+    return await getRepository(User).findOneBy({ id: releaseGood.updaterId })
+  }
+}
+
+async function prepOITempTable(domain: Domain, tx: EntityManager) {
+  await tx.query(
+    `
+    CREATE TEMP TABLE oi ON COMMIT DROP AS (
+      SELECT
+        SUM(oi.release_qty) as release_qty,
+        SUM(oi.release_uom_value) as release_uom_value,
+        oi.batch_id,
+        p.id as product_id,
+        oi.packing_type
+      FROM
+        order_inventories oi
+      LEFT JOIN
+        products p
+      ON
+        oi.product_id = p.id
+      WHERE
+        oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT') 
+        AND oi.batch_id NOTNULL
+        AND oi.product_id NOTNULL
+        AND oi.packing_type NOTNULL
+        AND oi.inventory_id IS NULL
+        AND oi.domain_id = $1
+      GROUP BY
+        oi.product_id,
+        oi.batch_id,
+        oi.packing_type,
+        p.id
+    )`,
+    [domain.id]
+  )
+}
+
+async function getAvailableAmount(
+  roBizId: string,
+  productIdRef: string,
+  batchId: string,
+  packingType: string,
+  tx: EntityManager
+): Promise<{ qty: number; uomValue: number; uom: string }> {
+  const result: any[] = await tx.getRepository(Inventory).query(`
+    SELECT
+      SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) as "qty",
+      SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) as "uom_value",
+      uom
+    FROM
+      inventories i
+      LEFT JOIN products p on i.product_id = p.id
+      LEFT JOIN oi on i.batch_id = oi.batch_id
+      AND p.id = oi.product_id
+      AND i.packing_type = oi.packing_type
+    WHERE
+      i.bizplace_id = '${roBizId}'
+      AND i.status = 'STORED'
+      AND i.batch_id = '${batchId}'
+      AND p.id = '${productIdRef}'
+      AND i.packing_type = '${packingType}'
+    GROUP BY
+      i.batch_id,
+      p.id,
+      i.packing_type,
+      i.uom
+  `)
+
+  let qty: number = 0
+  let uomValue: number = 0
+  let uom: string = ''
+  if (result?.length) {
+    qty = result[0].qty
+    uomValue = result[0].uom_value
+    uom = result[0].uom
+  }
+
+  return { qty, uomValue, uom }
+}
+
+async function dropOITempTable(domain: Domain, tx: EntityManager) {
+  await tx.query(`DROP TABLE oi`)
+}
+
+export async function bulkReleaseGoodsAvailableItemsFunction(
+  rawReleaseGoods: any[],
+  bizplaceId: string,
+  context: any,
+  tx?: EntityManager
+): Promise<any[]> {
+  const { domain } = context.state
+  const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
+
+  if (!rawReleaseGoods) return
+  const json_oi = JSON.stringify(
+    rawReleaseGoods.map(raw => {
+      return {
+        sku: raw.sku,
+        packing_type: raw.packingType,
+        packing_size: raw.packingSize,
+        uom: raw.uom,
+        releaseQty: raw.releaseQty,
+        release_qty: raw.releaseQty
+      }
+    })
+  )
+
+  await tx.query(
+    `
+        CREATE TEMP TABLE raw_release_goods(
+          product_id VARCHAR(50),
+          product_detail_id VARCHAR(50),
+          sku VARCHAR(150),
+          product_info VARCHAR(250),
+          packing_type VARCHAR(50),
+          packing_size INT,
+          uom VARCHAR(10),
+          release_qty INT
+        );
+      `
+  )
+
+  await tx.query(
+    `
+        INSERT INTO raw_release_goods
+        SELECT p.id AS product_id,
+        pd.id AS product_detail_id,
+        js.sku,
+        CASE WHEN p.description NOT IN (NULL, '', '-') THEN CONCAT(p.name, '(', p.description, ')')
+          ELSE p.name END AS product_info,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
+        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END
+        FROM JSON_POPULATE_RECORDSET(NULL::raw_release_goods, $1) js
+        LEFT JOIN products p ON LOWER(js.sku) = LOWER(p.sku) AND p.bizplace_id = $2
+        LEFT JOIN product_details pd ON p.id = pd.product_id
+        AND CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL AND js.uom NOTNULL
+          THEN pd.packing_type = js.packing_type AND pd.packing_size = js.packing_size AND pd.uom = js.uom 
+          WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL AND js.uom ISNULL 	
+            THEN pd.packing_type = js.packing_type AND pd.packing_size = js.packing_size AND pd.is_default IS TRUE
+            WHEN js.packing_type ISNULL AND js.packing_size ISNULL AND js.uom NOTNULL
+              THEN pd.uom = js.uom AND pd.is_default IS TRUE ELSE pd.is_default IS TRUE 
+        END;
+      `,
+    [json_oi, companyBizplaceId.id]
+  )
+
+  let availableItems = await tx.query(
+    `
+        WITH inv AS (
+        SELECT i.product_id, foo.product_detail_id, foo.sku, foo.product_info, i.packing_type, i.packing_size, i.uom,
+          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_qty) FROM order_inventories oi 
+              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_qty",
+          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
+              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_uom_value"
+        FROM inventories i
+        LEFT JOIN locations l
+        ON i.location_id = l.id
+        INNER JOIN (
+          SELECT rrg.product_id, rrg.product_detail_id, rrg.sku, rrg.product_info, rrg.packing_type, rrg.packing_size, rrg.uom 
+          FROM raw_release_goods rrg
+          GROUP BY rrg.product_id, rrg.product_detail_id, rrg.sku, rrg.product_info, rrg.packing_type, rrg.packing_size, rrg.uom
+        ) AS foo
+        ON i.product_id = foo.product_id::uuid
+        AND i.packing_type = foo.packing_type
+        AND i.packing_size = foo.packing_size
+        AND i.uom = foo.uom
+        AND i.domain_id = $1
+        AND i.bizplace_id = $2
+        WHERE l.type NOT IN ($3, $4)
+        GROUP BY i.product_id, foo.product_detail_id, foo.sku,foo.product_info, i.packing_type, i.packing_size, i.uom
+        ORDER BY foo.sku, remain_qty
+      ) SELECT * FROM inv WHERE remain_qty > 0
+      `,
+    [domain.id, bizplaceId, LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
+  )
+
+  await tx.query(`DROP TABLE raw_release_goods`)
+
+  availableItems = availableItems.map(item => {
+    return {
+      productId: item.product_id,
+      productDetailId: item.product_detail_id,
+      productInfo: item.product_info,
+      sku: item.sku,
+      packingType: item.packing_type,
+      packingSize: Number(item.packing_size || 0),
+      uom: item.uom,
+      remainQty: item.remain_qty,
+      remainUomValue: item.remain_uom_value
+    }
+  })
+
+  return _extractData(rawReleaseGoods, availableItems)
+}
+
+function _extractData(rawData, validatedData) {
+  return rawData.map(raw => {
+    const idx = validatedData.findIndex(val => {
+      const comparison = ['packingType', 'packingSize', 'uom']
+
+      let a: any = {},
+        b: any = {}
+
+      comparison.forEach(cc => {
+        if (raw[cc]) {
+          a[cc] = raw[cc]
+          b[cc] = val[cc]
+        }
+      })
+
+      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
+      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
+
+      return val.sku.toLowerCase() == raw.sku.toLowerCase() && a === b
+    })
+
+    let releaseUomValue = 0
+
+    // if sku is matched, assign qty and product id
+    if (idx >= 0) {
+      // assign qty to rawData as much as possible
+      releaseUomValue =
+        (Math.round((validatedData[idx]?.remainUomValue / validatedData[idx]?.remainQty) * 100) / 100) * raw.releaseQty
+
+      raw.assignedQty =
+        validatedData[idx].remainQty >= raw.releaseQty
+          ? raw.releaseQty > 0
+            ? raw.releaseQty
+            : 0
+          : validatedData[idx].remainQty
+
+      raw.assignedUomValue =
+        validatedData[idx].remainUomValue >= releaseUomValue
+          ? releaseUomValue > 0
+            ? releaseUomValue
+            : 0
+          : validatedData[idx].remainUomValue
+
+      // deduct qty & uomValue from validateData
+      validatedData[idx].remainQty -= raw.assignedQty
+      validatedData[idx].remainUomValue -= raw.assignedUomValue
+
+      raw.productId = validatedData[idx].productId
+      raw.productDetailId = validatedData[idx].productDetailId
+      raw.productInfo = validatedData[idx].productInfo
+      raw.packingType = validatedData[idx].packingType
+      raw.packingSize = validatedData[idx].packingSize
+      raw.uom = validatedData[idx].uom
+    } else {
+      raw.assignedQty = 0
+      raw.assignedUomValue = 0
+      raw.productId = null
+    }
+
+    let releaseDate = _getStdDateStr(new Date(raw.releaseDate || ''))
+
+    return {
+      ...raw,
+      releaseUomValue,
+      errorMsg:
+        !raw.productId || !raw.productDetailId
+          ? 'inventory or product not found'
+          : raw.releaseQty <= 0
+            ? 'invalid release qty'
+            : raw.assignedQty < raw.releaseQty
+              ? 'insufficient stock'
+              : raw.releaseDate == ''
+                ? 'release date is empty'
+                : releaseDate < _getStdDateStr(new Date())
+                  ? 'backdate is not allowed'
+                  : !raw.refNo
+                    ? 'ref no is empty'
+                    : ''
+    }
+  })
+}
+
+function getConditionValues(conditions: Filter[]): {
+  batchId?: string
+  containerNo?: string
+  product?: string[]
+  packingType?: string
+  inventory?: { batchId: string; productId: string }[]
+} {
+  return conditions.reduce((condition, cond: Filter): {} => {
+    condition = {
+      ...condition,
+      [cond.name]: cond.value
+    }
+
+    return condition
+  }, {})
+}
+
+function _getStdDateStr(date) {
+  if (isNaN(date.getFullYear())) return ''
+  else {
+    date.setHours(date.getHours() + 8)
+    return date.toISOString().split('T')[0]
+  }
+}