@things-factory/sales-base 8.0.2 → 8.0.5

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

@@ -1,980 +0,0 @@
-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]
-  }
-}