@things-factory/sales-base 5.0.13 → 6.0.0-alpha.1

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

@@ -1,5 +1,5 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Brackets, EntityManager, getRepository, Like, SelectQueryBuilder } from 'typeorm'
+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'
@@ -10,11 +10,12 @@ import {
   Domain,
   Filter,
   getQueryBuilderFromListParams,
+  getRepository,
   ListParam,
   Pagination,
   Sorting
 } from '@things-factory/shell'
-import { Inventory, InventoryPatch, Location } from '@things-factory/warehouse-base'
+import { Inventory, InventoryPatch } from '@things-factory/warehouse-base'
 
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
 import { ArrivalNotice } from '../arrival-notice/arrival-notice'
@@ -30,66 +31,98 @@ interface filterInterface {
 @Resolver(OrderInventory)
 export class OrderInventoryQuery {
   @Query(returns => OrderInventoryList)
-  async orderInventories(@Ctx() context: any, @Args() params: ListParam): Promise<OrderInventoryList> {
-    const { domain }: { domain: Domain } = context.state
-    let filters = params.filters
-
-    // in case client side passes arrival notice or release good number as filter (single value only)
-    const anParam = filters.find(
-      (filter: filterInterface) => filter.name === 'arrivalNoticeNo' && filter.operator === 'eq'
-    )
-    const rgParam = filters.find(
-      (filter: filterInterface) => filter.name === 'releaseGoodNo' && filter.operator === 'eq'
-    )
-
-    if (anParam && !filters.some((filter: filterInterface) => filter.name === 'arrivalNotice')) {
+  async orderInventories(@Ctx() context: ResolverContext, @Args() 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: anParam.value,
+          name: arrivalNoticeNoParam.value,
           domain
         }
       })
 
       if (foundArrivalNotice) {
-        filters = params.filters.filter((filter: filterInterface) => filter.name !== 'arrivalNoticeNo')
-        params.filters = [...filters, { name: 'arrivalNotice', operator: 'eq', value: foundArrivalNotice.id }]
-      } else throw new Error(`Cannot find result for order "${anParam.value}"`)
+        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 (rgParam && !filters.some(filter => filter.name === 'releaseGood')) {
+    if (releaseGoodNoParam && releaseGoodNoParam?.value) {
       const foundReleaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
         where: {
-          name: rgParam.value,
+          name: releaseGoodNoParam.value,
           domain
         }
       })
 
       if (foundReleaseGood) {
-        filters = params.filters.filter(filter => filter.name !== 'releaseGoodNo')
-        params.filters = [...filters, { name: 'releaseGood', operator: 'eq', value: foundReleaseGood.id }]
-      } else throw new Error(`Cannot find result for order "${rgParam.value}"`)
+        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 convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(OrderInventory).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'arrivalNotice',
-        'inventory',
-        'inventory.product',
-        'releaseGood',
-        'deliveryOrder',
-        'creator',
-        'updater'
-      ]
-    })
+    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: any,
+    @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[]
@@ -169,12 +202,12 @@ export class OrderInventoryQuery {
   }
 
   @Query(returns => OrderInventory)
-  async orderInventory(@Arg('id') id: string, @Ctx() context: any): Promise<OrderInventory> {
-    const { domain }: { domain: Domain } = context.state
+  async orderInventory(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<OrderInventory> {
+    const { domain } = context.state
 
     return await getRepository(OrderInventory).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         id
       },
       relations: ['domain', 'releaseGood', 'inventory', 'creator', 'updater']
@@ -184,15 +217,15 @@ export class OrderInventoryQuery {
   @Query(returns => Boolean)
   async validateOrderInventory(
     @Arg('patches', type => [InventoryPatch]) patches: InventoryPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    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, palletId: patches[i]?.palletId }
+        where: { domain: { id: domain.id }, palletId: patches[i]?.palletId }
       })
 
       if (!foundExistingPallet) {
@@ -220,8 +253,8 @@ export class OrderInventoryQuery {
   }
 
   @Query(returns => OrderInventoryList)
-  async inventoriesByOrder(@Ctx() context: any, @Args() params: ListParam): Promise<OrderInventoryList> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async inventoriesByOrder(@Ctx() context: ResolverContext, @Args() params: ListParam): Promise<OrderInventoryList> {
+    const { domain, user } = context.state
 
     let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
 
@@ -288,12 +321,12 @@ export class OrderInventoryQuery {
 
   @Query(returns => OrderInventoryList)
   async nonLoadedOrderInventories(
-    @Ctx() context: any,
+    @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 }: { page: number; limit: number } = pagination
+    const { page, limit } = pagination
 
     try {
       const productFilter = filters.find(x => x.name == 'productInfo')
@@ -315,7 +348,7 @@ export class OrderInventoryQuery {
         .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')
+        .innerJoinAndSelect('oi.product', 'product')
         .leftJoinAndSelect('oi.binLocation', 'bin_loc')
         .andWhere('rg.status IN (:...releaseGoodStatus)', {
           releaseGoodStatus: [ORDER_STATUS.PICKING, ORDER_STATUS.LOADING]
@@ -370,20 +403,20 @@ export class OrderInventoryQuery {
       }
 
       if (sortings?.length !== 0) {
-        const sorter = (sortings || []).reduce((acc, sort) => {
+        const sorter: OrderByCondition = (sortings || []).reduce((acc, sort) => {
           const order: string = sort.desc ? 'DESC' : 'ASC'
 
           switch (sort.name) {
             case 'productSku':
-              acc = { ...acc, ['Product.sku']: order }
+              acc = { ...acc, ['product.sku']: order }
               break
 
             case 'productName':
-              acc = { ...acc, ['Product.name']: order }
+              acc = { ...acc, ['product.name']: order }
               break
 
             case 'productBrand':
-              acc = { ...acc, ['Product.brand']: order }
+              acc = { ...acc, ['product.brand']: order }
 
             case 'binLocation':
               acc = { ...acc, ['bin_loc.name']: order }
@@ -447,194 +480,137 @@ export class OrderInventoryQuery {
     }
   }
 
+  @Directive('@transaction')
   @Query(returns => OrderInventoryList)
   async orderInventoriesOfMultipleReleaseOrders(
-    @Ctx() context: any,
+    @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 }: { domain: Domain } = context.state
-      const binNumberParam: any = filters.find((param: any) => param.name === 'binNumber')
-      let arrFilters = []
-
-      if (binNumberParam) {
-        let binLocation: Location = await getRepository(Location).findOne({
-          where: { domain, name: binNumberParam.value }
-        })
-
-        filters.splice(
-          filters.findIndex(item => item.name == 'binNumber'),
-          1
-        )
-        arrFilters.push({ ...binNumberParam, name: 'binLocationId', value: binLocation.id })
-      }
-
-      const releaseGoodsList: ReleaseGood[] = await getRepository(ReleaseGood).query(
-        `select id from release_goods where domain_id = '${domain.id}' and bizplace_id = '${partnerId}' and route_id is not null and status = 'PICKING'`
-      )
-
-      if (releaseGoodsList && releaseGoodsList.length) {
-        arrFilters.push({
-          name: 'releaseGoodId',
-          operator: 'in',
-          value: releaseGoodsList.map((foundRG: ReleaseGood) => foundRG.id),
-          relation: false
-        })
+      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 {
-        arrFilters.push({
-          name: 'releaseGoodId',
-          operator: 'is_null',
-          relation: false
-        })
+        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
+        `
       }
 
-      const params = { filters: arrFilters }
-      const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
-      buildQuery(qb, params, context)
-
-      qb.select('oi')
-      qb.innerJoinAndSelect('oi.releaseGood', 'rg')
-      qb.innerJoinAndSelect('oi.product', 'Product')
-      qb.leftJoinAndSelect('oi.binLocation', 'bin_loc')
-      qb.leftJoinAndSelect('oi.domain', 'domain')
-      qb.leftJoinAndSelect('oi.creator', 'creator')
-      qb.leftJoinAndSelect('oi.updater', 'updater')
-
-      if (sortings?.length !== 0) {
-        const sorter = (sortings || []).reduce((acc, sort) => {
-          const order: string = sort.desc ? 'DESC' : 'ASC'
-
-          switch (sort.name) {
-            case 'roName':
-              acc = { ...acc, ['rg.name']: order }
-              break
-
-            case 'productSku':
-              acc = { ...acc, ['Product.sku']: order }
-              break
-
-            case 'binNumber':
-              acc = { ...acc, ['bin_loc.name']: order }
-              break
-          }
+      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]
+      )
 
-          return acc
-        }, {})
-        qb.orderBy(sorter)
+      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`
+        }
       }
 
-      const [items, total] = await qb.getManyAndCount()
+      if (priority) {
+        prioritySort = ' order by '
 
-      return { items, total }
-    } catch (e) {
-      throw e
-    }
-  }
-
-  @Query(returns => OrderInventoryList)
-  async orderInventoriesOfMergedReleaseOrders(
-    @Ctx() context: any,
-    @Arg('partnerId') partnerId: string,
-    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
-    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
-  ): Promise<OrderInventoryList> {
-    try {
-      const { domain }: { domain: Domain } = context.state
-      const binNumberParam: any = filters.find((param: any) => param.name === 'binNumber')
-      const priorityParam: any = filters.find((param: any) => param.name === 'priority')
-      let arrFilters = []
-
-      if (priorityParam) {
-        filters.splice(
-          filters.findIndex(item => item.name == 'priority'),
-          1
-        )
-
-        switch (priorityParam.value) {
+        switch (priority) {
           case 'roSku':
-            sortings.push({ name: 'releaseGood', desc: true })
-            sortings.push({ name: 'productSku', desc: false })
+            prioritySort = prioritySort + '"createdAt" desc, "productSKU" asc'
             break
 
           case 'roBin':
-            sortings.push({ name: 'releaseGood', desc: true })
-            sortings.push({ name: 'binNumber', desc: false })
+            prioritySort = prioritySort + '"createdAt" desc, "binNumber" asc'
+            break
+
+          case 'roTote':
+            prioritySort = prioritySort + '"createdAt" desc, "toteNumber" asc'
             break
 
           case 'skuRo':
-            sortings.push({ name: 'productSku', desc: false })
-            sortings.push({ name: 'releaseGood', desc: true })
+            prioritySort = prioritySort + '"productSKU" asc, "createdAt" desc'
             break
 
           case 'skuBin':
-            sortings.push({ name: 'productSku', desc: false })
-            sortings.push({ name: 'binNumber', desc: false })
+            prioritySort = prioritySort + '"productSKU"  asc, "binNumber" asc'
             break
 
           case 'binSku':
-            sortings.push({ name: 'binNumber', desc: false })
-            sortings.push({ name: 'productSku', desc: false })
+            prioritySort = prioritySort + '"binNumber" asc, "productSKU" asc'
             break
 
           case 'binRo':
-            sortings.push({ name: 'binNumber', desc: false })
-            sortings.push({ name: 'releaseGood', desc: true })
+            prioritySort = prioritySort + '"binNumber" asc, "createdAt" desc'
             break
-        }
-      }
-
-      const releaseGoodsList: ReleaseGood[] = await getRepository(ReleaseGood).query(
-        `select oi.release_good_id as id from worksheets w
-        inner join worksheet_details wd on wd.worksheet_id =w.id 
-        inner join order_inventories oi on oi.id =wd.target_inventory_id
-        inner join release_goods rg on rg.id = oi.release_good_id
-        and oi.status in ('PICKING', 'PICKED', 'SORTING', 'SORTED')
-        and w.type = 'BATCH_PICKING' and w.status != 'DEACTIVATED'
-        and rg.domain_id = '${domain.id}' and rg.bizplace_id = '${partnerId}'
-        and rg.route_id is not null
-        group by oi.release_good_id`
-      )
-
-      if (releaseGoodsList && releaseGoodsList.length) {
-        arrFilters.push({
-          name: 'releaseGoodId',
-          operator: 'in',
-          value: releaseGoodsList.map((foundRG: ReleaseGood) => foundRG.id),
-          relation: false
-        })
-      } else {
-        arrFilters.push({
-          name: 'releaseGoodId',
-          operator: 'is_null',
-          relation: false
-        })
-      }
 
-      const params = { filters: arrFilters }
-      const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
-      buildQuery(qb, params, context)
-
-      qb.select('oi')
-      qb.innerJoinAndSelect('oi.releaseGood', 'rg')
-      qb.innerJoinAndSelect('oi.product', 'Product')
-      qb.leftJoinAndSelect('oi.binLocation', 'bin_loc')
-      qb.leftJoinAndSelect('oi.domain', 'domain')
-      qb.leftJoinAndSelect('oi.creator', 'creator')
-      qb.leftJoinAndSelect('oi.updater', 'updater')
-
-      if (binNumberParam) {
-        let binLocation: Location = await getRepository(Location).findOne({
-          where: { domain, name: binNumberParam.value }
-        })
-
-        filters.splice(
-          filters.findIndex(item => item.name == 'binNumber'),
-          1
-        )
-
-        qb.andWhere('bin_loc.id = :id', { id: binLocation.id })
+          case 'toteRo':
+            prioritySort = prioritySort + '"toteNumber" asc, "createdAt" desc'
+            break
+        }
       }
 
       if (sortings?.length !== 0) {
@@ -643,28 +619,40 @@ export class OrderInventoryQuery {
 
           switch (sort.name) {
             case 'roName':
-              acc = { ...acc, ['rg.name']: order }
-              break
-
-            case 'releaseGood':
-              acc = { ...acc, ['rg.created_at']: order }
+              acc = [...acc, '"releaseGoodName" ' + order]
               break
 
             case 'productSku':
-              acc = { ...acc, ['Product.sku']: order }
+              acc = [...acc, '"productSKU" ' + order]
               break
 
             case 'binNumber':
-              acc = { ...acc, ['bin_loc.name']: order }
+              acc = [...acc, '"binNumber" ' + order]
+              break
+
+            case 'toteNumber':
+              acc = [...acc, '"toteNumber" ' + order]
               break
           }
 
           return acc
-        }, {})
-        qb.orderBy(sorter)
+        }, [])
+
+        sort = (priority ? ', ' : ' order by ') + sorter.toString()
       }
 
-      const [items, total] = await qb.getManyAndCount()
+      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) {
@@ -674,70 +662,55 @@ export class OrderInventoryQuery {
 
   @Query(returns => OrderInventoryList)
   async orderInventoriesForReleaseGood(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Args() params: ListParam,
     @Arg('productTypes', type => [String], { nullable: true }) productTypes?: string[]
   ): Promise<OrderInventoryList> {
-    const { domain }: { domain: Domain } = context.state
-    let filters = params.filters
-
-    const rgParam = filters.find(
-      (filter: filterInterface) => filter.name === 'releaseGoodNo' && filter.operator === 'eq'
-    )
-
-    if (rgParam && !filters.some(filter => filter.name === 'releaseGood')) {
-      if (!rgParam.value) filters = params.filters.filter(filter => filter.name !== 'releaseGoodNo')
-      else {
-        const foundReleaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-          where: {
-            name: rgParam.value,
-            domain
-          }
-        })
-
-        if (foundReleaseGood) {
-          filters = params.filters.filter(filter => filter.name !== 'releaseGoodNo')
-          params.filters = [...filters, { name: 'releaseGood', operator: 'eq', value: foundReleaseGood.id }]
-        } else throw new Error(`Cannot find result for order "${rgParam.value}"`)
-      }
-    }
+    const { domain } = context.state
 
     const qb = getQueryBuilderFromListParams({
       repository: getRepository(OrderInventory),
       params,
       domain,
       alias: 'oi',
-      searchables: ['bizplace', 'product']
+      searchables: ['bizplace', 'product', 'releaseGood', 'lot'],
+      filtersMap: {
+        lot: {
+          /* 조인 테이블의 필터대상 컬럼이름을 디폴트('name')에서 다른 컬럼('sku')로 변경 */
+          relationColumn: 'inventory',
+          columnName: 'palletId'
+        }
+      }
     })
 
-    const [items, total] = await qb
-      .leftJoinAndSelect('oi.releaseGood', 'rg')
+    qb.leftJoinAndSelect('oi.releaseGood', 'rg')
       .leftJoinAndSelect('rg.deliverTo', 'deliverTo')
       .leftJoinAndSelect('deliverTo.bizplace', 'deliverToBizplace')
-      .leftJoinAndSelect('oi.product', 'p')
       .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
       })
-      .getManyAndCount()
+
+    const [items, total] = await qb.getManyAndCount()
 
     return { items, total }
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() orderInventory: OrderInventory): Promise<Domain> {
-    return await getRepository(Domain).findOne(orderInventory.domainId)
+    return await getRepository(Domain).findOneBy({ id: orderInventory.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() orderInventory: OrderInventory): Promise<User> {
-    return await getRepository(User).findOne(orderInventory.creatorId)
+    return await getRepository(User).findOneBy({ id: orderInventory.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() orderInventory: OrderInventory): Promise<User> {
-    return await getRepository(User).findOne(orderInventory.updaterId)
+    return await getRepository(User).findOneBy({ id: orderInventory.updaterId })
   }
 }