@things-factory/worksheet-base 5.0.13 → 6.0.0-alpha.1

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

@@ -1,250 +1,184 @@
-import { EntityManager, In } from 'typeorm'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
+import { logger } from '@things-factory/env'
 import {
+  DeliveryOrder,
   ORDER_INVENTORY_STATUS,
   ORDER_STATUS,
-  ORDER_VAS_STATUS,
   OrderInventory,
-  DeliveryOrder,
-  OrderVas,
   ReleaseGood
 } from '@things-factory/sales-base'
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+
+import { WORKSHEET_STATUS } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const rejectCancellationReleaseOrder = {
-  async rejectCancellationReleaseOrder(_: any, { name }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    let foundRO: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: { domain, 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
-    let foundOVs: OrderVas[] = foundRO.orderVass
-    let isDeactivatedPicking = false
-
-    // get the worksheet based on RO number
-    let foundWS: Worksheet[] = await tx.getRepository(Worksheet).find({
-      where: {
-        domain,
-        releaseGood: foundRO
-      }
-    })
-
-    // check worksheet table if started_at is not null to indicate that the worksheet has been activated 
-    if (foundWS && foundWS?.length) {
-      foundWS = foundWS.map((ws: Worksheet) => {
-        if (ws.startedAt && !ws.endedAt) {
-          return {
-            ...ws,
-            status: WORKSHEET_STATUS.EXECUTING,
-            updater: user
-          }
-        }
-        else if (ws.startedAt && ws.endedAt) {
-          return {
-            ...ws,
-            status: WORKSHEET_STATUS.DONE,
-            updater: user
-          }
-        }
-        else if (!ws.startedAt && !ws.endedAt && ws.type === WORKSHEET_TYPE.PICKING) {
-          isDeactivatedPicking = true
-          return {
-            ...ws,
-            status: WORKSHEET_STATUS.DEACTIVATED,
-            updater: user
-          }
-        }
+  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'
+        ]
       })
-      await tx.getRepository(Worksheet).save(foundWS)
-    }
-
-    // check if the worksheet is in Loading stage
-    const isLoadingStage = foundWS.some((ws: Worksheet) => ws.type === WORKSHEET_TYPE.LOADING)
-    
-    // change the order inventory status accordingly
-    let newOrderInventories: OrderInventory[] = targetOIs.map(
-      (oi: OrderInventory) => {
-        if (isLoadingStage && oi.deliveryOrder && oi.status === ORDER_INVENTORY_STATUS.PENDING_REVERSE)
-          oi.status = ORDER_INVENTORY_STATUS.LOADED
-            
-        else if (isLoadingStage && !oi.deliveryOrder && oi.status === ORDER_INVENTORY_STATUS.PENDING_REVERSE)
-          oi.status = ORDER_INVENTORY_STATUS.LOADING
-
-        else if (!isLoadingStage && oi.inventory && isDeactivatedPicking && oi.status === ORDER_INVENTORY_STATUS.PENDING_CANCEL)
-          oi.status = ORDER_INVENTORY_STATUS.READY_TO_PICK
-
-        else if (!isLoadingStage && oi.inventory && !isDeactivatedPicking && oi.status === ORDER_INVENTORY_STATUS.PENDING_CANCEL)
-          oi.status = ORDER_INVENTORY_STATUS.PICKING
-
-        else if (!isLoadingStage && oi.inventory && !isDeactivatedPicking && oi.status === ORDER_INVENTORY_STATUS.PENDING_REVERSE)
-          oi.status = ORDER_INVENTORY_STATUS.PICKED
-
-        else if (!isLoadingStage && !oi.inventory && isDeactivatedPicking && oi.status === ORDER_INVENTORY_STATUS.PENDING_CANCEL)
-          oi.status = ORDER_INVENTORY_STATUS.PENDING_SPLIT
-
-        return {
-          ...oi,
-          updater: user
-        }
-    })
-    await tx.getRepository(OrderInventory).save(newOrderInventories)
-
-    // find the worksheet details based on order inventories
-    let foundWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-      where: {
-        domain,
-        targetInventory: In(newOrderInventories.map((oi: OrderInventory) => oi.id ))
-      },
-      relations: ['targetInventory']
-    })
-
-    if (foundWSD && foundWSD?.length) {
-      foundWSD = foundWSD.map((wsd: WorksheetDetail) => {
-
-        //change the worksheet details status accordingly
-        newOrderInventories.forEach((oi: OrderInventory) => {
-          
-          if (wsd.targetInventory?.id === oi.id && wsd.type === WORKSHEET_TYPE.PICKING) {
-            switch (oi.status) {
-              case ORDER_INVENTORY_STATUS.READY_TO_PICK:
-                wsd.status = WORKSHEET_STATUS.DEACTIVATED
-                break
 
-              case ORDER_INVENTORY_STATUS.PICKING:
-                wsd.status = WORKSHEET_STATUS.EXECUTING
+      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 ORDER_INVENTORY_STATUS.REPLACED:
-                wsd.status = WORKSHEET_STATUS.REPLACED
+              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 ORDER_INVENTORY_STATUS.PICKED:
-                wsd.status = WORKSHEET_STATUS.DONE
+              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 ORDER_INVENTORY_STATUS.LOADING:
-                wsd.status = WORKSHEET_STATUS.DONE
+              case 'LOADING':
+                wdStatus = !startedAt
+                  ? WORKSHEET_STATUS.DEACTIVATED
+                  : orderInventory?.deliveryOrder
+                  ? WORKSHEET_STATUS.DONE
+                  : WORKSHEET_STATUS.EXECUTING
+                oiStatus = !startedAt
+                  ? ORDER_INVENTORY_STATUS.READY_TO_LOAD
+                  : orderInventory?.deliveryOrder
+                  ? ORDER_INVENTORY_STATUS.LOADED
+                  : ORDER_INVENTORY_STATUS.LOADING
+                roStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_LOAD : ORDER_INVENTORY_STATUS.LOADING
                 break
-
-              case ORDER_INVENTORY_STATUS.LOADED:
-                wsd.status = WORKSHEET_STATUS.DONE
+              default:
                 break
             }
-          }
-
-          else if (wsd.targetInventory?.id === oi.id && wsd.type === WORKSHEET_TYPE.LOADING) {
-            switch (oi.status) {
-              case ORDER_INVENTORY_STATUS.LOADING:
-                wsd.status = WORKSHEET_STATUS.EXECUTING
-                break
 
-              case ORDER_INVENTORY_STATUS.LOADED:
-                wsd.status = WORKSHEET_STATUS.DONE
-                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 }
           }
         })
-        
-        return {
-          ...wsd,
-          updater: user
-        }
-      })
-
-      await tx.getRepository(WorksheetDetail).save(foundWSD)
-    }
-
-    if (foundOVs && foundOVs?.length) {
-
-      // update status of order vass to accordingly
-      foundOVs = foundOVs.map((orderVas: OrderVas) => {
-        if (!isLoadingStage)
-          orderVas.status = ORDER_VAS_STATUS.READY_TO_PROCESS
-        
-        else
-          orderVas.status = ORDER_VAS_STATUS.COMPLETED
-        
-        return {
-          ...orderVas,
-          updater: user
-        }
-      })
-
-      await tx.getRepository(OrderVas).save(foundOVs)
-    }
-
-    // find DO and change status to previous status
-    let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
-      where: { domain, releaseGood: foundRO, 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)
-    }
-
-    const isLoadingRO = foundWS.some((ws: Worksheet) =>
-      ws.type === WORKSHEET_TYPE.LOADING &&
-      ws.status === WORKSHEET_STATUS.EXECUTING
-    )
-
-    if (isLoadingRO)
-      foundRO.status = ORDER_STATUS.LOADING
-
-    else {
-      var isReadyToLoadRO = foundWS.some((ws: Worksheet) => 
-        ws.type === WORKSHEET_TYPE.LOADING &&
-        ws.status === WORKSHEET_STATUS.DEACTIVATED
       )
-    }
 
-    if (isReadyToLoadRO) 
-      foundRO.status = ORDER_STATUS.READY_TO_LOAD
+      if (worksheetDetails[0].worksheet) {
+        await tx.getRepository(Worksheet).update(
+          { id: worksheetDetails[0].worksheet.id },
+          {
+            status: worksheetDetails[0].wStatus,
+            updatedAt: new Date(),
+            updater: user
+          }
+        )
+      }
 
-    else {
-      var isPickingRO = foundWS.some((ws: Worksheet) => 
-        ws.type === WORKSHEET_TYPE.PICKING &&
-        ws.status === WORKSHEET_STATUS.EXECUTING
-      )
-    }
-    
-    if (isPickingRO) 
-      foundRO.status = ORDER_STATUS.PICKING
-
-    else {
-      var isReadyToPickRO = foundWS.some((ws: Worksheet) => 
-        ws.type === WORKSHEET_TYPE.PICKING &&
-        ws.status === WORKSHEET_STATUS.DEACTIVATED
+      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.')
     }
+  }
+}
 
-    if (isReadyToPickRO) 
-      foundRO.status = ORDER_STATUS.READY_TO_PICK
-
-    await tx.getRepository(ReleaseGood).save({
-      ...foundRO,
-      updater: user
+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, 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
+      }
     })
 
-    return
+    await tx.getRepository(DeliveryOrder).save(foundDO)
   }
 }

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

@@ -1,8 +1,10 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
-import { OrderInventory, ORDER_INVENTORY_STATUS } from '@things-factory/sales-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 { EntityManager } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
 
@@ -12,7 +14,7 @@ export const relocatePalletResolver = {
     { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedLocationName },
     context: any
   ): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     await relocatePallet(
       tx,
       domain,
@@ -37,7 +39,7 @@ export async function relocatePallet(
   inspectedLocationName: string
 ): Promise<void> {
   let worksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-    where: { domain, name: worksheetDetailName, type: WORKSHEET_TYPE.CYCLE_COUNT },
+    where: { domain: { id: domain.id }, name: worksheetDetailName, type: WORKSHEET_TYPE.CYCLE_COUNT },
     relations: ['targetInventory', 'targetInventory.inventory', 'targetInventory.inventory.location']
   })
 

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

@@ -1,6 +1,3 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import {
@@ -10,7 +7,6 @@ import {
   OrderNoGenerator,
   ReleaseGood
 } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
@@ -24,9 +20,9 @@ export const replacePickingPalletsResolver = {
     { worksheetDetailName, worksheetType, inventories, returnLocation },
     context: any
   ) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     const prevWSD: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-      where: { domain, name: worksheetDetailName },
+      where: { domain: { id: domain.id }, name: worksheetDetailName },
       relations: [
         'bizplace',
         'worksheet',
@@ -73,7 +69,7 @@ export const replacePickingPalletsResolver = {
       inventories.map(async (inventory: Inventory) => {
         let foundInv: Inventory = await tx.getRepository(Inventory).findOne({
           where: {
-            domain,
+            domain: { id: domain.id },
             palletId: inventory.palletId
           },
           relations: ['location']

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

@@ -1,7 +1,5 @@
-import { getRepository } from 'typeorm'
-
 import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
+import { Domain, getRepository } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_TYPE } from '../../../constants'
@@ -9,10 +7,10 @@ import { Worksheet, WorksheetDetail } from '../../../entities'
 import { fetchExecutingWorksheet } from '../../../utils'
 
 export const returnWorksheetResolver = {
-  async returnWorksheet(_: any, { releaseGoodNo }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async returnWorksheet(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { domain } = context.state
     const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-      where: { domain, name: releaseGoodNo },
+      where: { domain: { id: domain.id }, name: releaseGoodNo },
       relations: ['bizplace']
     })
     if (!releaseGood) throw new Error(`Release good dosen't exist.`)

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

@@ -1,12 +1,14 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { ReturningWorksheetController } from '../../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const activateReturnResolver = {
-  async activateReturn(_: any, { worksheetNo, returnWorksheetDetails }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async activateReturn(_: any, { worksheetNo, returnWorksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     return await activateReturn(tx, domain, user, worksheetNo, returnWorksheetDetails)
   }
 }

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

@@ -1,14 +1,16 @@
+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 { EntityManager } from 'typeorm'
+
 import { ReturningWorksheetController } from '../../../../controllers'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 import { Worksheet } from '../../../../entities'
 
 export const completeReturnResolver = {
-  async completeReturn(_: any, { releaseGoodNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  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)

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

@@ -1,11 +1,13 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { ReturningWorksheetController } from '../../../../controllers'
 
 export const returningResolver = {
-  async returning(_: any, { worksheetDetailName, palletId, cartonId, toLocation }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async returning(_: any, { worksheetDetailName, palletId, cartonId, toLocation }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await returning(tx, domain, user, worksheetDetailName, palletId, cartonId, toLocation)
   }
 }

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

@@ -1,12 +1,14 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { SortingWorksheetController } from '../../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const activateSortingResolver = {
-  async activateSorting(_: any, { worksheetNo, sortingWorksheetDetails }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async activateSorting(_: any, { worksheetNo, sortingWorksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     return await activateSorting(tx, domain, user, worksheetNo, sortingWorksheetDetails)
   }
 }

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

@@ -1,14 +1,16 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
 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'
-import { SortingWorksheetController, LoadingWorksheetController } from '../../../../controllers/'
 
 export const completeOrderSortingResolver = {
-  async completeOrderSorting(_: any, { releaseGoodNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async completeOrderSorting(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await completeOrderSorting(tx, domain, user, releaseGoodNo)
   }
 }

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

@@ -1,11 +1,13 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { SortingWorksheetController } from '../../../../controllers/'
 
 export const completeWorksheetSortingResolver = {
-  async completeWorksheetSorting(_: any, { taskNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async completeWorksheetSorting(_: any, { taskNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await completeWorksheetSorting(tx, domain, user, taskNo)
   }
 }

package/server/graphql/resolvers/worksheet/sorting/scan-product-sorting.ts

@@ -1,11 +1,17 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { SortingWorksheetController } from '../../../../controllers'
 
 export const scanProductSortingResolver = {
-  async scanProductSorting(_: any, { taskNo, releaseGoodNo, productBarcode, serialNumber, toteNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async scanProductSorting(
+    _: any,
+    { taskNo, releaseGoodNo, productBarcode, serialNumber, toteNo },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
     await scanProductSorting(tx, domain, user, taskNo, releaseGoodNo, productBarcode, serialNumber, toteNo)
   }
 }

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

@@ -1,11 +1,17 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { SortingWorksheetController } from '../../../../controllers'
 
 export const sortingProductResolver = {
-  async sortingProduct(_: any, { taskNo, releaseGoodNo, productId, sortingQty, serialNumber, toteNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async sortingProduct(
+    _: any,
+    { taskNo, releaseGoodNo, productId, sortingQty, serialNumber, toteNo },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
     await sortingProduct(tx, domain, user, taskNo, releaseGoodNo, productId, sortingQty, serialNumber, toteNo)
   }
 }