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

package/server/controllers/vas/vas-worksheet-controller.ts

@@ -1,848 +0,0 @@
-import { EntityManager, Equal, In, Not } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import {
-  ArrivalNotice,
-  ORDER_STATUS,
-  ORDER_TYPES,
-  ORDER_VAS_STATUS,
-  OrderNoGenerator,
-  OrderVas,
-  ReleaseGood,
-  VAS,
-  VasOrder
-} from '@things-factory/sales-base'
-import {
-  Inventory,
-  INVENTORY_STATUS,
-  INVENTORY_TRANSACTION_TYPE,
-  InventoryHistory,
-  InventoryNoGenerator,
-  Location,
-  LOCATION_TYPE
-} from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
-import { Worksheet, WorksheetDetail } from '../../entities'
-import {
-  completeRelabeling,
-  completeRepackaging,
-  completeRepalletizing,
-  completeUnpacking,
-  FeaturedInventoryInterface,
-  RefOrderType
-} from '../../graphql/resolvers/worksheet/vas-transactions'
-import { PackingUnits } from '../../graphql/resolvers/worksheet/vas-transactions/interfaces/repackaging'
-import { generateInventoryHistory } from '../../utils'
-import { ReferenceOrderType, WorksheetController } from '../worksheet-controller'
-
-type CompleteTransactionType = (trxMgr: EntityManager, orderVas: OrderVas, user: User) => Promise<void>
-
-export class VasWorksheetController extends WorksheetController {
-  private readonly COMPLETE_TRX_MAP: Record<string, CompleteTransactionType> = {
-    'vas-repalletizing': completeRepalletizing,
-    'vas-repack': completeRepackaging,
-    'vas-repack-relabel': completeRepackaging,
-    'vas-relabel': completeRelabeling,
-    'vas-unpack': completeUnpacking
-  }
-
-  async generateVasWorksheet(referenceOrder: ReferenceOrderType): Promise<Worksheet> {
-    let orderStatus = referenceOrder.status
-    let orderVASs: OrderVas[]
-
-    if (referenceOrder instanceof ArrivalNotice) {
-      //@ts-ignore
-      const arrivalNotice: ArrivalNotice = await this.findRefOrder(ArrivalNotice, referenceOrder, ['orderVass'])
-      orderVASs = arrivalNotice.orderVass
-    } else if (referenceOrder instanceof ReleaseGood) {
-      //@ts-ignore
-      const releaseGood: ReleaseGood = await this.findRefOrder(ReleaseGood, referenceOrder, ['orderVass'])
-      orderVASs = releaseGood.orderVass
-    } else {
-      //@ts-ignore
-      const vasOrder: VasOrder = await this.findRefOrder(VasOrder, referenceOrder, ['orderVass'])
-      orderVASs = vasOrder.orderVass
-      orderStatus = ORDER_STATUS.READY_TO_EXECUTE
-    }
-
-    return await this.generateWorksheet(
-      WORKSHEET_TYPE.VAS,
-      referenceOrder,
-      orderVASs,
-      orderStatus,
-      ORDER_VAS_STATUS.READY_TO_PROCESS
-    )
-  }
-
-  async assignInventories(worksheetDetailIds: string[], inventories: Partial<Inventory>): Promise<void> {
-    const worksheetDetails: WorksheetDetail[] = await this.trxMgr.getRepository(WorksheetDetail).find({
-      where: { id: In(worksheetDetailIds) },
-      relations: [
-        'bizplace',
-        'worksheet',
-        'targetVas',
-        'targetVas.arrivalNotice',
-        'targetVas.releaseGood',
-        'targetVas.shippingOrder',
-        'targetVas.vasOrder',
-        'targetVas.vas',
-        'targetVas.targetProduct'
-      ]
-    })
-
-    let seq: number = 0
-
-    for (let worksheetDetail of worksheetDetails) {
-      const bizplace: Bizplace = worksheetDetail.bizplace
-      const worksheet: Worksheet = worksheetDetail.worksheet
-      const targetVas: OrderVas = worksheetDetail.targetVas
-
-      let newWorksheetDetail: Partial<WorksheetDetail> = Object.assign({}, worksheetDetail)
-      delete newWorksheetDetail.id
-
-      // get accumulated inventories qty
-      //@ts-ignore
-      const accInventoriesQty: number = inventories.reduce((acc, inv) => {
-        return acc + inv.qty
-      }, 0)
-
-      let operationGuide = JSON.parse(targetVas.operationGuide)
-      let vasOperationGuide = targetVas.vas?.operationGuide
-
-      if (vasOperationGuide === 'vas-repack' || vasOperationGuide === 'vas-repack-relabel') {
-        const mainInventory: Inventory = inventories[0]
-        const featuredInvs: FeaturedInventoryInterface[] = []
-        const foundInvs: Inventory[] = await this.trxMgr
-          .getRepository(Inventory)
-          //@ts-ignore
-          .findByIds(inventories.filter(inv => inv.id !== mainInventory.id).map(inv => inv.id))
-
-        /* Update lockedQty of featuredInvs */
-        for (let inventory of foundInvs) {
-          //@ts-ignore
-          const transferQty: number = inventories.find(inv => inv.id === inventory.id).qty
-          const transferUomValue: number = Math.round((inventory.uomValue / inventory.qty) * transferQty * 100) / 100
-
-          inventory.lockedQty += transferQty
-          inventory.lockedUomValue += transferUomValue
-
-          await this.trxMgr.getRepository(Inventory).save(inventory)
-
-          let featuredInv: FeaturedInventoryInterface = {
-            palletId: inventory.palletId,
-            originalQty: transferQty,
-            originalUomValue: transferUomValue,
-            packingSize: inventory.packingSize,
-            uomValuePerQty: inventory.uomValue / (inventory.qty * inventory.packingSize)
-          }
-
-          switch (operationGuide.data?.packingUnit) {
-            case PackingUnits.QTY:
-              featuredInv.currentUnitQty = transferQty * inventory.packingSize
-              break
-
-            case PackingUnits.UOM:
-              featuredInv.currentUomValue = transferUomValue
-              break
-          }
-
-          featuredInvs.push(featuredInv)
-        }
-
-        /* assign featuredInvs inside operationGuide.data */
-        operationGuide.data = {
-          ...operationGuide.data,
-          featuredInvs
-        }
-
-        /* assign main inventory as the only inventories */
-        //@ts-ignore
-        inventories = [mainInventory]
-      }
-
-      //@ts-ignore
-      for (let inventory of inventories) {
-        let newTargetVas: OrderVas = new OrderVas()
-
-        const foundInventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne(inventory.id)
-        if (!foundInventory) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(inventory.id))
-
-        // assigned inventory qty that was passed from client side
-        const assignedQty = inventory.qty
-        const unitUomValue: number = foundInventory.uomValue / foundInventory.qty
-
-        // update unpack qty for unpacking vas
-        if (vasOperationGuide === 'vas-unpack') {
-          operationGuide.data.unpackQty = Math.round(operationGuide.data.unpackQty / accInventoriesQty) * assignedQty
-        }
-
-        if (vasOperationGuide === 'vas-repack' || vasOperationGuide === 'vas-repack-relabel') {
-          switch (operationGuide.data?.packingUnit) {
-            case PackingUnits.UOM:
-              newTargetVas.qty = 1
-              newTargetVas.uomValue = targetVas.uomValue
-              break
-
-            default:
-              newTargetVas.qty = accInventoriesQty
-              newTargetVas.uomValue = accInventoriesQty * unitUomValue
-          }
-        } else {
-          newTargetVas.qty = assignedQty
-          newTargetVas.uomValue = assignedQty * unitUomValue
-        }
-
-        newTargetVas.set = targetVas.set
-        newTargetVas.targetType = targetVas.targetType
-        newTargetVas.targetBatchId = targetVas.targetBatchId
-        newTargetVas.packingType = targetVas.packingType
-        newTargetVas.operationGuide = operationGuide ? JSON.stringify(operationGuide) : null
-        newTargetVas.type = targetVas.type
-        newTargetVas.remark = targetVas.remark
-        newTargetVas.status = targetVas.status
-        newTargetVas.targetProduct = targetVas.targetProduct
-        newTargetVas.vasOrder = targetVas.vasOrder
-        newTargetVas.vas = targetVas.vas
-        newTargetVas.domain = this.domain
-        newTargetVas.name = OrderNoGenerator.orderVas()
-        newTargetVas.inventory = foundInventory
-        newTargetVas.bizplace = bizplace
-        newTargetVas.creator = this.user
-        newTargetVas.updater = this.user
-        newTargetVas = await this.trxMgr.getRepository(OrderVas).save(newTargetVas)
-
-        await this.createWorksheetDetails(worksheet, WORKSHEET_TYPE.VAS, [newTargetVas])
-        seq++
-
-        // update inventory locked qty & uom value
-        const currentLockedQty: number = foundInventory.lockedQty || 0
-        const currentLockedUomValue: number = foundInventory.lockedUomValue || 0
-
-        await this.trxMgr.getRepository(Inventory).save({
-          ...foundInventory,
-          lockedQty: inventory.qty + currentLockedQty,
-          lockedUomValue: inventory.qty * unitUomValue + currentLockedUomValue,
-          updater: this.user
-        })
-      }
-
-      await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.id)
-      await this.trxMgr.getRepository(OrderVas).delete(targetVas.id)
-    }
-  }
-
-  async activateVAS(worksheetNo: string, vasWorksheetDetails: Partial<WorksheetDetail>[]): Promise<Worksheet> {
-    const worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.VAS, [
-      'vasOrder',
-      'worksheetDetails',
-      'worksheetDetails.targetVas'
-    ])
-
-    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-    const targetVass: OrderVas[] = worksheetDetails.map((wsd: WorksheetDetail) => {
-      let targetVas: OrderVas = wsd.targetVas
-      targetVas.status = ORDER_VAS_STATUS.PROCESSING
-      targetVas.updater = this.user
-      return targetVas
-    })
-
-    // Update VAS Order if it's pure VAS Order (status: READY_TO_PROCESS => PROCESSING)
-    let vasOrder: VasOrder = worksheet.vasOrder
-    if (vasOrder?.id) {
-      vasOrder.status = ORDER_STATUS.PROCESSING
-      vasOrder.updater = this.user
-
-      await this.updateRefOrder(vasOrder)
-    }
-
-    await this.updateOrderTargets(targetVass)
-    return await this.activateWorksheet(worksheet, worksheetDetails, vasWorksheetDetails)
-  }
-
-  async unpackingWithPallet(
-    worksheetDetailName: string,
-    childProduct: Partial<Product>,
-    unpackQty: number,
-    unpackUomValue: number,
-    palletId: string,
-    locationName: string,
-    refOrder: RefOrderType
-  ): Promise<void> {
-    await this.checkPalletDuplication(palletId)
-
-    const worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
-      where: {
-        name: worksheetDetailName,
-        type: WORKSHEET_TYPE.VAS,
-        status: Not(Equal(WORKSHEET_STATUS.DEACTIVATED))
-      },
-      relations: ['bizplace', 'worksheet', 'worksheet.vasOrder', 'targetVas', 'targetVas.inventory']
-    })
-    if (!worksheetDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName))
-
-    const targetVas: OrderVas = worksheetDetail.targetVas
-    const bizplace: Bizplace = worksheetDetail.bizplace
-
-    const location: Location = await this.trxMgr.getRepository(Location).findOne({
-      where: {
-        domain: { id: this.domain.id },
-        name: locationName,
-        type: In([LOCATION_TYPE.SHELF, LOCATION_TYPE.BUFFER, LOCATION_TYPE.FLOOR])
-      },
-      relations: ['warehouse']
-    })
-    if (!location) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName))
-
-    const warehouse = location.warehouse
-    const zone: string = location.zone
-
-    // create new unpacked inventory
-    let newInventory: Partial<Inventory> = new Inventory()
-    newInventory.bizplace = bizplace
-    newInventory.name = InventoryNoGenerator.inventoryName()
-    newInventory.palletId = palletId
-    newInventory.batchId = worksheetDetail.targetVas.targetBatchId
-    //@ts-ignore
-    newInventory.product = childProduct
-    newInventory.packingType = childProduct.packingType
-    newInventory.uom = childProduct.primaryUnit
-    newInventory.remark = null
-    newInventory.qty = unpackQty
-    newInventory.uomValue = unpackUomValue * unpackQty
-    newInventory.refOrderId = refOrder.id
-    newInventory.warehouse = warehouse
-    newInventory.location = location
-    newInventory.zone = zone
-    newInventory.orderVasId = targetVas.id
-    newInventory.status = INVENTORY_STATUS.STORED
-
-    newInventory = await this.transactionInventory(
-      newInventory,
-      //@ts-ignore
-      refOrder,
-      newInventory.qty,
-      newInventory.uomValue,
-      INVENTORY_TRANSACTION_TYPE.UNPACKING
-    )
-
-    // find inventory history that might exist due to undo unpacking process
-    const existInventoryHistories: InventoryHistory[] = await this.trxMgr.getRepository(InventoryHistory).find({
-      where: {
-        domain: { id: this.domain.id },
-        inventory: null,
-        palletId
-      },
-      relations: ['domain', 'inventory']
-    })
-
-    // if found any, update the inventory id
-    if (existInventoryHistories.length) {
-      existInventoryHistories.forEach(async (invHistory: InventoryHistory) => {
-        await this.trxMgr.getRepository(InventoryHistory).save({
-          ...invHistory,
-          inventory: newInventory
-        })
-      })
-
-      newInventory = await this.trxMgr.getRepository(Inventory).save({
-        ...newInventory,
-        lastSeq: Math.max(...existInventoryHistories.map(invHist => invHist.seq)) + 1
-      })
-    }
-
-    // add picking and terminated for unpacking in RO
-    if (refOrder instanceof ReleaseGood) {
-      newInventory.qty = 0
-      newInventory.uomValue = 0
-      newInventory = await this.transactionInventory(
-        newInventory,
-        refOrder,
-        -newInventory.qty,
-        -newInventory.uomValue,
-        INVENTORY_TRANSACTION_TYPE.PICKING
-      )
-
-      newInventory.status = INVENTORY_STATUS.TERMINATED
-      await this.transactionInventory(newInventory, refOrder, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
-    }
-
-    // update actual qty and actual uom value of order_vass
-    let actualQty: number = 0
-    let actualUomValue: number = 0
-
-    actualQty = Number(targetVas.actualQty) + Number(unpackQty)
-    actualUomValue = Number(targetVas.actualUomValue) + Number(unpackUomValue)
-
-    let newTargetVas: OrderVas = Object.assign({}, targetVas)
-    newTargetVas.actualQty = actualQty
-    newTargetVas.actualUomValue = actualUomValue
-
-    await this.trxMgr.getRepository(Inventory).save(newInventory)
-    await this.trxMgr.getRepository(OrderVas).save(newTargetVas)
-  }
-
-  async executeVAS(worksheetDetail: Partial<WorksheetDetail>, palletId?: string): Promise<void> {
-    const worksheetDetailName = worksheetDetail.name
-    let foundWorksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
-      worksheetDetailName,
-      WORKSHEET_TYPE.VAS,
-      [
-        'bizplace',
-        'worksheet',
-        'worksheet.arrivalNotice',
-        'worksheet.releaseGood',
-        'targetVas',
-        'targetVas.vas',
-        'targetVas.arrivalNotice',
-        'targetVas.releaseGood',
-        'targetVas.vasOrder',
-        'targetVas.targetProduct',
-        'targetVas.inventory'
-      ]
-    )
-    const bizplace: Bizplace = foundWorksheetDetail.bizplace
-    const worksheet: Worksheet = foundWorksheetDetail.worksheet
-
-    if (palletId) {
-      const inventory: Inventory = await this.checkPalletAcceptable(palletId, worksheet, foundWorksheetDetail)
-
-      let targetVas: OrderVas = foundWorksheetDetail.targetVas
-      const totalTargetQty: number = targetVas.qty
-      // inventory assigment
-      targetVas.inventory = inventory
-      // 현재 작업 대상 target vas의 수량을 inventory의 수량 만큼 감소 시킴
-      targetVas.qty = inventory.qty
-      targetVas = await this.trxMgr.getRepository(OrderVas).save(targetVas)
-      // 남은 수량이 있다면 새로운 worksheet detail과 target vas를 생성
-
-      const remainQty: number = totalTargetQty - inventory.qty
-      if (remainQty > 0) {
-        let newTargetVas: Partial<OrderVas> = Object.assign({}, targetVas)
-        //@ts-ignore
-        delete newTargetVas.id
-        newTargetVas.domain = this.domain
-        newTargetVas.bizplace = bizplace
-        newTargetVas.name = OrderNoGenerator.orderVas()
-        newTargetVas.qty = remainQty
-        newTargetVas.creator = this.user
-        newTargetVas.updater = this.user
-        newTargetVas = await this.trxMgr.getRepository(OrderVas).save(newTargetVas)
-
-        // Create new worksheet detail
-        //@ts-ignore
-        await this.createWorksheetDetails(worksheet, WORKSHEET_TYPE.VAS, [newTargetVas], {
-          status: foundWorksheetDetail.status
-        })
-      }
-    }
-
-    //@ts-ignore
-    const targetVas: VasOrder = foundWorksheetDetail.targetVas
-    if (!targetVas) throw new Error(`VAS doesn't exists`)
-
-    const inventory: Inventory = foundWorksheetDetail.targetVas.inventory
-
-    // reset lockedQty if there's inventory found
-    if (
-      inventory &&
-      //@ts-ignore
-      inventory.lockedQty >= targetVas.qty &&
-      //@ts-ignore
-      targetVas.vas.operationGuide &&
-      //@ts-ignore
-      targetVas.vas.operationGuide !== 'vas-repack' &&
-      //@ts-ignore
-      targetVas.vas.operationGuide !== 'vas-repack-relabel'
-    ) {
-      await this.trxMgr.getRepository(Inventory).save({
-        ...inventory,
-        //@ts-ignore
-        lockedQty: inventory.lockedQty - targetVas.qty,
-        //@ts-ignore
-        lockedUomValue: inventory.lockedUomValue - targetVas.uomValue
-      })
-    }
-
-    // 1. update status of worksheetDetail (EXECUTING => DONE)
-    foundWorksheetDetail = Object.assign(foundWorksheetDetail, worksheetDetail)
-    foundWorksheetDetail.status = WORKSHEET_STATUS.DONE
-    foundWorksheetDetail.updater = this.user
-    await this.trxMgr.getRepository(WorksheetDetail).save(foundWorksheetDetail)
-
-    // 2. update vas
-    targetVas.status = ORDER_VAS_STATUS.COMPLETED
-    targetVas.updater = this.user
-    //@ts-ignore
-    await this.updateOrderTargets([targetVas])
-  }
-
-  async undoVAS(worksheetDetail: Partial<WorksheetDetail>): Promise<void> {
-    const worksheetDetailName: string = worksheetDetail.name
-    worksheetDetail = await this.findWorksheetDetailByName(worksheetDetailName, [
-      'worksheet',
-      'targetVas',
-      'targetVas.vas',
-      'targetVas.vasOrder',
-      'targetVas.inventory'
-    ])
-    this.checkRecordValidity(worksheetDetail, { status: WORKSHEET_STATUS.DONE, type: WORKSHEET_TYPE.VAS })
-
-    let targetVas: OrderVas = worksheetDetail.targetVas
-    const inventory: Inventory = targetVas.inventory
-
-    // update lockedQty if there's inventory found
-    if (inventory) {
-      await this.trxMgr.getRepository(Inventory).save({
-        ...inventory,
-        lockedQty: inventory.lockedQty + targetVas.qty,
-        lockedUomValue: inventory.lockedUomValue + targetVas.uomValue
-      })
-    }
-
-    targetVas.status = ORDER_VAS_STATUS.PROCESSING
-    targetVas.updater = this.user
-    await this.updateOrderTargets([targetVas])
-
-    worksheetDetail.status = WORKSHEET_STATUS.EXECUTING
-    worksheetDetail.issue = ''
-    worksheetDetail.updater = this.user
-    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
-  }
-
-  async undoVasInventory(worksheetDetailName: string, palletId: string): Promise<void> {
-    const worksheetDetail = await this.findWorksheetDetailByName(worksheetDetailName, [
-      'domain',
-      'bizplace',
-      'worksheet',
-      'targetVas',
-      'targetVas.vas',
-      'targetVas.vasOrder',
-      'targetVas.inventory'
-    ])
-    const bizplace: Bizplace = worksheetDetail.bizplace
-    const targetVas: OrderVas = worksheetDetail.targetVas
-    const { arrivalNotice, releaseGood, vasOrder } = targetVas
-    const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder
-
-    let vasInventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne({
-      where: {
-        domain: { id: this.domain.id },
-        bizplace: { id: bizplace.id },
-        orderVasId: targetVas.id,
-        palletId
-      }
-    })
-
-    let newTargetVas: OrderVas = new OrderVas()
-    //@ts-ignore
-    newTargetVas.id = targetVas.id
-    newTargetVas.name = targetVas.name
-    newTargetVas.description = targetVas.description
-    newTargetVas.set = targetVas.set
-    newTargetVas.targetType = targetVas.targetType
-    newTargetVas.targetBatchId = targetVas.targetBatchId
-    newTargetVas.packingType = targetVas.packingType
-    newTargetVas.operationGuide = targetVas.operationGuide
-    newTargetVas.type = targetVas.type
-    newTargetVas.remark = targetVas.remark
-    newTargetVas.status = targetVas.status
-    newTargetVas.targetProduct = targetVas.targetProduct
-    newTargetVas.vasOrder = targetVas.vasOrder
-    newTargetVas.vas = targetVas.vas
-    newTargetVas.domain = this.domain
-    newTargetVas.name = targetVas.name
-    newTargetVas.qty = targetVas.qty
-    newTargetVas.uomValue = targetVas.uomValue
-    newTargetVas.inventory = targetVas.inventory
-    newTargetVas.bizplace = bizplace
-    newTargetVas.creator = this.user
-    newTargetVas.updater = this.user
-    newTargetVas.actualQty = targetVas.actualQty - vasInventory.qty
-    newTargetVas.actualUomValue =
-      targetVas.actualUomValue - Math.round((vasInventory.uomValue / vasInventory.qty) * 100) / 100
-
-    vasInventory.lastSeq++
-    vasInventory.status = INVENTORY_STATUS.DELETED
-    vasInventory = await this.transactionInventory(
-      vasInventory,
-      refOrder,
-      -vasInventory.qty,
-      -vasInventory.uomValue,
-      INVENTORY_TRANSACTION_TYPE.UNDO_UNPACKING
-    )
-    // vasInventory.qty = 0
-    // vasInventory.weight = 0
-    // vasInventory.uomValue = 0
-    // vasInventory.updater = this.user
-
-    await this.updateOrderTargets([newTargetVas])
-
-    await this.trxMgr.getRepository(InventoryHistory).update({ inventory: vasInventory }, { inventory: null })
-    await this.trxMgr.getRepository(Inventory).delete({ id: vasInventory.id })
-  }
-
-  private async checkPalletAcceptable(
-    palletId: string,
-    worksheet: Worksheet,
-    worksheetDetail: WorksheetDetail
-  ): Promise<Inventory> {
-    // inventory가 존재해야함
-    const inventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne({
-      where: { domain: { id: this.domain.id }, palletId },
-      relations: ['product']
-    })
-    if (!inventory) throw new Error(`Can't find inventory by pallet ID (${palletId})`)
-
-    // 현재 작업 set에서 하나라도 모두 완료된 유형의 VAS가 존재할 경우
-    // 해당 VAS를 처리한 pallet 리스트에 한하여 작업을 수행 해야함 (동일한 SET는 동일한 군집의 Pallet을 대상으로 처리되어야 하기 때문에)
-    worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
-      where: { id: worksheet.id },
-      relations: [
-        'worksheetDetails',
-        'worksheetDetails.targetVas',
-        'worksheetDetails.targetVas.inventory',
-        'worksheetDetails.targetVas.vas'
-      ]
-    })
-
-    const vasIds: string[] = worksheet.worksheetDetails
-      .filter((wsd: WorksheetDetail) => wsd.targetVas.set === worksheetDetail.targetVas.set)
-      .map((wsd: WorksheetDetail) => wsd.targetVas.vas.id)
-
-    let completedCnt: { [key: string]: number } = {}
-    vasIds.forEach((vasId: string) => (completedCnt[vasId] = 0))
-    worksheet.worksheetDetails.forEach((wsd: WorksheetDetail) => {
-      if (wsd.status !== WORKSHEET_STATUS.DONE) {
-        completedCnt[wsd.targetVas.vas.id]++
-      }
-    })
-    let finishedVasId: string
-    for (let vasId in completedCnt) {
-      if (completedCnt[vasId] === 0) {
-        finishedVasId = vasId
-        break
-      }
-    }
-
-    if (finishedVasId) {
-      const availPalletIds: string[] = worksheet.worksheetDetails
-        .filter((wsd: WorksheetDetail) => wsd.targetVas.vas.id === finishedVasId)
-        .map((wsd: WorksheetDetail) => wsd.targetVas.inventory.palletId)
-
-      if (availPalletIds.indexOf(inventory.palletId) >= 0) {
-        return inventory
-      } else {
-        throw new Error(
-          this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('execute VAS', `${palletId} is not suitable for doing this VAS`)
-        )
-      }
-    }
-
-    // refOrder에 따라 적절한 상태를 가지고 있어야함
-    // Arrival Notice = 'PARTIALLY_UNLOADED or PUTTING_AWAY
-    const refOrder: ArrivalNotice | ReleaseGood = worksheet.arrivalNotice || worksheet.releaseGood
-    if (refOrder instanceof ArrivalNotice) {
-      const acceptableStatus = [INVENTORY_STATUS.PARTIALLY_UNLOADED, INVENTORY_STATUS.PUTTING_AWAY]
-      if (acceptableStatus.indexOf(inventory.status) < 0)
-        throw new Error(`The pallet doesn't have right status for doing VAS`)
-    } else if (refOrder instanceof ReleaseGood) {
-      throw new Error('TODO: Status check for Release Good')
-    }
-
-    // target vas의 조건에 충족해야 함 (targetBatchId, targetProduct)
-    const { targetBatchId, targetProduct } = worksheetDetail.targetVas
-    if (targetBatchId && targetBatchId !== inventory.batchId) {
-      throw new Error(`The pallet (${inventory.palletId}) doesn't have correct batch ID (${targetBatchId})`)
-    }
-
-    if (targetProduct?.id && targetProduct.id !== inventory.product.id) {
-      throw new Error(`The pallet (${inventory.palletId}) doesn't have correct product (${targetProduct.name})`)
-    }
-
-    // reference order와 관계되어 있는 inventory여야 함
-    if (refOrder instanceof ArrivalNotice) {
-      if (inventory.refOrderId !== refOrder.id)
-        throw new Error(`The pallet ${inventory.palletId} is not related with GAN (${refOrder.name})`)
-    }
-
-    // 다른 vas order set에 포함되어 있지 않아야함
-    const relatedInvs: Inventory[] = worksheet.worksheetDetails
-      .filter(
-        (
-          wsd: WorksheetDetail // 현재 작업대상이 아니고 현재 작업 대상과 같은 세트가 아니고 인벤토리 값이 있는
-        ) =>
-          wsd.id !== worksheetDetail.id &&
-          wsd.targetVas.set !== worksheetDetail.targetVas.set &&
-          wsd.targetVas.inventory
-      )
-      .map((wsd: WorksheetDetail) => wsd.targetVas.inventory)
-
-    if (relatedInvs.find((relInv: Inventory) => relInv.palletId === inventory.palletId)) {
-      throw new Error(`The pallet (${inventory.palletId}) is already assigned for another VAS SET`)
-    }
-
-    // 현재 작업유형에 동이한 pallet으로 처리된 이력이 없어야함
-    const completedWSD: WorksheetDetail[] = worksheet.worksheetDetails.filter(
-      (wsd: WorksheetDetail) =>
-        wsd.status === WORKSHEET_STATUS.DONE &&
-        wsd.targetVas.set === worksheetDetail.targetVas.set &&
-        wsd.targetVas.vas.id === worksheetDetail.targetVas.vas.id
-    )
-
-    if (completedWSD.find((wsd: WorksheetDetail) => wsd.targetVas.inventory.palletId === palletId)) {
-      throw new Error(
-        this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('execute VAS', `VAS is finished for pallet (${palletId}) already`)
-      )
-    }
-
-    return inventory
-  }
-
-  async completeVAS(orderNo: string, orderType: string, vasWorksheetDetails: WorksheetDetail[]): Promise<Worksheet> {
-    //@ts-ignore
-    const ENTITY_MAP: { [key: string]: ArrivalNotice | ReleaseGood | VasOrder } = {
-      [ORDER_TYPES.ARRIVAL_NOTICE]: ArrivalNotice,
-      [ORDER_TYPES.RELEASE_OF_GOODS]: ReleaseGood,
-      [ORDER_TYPES.VAS_ORDER]: VasOrder
-    }
-    //@ts-ignore
-    let refOrder: ReferenceOrderType = await this.findRefOrder(ENTITY_MAP[orderType], {
-      domain: this.domain,
-      name: orderNo
-    })
-    let worksheet: Worksheet = await this.findWorksheetByRefOrder(refOrder, WORKSHEET_TYPE.VAS, [
-      'worksheetDetails',
-      'worksheetDetails.targetVas',
-      'worksheetDetails.targetVas.vas',
-      'worksheetDetails.targetVas.inventory'
-    ])
-
-    const isPureVAS: boolean = refOrder instanceof VasOrder
-    if (isPureVAS) {
-      refOrder.status = ORDER_STATUS.DONE
-      await this.updateRefOrder(refOrder)
-    }
-
-    // Do complete operation transactions if there it is
-    let foundWorksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-    let targetVASs: OrderVas[] = foundWorksheetDetails.map((wsd: WorksheetDetail) => wsd.targetVas)
-
-    // assign issues brought from execute VAS page to foundWorksheetDetails
-    foundWorksheetDetails = foundWorksheetDetails.map(worksheetDetail => {
-      return {
-        ...worksheetDetail,
-        issue: vasWorksheetDetails.find(wsd => wsd.name === worksheetDetail.name).issue || null
-      }
-    })
-
-    // reduce parent inventory qty if same parent is selected
-    targetVASs = targetVASs.reduce((acc, curr) => {
-      if (curr.inventory) {
-        for (let i = 0; i < acc.length; i++) {
-          if (acc[i].inventory?.id === curr.inventory?.id) {
-            curr.inventory.qty -= acc[i].qty
-            curr.inventory.uomValue -= acc[i].uomValue
-            curr.inventory.lockedQty -= acc[i].qty
-            curr.inventory.lockedUomValue -= acc[i].uomValue
-          }
-        }
-      }
-
-      acc.push(curr)
-
-      return acc
-    }, [])
-
-    for (const targetVas of targetVASs) {
-      const { issue }: { issue: string } = foundWorksheetDetails.find(
-        (wsd: WorksheetDetail) => wsd.targetVas.id === targetVas.id
-      )
-
-      // if (targetVas.operationGuide && (!issue || (targetVas.vas.name.toUpperCase() == VAS.REPACKAGING && issue))) {
-      //   await this.doOperationTransaction(targetVas)
-      // } /*else if (targetVas.operationGuide && targetVas.vas.name.toUpperCase() === VAS.REPACKAGING && issue) {
-      //   await this.doOperationTransaction(targetVas)
-      // }*/
-
-      if (targetVas.operationGuide && !issue) {
-        await this.doOperationTransaction(targetVas)
-      }
-
-      if (targetVas.vas.name.toUpperCase() === VAS.UNPACKING && !(refOrder instanceof ArrivalNotice)) {
-        // Update qty and uom value of parent inventory (only applies for pure vas and RO)
-        const parentInventory: Inventory = targetVas.inventory
-        let newParentInventory: Partial<Inventory> = Object.assign({}, parentInventory)
-        newParentInventory.qty = parentInventory.qty - targetVas.qty
-        newParentInventory.uomValue = Math.round((parentInventory.uomValue - targetVas.uomValue) * 100) / 100
-        newParentInventory.lockedQty = parentInventory.lockedQty - targetVas.qty
-        newParentInventory.lockedUomValue =
-          Math.round((parentInventory.lockedUomValue - targetVas.uomValue) * 100) / 100
-
-        // update qty and uomValue for VasOrder
-        // if refOrder is from ReleaseGood, no need to update because this trxn is consider similar to LOADING trxn
-        if (refOrder instanceof VasOrder) {
-          await this.transactionInventory(
-            newParentInventory,
-            refOrder,
-            -targetVas.qty,
-            -targetVas.uomValue,
-            INVENTORY_TRANSACTION_TYPE.UNPACKED
-          )
-        } else if (refOrder instanceof ReleaseGood) {
-          await generateInventoryHistory(
-            //@ts-ignore
-            newParentInventory,
-            refOrder,
-            INVENTORY_TRANSACTION_TYPE.UNPACKED,
-            0,
-            0,
-            this.user,
-            this.trxMgr
-          )
-        }
-
-        // add TERMINATED status if inventory qty = 0
-        if (newParentInventory.qty === 0) {
-          newParentInventory.status = INVENTORY_STATUS.TERMINATED
-          await this.transactionInventory(newParentInventory, refOrder, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
-        }
-      }
-    }
-
-    // update worksheet details if there is any issue found from the list
-    if (foundWorksheetDetails.some((wsd: Partial<WorksheetDetail>) => wsd.issue)) {
-      const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-      foundWorksheetDetails = this.renewWorksheetDetails(worksheetDetails, foundWorksheetDetails, 'name', {
-        updater: this.user
-      })
-
-      const worksheetDetailsWithIssue: WorksheetDetail[] = foundWorksheetDetails.filter(
-        (wsd: WorksheetDetail) => wsd.issue
-      ) as WorksheetDetail[]
-
-      if (worksheetDetailsWithIssue.length) {
-        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetailsWithIssue)
-      }
-    }
-
-    let orderStatus: string =
-      refOrder instanceof ArrivalNotice
-        ? ORDER_STATUS.READY_TO_UNLOAD
-        : refOrder instanceof ReleaseGood
-          ? ORDER_STATUS.LOADING
-          : ORDER_STATUS.DONE
-
-    worksheet = await this.completeWorksheet(worksheet, orderStatus)
-    return worksheet
-  }
-
-  async doOperationTransaction(targetVas: OrderVas): Promise<void> {
-    const operationGuide: string = targetVas.vas?.operationGuide
-    if (operationGuide) {
-      await this.COMPLETE_TRX_MAP[operationGuide](this.trxMgr, targetVas, this.user)
-    }
-  }
-}