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

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

@@ -0,0 +1,186 @@
+import { logger } from '@things-factory/env'
+import {
+  DeliveryOrder,
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderInventory,
+  ReleaseGood
+} from '@things-factory/sales-base'
+
+import { WORKSHEET_STATUS } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const rejectCancellationReleaseOrder = {
+  async rejectCancellationReleaseOrder(_: any, { name }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+
+    try {
+      // find release order
+      let foundRO: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_CANCEL },
+        relations: [
+          'bizplace',
+          'orderInventories',
+          'orderInventories.inventory',
+          'orderInventories.inventory.location',
+          'orderInventories.deliveryOrder',
+          'orderVass'
+        ]
+      })
+
+      if (!foundRO) throw new Error(`Release order doesn't exists.`)
+
+      let targetOIs: OrderInventory[] = foundRO.orderInventories
+
+      // perform update on all order inventories and worksheet
+      let worksheetDetails = await Promise.all(
+        targetOIs.map(async orderInventory => {
+          let existingWorksheetDetail: WorksheetDetail = await tx
+            .getRepository(WorksheetDetail)
+            .createQueryBuilder('wd')
+            .innerJoinAndSelect('wd.worksheet', 'ws')
+            .where('wd.target_inventory_id = :orderInventoryId', { orderInventoryId: orderInventory.id })
+            .orderBy('ws.created_at', 'DESC')
+            .addOrderBy('wd.name')
+            .getOne()
+
+          if (existingWorksheetDetail) {
+            const startedAt = existingWorksheetDetail.worksheet.startedAt
+            const wdType = existingWorksheetDetail.worksheet.type
+            let wdStatus, oiStatus, roStatus, wStatus
+            switch (wdType) {
+              case 'PICKING':
+              case 'BATCH_PICKING':
+                wdStatus = !startedAt
+                  ? WORKSHEET_STATUS.DEACTIVATED
+                  : orderInventory.pickedQty == orderInventory.releaseQty
+                    ? WORKSHEET_STATUS.DONE
+                    : WORKSHEET_STATUS.EXECUTING
+                oiStatus = !startedAt
+                  ? ORDER_INVENTORY_STATUS.READY_TO_PICK
+                  : orderInventory.pickedQty == orderInventory.releaseQty
+                    ? ORDER_INVENTORY_STATUS.PICKED
+                    : ORDER_INVENTORY_STATUS.PICKING
+                roStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_PICK : ORDER_INVENTORY_STATUS.PICKING
+                break
+              case 'PACKING':
+                wdStatus = !startedAt
+                  ? WORKSHEET_STATUS.DEACTIVATED
+                  : orderInventory.packedQty == orderInventory.releaseQty
+                    ? WORKSHEET_STATUS.DONE
+                    : WORKSHEET_STATUS.EXECUTING
+                oiStatus = !startedAt
+                  ? ORDER_INVENTORY_STATUS.READY_TO_PACK
+                  : orderInventory.packedQty == orderInventory.releaseQty
+                    ? ORDER_INVENTORY_STATUS.PACKED
+                    : ORDER_INVENTORY_STATUS.PACKING
+                roStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_PACK : ORDER_INVENTORY_STATUS.PACKING
+                break
+              case 'SORTING':
+                wdStatus = !startedAt
+                  ? WORKSHEET_STATUS.DEACTIVATED
+                  : orderInventory.sortedQty == orderInventory.releaseQty
+                    ? WORKSHEET_STATUS.DONE
+                    : WORKSHEET_STATUS.EXECUTING
+                oiStatus = !startedAt
+                  ? ORDER_INVENTORY_STATUS.READY_TO_SORT
+                  : orderInventory.sortedQty == orderInventory.releaseQty
+                    ? ORDER_INVENTORY_STATUS.PICKED
+                    : ORDER_INVENTORY_STATUS.SORTING
+                roStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_SORT : ORDER_INVENTORY_STATUS.SORTING
+                break
+              case 'LOADING':
+                wdStatus = !startedAt
+                  ? WORKSHEET_STATUS.DEACTIVATED
+                  : orderInventory?.deliveryOrder
+                    ? WORKSHEET_STATUS.DONE
+                    : WORKSHEET_STATUS.EXECUTING
+                oiStatus = !startedAt
+                  ? //@ts-ignore
+                    ORDER_INVENTORY_STATUS.READY_TO_LOAD
+                  : orderInventory?.deliveryOrder
+                    ? ORDER_INVENTORY_STATUS.LOADED
+                    : ORDER_INVENTORY_STATUS.LOADING
+                //@ts-ignore
+                roStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_LOAD : ORDER_INVENTORY_STATUS.LOADING
+                break
+              default:
+                break
+            }
+
+            wStatus = !startedAt ? WORKSHEET_STATUS.DEACTIVATED : WORKSHEET_STATUS.EXECUTING
+
+            await tx
+              .getRepository(WorksheetDetail)
+              .update({ id: existingWorksheetDetail.id }, { status: wdStatus, updatedAt: new Date(), updater: user })
+            await tx
+              .getRepository(OrderInventory)
+              .update({ id: orderInventory.id }, { status: oiStatus, updatedAt: new Date(), updater: user } as any)
+
+            return { worksheet: existingWorksheetDetail.worksheet, wStatus, roStatus }
+          } else {
+            await tx.getRepository(OrderInventory).update({ id: orderInventory.id }, {
+              status: ORDER_INVENTORY_STATUS.PENDING_WORKSHEET,
+              updatedAt: new Date(),
+              updater: user
+            } as any)
+            return { worksheet: null, wStatus: null, roStatus: ORDER_STATUS.PENDING_WORKSHEET }
+          }
+        })
+      )
+
+      if (worksheetDetails[0].worksheet) {
+        await tx.getRepository(Worksheet).update(
+          { id: worksheetDetails[0].worksheet.id },
+          {
+            status: worksheetDetails[0].wStatus,
+            updatedAt: new Date(),
+            updater: user
+          }
+        )
+      }
+
+      await tx.getRepository(ReleaseGood).update({ id: foundRO.id }, {
+        status: worksheetDetails[0].roStatus,
+        updatedAt: new Date(),
+        updater: user
+      } as any)
+
+      // reverse DO status
+      await reverseDO(foundRO, context)
+
+      return
+    } catch (error) {
+      logger.error(
+        `reject-cancellation-release-order[rejectCancellationReleaseOrder]:(data:${JSON.stringify({
+          name,
+          tx,
+          domain,
+          user
+        })}) ${error}`
+      )
+      throw new Error('Something went wrong. Please contact support.')
+    }
+  }
+}
+
+async function reverseDO(releaseGood: ReleaseGood, context: ResolverContext) {
+  const { tx, domain, user } = context.state
+
+  // find DO and change status to previous status
+  let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
+    where: { domain: { id: domain.id }, releaseGood: { id: releaseGood.id }, status: ORDER_STATUS.PENDING_CANCEL },
+    relations: ['transportVehicle']
+  })
+  if (foundDO && foundDO?.length) {
+    foundDO = foundDO.map((deliveryOrder: DeliveryOrder) => {
+      return {
+        ...deliveryOrder,
+        status: ORDER_STATUS.READY_TO_DISPATCH,
+        updater: user
+      }
+    })
+
+    await tx.getRepository(DeliveryOrder).save(foundDO)
+  }
+}

package/server/graphql/resolvers/worksheet/relocate-pallet.ts

@@ -0,0 +1,67 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { ORDER_INVENTORY_STATUS, OrderInventory } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Location } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { WorksheetDetail } from '../../../entities'
+
+export const relocatePalletResolver = {
+  async relocatePallet(
+    _: any,
+    { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedLocationName },
+    context: any
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
+    await relocatePallet(
+      tx,
+      domain,
+      user,
+      worksheetDetailName,
+      inspectedBatchNo,
+      inspectedQty,
+      inspectedUomValue,
+      inspectedLocationName
+    )
+  }
+}
+
+export async function relocatePallet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inspectedBatchNo: string,
+  inspectedQty: number,
+  inspectedUomValue: number,
+  inspectedLocationName: string
+): Promise<void> {
+  let worksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
+    where: { domain: { id: domain.id }, name: worksheetDetailName, type: WORKSHEET_TYPE.CYCLE_COUNT },
+    relations: ['targetInventory', 'targetInventory.inventory', 'targetInventory.inventory.location']
+  })
+
+  if (!worksheetDetail) throw new Error('Failed to find worksheet detail')
+
+  let targetInventory: OrderInventory = worksheetDetail.targetInventory
+  const location: Location = targetInventory?.inventory?.location
+  if (location.name === inspectedLocationName) throw new Error(`You can't relocate at same location`)
+
+  const inspectedLocation: Location = await tx.getRepository(Location).findOne({
+    where: { name: inspectedLocationName, domain: { id: domain.id } }
+  })
+
+  worksheetDetail.status = WORKSHEET_STATUS.NOT_TALLY
+  worksheetDetail.updater = user
+  await tx.getRepository(WorksheetDetail).save(worksheetDetail)
+
+  targetInventory.inspectedLocation = inspectedLocation
+  targetInventory.inspectedBatchNo = inspectedBatchNo
+  targetInventory.inspectedQty = inspectedQty
+  targetInventory.inspectedUomValue = inspectedUomValue
+  targetInventory.status = ORDER_INVENTORY_STATUS.RELOCATED
+  targetInventory.updater = user
+  await tx.getRepository(OrderInventory).save(targetInventory)
+}

package/server/graphql/resolvers/worksheet/replace-picking-pallets.ts

@@ -0,0 +1,127 @@
+import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_TYPES,
+  OrderInventory,
+  OrderNoGenerator,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { WorksheetNoGenerator } from '../../../utils'
+import { picking } from './picking/picking'
+
+export const replacePickingPalletsResolver = {
+  async replacePickingPallets(
+    _: any,
+    { worksheetDetailName, worksheetType, inventories, returnLocation },
+    context: any
+  ) {
+    const { tx, domain, user } = context.state
+    const prevWSD: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
+      where: { domain: { id: domain.id }, name: worksheetDetailName },
+      relations: [
+        'bizplace',
+        'worksheet',
+        'targetInventory',
+        'targetInventory.releaseGood',
+        'targetInventory.inventory',
+        'targetInventory.inventory.product'
+      ]
+    })
+    const prevOrderInv: OrderInventory = prevWSD.targetInventory
+    const prevInv: Inventory = prevOrderInv.inventory
+    const product: Product = prevInv.product
+    const batchId: string = prevOrderInv.batchId
+    const productName: string = prevOrderInv.productName
+    const packingType: string = prevOrderInv.packingType
+
+    const worksheet: Worksheet = prevWSD.worksheet
+    const releaseGood: ReleaseGood = prevWSD.targetInventory.releaseGood
+    const customerBizplace: Bizplace = prevWSD.bizplace
+
+    // remove locked qty and locked uomValue
+    await tx.getRepository(Inventory).save({
+      ...prevInv,
+      lockedQty: prevInv.lockedQty - prevOrderInv.releaseQty,
+      lockedUomValue: prevInv.lockedUomValue - prevOrderInv.releaseUomValue,
+      updater: user
+    })
+
+    // 2. update status of previous order Inventory
+    await tx.getRepository(OrderInventory).save({
+      ...prevOrderInv,
+      status: ORDER_INVENTORY_STATUS.REPLACED,
+      updater: user
+    })
+
+    // 3. update status of prev worksheet detail
+    await tx.getRepository(WorksheetDetail).save({
+      ...prevWSD,
+      status: WORKSHEET_STATUS.REPLACED,
+      updater: user
+    })
+
+    await Promise.all(
+      inventories.map(async (inventory: Inventory) => {
+        let foundInv: Inventory = await tx.getRepository(Inventory).findOne({
+          where: {
+            domain: { id: domain.id },
+            palletId: inventory.palletId
+          },
+          relations: ['location']
+        })
+        const unitUomValue: number = foundInv.uomValue / foundInv.qty
+
+        // 4. create new order inventories
+        const targetInventory: OrderInventory = await tx.getRepository(OrderInventory).save({
+          domain,
+          bizplace: customerBizplace,
+          name: OrderNoGenerator.orderInventory(),
+          releaseGood,
+          releaseQty: inventory.qty,
+          releaseUomValue: unitUomValue * inventory.qty,
+          inventory: foundInv,
+          product,
+          batchId,
+          type: ORDER_TYPES.RELEASE_OF_GOODS,
+          status: ORDER_INVENTORY_STATUS.PICKING,
+          productName,
+          packingType,
+          packingSize: inventory.packingSize,
+          creator: user,
+          updater: user
+        })
+
+        // 5. create new worksheet details
+        const wsd: WorksheetDetail = await tx.getRepository(WorksheetDetail).save({
+          domain,
+          bizplace: customerBizplace,
+          worksheet,
+          name:
+            worksheetType === WORKSHEET_TYPE.PICKING
+              ? WorksheetNoGenerator.pickingDetail()
+              : WorksheetNoGenerator.batchPickingDetail(),
+          targetInventory,
+          type: worksheetType,
+          status: WORKSHEET_STATUS.EXECUTING,
+          creator: user,
+          updater: user
+        })
+
+        foundInv.lockedQty = foundInv.lockedQty ? foundInv.lockedQty + inventory.qty : inventory.qty
+        foundInv.lockedUomValue = foundInv.lockedUomValue
+          ? foundInv.lockedUomValue + unitUomValue * inventory.qty
+          : unitUomValue * inventory.qty
+
+        foundInv = await tx.getRepository(Inventory).save(foundInv)
+
+        // 6. execute picking transaction
+        await picking(tx, domain, user, wsd.name, worksheetType, foundInv.palletId, returnLocation, inventory.qty)
+      })
+    )
+  }
+}

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

@@ -0,0 +1,70 @@
+import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { Domain, getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
+
+export const returnWorksheetResolver = {
+  async returnWorksheet(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { domain } = context.state
+    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+      where: { domain: { id: domain.id }, name: releaseGoodNo },
+      relations: ['bizplace']
+    })
+    if (!releaseGood) throw new Error(`Release good dosen't exist.`)
+
+    const worksheet: Worksheet = await fetchExecutingWorksheet(
+      domain,
+      releaseGood.bizplace,
+      [
+        'bizplace',
+        'bizplace.domain',
+        'bizplace.company',
+        'bizplace.company.domain',
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.inventory',
+        'worksheetDetails.targetInventory.inventory.location',
+        'worksheetDetails.targetInventory.inventory.product'
+      ],
+      WORKSHEET_TYPE.WAREHOUSE_RETURN,
+      releaseGood
+    )
+
+    const customerCompanyDomain: Domain = worksheet.bizplace?.company.domain
+
+    return {
+      worksheetInfo: {
+        bizplaceName: releaseGood.bizplace.name,
+        partnerDomainId: worksheet?.bizplace.domain.id,
+        customerCompanyDomainId: customerCompanyDomain.id,
+        refNo: releaseGood.refNo,
+        refNo2: releaseGood.refNo2,
+        refNo3: releaseGood.refNo3,
+        startedAt: worksheet.startedAt
+      },
+      worksheetDetailInfos: worksheet.worksheetDetails.map((returnWSD: WorksheetDetail) => {
+        const targetInventory: OrderInventory = returnWSD.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+        return {
+          name: returnWSD.name,
+          palletId: inventory.palletId,
+          cartonId: inventory.cartonId,
+          batchId: inventory.batchId,
+          batchIdRef: inventory.batchIdRef,
+          product: inventory.product,
+          expirationDate: inventory.expirationDate,
+          qty: targetInventory.releaseQty,
+          status: returnWSD.status,
+          description: returnWSD.description,
+          targetName: targetInventory.name,
+          packingType: inventory.packingType,
+          packingSize: inventory.packingSize,
+          location: inventory.location
+        }
+      })
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReturningWorksheetController } from '../../../../controllers'
+import { Worksheet, WorksheetDetail } from '../../../../entities'
+
+export const activateReturnResolver = {
+  async activateReturn(_: any, { worksheetNo, returnWorksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    return await activateReturn(tx, domain, user, worksheetNo, returnWorksheetDetails)
+  }
+}
+export async function activateReturn(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  returningWorksheetDetails: Partial<WorksheetDetail>[]
+): Promise<Worksheet> {
+  const worksheetController: ReturningWorksheetController = new ReturningWorksheetController(tx, domain, user)
+  return await worksheetController.activateReturning(worksheetNo, returningWorksheetDetails)
+}

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

@@ -0,0 +1,39 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReturningWorksheetController } from '../../../../controllers'
+import { WorksheetController } from '../../../../controllers/worksheet-controller'
+import { Worksheet } from '../../../../entities'
+
+export const completeReturnResolver = {
+  async completeReturn(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    let worksheet: Worksheet = await completeReturn(tx, domain, user, releaseGoodNo)
+
+    const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
+    if (!worksheet.bizplace?.id) {
+      worksheet = await worksheetController.findWorksheetById(worksheet.id, ['bizplace'])
+    }
+
+    const bizplace: Bizplace = worksheet.bizplace
+    await worksheetController.notifyToCustomer(bizplace, {
+      title: `Stock has been returned to storage (${bizplace.name}, ${releaseGoodNo})`,
+      body: 'Return process has been completed',
+      url: context.header.referer,
+      data: { url: context.header.referer }
+    })
+  }
+}
+
+export async function completeReturn(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  releaseGoodNo: string
+): Promise<Worksheet> {
+  const worksheetController: ReturningWorksheetController = new ReturningWorksheetController(tx, domain, user)
+  return await worksheetController.completeReturning(releaseGoodNo)
+}

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

@@ -0,0 +1,9 @@
+import { activateReturnResolver } from './activate-return'
+import { returningResolver } from './returning'
+import { completeReturnResolver } from './complete-return'
+
+export const Mutations = {
+  ...activateReturnResolver,
+  ...returningResolver,
+  ...completeReturnResolver
+}

package/server/graphql/resolvers/worksheet/returning/returning.ts

@@ -0,0 +1,26 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReturningWorksheetController } from '../../../../controllers'
+
+export const returningResolver = {
+  async returning(_: any, { worksheetDetailName, palletId, cartonId, toLocation }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await returning(tx, domain, user, worksheetDetailName, palletId, cartonId, toLocation)
+  }
+}
+
+export async function returning(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: [string],
+  palletId: string,
+  cartonId: string,
+  toLocation: string
+): Promise<void> {
+  const worksheetController: ReturningWorksheetController = new ReturningWorksheetController(tx, domain, user)
+  await worksheetController.returning(worksheetDetailName, palletId, cartonId, toLocation)
+}

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

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

package/server/graphql/resolvers/worksheet/sorting/complete-order-sorting.ts

@@ -0,0 +1,40 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS } from '../../../../constants'
+import { LoadingWorksheetController, SortingWorksheetController } from '../../../../controllers/'
+import { Worksheet } from '../../../../entities'
+
+export const completeOrderSortingResolver = {
+  async completeOrderSorting(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await completeOrderSorting(tx, domain, user, releaseGoodNo)
+  }
+}
+
+export async function completeOrderSorting(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  releaseGoodNo: string
+): Promise<void> {
+  try {
+    const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
+    const releaseGood = await sortingWSCtrl.completeOrderSorting(releaseGoodNo)
+
+    const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+    let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
+      releaseGood.name,
+      releaseGood.orderInventories.filter(itm => itm.status != ORDER_INVENTORY_STATUS.COMPLETE_SPLIT)
+    )
+
+    if (loadingWorksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
+      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheet.worksheetDetails)
+    }
+  } catch (e) {
+    throw e
+  }
+}

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

@@ -0,0 +1,23 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { SortingWorksheetController } from '../../../../controllers/'
+
+export const completeWorksheetSortingResolver = {
+  async completeWorksheetSorting(_: any, { taskNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await completeWorksheetSorting(tx, domain, user, taskNo)
+  }
+}
+
+export async function completeWorksheetSorting(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  taskNo: string
+): Promise<void> {
+  const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
+  await sortingWSCtrl.completeWorksheetSorting(taskNo)
+}

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

@@ -0,0 +1,13 @@
+import { activateSortingResolver } from './activate-sorting'
+import { sortingProductResolver } from './sorting-product'
+import { scanProductSortingResolver } from './scan-product-sorting'
+import { completeOrderSortingResolver } from './complete-order-sorting'
+import { completeWorksheetSortingResolver } from './complete-worksheet-sorting'
+
+export const Mutations = {
+  ...activateSortingResolver,
+  ...sortingProductResolver,
+  ...scanProductSortingResolver,
+  ...completeOrderSortingResolver,
+  ...completeWorksheetSortingResolver
+}