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

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

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

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

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

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

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

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

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

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

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

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

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

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