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

package/server/graphql/resolvers/worksheet/pending-cancellation-release-order.ts

@@ -0,0 +1,234 @@
+import { In } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import {
+  DeliveryOrder,
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  ORDER_VAS_STATUS,
+  OrderInventory,
+  OrderVas,
+  ReleaseGood
+} from '@things-factory/sales-base'
+
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const pendingCancellationReleaseOrder = {
+  async pendingCancellationReleaseOrder(_: any, { name }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    const foundRO: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: ['bizplace', 'orderInventories', 'orderVass']
+    })
+
+    if (foundRO.status === 'DONE') throw new Error('Release good has been completed!')
+    if (!foundRO) throw new Error(`Release good order doesn't exists.`)
+    let targetOIs: OrderInventory[] = foundRO.orderInventories
+    let foundOVs: OrderVas[] = foundRO.orderVass
+    let customerBizplace: Bizplace = foundRO.bizplace
+    let pickedOIs: OrderInventory[]
+    let pickingOIs: OrderInventory[]
+
+    // 1. Check RO status
+    if (
+      foundRO.status === ORDER_STATUS.LOADING ||
+      foundRO.status === ORDER_STATUS.PACKING ||
+      foundRO.status === ORDER_STATUS.SORTING
+    ) {
+      // 1a. Case 1: RO is done or loading, pending cancel order, worksheet, worksheet detail, order inventory
+      // update status of order inventory to PENDING_CANCEL
+      pickedOIs = targetOIs.map((orderInv: OrderInventory) => {
+        return {
+          ...orderInv,
+          status: ORDER_INVENTORY_STATUS.PENDING_REVERSE,
+          updater: user
+        }
+      })
+      await tx.getRepository(OrderInventory).save(pickedOIs)
+    } else if (
+      foundRO.status === ORDER_STATUS.PICKING ||
+      foundRO.status === ORDER_STATUS.READY_TO_PICK ||
+      foundRO.status === ORDER_STATUS.PENDING_WORKSHEET
+    ) {
+      pickingOIs = targetOIs
+        .filter(
+          (oi: OrderInventory) =>
+            oi.status === ORDER_INVENTORY_STATUS.ASSIGNED ||
+            oi.status === ORDER_INVENTORY_STATUS.PICKING ||
+            oi.status === ORDER_INVENTORY_STATUS.READY_TO_PICK ||
+            oi.status === ORDER_INVENTORY_STATUS.PENDING_SPLIT ||
+            oi.status === ORDER_INVENTORY_STATUS.PENDING_WORKSHEET
+        )
+        .map((targetOI: OrderInventory) => {
+          return {
+            ...targetOI,
+            status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
+            updater: user
+          }
+        })
+      await tx.getRepository(OrderInventory).save(pickingOIs)
+
+      pickedOIs = targetOIs
+        .filter((pickedOI: OrderInventory) => pickedOI.status === ORDER_INVENTORY_STATUS.PICKED)
+        .map((targetOI: OrderInventory) => {
+          return {
+            ...targetOI,
+            status: ORDER_INVENTORY_STATUS.PENDING_REVERSE,
+            updater: user
+          }
+        })
+      await tx.getRepository(OrderInventory).save(pickedOIs)
+    }
+
+    // update status of order vass to PENDING_CANCEL
+    if (foundOVs && foundOVs.length) {
+      foundOVs = foundOVs.map((orderVas: OrderVas) => {
+        return {
+          ...orderVas,
+          status: ORDER_VAS_STATUS.PENDING_CANCEL,
+          updater: user
+        }
+      })
+      await tx.getRepository(OrderVas).save(foundOVs)
+    }
+
+    // find worksheet and update status to PENDING_CANCEL
+    let foundWS: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        releaseGood: { id: foundRO.id }
+      },
+      order: { createdAt: 'DESC' }
+    })
+
+    if (foundWS) {
+      await tx.getRepository(Worksheet).update(
+        { id: foundWS.id },
+        {
+          status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
+          updater: user
+        }
+      )
+
+      if (pickedOIs && pickedOIs.length) {
+        let pickedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+          where: {
+            domain: { id: domain.id },
+            targetInventory: { id: In(pickedOIs.map(oi => oi.id)) },
+            status: ORDER_INVENTORY_STATUS.DONE,
+            worksheet: { id: foundWS.id }
+          }
+        })
+
+        pickedWSD = pickedWSD.map((wsd: WorksheetDetail) => {
+          return {
+            ...wsd,
+            status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
+            updater: user
+          }
+        })
+        await tx.getRepository(WorksheetDetail).save(pickedWSD)
+
+        let replacedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+          where: {
+            domain: { id: domain.id },
+            targetInventory: { id: In(pickedOIs.map(oi => oi.id)) },
+            status: ORDER_INVENTORY_STATUS.REPLACED,
+            worksheet: { id: foundWS.id }
+          },
+          relations: ['targetInventory']
+        })
+
+        if (replacedWSD && replacedWSD.length) {
+          let replacedOI: OrderInventory[] = replacedWSD.map((wsd: WorksheetDetail) => wsd.targetInventory)
+          replacedOI = replacedOI.map((oi: OrderInventory) => {
+            return {
+              ...oi,
+              status: ORDER_INVENTORY_STATUS.REPLACED,
+              updater: user
+            }
+          })
+          await tx.getRepository(OrderInventory).save(replacedOI)
+        }
+      }
+
+      if (pickingOIs && pickingOIs.length) {
+        let pickingWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+          where: {
+            domain: { id: domain.id },
+            targetInventory: { id: In(pickingOIs.map(oi => oi.id)) },
+            worksheet: { id: foundWS.id }
+          }
+        })
+
+        pickingWSD = pickingWSD.map((wsd: WorksheetDetail) => {
+          return {
+            ...wsd,
+            status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
+            updater: user
+          }
+        })
+        await tx.getRepository(WorksheetDetail).save(pickingWSD)
+      }
+    }
+
+    // find DO and change status to pending cancel
+    let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
+      where: { domain: { id: domain.id }, releaseGood: { id: foundRO.id } }
+    })
+
+    foundDO = foundDO.map((deliveryOrder: DeliveryOrder) => {
+      return {
+        ...deliveryOrder,
+        status: ORDER_STATUS.PENDING_CANCEL,
+        updater: user
+      }
+    })
+    await tx.getRepository(DeliveryOrder).save(foundDO)
+
+    await tx.getRepository(ReleaseGood).save({
+      ...foundRO,
+      status: ORDER_STATUS.PENDING_CANCEL,
+      updater: user
+    })
+
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+    // // notification logics
+    // // get Office Admin Users
+    // const users: any[] = await tx
+    //   .getRepository('users_roles')
+    //   .createQueryBuilder('ur')
+    //   .select('ur.users_id', 'id')
+    //   .where(qb => {
+    //     const subQuery = qb
+    //       .subQuery()
+    //       .select('role.id')
+    //       .from(Role, 'role')
+    //       .where("role.name = 'Office Admin'")
+    //       .andWhere('role.domain_id = :domain', { domain: domain.id })
+    //       .getQuery()
+    //     return 'ur.roles_id IN ' + subQuery
+    //   })
+    //   .getRawMany()
+
+    // // send notification to Office Admin Users
+    // if (users?.length && context.header?.referer) {
+    //   const receivers: any[] = users.map(user => user.id)
+    //   const msg = {
+    //     title: `${foundRO.name} cancellation`,
+    //     body: `${customerBizplace.name} is requesting to cancel order`,
+    //     url: context.header.referer,
+    //     data: { url: context.header.referer }
+    //   }
+
+    //   await sendNotification({
+    //     receivers,
+    //     message: { ...msg }
+    //   })
+    // }
+
+    return
+  }
+}

package/server/graphql/resolvers/worksheet/picking/activate-batch-picking.ts

@@ -0,0 +1,40 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Domain } from '@things-factory/shell'
+
+import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const activateBatchPickingResolver = {
+  async activateBatchPicking(_: any, { worksheetNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    return await activateBatchPicking(tx, domain, user, worksheetNo)
+  }
+}
+
+export async function activateBatchPicking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string
+): Promise<Worksheet> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  const worksheet = await worksheetController.activateBatchPicking(worksheetNo)
+  const worksheetDetails = worksheet.worksheetDetails
+  const companyDomain: Domain = worksheet?.bizplace.company.domain
+
+  // find for any existing marketplace store connections
+  const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+    where: { domain: { id: companyDomain.id }, status: 'ACTIVE', isAutoUpdateStockQty: true },
+    relations: ['marketplaceDistributors']
+  })
+
+  if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+    let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+    const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+    await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+  }
+  return worksheet
+}

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

@@ -0,0 +1,98 @@
+import { EntityManager } from 'typeorm'
+
+import { ApplicationType, User } from '@things-factory/auth-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { MarketplaceOrder } from '@things-factory/marketplace-base'
+import { ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const activatePickingResolver = {
+  async activatePicking(_: any, { worksheetNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    return await activatePicking(tx, domain, user, worksheetNo)
+  }
+}
+
+export async function activatePicking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string
+): Promise<Worksheet> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  const worksheet = await worksheetController.activatePicking(worksheetNo)
+  const companyDomain: Domain = worksheet?.bizplace.company.domain
+
+  let releaseGood: ReleaseGood = worksheet.releaseGood
+
+  const orderSource: string = releaseGood.source
+  switch (orderSource) {
+    case ApplicationType.MMS:
+      // find for any existing marketplace store connections
+      const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+        where: { domain: { id: companyDomain.id }, status: 'ACTIVE', isAutoUpdateStockQty: true },
+        relations: ['marketplaceDistributors']
+      })
+
+      if (marketplaceStores?.length) {
+        if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+          const worksheetDetails = worksheet.worksheetDetails
+          let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+          await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+        }
+
+        const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+          where: { orderNo: releaseGood.refNo, domain: { id: companyDomain.id } },
+          relations: ['marketplaceStore']
+        })
+
+        if (marketplaceOrder) {
+          const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+          if (marketplaceStore.isAutoUpdateShipment) {
+            const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+            await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
+          }
+        }
+      }
+      break
+
+    default:
+      break
+  }
+
+  // if (releaseGood.type === 'b2c') {
+  //   const sellercraft: Sellercraft = await tx
+  //     .getRepository(Sellercraft)
+  //     .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+  //   if (marketplaceStores?.length && !sellercraft) {
+  //     if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+  //       const worksheetDetails = worksheet.worksheetDetails
+  //       let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+  //       const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+  //       await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+  //     }
+
+  //     const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+  //       where: { orderNo: releaseGood.refNo, domain: { id: companyDomain.id } },
+  //       relations: ['marketplaceStore']
+  //     })
+
+  //     if (marketplaceOrder) {
+  //       const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+  //       if (marketplaceStore.isAutoUpdateShipment) {
+  //         const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+  //         await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
+  //       }
+  //     }
+  //   }
+  // }
+
+  return worksheet
+}

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

@@ -0,0 +1,50 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+import { WorksheetDetail } from '../../../../entities'
+
+export const assignPickingInventoriesResolver = {
+  async assignPickingInventories(
+    _: any,
+    { worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails },
+    context: any
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
+    await assignPickingInventories(
+      tx,
+      domain,
+      user,
+      worksheetNo,
+      batchId,
+      productId,
+      packingType,
+      packingSize,
+      worksheetDetails
+    )
+  }
+}
+
+export async function assignPickingInventories(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  batchId: string,
+  productId: string,
+  packingType: string,
+  packingSize: number,
+  worksheetDetails: Partial<WorksheetDetail>[]
+): Promise<void> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.assignPickingInventories(
+    worksheetNo,
+    batchId,
+    productId,
+    packingType,
+    packingSize,
+    worksheetDetails
+  )
+}

package/server/graphql/resolvers/worksheet/picking/assign-picking-worker.ts

@@ -0,0 +1,44 @@
+import { In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import { Worksheet } from '../../../../entities'
+
+export const assignPickingWorkerResolver = {
+  async assignPickingWorker(
+    _parentObj: void,
+    { worksheetId, userId }: { worksheetId: [string]; userId: string },
+    context: any
+  ): Promise<void> {
+    const { tx, domain } = context.state
+    const assignee: User = await tx.getRepository(User).findOne({
+      where: { id: userId },
+      relations: ['domains']
+    })
+    if ((assignee?.domains || []).every((userDomain: Domain) => userDomain.id !== domain.id))
+      throw new Error('Target user is not belong to current domain')
+
+    if (!assignee) throw new Error('failed to find target user')
+
+    await Promise.all(
+      worksheetId.map(async worksheetId => {
+        const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+          where: {
+            id: worksheetId,
+            type: In([WORKSHEET_TYPE.BATCH_PICKING, WORKSHEET_TYPE.PICKING])
+          }
+          /* CONFIRMME regarding TYPEORM */
+        })
+
+        if (!worksheet) throw new Error('failed to find target picking worksheet')
+        if (worksheet.status !== WORKSHEET_STATUS.DEACTIVATED)
+          throw new Error(`current status of worksheet is not able to assign worker`)
+
+        worksheet.assignee = assignee
+        await tx.getRepository(Worksheet).save(worksheet)
+      })
+    )
+  }
+}

package/server/graphql/resolvers/worksheet/picking/batch-picking.ts

@@ -0,0 +1,32 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const batchPickingResolver = {
+  async batchPicking(
+    _: any,
+    { taskNo, worksheetType, palletId, locationName, binLocationName, releaseQty },
+    context: any
+  ) {
+    const { tx, domain, user } = context.state
+    await batchPicking(tx, domain, user, taskNo, worksheetType, palletId, locationName, binLocationName, releaseQty)
+  }
+}
+
+export async function batchPicking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  taskNo: string,
+  worksheetType: string,
+  palletId: string,
+  locationName: string,
+  binLocationName: string,
+  releaseQty: number
+) {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.batchPicking(taskNo, worksheetType, palletId, locationName, binLocationName, releaseQty)
+}

package/server/graphql/resolvers/worksheet/picking/complete-batch-picking.ts

@@ -0,0 +1,137 @@
+import { EntityManager } from 'typeorm'
+
+import { ApplicationType, User } from '@things-factory/auth-base'
+import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import {
+  PackingWorksheetController,
+  PickingWorksheetController,
+  SellercraftController,
+  SortingWorksheetController
+} from '../../../../controllers/'
+import { WorksheetController } from '../../../../controllers/worksheet-controller'
+import { Worksheet, WorksheetDetail } from '../../../../entities'
+
+export const completeBatchPickingResolver = {
+  async completeBatchPicking(_: any, { taskNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+
+    await completeBatchPicking(tx, domain, user, taskNo)
+
+    const bizplace: Bizplace = await getMyBizplace(domain, user)
+    const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
+    await worksheetController.notifyToCustomer(bizplace, {
+      title: `Picking has been completed (${bizplace.name}, ${taskNo})`,
+      body: `Items now are ready for sorting`,
+      url: context.header.referer,
+      data: { url: context.header.referer }
+    })
+  }
+}
+
+export async function completeBatchPicking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  taskNo: string
+): Promise<void> {
+  const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  const worksheet = await pickingWSCtrl.completeBatchPicking(taskNo)
+
+  const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+  const targetInventories: OrderInventory[] = worksheetDetails
+    .filter(wsd => wsd.status != 'MISSING')
+    .map((wsd: WorksheetDetail) => wsd.targetInventory)
+
+  const releaseGoods: ReleaseGood[] = worksheetDetails.map(
+    worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.releaseGood
+  )
+  const uniqueReleaseGoods: ReleaseGood[] = []
+  const map = new Map()
+  for (const releaseGood of releaseGoods) {
+    if (!map.has(releaseGood.id)) {
+      map.set(releaseGood.id, true)
+      uniqueReleaseGoods.push({ ...releaseGood })
+    }
+  }
+
+  await Promise.all(
+    uniqueReleaseGoods.map(async releaseGood => {
+      let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: { id: releaseGood.id },
+        relations: ['orderProducts', 'orderProducts.product']
+      })
+      const orderSource: string = foundReleaseGood.source
+      switch (orderSource) {
+        case ApplicationType.SELLERCRAFT:
+          const sellercraft: Sellercraft = await tx
+            .getRepository(Sellercraft)
+            .findOneBy({ domain: { id: worksheet.bizplace.domain.id }, status: SellercraftStatus.ACTIVE })
+
+          if (sellercraft) {
+            const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+            if (!foundReleaseGood?.packageId) {
+              foundReleaseGood = await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
+              if (foundReleaseGood?.packageId) {
+                await tx
+                  .getRepository(ReleaseGood)
+                  .update(
+                    { id: foundReleaseGood.id },
+                    { packageId: foundReleaseGood.packageId, updater: foundReleaseGood.updater }
+                  )
+              }
+            }
+
+            sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
+          }
+          break
+
+        default:
+          break
+      }
+    })
+  )
+
+  const pickPackTargetInventories: OrderInventory[] = targetInventories
+    .filter(targetInventory => targetInventory.releaseGood.packingOption)
+    .map((pickPackTargetInventory: OrderInventory) => {
+      return pickPackTargetInventory
+    })
+
+  const pickSortTargetInventories: OrderInventory[] = targetInventories
+    .filter(targetInventory => !targetInventory.releaseGood.packingOption)
+    .map((pickSortTargetInventory: OrderInventory) => {
+      return pickSortTargetInventory
+    })
+
+  if (pickPackTargetInventories?.length) {
+    // pull out all unique RO
+    const roNoList: string[] = pickPackTargetInventories.map((oi: OrderInventory) => oi.releaseGood.name)
+    let uniqueRoNo: string[] = []
+    roNoList.forEach(roNo => {
+      if (!uniqueRoNo.includes(roNo)) {
+        uniqueRoNo.push(roNo)
+      }
+    })
+
+    // loop to generate packing worksheet
+    for (let i: number = 0; i < uniqueRoNo.length; i++) {
+      const releaseGoodNo: string = uniqueRoNo[i]
+      const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+      await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+    }
+  }
+
+  if (pickSortTargetInventories?.length) {
+    const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
+    const sortingWorksheet: Worksheet = await sortingWSCtrl.generateSortingWorksheet(
+      worksheet,
+      pickSortTargetInventories
+    )
+
+    await sortingWSCtrl.activateSorting(sortingWorksheet.name, sortingWorksheet.worksheetDetails)
+  }
+}