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

package/server/graphql/resolvers/worksheet/unloading/scan-product-unload.ts

@@ -0,0 +1,26 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { UnloadingWorksheetController } from '../../../../controllers'
+
+export const scanProductUnloadResolver = {
+  async scanProductUnload(_: any, { worksheetDetailName, productBarcode, inventory }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await scanProductUnload(tx, domain, user, worksheetDetailName, productBarcode, inventory)
+  }
+}
+
+async function scanProductUnload(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  productBarcode: string,
+  inventory: Partial<Inventory>
+): Promise<void> {
+  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
+  await worksheetController.scanProductUnload(worksheetDetailName, productBarcode, inventory)
+}

package/server/graphql/resolvers/worksheet/unloading/scan-serial-number-unload.ts

@@ -0,0 +1,26 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { UnloadingWorksheetController } from '../../../../controllers'
+
+export const scanSerialNumberUnloadResolver = {
+  async scanSerialNumberUnload(_: any, { worksheetDetailName, serialNumber, inventory }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await scanSerialNumberUnload(tx, domain, user, worksheetDetailName, serialNumber, inventory)
+  }
+}
+
+async function scanSerialNumberUnload(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  serialNumber: string,
+  inventory: Partial<Inventory>
+): Promise<void> {
+  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
+  await worksheetController.scanSerialNumberUnload(worksheetDetailName, serialNumber, inventory)
+}

package/server/graphql/resolvers/worksheet/unloading/undo-serial-number-unload.ts

@@ -0,0 +1,24 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { UnloadingWorksheetController } from '../../../../controllers'
+
+export const undoSerialNumberUnloadResolver = {
+  async undoSerialNumberUnload(_: any, { worksheetDetailName, inventoryItemId }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await undoSerialNumberUnload(tx, domain, user, worksheetDetailName, inventoryItemId)
+  }
+}
+
+async function undoSerialNumberUnload(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inventoryItemId: string
+): Promise<void> {
+  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
+  await worksheetController.undoSerialNumberUnload(worksheetDetailName, inventoryItemId)
+}

package/server/graphql/resolvers/worksheet/unloading/undo-unloading.ts

@@ -0,0 +1,25 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { UnloadingWorksheetController } from '../../../../controllers'
+
+export const undoUnloadingResolver = {
+  async undoUnloading(_: any, { orderType, orderNo, inventoryIds }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await undoUnloading(tx, domain, user, orderType, orderNo, inventoryIds)
+  }
+}
+
+async function undoUnloading(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  orderType: string,
+  orderNo: string,
+  inventoryIds: [string]
+): Promise<void> {
+  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
+  await worksheetController.undoUnload(orderType, orderNo, inventoryIds)
+}

package/server/graphql/resolvers/worksheet/unloading/unload.ts

@@ -0,0 +1,26 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { UnloadingWorksheetController } from '../../../../controllers'
+
+export const unloadResolver = {
+  async unload(_: any, { worksheetDetailName, inventory, productBarcode }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    return await unload(tx, domain, user, worksheetDetailName, inventory, productBarcode)
+  }
+}
+
+async function unload(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inventory: Partial<Inventory>,
+  productBarcode: string
+): Promise<string> {
+  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
+  return await worksheetController.unload(worksheetDetailName, inventory, productBarcode)
+}

package/server/graphql/resolvers/worksheet/unloading-return/activate-unloading-return.ts

@@ -0,0 +1,28 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { UnloadingReturningWorksheetController, UnloadingReturningWorksheetDetail } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const activateUnloadingReturnResolver = {
+  async activateUnloadingReturn(_: any, { worksheetNo, unloadingReturnWorksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    return await activateUnloadingReturn(tx, domain, user, worksheetNo, unloadingReturnWorksheetDetails)
+  }
+}
+export async function activateUnloadingReturn(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  outboundReturnWorksheetDetails: UnloadingReturningWorksheetDetail[]
+): Promise<Worksheet> {
+  const worksheetController: UnloadingReturningWorksheetController = new UnloadingReturningWorksheetController(
+    tx,
+    domain,
+    user
+  )
+  return await worksheetController.activateUnloadingReturn(worksheetNo, outboundReturnWorksheetDetails)
+}

package/server/graphql/resolvers/worksheet/unloading-return/complete-unload-return-partially.ts

@@ -0,0 +1,29 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { UnloadingReturningWorksheetController } from '../../../../controllers'
+import { WorksheetDetail } from '../../../../entities'
+
+export const completeUnloadReturnPartiallyResolver = {
+  async completeUnloadReturnPartially(_: any, { returnOrderNo, worksheetDetail }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await completeUnloadReturnPartially(tx, domain, user, returnOrderNo, worksheetDetail)
+  }
+}
+
+export async function completeUnloadReturnPartially(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  returnOrderNo: string,
+  unloadingWorksheetDetail: Partial<WorksheetDetail>[]
+): Promise<void> {
+  const worksheetController: UnloadingReturningWorksheetController = new UnloadingReturningWorksheetController(
+    tx,
+    domain,
+    user
+  )
+  await worksheetController.completeUnloadReturnPartially(returnOrderNo, unloadingWorksheetDetail)
+}

package/server/graphql/resolvers/worksheet/unloading-return/complete-unload-returning.ts

@@ -0,0 +1,91 @@
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ReturnOrder } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import { PutawayReturningWorksheetController, UnloadingReturningWorksheetController } from '../../../../controllers'
+import { SellercraftController } from '../../../../controllers/ecommerce'
+import { Worksheet, WorksheetDetail } from '../../../../entities'
+
+export const completeUnloadReturningResolver = {
+  async completeUnloadReturning(_: any, { returnOrderNo, worksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await completeUnloadReturning(tx, domain, user, returnOrderNo, worksheetDetails)
+
+    const returnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
+      where: { domain: { id: domain.id }, name: returnOrderNo },
+      relations: [
+        'bizplace',
+        'bizplace.domain',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.product',
+        'orderInventories.product.productDetails'
+      ]
+    })
+
+    const customerDomain: Domain = returnOrder.bizplace.domain
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOneBy({ domain: customerDomain, status: SellercraftStatus.ACTIVE })
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.registerProductReturn(sellercraft, returnOrder)
+    }
+
+    const putawayWSCtrl: PutawayReturningWorksheetController = new PutawayReturningWorksheetController(tx, domain, user)
+    let putawayWorksheet: Worksheet
+
+    try {
+      putawayWorksheet = await putawayWSCtrl.findWorksheetByRefOrder(returnOrderNo, WORKSHEET_TYPE.PUTAWAY_RETURN)
+    } catch (e) {
+      const inventories: Inventory[] = await tx.getRepository(Inventory).find({
+        where: {
+          domain: { id: domain.id },
+          refOrderId: returnOrder.id,
+          status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.CHECKED])
+        }
+      })
+      putawayWorksheet = await putawayWSCtrl.generatePutawayReturnWorksheet(returnOrder.name, inventories)
+    }
+
+    if (putawayWorksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
+      await putawayWSCtrl.activatePutawayReturning(putawayWorksheet.name, putawayWorksheet.worksheetDetails)
+    }
+
+    const worksheetController: UnloadingReturningWorksheetController = new UnloadingReturningWorksheetController(
+      tx,
+      domain,
+      user
+    )
+
+    if (context.header && context.header.referer) {
+      worksheetController.notifyToOfficeAdmin({
+        title: `Unloading Completed (${returnOrder.bizplace.name}, ${returnOrder.name})`,
+        body: `${returnOrder.name} is ready for putaway`,
+        url: context.header.referer,
+        data: { url: context.header.referer }
+      })
+    }
+  }
+}
+
+export async function completeUnloadReturning(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  returnOrderNo: string,
+  unloadingReturnWorksheetDetails: Partial<WorksheetDetail>[]
+): Promise<void> {
+  const worksheetController: UnloadingReturningWorksheetController = new UnloadingReturningWorksheetController(
+    tx,
+    domain,
+    user
+  )
+  await worksheetController.completeUnloadReturning(returnOrderNo, unloadingReturnWorksheetDetails)
+}

package/server/graphql/resolvers/worksheet/unloading-return/index.ts

@@ -0,0 +1,9 @@
+import { activateUnloadingReturnResolver } from './activate-unloading-return'
+import { completeUnloadReturningResolver } from './complete-unload-returning'
+import { completeUnloadReturnPartiallyResolver } from './complete-unload-return-partially'
+
+export const Mutations = {
+  ...activateUnloadingReturnResolver,
+  ...completeUnloadReturningResolver,
+  ...completeUnloadReturnPartiallyResolver
+}

package/server/graphql/resolvers/worksheet/unloading-return-worksheet.ts

@@ -0,0 +1,75 @@
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderInventory, ReturnOrder } from '@things-factory/sales-base'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
+
+export const unloadingReturnWorksheetResolver = {
+  async unloadingReturnWorksheet(_: any, { returnOrderNo }, context: ResolverContext) {
+    const { domain } = context.state
+    const returnOrder: ReturnOrder = await getRepository(ReturnOrder).findOne({
+      where: { domain: { id: domain.id }, name: returnOrderNo },
+      relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
+    })
+    if (!returnOrder) throw new Error(`Return Order doesn't exist.`)
+
+    const customerBizplace: Bizplace = returnOrder.bizplace
+    const customerCompanyDomain: Domain = returnOrder.bizplace?.company.domain
+
+    const worksheet: Worksheet = await fetchExecutingWorksheet(
+      domain,
+      customerBizplace,
+      [
+        'bizplace',
+        'bizplace.domain',
+        'bufferLocation',
+        'bufferLocation.warehouse',
+        'returnOrder',
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.inventory',
+        'creator',
+        'updater'
+      ],
+      WORKSHEET_TYPE.UNLOADING_RETURN,
+      returnOrder
+    )
+
+    return {
+      worksheetInfo: {
+        bizplaceName: customerBizplace.name,
+        partnerDomainId: customerBizplace?.domain.id,
+        customerCompanyDomainId: customerCompanyDomain.id,
+        bufferLocation: worksheet.bufferLocation.name,
+        startedAt: worksheet.startedAt,
+        refNo: returnOrder.refNo
+      },
+      worksheetDetailInfos: worksheet.worksheetDetails.map((productWSD: WorksheetDetail) => {
+        const targetInventory: OrderInventory = productWSD.targetInventory
+
+        return {
+          id: productWSD.id,
+          name: productWSD.name,
+          batchId: targetInventory.batchId,
+          palletId: targetInventory.inventory.palletId,
+          product: targetInventory.product,
+          description: productWSD.description,
+          targetName: targetInventory.name,
+          packingType: targetInventory.packingType,
+          packingSize: targetInventory.inventory.packingSize,
+          palletQty: targetInventory.palletQty,
+          actualPalletQty: targetInventory.actualPalletQty,
+          packQty: targetInventory.returnQty,
+          actualPackQty: targetInventory.actualPackQty,
+          remark: targetInventory.remark,
+          inventory: targetInventory.inventory,
+          issue: productWSD.issue,
+          status: productWSD.status
+        }
+      })
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/unloading-worksheet.ts

@@ -0,0 +1,98 @@
+import { Bizplace } from '@things-factory/biz-base'
+import { ArrivalNotice, OrderProduct } from '@things-factory/sales-base'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
+
+export const unloadingWorksheetResolver = {
+  async unloadingWorksheet(_: any, { arrivalNoticeNo }, context: ResolverContext) {
+    const { domain } = context.state
+    const arrivalNotice: ArrivalNotice = await getRepository(ArrivalNotice).findOne({
+      where: { domain: { id: domain.id }, name: arrivalNoticeNo /*status: ORDER_STATUS.PROCESSING*/ },
+      relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
+    })
+    if (!arrivalNotice) throw new Error(`Arrival notice doesn't exist.`)
+
+    const customerBizplace: Bizplace = arrivalNotice.bizplace
+    const customerCompanyDomain: Domain = arrivalNotice.bizplace?.company.domain
+    const worksheet: Worksheet = await fetchExecutingWorksheet(
+      domain,
+      customerBizplace,
+      [
+        'bizplace',
+        'bufferLocation',
+        'bufferLocation.warehouse',
+        'arrivalNotice',
+        'worksheetDetails',
+        'worksheetDetails.targetProduct',
+        'worksheetDetails.targetProduct.product',
+        'creator',
+        'updater'
+      ],
+      WORKSHEET_TYPE.UNLOADING,
+      arrivalNotice
+    )
+
+    const vasWorksheet: Worksheet = await getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        arrivalNotice: { id: arrivalNotice.id },
+        type: WORKSHEET_TYPE.VAS
+      },
+      relations: [
+        'bizplace',
+        'bizplace.domain',
+        'bufferLocation',
+        'bufferLocation.warehouse',
+        'arrivalNotice',
+        'worksheetDetails',
+        'worksheetDetails.targetVas',
+        'worksheetDetails.targetVas.vas',
+        'creator',
+        'updater'
+      ]
+    })
+
+    return {
+      worksheetInfo: {
+        arrivalNotice,
+        bizplaceName: customerBizplace.name,
+        partnerDomainId: customerBizplace?.domain.id,
+        customerCompanyDomainId: customerCompanyDomain.id,
+        containerNo: arrivalNotice.containerNo,
+        bufferLocation: worksheet.bufferLocation.name,
+        startedAt: worksheet.startedAt,
+        refNo: arrivalNotice.refNo,
+        refNo2: arrivalNotice?.refNo2,
+        refNo3: arrivalNotice?.refNo3,
+        looseItem: arrivalNotice.looseItem,
+        orderVas: vasWorksheet ? vasWorksheet.worksheetDetails : null
+      },
+      worksheetDetailInfos: worksheet.worksheetDetails.map(async (productWSD: WorksheetDetail) => {
+        const targetProduct: OrderProduct = productWSD.targetProduct
+
+        return {
+          id: productWSD.id,
+          name: productWSD.name,
+          batchId: targetProduct.batchId,
+          batchIdRef: targetProduct.batchIdRef,
+          product: targetProduct.product,
+          description: productWSD.description,
+          targetName: targetProduct.name,
+          packingType: targetProduct.packingType,
+          packingSize: targetProduct.packingSize,
+          palletQty: targetProduct.palletQty,
+          actualPalletQty: targetProduct.actualPalletQty,
+          packQty: targetProduct.packQty,
+          actualPackQty: targetProduct.actualPackQty,
+          remark: targetProduct.remark,
+          issue: productWSD.issue,
+          status: productWSD.status,
+          manufactureDate: targetProduct.manufactureDate ? new Date(targetProduct.manufactureDate) : null
+        }
+      })
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/update-worksheet.ts

@@ -0,0 +1,25 @@
+import { In } from 'typeorm'
+
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+
+import { Worksheet } from '../../../entities'
+
+export const updateWorksheet = {
+  async updateWorksheet(_: any, { id, patch }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+
+    const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) },
+        id
+      }
+    })
+
+    return await tx.getRepository(Worksheet).save({
+      ...worksheet,
+      ...patch,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/worksheet/vas/activate-vas.ts

@@ -0,0 +1,25 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { VasWorksheetController } from '../../../../controllers'
+import { WorksheetDetail } from '../../../../entities'
+
+export const activateVasResolver = {
+  async activateVas(_: any, { worksheetNo, vasWorksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    return await activateVas(tx, domain, user, worksheetNo, vasWorksheetDetails)
+  }
+}
+
+export async function activateVas(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  vasWorksheetDetails: Partial<WorksheetDetail>[]
+) {
+  const worksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
+  return await worksheetController.activateVAS(worksheetNo, vasWorksheetDetails)
+}

package/server/graphql/resolvers/worksheet/vas/assign-vas-inventories.ts

@@ -0,0 +1,25 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { VasWorksheetController } from '../../../../controllers'
+
+export const assignVasInventoriesResolver = {
+  async assignVasInventories(_: any, { worksheetDetailIds, inventories }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await assignVasInventories(tx, domain, user, worksheetDetailIds, inventories)
+  }
+}
+
+export async function assignVasInventories(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailIds: string[],
+  inventories: Partial<Inventory>
+): Promise<void> {
+  const worksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
+  await worksheetController.assignInventories(worksheetDetailIds, inventories)
+}

package/server/graphql/resolvers/worksheet/vas/complete-vas.ts

@@ -0,0 +1,72 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { ArrivalNotice, ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_TYPE } from '../../../../constants'
+import { LoadingWorksheetController, PutawayWorksheetController, VasWorksheetController } from '../../../../controllers'
+import { Worksheet, WorksheetDetail } from '../../../../entities'
+
+export const completeVasResolver = {
+  async completeVas(_: any, { orderNo, orderType, worksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await completeVAS(tx, domain, user, orderNo, orderType, worksheetDetails)
+  }
+}
+
+export async function completeVAS(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  orderNo: string,
+  orderType: string,
+  worksheetDetails: WorksheetDetail[]
+): Promise<Worksheet> {
+  const worksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
+  let worksheet: Worksheet = await worksheetController.completeVAS(orderNo, orderType, worksheetDetails)
+
+  // if (orderType === ORDER_TYPES.ARRIVAL_NOTICE) {
+  //   if (!worksheet.worksheetDetails?.length || !worksheet.arrivalNotice?.id) {
+  //     worksheet = await worksheetController.findWorksheetById(worksheet.id, ['worksheetDetails', 'arrivalNotice'])
+  //   }
+
+  //   const arrivalNotice: ArrivalNotice = worksheet.arrivalNotice
+  //   await activatePutawayWorksheet(tx, domain, user, arrivalNotice)
+  // } else if (orderType === ORDER_TYPES.RELEASE_OF_GOODS) {
+  //   if (!worksheet.worksheetDetails?.length || !worksheet.releaseGood?.id) {
+  //     worksheet = await worksheetController.findWorksheetById(worksheet.id, ['worksheetDetails', 'releaseGood'])
+  //   }
+
+  //   const releaseGood: ReleaseGood = worksheet.releaseGood
+  //   await activateLoadingWorksheet(tx, domain, user, releaseGood)
+  // }
+
+  return worksheet
+}
+
+async function activatePutawayWorksheet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  arrivalNotice: ArrivalNotice
+): Promise<void> {
+  const worksheetController: PutawayWorksheetController = new PutawayWorksheetController(tx, domain, user)
+  const worksheet: Worksheet = await worksheetController.findWorksheetByRefOrder(arrivalNotice, WORKSHEET_TYPE.PUTAWAY)
+  const worksheetNo: string = worksheet.name
+  const putawayWorksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+  await worksheetController.activatePutaway(worksheetNo, putawayWorksheetDetails)
+}
+
+async function activateLoadingWorksheet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  releaseGood: ReleaseGood
+): Promise<void> {
+  const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+  const worksheet: Worksheet = await worksheetController.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.LOADING)
+  const worksheetNo: string = worksheet.name
+  const loadingWorksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+  await worksheetController.activateLoading(worksheetNo, loadingWorksheetDetails)
+}

package/server/graphql/resolvers/worksheet/vas/execute-vas.ts

@@ -0,0 +1,31 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { VasWorksheetController } from '../../../../controllers'
+import { WorksheetDetail } from '../../../../entities'
+
+export const executeVasResolver = {
+  async executeVas(_: any, { worksheetDetail, palletId }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    /**
+     * @description If pallet id param is exists.
+     * Meaning, the VAS order have been requested with Arrival Notice or Release Order
+     * Those types of VAS doesn't have flow to assign specific vas target inventory
+     * Assignment should be done within executeVas transaction.
+     */
+    await executeVas(tx, domain, user, worksheetDetail, palletId)
+  }
+}
+
+export async function executeVas(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetail: Partial<WorksheetDetail>,
+  palletId?: string
+): Promise<void> {
+  const worksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
+  await worksheetController.executeVAS(worksheetDetail, palletId)
+}

package/server/graphql/resolvers/worksheet/vas/index.ts

@@ -0,0 +1,15 @@
+import { assignVasInventoriesResolver } from './assign-vas-inventories'
+import { activateVasResolver } from './activate-vas'
+import { executeVasResolver } from './execute-vas'
+import { undoVasResolver } from './undo-vas'
+import { completeVasResolver } from './complete-vas'
+import { undoVasInventoryResolver } from './undo-vas-inventory'
+
+export const Mutations = {
+  ...assignVasInventoriesResolver,
+  ...activateVasResolver,
+  ...executeVasResolver,
+  ...undoVasResolver,
+  ...completeVasResolver,
+  ...undoVasInventoryResolver
+}