@things-factory/sales-base 8.0.0-beta.0 → 8.0.0-beta.2

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

@@ -1,722 +0,0 @@
-import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Brackets, Like, OrderByCondition, SelectQueryBuilder } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import {
-  buildQuery,
-  convertListParams,
-  Domain,
-  Filter,
-  getQueryBuilderFromListParams,
-  getRepository,
-  ListParam,
-  Pagination,
-  Sorting
-} from '@things-factory/shell'
-import { Inventory, InventoryPatch } from '@things-factory/warehouse-base'
-
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
-import { ArrivalNotice } from '../arrival-notice/arrival-notice'
-import { OrderInventoryList } from '../order-inventory/order-inventory-types'
-import { ReleaseGood } from '../release-good/release-good'
-import { OrderInventory } from './order-inventory'
-
-interface filterInterface {
-  name: string
-  operator: string
-  value: any
-}
-@Resolver(OrderInventory)
-export class OrderInventoryQuery {
-  @Query(returns => OrderInventoryList)
-  async orderInventories(
-    @Ctx() context: ResolverContext,
-    @Args(type => ListParam) params: ListParam
-  ): Promise<OrderInventoryList> {
-    const { domain } = context.state
-    const arrivalNoticeNoParam: any = params.filters.find((param: any) => param.name === 'arrivalNoticeNo')
-    const releaseGoodNoParam: any = params.filters.find((param: any) => param.name === 'releaseGoodNo')
-
-    if (arrivalNoticeNoParam && arrivalNoticeNoParam?.value) {
-      const foundArrivalNotice: ArrivalNotice = await getRepository(ArrivalNotice).findOne({
-        where: {
-          name: arrivalNoticeNoParam.value,
-          domain: { id: domain.id }
-        }
-      })
-
-      if (foundArrivalNotice) {
-        params.filters.splice(
-          params.filters.findIndex(item => item.name == 'arrivalNoticeNo'),
-          1
-        )
-        params.filters.push({ name: 'arrivalNoticeId', operator: 'eq', value: foundArrivalNotice.id })
-      } else {
-        throw new Error(`Cannot find result for order "${arrivalNoticeNoParam.value}"`)
-      }
-    }
-
-    if (releaseGoodNoParam && releaseGoodNoParam?.value) {
-      const foundReleaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-        where: {
-          name: releaseGoodNoParam.value,
-          domain: { id: domain.id }
-        }
-      })
-
-      if (foundReleaseGood) {
-        params.filters.splice(
-          params.filters.findIndex(item => item.name == 'releaseGoodNo'),
-          1
-        )
-        params.filters.push({ name: 'releaseGoodId', operator: 'eq', value: foundReleaseGood.id })
-      } else {
-        throw new Error(`Cannot find result for order "${releaseGoodNoParam.value}"`)
-      }
-    }
-
-    const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
-    buildQuery(qb, params, context)
-
-    qb.leftJoinAndSelect('oi.domain', 'domain')
-    qb.leftJoinAndSelect('oi.arrivalNotice', 'arrivalNotice')
-    qb.leftJoinAndSelect('oi.orderProduct', 'orderProduct')
-    qb.leftJoinAndSelect('oi.inventory', 'inventory')
-    qb.leftJoinAndSelect('inventory.product', 'product')
-    qb.leftJoinAndSelect('inventory.location', 'location')
-    qb.leftJoinAndSelect('oi.releaseGood', 'releaseGood')
-    qb.leftJoinAndSelect('oi.deliveryOrder', 'deliveryOrder')
-    qb.leftJoinAndSelect('oi.creator', 'creator')
-    qb.leftJoinAndSelect('oi.updater', 'updater')
-
-    let sort: OrderByCondition = {}
-    if (params?.sortings) {
-      if (params.sortings.some(e => e.name === 'inventoryPalletId')) {
-        // overwrite the worksheet status sorting since inventory check status is needed
-        sort = {
-          'inventory.palletId': params.sortings[params.sortings.findIndex(item => item.name == 'inventoryPalletId')]
-            .desc
-            ? 'DESC'
-            : 'ASC',
-          'oi.createdAt': params.sortings[params.sortings.findIndex(item => item.name == 'createdAt')]?.desc
-            ? 'DESC'
-            : 'ASC'
-        }
-      } else if (params.sortings.some(e => e.name === 'createdAt')) {
-        sort = {
-          ...sort,
-          'oi.createdAt': params.sortings[params.sortings.findIndex(item => item.name == 'createdAt')]?.desc
-            ? 'DESC'
-            : 'ASC'
-        }
-      }
-    } else {
-      sort = { 'oi.createdAt': 'ASC' }
-    }
-
-    qb.orderBy(sort)
-
-    let [items, total] = await qb.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => OrderInventoryList)
-  async mergedProductOrderInventories(
-    @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<OrderInventoryList> {
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-    let [items, total] = await getRepository(OrderInventory).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'arrivalNotice',
-        'inventory',
-        'product',
-        'releaseGood',
-        'deliveryOrder',
-        'creator',
-        'updater'
-      ]
-    })
-
-    items = items
-      .map((item: OrderInventory) => {
-        const product: Product = item.product
-        return {
-          productName: `(${product?.sku ? product.sku : '-'}) ${product.name}`,
-          packingType: item.packingType,
-          packingSize: item.packingSize,
-          sku: item.product.sku,
-          batchId: item.batchId,
-          batchIdRef: item.batchIdRef,
-          releaseQty: item.releaseQty,
-          releaseUomValue: item.releaseUomValue
-        }
-      })
-      .reduce((newItem, item) => {
-        let foundItem = newItem.find(
-          newItem =>
-            newItem.sku === item.sku &&
-            newItem.packingType === item.packingType &&
-            newItem.packingSize === item.packingSize &&
-            newItem.batchId === item.batchId
-        )
-        if (!foundItem) {
-          foundItem = {
-            productName: item.productName,
-            packingType: item.packingType,
-            packingSize: item.packingSize,
-            sku: item.sku,
-            batchId: item.batchId,
-            batchIdRef: item.batchIdRef,
-            releaseQty: item.releaseQty,
-            releaseUomValue: item.releaseUomValue
-          }
-
-          newItem.push(foundItem)
-          return newItem
-        } else {
-          return newItem.map(ni => {
-            if (
-              ni.sku === item.sku &&
-              ni.packingType === item.packingType &&
-              ni.packingSize === item.packingSize &&
-              ni.batchId === item.batchId
-            ) {
-              return {
-                ...ni,
-                releaseQty: ni.releaseQty + item.releaseQty,
-                releaseUomValue: ni.releaseUomValue + item.releaseUomValue
-              }
-            } else {
-              return ni
-            }
-          })
-        }
-      }, [])
-
-    return { items, total }
-  }
-
-  @Query(returns => OrderInventory)
-  async orderInventory(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<OrderInventory> {
-    const { domain } = context.state
-
-    return await getRepository(OrderInventory).findOne({
-      where: {
-        domain: { id: domain.id },
-        id
-      },
-      relations: ['domain', 'releaseGood', 'inventory', 'creator', 'updater']
-    })
-  }
-
-  @Query(returns => Boolean)
-  async validateOrderInventory(
-    @Arg('patches', type => [InventoryPatch]) patches: InventoryPatch[],
-    @Ctx() context: ResolverContext
-  ) {
-    const { domain, user, tx } = context.state
-
-    let error = []
-
-    for (let i = 0; i < patches.length; i++) {
-      let foundExistingPallet: Inventory = await getRepository(Inventory).findOne({
-        where: { domain: { id: domain.id }, palletId: patches[i]?.palletId }
-      })
-
-      if (!foundExistingPallet) {
-        foundExistingPallet = await getRepository(Inventory).findOne({
-          where: { id: patches[i]?.id }
-        })
-      }
-
-      if (patches[i]?.batchId != null) {
-        const worksheet: OrderInventory[] = await getRepository(OrderInventory).find({
-          where: { inventory: foundExistingPallet?.id as any, status: 'PICKING' }
-        })
-
-        if (worksheet.length > 0) {
-          error = [...worksheet]
-        }
-      }
-    }
-
-    if (error.length == 0) {
-      return true
-    } else {
-      return false
-    }
-  }
-
-  @Query(returns => OrderInventoryList)
-  async inventoriesByOrder(
-    @Ctx() context: ResolverContext,
-    @Args(type => ListParam) params: ListParam
-  ): Promise<OrderInventoryList> {
-    const { domain, user } = context.state
-
-    let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
-
-    if (!params.filters.find((filter: any) => filter.name === 'bizplaceId')) {
-      params.filters.push({
-        name: 'bizplaceId',
-        operator: 'in',
-        value: permittedBizplaceIds,
-        relation: true
-      })
-    } else {
-      permittedBizplaceIds = params.filters.find(filter => filter.name === 'bizplaceId').value
-      params.filters.find(filter => filter.name === 'bizplaceId').relation = true
-    }
-
-    if (params.filters.find((filter: any) => filter.name === 'releaseGoodName')?.value) {
-      let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-        where: {
-          name: Like(params.filters.find(filter => filter.name === 'releaseGoodName').value)
-        }
-      })
-
-      if (releaseGood) {
-        params.filters = params.filters.filter(filter => filter.name != 'releaseGoodName')
-
-        params.filters.push({
-          name: 'releaseGoodId',
-          operator: 'eq',
-          value: releaseGood.id,
-          relation: true
-        })
-      }
-    }
-    const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
-    buildQuery(qb, params, context)
-
-    qb.innerJoinAndSelect('oi.releaseGood', 'releaseGood')
-      .leftJoinAndSelect('oi.domain', 'domain')
-      .leftJoinAndSelect('oi.bizplace', 'bizplace')
-      .leftJoinAndSelect('oi.inventory', 'inventory')
-      .leftJoinAndSelect('inventory.product', 'product')
-      .leftJoinAndSelect('oi.creator', 'creator')
-      .leftJoinAndSelect('oi.updater', 'updater')
-
-    qb.andWhere('releaseGood.status = :status', { status: 'DONE' })
-    let [items, total] = await qb.getManyAndCount()
-
-    items = items.map((item: OrderInventory) => {
-      return {
-        ...item,
-        id: item.inventory.id,
-        releaseGoodName: item.releaseGood.name,
-        palletId: item.inventory.palletId,
-        productId: item.inventory.product.id,
-        productName: item.inventory.product.name,
-        productSKU: item.inventory.product.sku,
-        productBrand: item.inventory.product.brand,
-        packingSize: item.inventory.packingSize
-      }
-    })
-
-    return { items, total }
-  }
-
-  @Query(returns => OrderInventoryList)
-  async nonLoadedOrderInventories(
-    @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<OrderInventoryList> {
-    const { page, limit } = pagination
-
-    try {
-      const productFilter = filters.find(x => x.name == 'productInfo')
-      const roNoFilter = filters.find(x => x.name == 'roNo')
-      const refNoFilter = filters.find(x => x.name == 'refNo')
-      const binLocationFilter = filters.find(x => x.name == 'binLocation')
-      const lotIdFilter = filters.find(x => x.name == 'palletId')
-      const cartonIdFilter = filters.find(x => x.name == 'cartonId')
-
-      filters = filters.filter(
-        filter => ['productInfo', 'roNo', 'refNo', 'binLocation', 'palletId', 'cartonId'].indexOf(filter.name) == -1
-      )
-
-      const params = { filters, pagination }
-      const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
-      buildQuery(qb, params, context)
-
-      qb.select('oi')
-        .addSelect('(oi.release_uom_value / oi.release_qty) * oi.picked_qty', 'picked_uom_value')
-        .innerJoinAndSelect('oi.inventory', 'inv')
-        .innerJoinAndSelect('oi.releaseGood', 'rg')
-        .innerJoinAndSelect('oi.product', 'product')
-        .leftJoinAndSelect('oi.binLocation', 'bin_loc')
-        .andWhere('rg.status IN (:...releaseGoodStatus)', {
-          releaseGoodStatus: [ORDER_STATUS.PICKING, ORDER_STATUS.LOADING]
-        })
-        .andWhere('oi.status IN (:...orderInventoryStatus)', {
-          orderInventoryStatus: [
-            ORDER_INVENTORY_STATUS.PICKED,
-            ORDER_INVENTORY_STATUS.LOADING,
-            ORDER_INVENTORY_STATUS.LOADED
-          ]
-        })
-
-      if (productFilter) {
-        let productFilterValue = `%${productFilter.value.toLowerCase()}%`
-        qb.andWhere(qb => {
-          const subQuery = qb
-            .subQuery()
-            .select()
-            .from(Product, `products`)
-            .where(`products.id = oi.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 })
-                  .orWhere('Lower(products.brand) LIKE :productInfo', { productInfo: productFilterValue })
-              })
-            )
-            .getQuery()
-          return `EXISTS ${subQuery}`
-        })
-      }
-
-      if (roNoFilter) {
-        qb.andWhere('Lower(rg.name) LIKE :roNo', { roNo: roNoFilter.value.toLowerCase() })
-      }
-
-      if (refNoFilter) {
-        qb.andWhere('Lower(rg.ref_no) LIKE :refNo', { refNo: refNoFilter.value.toLowerCase() })
-      }
-
-      if (binLocationFilter) {
-        qb.andWhere('Lower(bin_loc.name) LIKE :binLocation', { binLocation: binLocationFilter.value.toLowerCase() })
-      }
-
-      if (lotIdFilter) {
-        qb.andWhere('Lower(inv.pallet_id) LIKE :palletId', { palletId: lotIdFilter.value.toLowerCase() })
-      }
-
-      if (cartonIdFilter) {
-        qb.andWhere('Lower(inv.carton_id) LIKE :cartonId', { cartonId: cartonIdFilter.value.toLowerCase() })
-      }
-
-      if (sortings?.length !== 0) {
-        const sorter: OrderByCondition = (sortings || []).reduce((acc, sort) => {
-          const order: string = sort.desc ? 'DESC' : 'ASC'
-
-          switch (sort.name) {
-            case 'productSku':
-              acc = { ...acc, ['product.sku']: order }
-              break
-
-            case 'productName':
-              acc = { ...acc, ['product.name']: order }
-              break
-
-            case 'productBrand':
-              acc = { ...acc, ['product.brand']: order }
-
-            case 'binLocation':
-              acc = { ...acc, ['bin_loc.name']: order }
-              break
-
-            default:
-              acc = { ...acc, [`oi.${sort.name}`]: order }
-              break
-          }
-
-          return acc
-        }, {})
-        qb.orderBy(sorter)
-      }
-
-      let items = await qb
-        .offset((page - 1) * limit)
-        .limit(limit)
-        .getRawMany()
-
-      let total = await qb.getCount()
-      return {
-        total,
-        items: items.reduce((acc, item) => {
-          acc.push(
-            Object.assign(new OrderInventory(), {
-              id: item.oi_id,
-              batchId: item.oi_batch_id,
-              packingType: item.oi_packing_type,
-              packingSize: item.oi_packing_size,
-              uom: item.oi_uom,
-              pickedQty: item.oi_picked_qty,
-              pickedUomValue: item.picked_uom_value,
-              product: new Product(item),
-              binLocation: {
-                id: item.bin_loc_id,
-                name: item.bin_loc_name,
-                description: item.bin_loc_description
-              },
-              releaseGood: {
-                id: item.rg_id,
-                name: item.rg_name,
-                refNo: item.rg_ref_no,
-                description: item.rg_description
-              },
-              inventory: {
-                id: item.inv_id,
-                palletId: item.inv_pallet_id,
-                cartonId: item.inv_carton_id
-              },
-              createdAt: item.oi_created_at,
-              updatedAt: item.oi_updated_at
-            })
-          )
-
-          return acc
-        }, [])
-      }
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Directive('@transaction')
-  @Query(returns => OrderInventoryList)
-  async orderInventoriesOfMultipleReleaseOrders(
-    @Ctx() context: ResolverContext,
-    @Arg('partnerId') partnerId: string,
-    @Arg('priority', { nullable: true }) priority: string,
-    @Arg('binNumber', { nullable: true }) binNumber: string,
-    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
-    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
-  ): Promise<OrderInventoryList> {
-    try {
-      const { domain, tx } = context.state
-      const withSkuParam: any = filters.find((param: any) => param.name === 'withSku')
-      const withToteParam: any = filters.find((param: any) => param.name === 'withTote')
-      const mergedPageParam: any = filters.find((param: any) => param.name === 'merged')
-
-      let sort = ''
-      let prioritySort = ''
-      let releaseOrderIdQuery = ''
-
-      // Require further evaluation. Potential performance issue.
-      if (mergedPageParam) {
-        releaseOrderIdQuery = `
-        select rg.id from release_goods rg
-        inner join order_inventories oi on oi.release_good_id = rg.id
-        inner join worksheet_details wd on wd.target_inventory_id = oi.id
-        inner join worksheets w on w.id = wd.worksheet_id
-        where rg.route_id is not null and rg.type = 'b2b'
-        and rg.domain_id = $1 and rg.bizplace_id = $2
-        and w.type in ('BATCH_PICKING', 'SORTING', 'LOADING') and w.status = 'EXECUTING'
-        and rg.id not in (select rg2.id from release_goods rg2 
-          inner join worksheets w2 on w2.release_good_id = rg2.id 
-          where rg2.domain_id = $1 and rg2.bizplace_id = $2
-          and rg2.route_id is not null and rg2.type = 'b2b' 
-          and w2.type in ('PICKING'))
-        group by rg.id
-        `
-      } else {
-        releaseOrderIdQuery = `
-        select rg.id from release_goods rg 
-        inner join worksheets w on w.release_good_id = rg.id 
-        where rg.domain_id = $1 and rg.bizplace_id = $2
-        and rg.route_id is not null and rg.type = 'b2b' 
-        and w.type in ('PICKING', 'LOADING') and w.status = 'EXECUTING'
-        and rg.id not in (select rg2.id from release_goods rg2 
-          inner join order_inventories oi2 on oi2.release_good_id = rg2.id
-          inner join worksheet_details wd2 on wd2.target_inventory_id = oi2.id
-          inner join worksheets w2 on w2.id = wd2.worksheet_id
-          where rg2.route_id is not null and rg2.type = 'b2b'
-          and rg2.domain_id = $1 and rg2.bizplace_id = $2
-          and w2.type in ('BATCH_PICKING'))
-        group by rg.id
-        `
-      }
-
-      await tx.query(
-        `
-          create temp table temp_route_label ON COMMIT drop as (
-            select distinct(ot.name) as "toteNumber", oi.id, rg3.name as "releaseGoodName", (case when ot.name is null then oi.release_qty else null end) as "releaseQty", 
-            (case when ot.name is null then p.sku else null end) as "productSKU", (case when ot.name is null then p.name else null end) as "productName", (case when ot.name is null then l.name else null end) as "binNumber",
-            rg3.route_id as "routeId", rg3.store_id as "storeId", rg3.store_name as "storeName", rg3.stop_id as "stopId", 
-            rg3.created_at as "createdAt" from order_inventories oi 
-            inner join release_goods rg3 on rg3.id = oi.release_good_id
-            inner join products p on p.id = oi.product_id
-            left join locations l on l.id = oi.bin_location_id
-            left join order_tote_items oti on oti.order_inventory_id = oi.id
-            left join order_totes ot on ot.id = oti.order_tote_id
-            where oi.release_good_id in 
-              (${releaseOrderIdQuery})
-          )
-        `,
-        [domain.id, partnerId]
-      )
-
-      let withSkuQuery = withSkuParam?.value == true ? `AND tmp."binNumber" is null AND tmp."toteNumber" is null` : ''
-      let withBinQuery = ''
-      let withToteQuery =
-        withToteParam?.value == true
-          ? (withSkuParam?.value == true || binNumber ? `OR ` : 'AND ') + `tmp."toteNumber" is not null`
-          : ''
-
-      if (binNumber) {
-        if (binNumber !== 'all' && binNumber !== '') {
-          withBinQuery =
-            (withSkuParam?.value == true || withToteParam?.value == false ? `OR ` : `AND `) +
-            `tmp."binNumber" = '` +
-            binNumber +
-            `'`
-        } else if (binNumber == 'all') {
-          withBinQuery =
-            (withSkuParam?.value == true || withToteParam?.value == false ? `OR ` : `AND `) +
-            `tmp."binNumber" is not null`
-        }
-      }
-
-      if (priority) {
-        prioritySort = ' order by '
-
-        switch (priority) {
-          case 'roSku':
-            prioritySort = prioritySort + '"createdAt" desc, "productSKU" asc'
-            break
-
-          case 'roBin':
-            prioritySort = prioritySort + '"createdAt" desc, "binNumber" asc'
-            break
-
-          case 'roTote':
-            prioritySort = prioritySort + '"createdAt" desc, "toteNumber" asc'
-            break
-
-          case 'skuRo':
-            prioritySort = prioritySort + '"productSKU" asc, "createdAt" desc'
-            break
-
-          case 'skuBin':
-            prioritySort = prioritySort + '"productSKU"  asc, "binNumber" asc'
-            break
-
-          case 'binSku':
-            prioritySort = prioritySort + '"binNumber" asc, "productSKU" asc'
-            break
-
-          case 'binRo':
-            prioritySort = prioritySort + '"binNumber" asc, "createdAt" desc'
-            break
-
-          case 'toteRo':
-            prioritySort = prioritySort + '"toteNumber" asc, "createdAt" desc'
-            break
-        }
-      }
-
-      if (sortings?.length !== 0) {
-        const sorter = (sortings || []).reduce((acc, sort) => {
-          const order: string = sort.desc ? 'DESC' : 'ASC'
-
-          switch (sort.name) {
-            case 'roName':
-              acc = [...acc, '"releaseGoodName" ' + order]
-              break
-
-            case 'productSku':
-              acc = [...acc, '"productSKU" ' + order]
-              break
-
-            case 'binNumber':
-              acc = [...acc, '"binNumber" ' + order]
-              break
-
-            case 'toteNumber':
-              acc = [...acc, '"toteNumber" ' + order]
-              break
-          }
-
-          return acc
-        }, [])
-
-        sort = (priority ? ', ' : ' order by ') + sorter.toString()
-      }
-
-      let items = await tx.query(
-        `
-          select * from temp_route_label tmp where 1 = 1
-          ${withSkuQuery}
-          ${withBinQuery}
-          ${withToteQuery}
-          ${prioritySort}
-          ${sort}
-          `
-      )
-
-      let total = items.length
-
-      return { items, total }
-    } catch (e) {
-      throw e
-    }
-  }
-
-  @Query(returns => OrderInventoryList)
-  async orderInventoriesForReleaseGood(
-    @Ctx() context: ResolverContext,
-    @Args(type => ListParam) params: ListParam,
-    @Arg('productTypes', type => [String], { nullable: true }) productTypes?: string[]
-  ): Promise<OrderInventoryList> {
-    const { domain } = context.state
-
-    const qb = getQueryBuilderFromListParams({
-      repository: getRepository(OrderInventory),
-      params,
-      domain,
-      alias: 'oi',
-      searchables: ['bizplace', 'product', 'releaseGood', 'lot'],
-      filtersMap: {
-        lot: {
-          /* 조인 테이블의 필터대상 컬럼이름을 디폴트('name')에서 다른 컬럼('sku')로 변경 */
-          relationColumn: 'inventory',
-          columnName: 'palletId'
-        }
-      }
-    })
-
-    qb.leftJoinAndSelect('oi.releaseGood', 'rg')
-      .leftJoinAndSelect('rg.deliverTo', 'deliverTo')
-      .leftJoinAndSelect('deliverTo.bizplace', 'deliverToBizplace')
-      .leftJoinAndSelect('oi.inventory', 'i')
-      .leftJoinAndSelect('oi.product', 'p')
-      .leftJoinAndSelect('oi.bizplace', 'b')
-      .andWhere('oi.type = :oiType', { oiType: 'RELEASE_OF_GOODS' })
-      .andWhere('p.type IN (:...productTypes)', {
-        productTypes: productTypes
-      })
-
-    const [items, total] = await qb.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() orderInventory: OrderInventory): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: orderInventory.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() orderInventory: OrderInventory): Promise<User> {
-    return await getRepository(User).findOneBy({ id: orderInventory.creatorId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() orderInventory: OrderInventory): Promise<User> {
-    return await getRepository(User).findOneBy({ id: orderInventory.updaterId })
-  }
-}