@things-factory/worksheet-base 8.0.0-beta.8 → 8.0.0

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

@@ -0,0 +1,848 @@
+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)
+    }
+  }
+}