@things-factory/sales-base 8.0.2 → 8.0.5

package/server/service/reverse-kitting-order/reverse-kitting-order-mutation.ts

@@ -1,500 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { Equal, In, Not } from 'typeorm'
-
-import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Product, ProductDetail } from '@things-factory/product-base'
-import {
-  Inventory,
-  INVENTORY_STATUS,
-  INVENTORY_TRANSACTION_TYPE,
-  InventoryHistory,
-  InventoryNoGenerator,
-  InventoryPatch,
-  Location,
-  LOCATION_TYPE,
-  Warehouse
-} from '@things-factory/warehouse-base'
-
-import { ORDER_STATUS, ORDER_TYPES, ORDER_VAS_STATUS } from '../../constants'
-import { InventoryUtil } from '../../utils'
-import { OrderNoGenerator } from '../../utils/order-no-generator'
-import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
-import { ReverseKittingOrder } from './reverse-kitting-order'
-import { NewReverseKittingOrder } from './reverse-kitting-order-type'
-
-@Resolver(ReverseKittingOrder)
-export class ReverseKittingOrderMutation {
-  @Directive('@transaction')
-  @Mutation(returns => ReverseKittingOrder, { description: 'To create new ReverseKittingOrder' })
-  async generateReverseKittingOrder(
-    @Arg('reverseKittingOrder', type => NewReverseKittingOrder) reverseKittingOrder: NewReverseKittingOrder,
-    @Ctx() context: ResolverContext
-  ): Promise<ReverseKittingOrder> {
-    const { tx, domain, user } = context.state
-
-    const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
-      where: { id: reverseKittingOrder.customerBizplaceId }
-    })
-
-    if (!customerBizplace) throw new Error('company is not found')
-
-    let reverseKittingOrderOIs = reverseKittingOrder.reverseKittingOrderInventories
-
-    // 1. Create reverse kitting order
-    const createdReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).save({
-      ...reverseKittingOrder,
-      name: OrderNoGenerator.vasOrder(),
-      domain,
-      bizplace: customerBizplace,
-      status: ORDER_STATUS.PENDING,
-      creator: user
-    })
-
-    // 2. Create Reverse Kitting Order Items
-    reverseKittingOrderOIs = await Promise.all(
-      reverseKittingOrderOIs.map(async (reverseKittingOI: any) => {
-        if (reverseKittingOI?.inventory?.id) {
-          const foundInv: Inventory = await tx.getRepository(Inventory).findOneBy({ id: reverseKittingOI.inventory.id })
-          reverseKittingOI.inventory = foundInv
-
-          foundInv.lockedQty = Number(foundInv.lockedQty) + reverseKittingOI.qty
-          foundInv.lockedUomValue = Number(foundInv.lockedUomValue) + reverseKittingOI.uomValue
-          foundInv.updater = user
-
-          await tx.getRepository(Inventory).save(foundInv)
-        }
-        return {
-          ...reverseKittingOI,
-          domain,
-          name: OrderNoGenerator.orderVas(),
-          reverseKittingOrder: createdReverseKittingOrder,
-          bizplace: customerBizplace,
-          type: ORDER_TYPES.VAS_ORDER,
-          status: ORDER_VAS_STATUS.PENDING,
-          creator: user
-        }
-      })
-    )
-    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOrderOIs)
-
-    return createdReverseKittingOrder
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ReverseKittingOrder, { description: 'To execute reverse kitting order' })
-  async executingReverseKittingOrder(
-    @Arg('name') name: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ReverseKittingOrder> {
-    const { domain, user, tx } = context.state
-
-    const reverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: {
-        domain: { id: domain.id },
-        name,
-        status: ORDER_STATUS.EXECUTING,
-        bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) }
-      },
-      relations: [
-        'domain',
-        'bizplace',
-        'reverseKittingOrderInventories',
-        'reverseKittingOrderInventories.inventory',
-        'reverseKittingOrderInventories.inventory.product',
-        'reverseKittingOrderInventories.inventory.location',
-        'reverseKittingOrderInventories.inventory.warehouse',
-        'creator',
-        'updater'
-      ]
-    })
-
-    if (!reverseKittingOrder) throw new Error(`Reverse Kitting Order not exists`)
-
-    return reverseKittingOrder
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ReverseKittingOrder, { description: 'To confirm reverse kitting order' })
-  async confirmReverseKittingOrder(
-    @Arg('name') name: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ReverseKittingOrder> {
-    const { user, domain, tx } = context.state
-
-    const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING },
-      relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
-    })
-
-    let reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
-
-    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
-
-    // 1. Reverse Kitting Order Status change (PENDING => READY_TO_EXECUTE)
-    const reverseKitting: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).save({
-      ...foundReverseKittingOrder,
-      status: ORDER_STATUS.READY_TO_EXECUTE,
-      updater: user
-    })
-
-    reverseKittingOIs = reverseKittingOIs.map((reverseKittingOI: ReverseKittingOrderInventory) => {
-      return { ...reverseKittingOI, status: ORDER_VAS_STATUS.READY_TO_PROCESS }
-    })
-    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
-
-    return reverseKitting
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To confirm reverse kitting order' })
-  async completeReverseKittingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx, domain, user } = context.state
-
-    let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.EXECUTING },
-      relations: [
-        'bizplace',
-        'reverseKittingOrderInventories',
-        'reverseKittingOrderInventories.inventory',
-        'creator',
-        'updater'
-      ]
-    })
-
-    if (!foundReverseKittingOrder) throw new Error(foundReverseKittingOrder.name + ` not found`)
-
-    let reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
-
-    await Promise.all(
-      reverseKittingOIs.map(async reverseKittingOI => {
-        let inventory: Inventory = reverseKittingOI.inventory
-        inventory.qty = inventory.qty - reverseKittingOI.qty
-        inventory.lockedQty = inventory.lockedQty - reverseKittingOI.qty
-        inventory.uomValue = inventory.uomValue - reverseKittingOI.uomValue
-        inventory.lockedUomValue = inventory.lockedUomValue - reverseKittingOI.uomValue
-
-        await InventoryUtil.transactionInventory(
-          inventory,
-          foundReverseKittingOrder,
-          -reverseKittingOI.qty,
-          -reverseKittingOI.uomValue,
-          INVENTORY_TRANSACTION_TYPE.REVERSE_KITTING,
-          user,
-          tx
-        )
-      })
-    )
-
-    reverseKittingOIs = reverseKittingOIs.map(reverseKittingOI => {
-      return {
-        ...reverseKittingOI,
-        status: ORDER_VAS_STATUS.TERMINATED,
-        updater: user
-      }
-    })
-
-    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
-
-    foundReverseKittingOrder.status = ORDER_STATUS.DONE
-    foundReverseKittingOrder.updater = user
-
-    await tx.getRepository(ReverseKittingOrder).save(foundReverseKittingOrder)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ReverseKittingOrder, { description: 'To cancel reverse kitting order' })
-  async cancelReverseKittingOrder(
-    @Arg('name') name: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ReverseKittingOrder> {
-    const { user, domain, tx } = context.state
-
-    const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.READY_TO_EXECUTE },
-      relations: [
-        'bizplace',
-        'reverseKittingOrderInventories',
-        'reverseKittingOrderInventories.inventory',
-        'creator',
-        'updater'
-      ]
-    })
-
-    let reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
-
-    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
-
-    // 1. Reverse Kitting Order Status change (PENDING => PENDING_RECEIVE)
-    const reverseKitting: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).save({
-      ...foundReverseKittingOrder,
-      status: ORDER_STATUS.CANCELLED,
-      updater: user
-    })
-
-    reverseKittingOIs = await Promise.all(
-      reverseKittingOIs.map(async (reverseKittingOI: ReverseKittingOrderInventory) => {
-        if (reverseKittingOI?.inventory?.id) {
-          reverseKittingOI.inventory = await tx
-            .getRepository(Inventory)
-            .findOneBy({ id: reverseKittingOI.inventory.id })
-
-          await tx.getRepository(Inventory).save({
-            ...reverseKittingOI.inventory,
-            lockedQty: reverseKittingOI.inventory.lockedQty - reverseKittingOI.qty,
-            lockedUomValue: reverseKittingOI.inventory.lockedUomValue - reverseKittingOI.uomValue,
-            updater: user
-          })
-        }
-
-        return { ...reverseKittingOI, status: ORDER_VAS_STATUS.CANCELLED }
-      })
-    )
-    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
-
-    return reverseKitting
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To undo the execution of reverse kitting order' })
-  async undoReverseKittingInventory(
-    @Arg('reverseKittingOIName') reverseKittingOIName: string,
-    @Arg('palletId') palletId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { tx, domain, user } = context.state
-
-    //@sumjoekin please add stricter validation. It is dangerous without strict validation. Unexpected behaviour will cause accidental deletion of inventory.
-
-    const reverseKittingOI: ReverseKittingOrderInventory = await tx
-      .getRepository(ReverseKittingOrderInventory)
-      .findOne({
-        where: { domain: { id: domain.id }, name: reverseKittingOIName },
-        relations: ['bizplace', 'reverseKittingOrder']
-      })
-
-    const bizplace: Bizplace = reverseKittingOI.bizplace
-    const reverseKittingOrder: ReverseKittingOrder = reverseKittingOI.reverseKittingOrder
-    let foundInventory: Inventory = await tx.getRepository(Inventory).findOne({
-      where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, orderVasId: reverseKittingOI.id, palletId },
-      relations: ['bizplace', 'product']
-    })
-    if (!foundInventory) throw new Error(`There's no results matched with condition ${foundInventory.palletId}`)
-
-    let operationGuide: any = JSON.parse(reverseKittingOI.operationGuide)
-    let productCombinationSets: any[] = operationGuide.data.productCombinationSets
-    productCombinationSets = productCombinationSets.map(item => {
-      if (foundInventory.product.id == item.productId) {
-        item.actualQty -= foundInventory.qty
-      }
-      return item
-    })
-    operationGuide.data.productCombinationSets = productCombinationSets
-
-    await tx
-      .getRepository(ReverseKittingOrderInventory)
-      .update({ id: reverseKittingOI.id }, { operationGuide: operationGuide })
-
-    foundInventory.lastSeq++
-    foundInventory.status = INVENTORY_STATUS.DELETED
-    foundInventory = await InventoryUtil.transactionInventory(
-      foundInventory,
-      reverseKittingOrder,
-      -foundInventory.qty,
-      -foundInventory.uomValue,
-      INVENTORY_TRANSACTION_TYPE.UNDO_REVERSE_KITTING,
-      user,
-      tx
-    )
-    foundInventory.qty = 0
-    foundInventory.uomValue = 0
-    foundInventory.updater = user
-
-    await tx.getRepository(InventoryHistory).update({ inventory: foundInventory }, { inventory: null })
-
-    await tx.getRepository(Inventory).delete({ id: foundInventory.id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ReverseKittingOrder, { description: 'To activate reverse kitting order' })
-  async activateReverseKittingOrder(
-    @Arg('name') name: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ReverseKittingOrder> {
-    const { user, domain, tx } = context.state
-
-    const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.READY_TO_EXECUTE },
-      relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
-    })
-
-    let reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
-
-    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
-
-    // 1. Reverse Kitting Order Status change (PENDING => PENDING_RECEIVE)
-    const reverseKitting: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).save({
-      ...foundReverseKittingOrder,
-      status: ORDER_STATUS.EXECUTING,
-      updater: user
-    })
-
-    reverseKittingOIs = reverseKittingOIs.map((reverseKittingOI: ReverseKittingOrderInventory) => {
-      return { ...reverseKittingOI, status: ORDER_VAS_STATUS.PROCESSING }
-    })
-    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
-
-    return reverseKitting
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To execute reverse kitting order' })
-  async executeReverseKitting(
-    @Arg('name') name: string,
-    @Arg('inventory', type => InventoryPatch) inventory: Partial<Inventory>,
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { user, domain, tx } = context.state
-
-    let reverseKittingOI: ReverseKittingOrderInventory = await tx.getRepository(ReverseKittingOrderInventory).findOne({
-      where: {
-        name,
-        domain: { id: domain.id },
-        status: Not(Equal(ORDER_VAS_STATUS.READY_TO_PROCESS))
-      },
-      relations: ['bizplace', 'reverseKittingOrder', 'reverseKittingOrder.bizplace', 'inventory']
-    })
-
-    const foundReverseKittingOrder: ReverseKittingOrder = reverseKittingOI.reverseKittingOrder
-    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
-
-    const customerBizplace: Bizplace = foundReverseKittingOrder.bizplace
-
-    const productDetail: ProductDetail = await tx.getRepository(ProductDetail).findOne({
-      where: { id: (inventory as any).productDetailId },
-      relations: ['product']
-    })
-
-    const location: Location = await tx.getRepository(Location).findOne({
-      where: {
-        domain: { id: domain.id },
-        name: (inventory as any).locationName,
-        type: In([LOCATION_TYPE.SHELF, LOCATION_TYPE.BUFFER, LOCATION_TYPE.FLOOR])
-      },
-      relations: ['warehouse']
-    })
-    if (!location) throw new Error((inventory as any).locationName + ' not exists')
-
-    const palletId: string = inventory.palletId
-    await InventoryUtil.checkPalletDuplication(inventory.palletId, domain, tx)
-
-    const product: Product = productDetail.product
-    const packingType: string = productDetail.packingType
-    const packingSize: number = productDetail.packingSize
-    const uom: string = productDetail.uom
-    const qty: number = inventory.qty
-    const uomValue: number = Math.round(qty * productDetail.uomValue * 100) / 100
-    const batchId: string = reverseKittingOI.inventory.batchId
-    const orderId: string = foundReverseKittingOrder.id
-    const warehouse: Warehouse = location.warehouse
-    const zone: string = location.zone
-
-    let newInventory: Partial<Inventory> = new Inventory()
-    newInventory.bizplace = customerBizplace
-    newInventory.name = InventoryNoGenerator.inventoryName()
-    newInventory.orderVasId = reverseKittingOI.id
-    newInventory.palletId = palletId
-    newInventory.batchId = batchId
-    newInventory.product = product
-    newInventory.packingType = packingType
-    newInventory.packingSize = packingSize
-    newInventory.uom = uom
-    newInventory.qty = qty
-    newInventory.uomValue = uomValue
-    newInventory.refOrderId = orderId
-    newInventory.warehouse = warehouse
-    newInventory.location = location
-    newInventory.zone = zone
-    newInventory.refInventory = reverseKittingOI.inventory
-    newInventory.status = INVENTORY_STATUS.STORED
-    newInventory.domain = domain
-    newInventory.creator = user
-    newInventory.updater = user
-
-    newInventory = await InventoryUtil.transactionInventory(
-      newInventory as any,
-      foundReverseKittingOrder,
-      newInventory.qty,
-      newInventory.uomValue,
-      INVENTORY_TRANSACTION_TYPE.REVERSE_KITTING,
-      user,
-      tx
-    )
-
-    let operationGuide: any = JSON.parse(reverseKittingOI.operationGuide)
-    let productCombinationSets: any[] = operationGuide.data.productCombinationSets
-    operationGuide.data.productCombinationSets = productCombinationSets.map(item => {
-      if (item.productDetailId == (inventory as any).productDetailId) {
-        item.actualQty += qty
-      }
-      return item
-    })
-    reverseKittingOI.operationGuide = JSON.stringify(operationGuide)
-
-    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOI)
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete ReverseKittingOrder' })
-  async deleteReverseKittingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx, user } = context.state
-    let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: [
-        'bizplace',
-        'reverseKittingOrderInventories',
-        'reverseKittingOrderInventories.inventory',
-        'creator',
-        'updater'
-      ]
-    })
-
-    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
-
-    const reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
-
-    // Delete order reverse kittings by ids
-    await Promise.all(
-      reverseKittingOIs.map(async (reverseKittingOI: ReverseKittingOrderInventory) => {
-        if (reverseKittingOI?.inventory?.id) {
-          reverseKittingOI.inventory = await tx
-            .getRepository(Inventory)
-            .findOneBy({ id: reverseKittingOI.inventory.id })
-
-          await tx.getRepository(Inventory).save({
-            ...reverseKittingOI.inventory,
-            lockedQty: reverseKittingOI.inventory.lockedQty - reverseKittingOI.qty,
-            lockedUomValue: reverseKittingOI.inventory.lockedUomValue - reverseKittingOI.uomValue,
-            updater: user
-          })
-        }
-        return reverseKittingOI
-      })
-    )
-
-    // 1. delete order reverse kittings
-    const productIds = reverseKittingOIs.map((ork: ReverseKittingOrderInventory) => ork.id)
-    if (productIds.length) {
-      await tx.getRepository(ReverseKittingOrderInventory).delete({ id: In(productIds) })
-    }
-
-    // 2. delete Reverse Kitting Order
-    await tx.getRepository(ReverseKittingOrder).delete({ domain: { id: domain.id }, name })
-
-    return true
-  }
-}

package/server/service/reverse-kitting-order/reverse-kitting-order-query.ts

@@ -1,197 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { Product, ProductDetail } from '@things-factory/product-base'
-import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-
-import { ORDER_VAS_STATUS } from '../../constants'
-import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
-import { ReverseKittingOrder } from './reverse-kitting-order'
-import { LotInfo, ReverseKittingInventoryDetail, ReverseKittingOrderList } from './reverse-kitting-order-type'
-
-@Resolver(ReverseKittingOrder)
-export class ReverseKittingOrderQuery {
-  @Query(returns => ReverseKittingOrder, { description: 'To fetch a ReverseKittingOrder' })
-  async reverseKittingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReverseKittingOrder> {
-    const { domain, user } = context.state
-
-    return await getRepository(ReverseKittingOrder).findOne({
-      where: {
-        domain: { id: domain.id },
-        name,
-        bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) }
-      },
-      relations: [
-        'domain',
-        'bizplace',
-        'reverseKittingOrderInventories',
-        'reverseKittingOrderInventories.vas',
-        'reverseKittingOrderInventories.inventory',
-        'reverseKittingOrderInventories.inventory.product',
-        'reverseKittingOrderInventories.inventory.location',
-        'reverseKittingOrderInventories.inventory.warehouse',
-        'creator',
-        'updater'
-      ]
-    })
-  }
-
-  @Query(returns => [ReverseKittingOrder], { description: 'To fetch a ReverseKittingOrder' })
-  async reverseKittingInventories(
-    @Arg('reverseKittingOIName') reverseKittingOIName: string,
-    @Arg('productDetailId') productDetailId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Inventory[]> {
-    const { domain } = context.state
-
-    const productDetail: ProductDetail = await getRepository(ProductDetail).findOne({
-      where: { id: productDetailId },
-      relations: ['product']
-    })
-
-    const product: Product = productDetail.product
-
-    const foundReverseKittingOI: ReverseKittingOrderInventory = await getRepository(
-      ReverseKittingOrderInventory
-    ).findOne({
-      where: {
-        domain: { id: domain.id },
-        name: reverseKittingOIName,
-        status: ORDER_VAS_STATUS.PROCESSING
-      },
-      relations: ['bizplace', 'reverseKittingOrder', 'inventory']
-    })
-
-    if (!foundReverseKittingOI) return
-
-    const reverseKittingOrder: ReverseKittingOrder = foundReverseKittingOI.reverseKittingOrder
-    const customerBizplace: Bizplace = foundReverseKittingOI.bizplace
-    return await getRepository(Inventory).find({
-      where: {
-        domain: { id: domain.id },
-        bizplace: { id: customerBizplace } as any,
-        refOrderId: reverseKittingOrder.id,
-        orderVasId: foundReverseKittingOI.id,
-        product: { id: product.id },
-        status: INVENTORY_STATUS.STORED
-      },
-      relations: ['product', 'bizplace', 'location']
-    })
-  }
-
-  @Query(returns => [ReverseKittingInventoryDetail], {
-    description: 'To generate lot id and label for reverse kitting'
-  })
-  async generateReverseKittingLotId(
-    @Arg('targets', type => [LotInfo]) targets: LotInfo[],
-    @Arg('type') type: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ReverseKittingInventoryDetail[]> {
-    const { tx, domain } = context.state
-    // 1. get and set the date
-    const today = new Date()
-    const year = today.getFullYear()
-    const month = today.getMonth()
-    const day = today.getDate()
-
-    const yy = String(year).substr(String(year).length - 2)
-    const mm = String(month + 1).padStart(2, '0')
-    const dd = String(day).padStart(2, '0')
-
-    const date = yy + mm + dd
-    let results = []
-
-    // 2. get worksheet detail
-    let ids = targets.map(target => target.id)
-
-    // - getRepository using In(array) to pass the value to defined variable
-    const foundOrderReverseKittings: ReverseKittingOrderInventory[] = await tx
-      .getRepository(ReverseKittingOrderInventory)
-      .find({
-        where: {
-          domain: { id: domain.id },
-          id: In(ids)
-        },
-        relations: ['domain', 'bizplace']
-      })
-
-    // 3. from worksheet detail get product name, product type, batchid, packing type, bizplace
-
-    if (foundOrderReverseKittings.length <= 0) throw new Error('Unable to find order reverse kittings')
-    else {
-      for (let i = 0; i < foundOrderReverseKittings.length; i++) {
-        let foundORK = foundOrderReverseKittings[i]
-        for (let idx = 0; idx < targets.length; idx++) {
-          if (foundORK.id === targets[idx].id) {
-            // 4. generate pallet id based on print qty > call generateId resolver
-            for (let i = 0; i < targets[idx].printQty; i++) {
-              const generatedPalletId = await generateId({
-                domain,
-                type,
-                seed: {
-                  batchId: foundORK.inventory.batchId,
-                  date: date
-                }
-              })
-
-              // 5. map all data to be returned
-              if (foundORK != null) {
-                results.push({
-                  ...foundORK,
-                  palletId: generatedPalletId,
-                  bizplace: foundORK.bizplace
-                })
-              }
-            }
-          }
-        }
-      }
-    }
-
-    return results
-  }
-
-  @Query(returns => ReverseKittingOrderList, { description: 'To fetch multiple ReverseKittingOrders' })
-  async reverseKittingOrders(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<ReverseKittingOrderList> {
-    const { domain, user } = context.state
-
-    const convertedParams = convertListParams(params)
-    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
-
-    const [items, total] = await getRepository(ReverseKittingOrder).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'bizplace',
-        'reverseKittingOrderInventories',
-        'reverseKittingOrderInventories.inventory',
-        'reverseKittingOrderInventories.inventory.product',
-        'creator',
-        'updater'
-      ]
-    })
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: reverseKittingOrder.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: reverseKittingOrder.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: reverseKittingOrder.creatorId })
-  }
-}