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

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

@@ -1,234 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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