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

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

@@ -1,31 +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 scanProductSortingResolver = {
-  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)
-  }
-}
-
-export async function scanProductSorting(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  taskNo: string,
-  releaseGoodNo: string,
-  productBarcode?: string,
-  serialNumber?: string,
-  toteNo?: string
-) {
-  const worksheetController: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  await worksheetController.scanProductSorting(taskNo, releaseGoodNo, productBarcode, serialNumber, toteNo)
-}

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

@@ -1,32 +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 sortingProductResolver = {
-  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)
-  }
-}
-
-export async function sortingProduct(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  taskNo: string,
-  releaseGoodNo: string,
-  productId: string,
-  sortingQty: number,
-  serialNumber?: string,
-  toteNo?: string
-) {
-  const worksheetController: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  await worksheetController.sortingProduct(taskNo, releaseGoodNo, productId, sortingQty, serialNumber, toteNo)
-}

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

@@ -1,87 +0,0 @@
-import { SelectQueryBuilder } from 'typeorm'
-
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
-import { getRepository } from '@things-factory/shell'
-
-import { WORKSHEET_TYPE } from '../../../constants'
-import { fetchExecutingBatchWorksheet } from '../../../utils'
-
-export const sortingWorksheetResolver = {
-  async sortingWorksheet(_: any, { releaseGoodNo, taskNo }, context: ResolverContext) {
-    const { domain } = context.state
-    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-      where: { domain: { id: domain.id }, name: releaseGoodNo, status: ORDER_STATUS.SORTING },
-      relations: ['bizplace', 'bizplace.domain']
-    })
-    if (!releaseGood) throw new Error(`Couldn't find sorting worksheet by order no (${releaseGoodNo})`)
-
-    const worksheet = await fetchExecutingBatchWorksheet(
-      domain,
-      taskNo,
-      releaseGood.bizplace,
-      ['bizplace'],
-      WORKSHEET_TYPE.SORTING
-    )
-
-    const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('OI')
-    qb.select('SUM(OI.releaseQty)', 'releaseQty')
-      .addSelect('SUM(OI.sortedQty)', 'sortedQty')
-      .addSelect(`string_agg(CONCAT(BIN.name, '(', OI.releaseQty, ')' ), ' ')`, 'binRemarks')
-      .addSelect('PROD.id', 'productId')
-      .addSelect('PROD.name', 'productName')
-      .addSelect('PROD.sku', 'productSku')
-      .addSelect('PROD.description', 'productDescription')
-      .addSelect('PROD.isRequireSerialNumberScanningOutbound', 'isRequireSerialNumberScanningOutbound')
-      .addSelect('OI.batch_id', 'batchId')
-      .addSelect('OI.packing_type', 'packingType')
-      .addSelect('OI.packing_size', 'packingSize')
-      .addSelect('INV.expiration_date', 'expirationDate')
-      .leftJoin('OI.product', 'PROD')
-      .leftJoin('OI.inventory', 'INV')
-      .leftJoin('OI.binLocation', 'BIN')
-      .where('OI.release_good_id = :releaseGoodId', { releaseGoodId: releaseGood?.id })
-      .andWhere('OI.status <> :releaseGoodStatus', { releaseGoodStatus: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT })
-      .groupBy('PROD.id')
-      .addGroupBy('PROD.name')
-      .addGroupBy('PROD.sku')
-      .addGroupBy('PROD.description')
-      .addGroupBy('PROD.isRequireSerialNumberScanningOutbound')
-      .addGroupBy('INV.expiration_date')
-      .addGroupBy('OI.batch_id')
-      .addGroupBy('OI.packing_type')
-      .addGroupBy('OI.packing_size')
-      .orderBy('PROD.sku', 'ASC')
-
-    const items: any[] = await qb.getRawMany()
-
-    return {
-      worksheetInfo: {
-        bizplaceName: releaseGood.bizplace.name,
-        partnerDomainId: releaseGood.bizplace?.domain.id,
-        startedAt: worksheet.startedAt,
-        refNo: releaseGood.refNo,
-        refNo2: releaseGood.refNo2,
-        refNo3: releaseGood.refNo3,
-        releaseGood
-      },
-      worksheetDetailInfos: items.map((item: any) => {
-        return {
-          batchId: item?.batchId,
-          productId: item?.productId,
-          productSku: item?.productSku,
-          productName: item?.productName,
-          productDescription: item?.productDescription,
-          isRequireSerialNumberScanningOutbound: item?.isRequireSerialNumberScanningOutbound,
-          releaseQty: item.releaseQty,
-          sortedQty: item.sortedQty,
-          status: item.status,
-          expirationDate: item?.expirationDate,
-          packingType: item?.packingType,
-          packingSize: item?.packingSize,
-          binRemarks: item?.binRemarks,
-          releaseGood
-        }
-      })
-    }
-  }
-}

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

@@ -1,176 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { ORDER_PRODUCT_STATUS, OrderInventory } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import {
-  Inventory,
-  INVENTORY_STATUS,
-  INVENTORY_TRANSACTION_TYPE,
-  InventoryHistory,
-  InventoryNoGenerator
-} from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
-import { Worksheet, WorksheetDetail } from '../../../entities'
-
-export const transfer = {
-  async transfer(_: any, { palletId, toPalletId, qty }, context: ResolverContext) {
-    const { tx, domain, bizplace, user } = context.state
-
-    // 1. get to inventory
-    let toInventory: Inventory = await tx.getRepository(Inventory).findOne({
-      where: { domain: { id: domain.id }, palletId: toPalletId },
-      relations: ['bizplace', 'product', 'warehouse', 'location']
-    })
-    if (!toInventory) throw new Error(`to pallet doesn't exists`)
-
-    // 2. get from inventory
-    let fromInventory: Inventory = await tx.getRepository(Inventory).findOne({
-      where: { domain: { id: domain.id }, palletId },
-      relations: ['bizplace', 'product', 'warehouse', 'location']
-    })
-    if (!fromInventory) throw new Error(`from pallet doesn't exists`)
-    if (toInventory.batchId !== fromInventory.batchId) throw new Error(`Can't transfer to different batch`)
-
-    // 3. get worksheet & worksheet detail
-    const worksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-      where: {
-        domain: { id: domain.id },
-        targetInventory: { id: fromInventory.id },
-        status: WORKSHEET_STATUS.EXECUTING,
-        type: WORKSHEET_TYPE.PUTAWAY
-      },
-      relations: ['worksheet', 'targetInventory']
-    })
-    if (!worksheetDetail) throw new Error(`Worksheet Detail doesn't exists`)
-    const worksheet: Worksheet = worksheetDetail.worksheet
-    if (!worksheet) throw new Error(`Worksheet doesn't exists`)
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-
-    // 4. transfer qty
-    // 4. 1) if result < 0
-    //    - throw error
-    const leftQty = fromInventory.qty - qty
-    if (leftQty < 0) throw new Error(`Invalid qty, can't exceed limitation`)
-
-    // 4. 2) if result == 0
-    if (leftQty == 0) {
-      //    - plus qty to (toInventory)
-      await tx.getRepository(Inventory).save({
-        ...toInventory,
-        qty: toInventory.qty + qty,
-        lastSeq: toInventory.lastSeq + 1,
-        updater: user
-      })
-      //    - add inventory history
-      //@ts-ignore
-      delete toInventory.id
-      await tx.getRepository(InventoryHistory).save({
-        ...toInventory,
-        domain: domain,
-        name: InventoryNoGenerator.inventoryHistoryName(),
-        product: toInventory.product,
-        warehouse: toInventory.warehouse,
-        location: toInventory.location,
-        seq: toInventory.lastSeq,
-        transactionType: INVENTORY_TRANSACTION_TYPE.TRANSFERED_IN,
-        creator: user,
-        updater: user
-      })
-      //    - update (fromInventory)
-      await tx.getRepository(Inventory).save({
-        ...fromInventory,
-        qty: leftQty, // 0
-        status: INVENTORY_STATUS.TERMINATED,
-        lastSeq: fromInventory.lastSeq + 1,
-        updater: user
-      })
-
-      await tx.getRepository(OrderInventory).save({
-        ...targetInventory,
-        status: ORDER_PRODUCT_STATUS.TERMINATED
-      })
-
-      fromInventory = await tx.getRepository(Inventory).findOne({
-        where: { id: fromInventory.id },
-        relations: ['bizplace', 'product', 'warehouse', 'location']
-      })
-
-      //    - add inventory history
-      await tx.getRepository(InventoryHistory).save({
-        ...fromInventory,
-        name: InventoryNoGenerator.inventoryHistoryName(),
-        product: fromInventory.product,
-        warehouse: fromInventory.warehouse,
-        location: fromInventory.location,
-        seq: fromInventory.lastSeq,
-        transactionType: INVENTORY_TRANSACTION_TYPE.TRANSFERED_OUT,
-        creator: user,
-        updater: user
-      })
-
-      //    - update worksheetDetail (EXECUTING => DONE)
-      await tx.getRepository(WorksheetDetail).save({
-        ...worksheetDetail,
-        status: WORKSHEET_STATUS.DONE,
-        updater: user
-      })
-    }
-    // 4. 3) if result > 0
-    else if (leftQty > 0) {
-      await tx.getRepository(Inventory).save({
-        ...toInventory,
-        qty: toInventory.qty + qty,
-        lastSeq: toInventory.lastSeq + 1,
-        updater: user
-      })
-
-      toInventory = await tx.getRepository(Inventory).findOne({
-        where: { id: toInventory.id },
-        relations: ['bizplace', 'product', 'warehouse', 'location']
-      })
-      //    - add inventory history
-      //@ts-ignore
-      delete toInventory.id
-      await tx.getRepository(InventoryHistory).save({
-        ...toInventory,
-        domain,
-        name: InventoryNoGenerator.inventoryHistoryName(),
-        product: toInventory.product,
-        warehouse: toInventory.warehouse,
-        location: toInventory.location,
-        seq: toInventory.lastSeq,
-        transactionType: INVENTORY_TRANSACTION_TYPE.TRANSFERED_IN,
-        creator: user,
-        updater: user
-      })
-
-      await tx.getRepository(Inventory).save({
-        ...fromInventory,
-        qty: leftQty,
-        lastSeq: fromInventory.lastSeq + 1,
-        updater: user
-      })
-
-      fromInventory = await tx.getRepository(Inventory).findOne({
-        where: { id: fromInventory.id },
-        relations: ['bizplace', 'product', 'warehouse', 'location']
-      })
-
-      //    - add inventory history
-      await tx.getRepository(InventoryHistory).save({
-        ...fromInventory,
-        name: InventoryNoGenerator.inventoryHistoryName(),
-        product: fromInventory.product,
-        warehouse: fromInventory.warehouse,
-        location: fromInventory.location,
-        seq: fromInventory.lastSeq,
-        transactionType: INVENTORY_TRANSACTION_TYPE.TRANSFERED_OUT,
-        creator: user,
-        updater: user
-      })
-    }
-  }
-}

package/server/graphql/resolvers/worksheet/unloaded-inventories-by-reusable-pallet.ts

@@ -1,54 +0,0 @@
-import { In } from 'typeorm'
-
-//@ts-ignore
-import { ArrivalNotice, Bizplace } from '@things-factory/sales-base'
-import { getRepository } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS, Pallet } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
-import { WorksheetDetail } from '../../../entities'
-
-export const unloadedInventoriesByReusablePallet = {
-  async unloadedInventoriesByReusablePallet(
-    _: any,
-    { reusablePalletId, worksheetDetailName },
-    context: ResolverContext
-  ) {
-    const { domain } = context.state
-    const foundWorksheetDetail: WorksheetDetail = await getRepository(WorksheetDetail).findOne({
-      where: {
-        domain: { id: domain.id },
-        name: worksheetDetailName,
-        type: WORKSHEET_TYPE.UNLOADING,
-        status: In([WORKSHEET_STATUS.EXECUTING, WORKSHEET_STATUS.PARTIALLY_UNLOADED])
-      },
-      relations: ['bizplace', 'targetProduct', 'worksheet', 'worksheet.arrivalNotice', 'worksheet.bufferLocation']
-    })
-
-    if (!foundWorksheetDetail) return []
-
-    let foundReusablePallet: Pallet
-
-    foundReusablePallet = await getRepository(Pallet).findOne({
-      where: {
-        domain: { id: domain.id },
-        name: reusablePalletId
-      },
-      relations: ['domain']
-    })
-
-    let arrivalNotice: ArrivalNotice = foundWorksheetDetail.worksheet.arrivalNotice
-    let customerBizplace: Bizplace = foundWorksheetDetail.bizplace
-    return await getRepository(Inventory).find({
-      where: {
-        domain: { id: domain.id },
-        bizplace: { id: customerBizplace.id },
-        batchId: foundWorksheetDetail.targetProduct.batchId,
-        refOrderId: arrivalNotice.id,
-        reusablePallet: foundReusablePallet,
-        status: INVENTORY_STATUS.UNLOADED
-      },
-      relations: ['reusablePallet', 'product']
-    })
-  }
-}

package/server/graphql/resolvers/worksheet/unloaded-inventories.ts

@@ -1,78 +0,0 @@
-import { In } from 'typeorm'
-
-//@ts-ignore
-import { ArrivalNotice, Bizplace, ReturnOrder } from '@things-factory/sales-base'
-import { getRepository } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
-import { WorksheetDetail } from '../../../entities'
-
-export const unloadedInventories = {
-  async unloadedInventories(_: any, { worksheetDetailNames }, context: ResolverContext) {
-    const { domain } = context.state
-    const foundWorksheetDetails: WorksheetDetail[] = await getRepository(WorksheetDetail).find({
-      where: {
-        domain: { id: domain.id },
-        name: In(worksheetDetailNames),
-        type: In([WORKSHEET_TYPE.UNLOADING, WORKSHEET_TYPE.UNLOADING_RETURN]),
-        status: In([WORKSHEET_STATUS.EXECUTING, WORKSHEET_STATUS.PARTIALLY_UNLOADED])
-      },
-      relations: [
-        'bizplace',
-        'targetProduct',
-        'targetInventory',
-        'worksheet',
-        'worksheet.arrivalNotice',
-        'worksheet.returnOrder',
-        'worksheet.bufferLocation'
-      ]
-    })
-
-    if (!foundWorksheetDetails?.length) return []
-
-    const arrivalNotice: ArrivalNotice = foundWorksheetDetails[0].worksheet.arrivalNotice
-    const returnOrder: ReturnOrder = foundWorksheetDetails[0].worksheet.returnOrder
-    const customerBizplace: Bizplace = foundWorksheetDetails[0].bizplace
-    if (arrivalNotice) {
-      let foundInv = await getRepository(Inventory).find({
-        where: {
-          domain: { id: domain.id },
-          bizplace: { id: customerBizplace.id },
-          refOrderId: arrivalNotice.id,
-          batchId: In(foundWorksheetDetails.map(wsd => wsd.targetProduct.batchId)),
-          location: In(foundWorksheetDetails.map(wsd => wsd.worksheet.bufferLocation.id)),
-          orderProductId: In(foundWorksheetDetails.map(wsd => wsd.targetProduct.id)),
-          status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.CHECKED])
-        },
-        relations: ['reusablePallet', 'product', 'bizplace']
-      })
-      const items = foundInv.map((inv: Inventory) => {
-        const expirationDate: Date = inv.expirationDate ? new Date(inv.expirationDate) : null
-        const manufactureDate: Date = inv.manufactureDate ? new Date(inv.manufactureDate) : null
-        return {
-          ...inv,
-          expirationDate: expirationDate,
-          manufactureDate: manufactureDate
-        }
-      })
-
-      return items
-    }
-
-    if (returnOrder) {
-      return await getRepository(Inventory).find({
-        where: {
-          domain: { id: domain.id },
-          bizplace: { id: customerBizplace.id },
-          refOrderId: returnOrder.id,
-          batchId: In(foundWorksheetDetails.map(wsd => wsd.targetInventory.batchId)),
-          location: In(foundWorksheetDetails.map(wsd => wsd.worksheet.bufferLocation.id)),
-          orderInventoryId: In(foundWorksheetDetails.map(wsd => wsd.targetInventory.id)),
-          status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.CHECKED])
-        },
-        relations: ['reusablePallet', 'product', 'bizplace']
-      })
-    }
-  }
-}

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

@@ -1,56 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { ArrivalNotice } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-import { WORKSHEET_TYPE } from '../../../../constants'
-import { UnloadingWorksheetController, UnloadingWorksheetDetail } from '../../../../controllers'
-import { Worksheet } from '../../../../entities'
-import { activatePicking } from '../picking/activate-picking'
-import { worksheetByOrderNo } from '../worksheet-by-order-no'
-
-export const activateUnloadingResolver = {
-  async activateUnloading(_: any, { worksheetNo, unloadingWorksheetDetails }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    let unloadingWS: Worksheet = await activateUnloading(tx, domain, user, worksheetNo, unloadingWorksheetDetails)
-
-    if (!unloadingWS?.arrivalNotice?.id) {
-      unloadingWS = await tx.getRepository(Worksheet).findOne({
-        where: { id: unloadingWS.id },
-        relations: ['arrivalNotice']
-      })
-    }
-
-    let arrivalNotice: ArrivalNotice = unloadingWS.arrivalNotice
-    const crossDocking: boolean = arrivalNotice.crossDocking
-
-    if (crossDocking) {
-      arrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-        where: { id: arrivalNotice.id },
-        relations: ['releaseGood']
-      })
-      const releaseGood = arrivalNotice.releaseGood
-      const { name: pickingWorksheetNo } = await worksheetByOrderNo(
-        domain,
-        releaseGood.name,
-        WORKSHEET_TYPE.PICKING,
-        tx
-      )
-      await activatePicking(tx, domain, user, pickingWorksheetNo)
-    }
-
-    return unloadingWS
-  }
-}
-
-export async function activateUnloading(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  worksheetNo: string,
-  unloadingWorksheetDetails: UnloadingWorksheetDetail[]
-): Promise<Worksheet> {
-  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
-  return await worksheetController.activateUnloading(worksheetNo, unloadingWorksheetDetails)
-}

package/server/graphql/resolvers/worksheet/unloading/complete-product-scan-unload.ts

@@ -1,25 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-
-import { UnloadingWorksheetController } from '../../../../controllers'
-
-export const completeProductScanUnloadResolver = {
-  async completeProductScanUnload(_: any, { worksheetDetailName, inventory }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    await completeProductScanUnload(tx, domain, user, worksheetDetailName, inventory)
-  }
-}
-
-async function completeProductScanUnload(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  worksheetDetailName: string,
-  inventory: Partial<Inventory>
-): Promise<void> {
-  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
-  await worksheetController.completeProductScanUnload(worksheetDetailName, inventory)
-}

package/server/graphql/resolvers/worksheet/unloading/complete-unloading-partially.ts

@@ -1,25 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { UnloadingWorksheetController } from '../../../../controllers'
-import { WorksheetDetail } from '../../../../entities'
-
-export const completeUnloadingPartiallyResolver = {
-  async completeUnloadingPartially(_: any, { arrivalNoticeNo, worksheetDetail }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    await completeUnloadingPartially(tx, domain, user, arrivalNoticeNo, worksheetDetail)
-  }
-}
-
-export async function completeUnloadingPartially(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  arrivalNoticeNo: string,
-  unloadingWorksheetDetail: Partial<WorksheetDetail>[]
-): Promise<void> {
-  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
-  await worksheetController.completeUnloadingPartially(arrivalNoticeNo, unloadingWorksheetDetail)
-}

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

@@ -1,76 +0,0 @@
-import { EntityManager, In } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { ArrivalNotice, generateGoodsReceivalNote } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS } from '../../../../constants'
-import { PutawayWorksheetController, UnloadingWorksheetController } from '../../../../controllers'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
-
-export const completeUnloadingResolver = {
-  async completeUnloading(_: any, { arrivalNoticeNo, worksheetDetails }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    await completeUnloading(tx, domain, user, arrivalNoticeNo, worksheetDetails)
-
-    const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain: { id: domain.id }, name: arrivalNoticeNo },
-      relations: [
-        'purchaseOrder',
-        'bizplace',
-        'bizplace.domain',
-        'bizplace.company',
-        'bizplace.company.domain',
-        'orderProducts',
-        'orderProducts.product',
-        'orderProducts.product.productDetails',
-        'orderProducts.product.productDetails.childProductDetail'
-      ]
-    })
-
-    const putawayWSCtrl: PutawayWorksheetController = new PutawayWorksheetController(tx, domain, user)
-    let putawayWorksheet: Worksheet
-
-    const inventories: Inventory[] = await tx.getRepository(Inventory).find({
-      where: {
-        domain: { id: domain.id },
-        refOrderId: arrivalNotice.id,
-        status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.CHECKED])
-      }
-    })
-
-    putawayWorksheet = await putawayWSCtrl.generatePutawayWorksheet(arrivalNotice.name, inventories)
-
-    if (putawayWorksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
-      await putawayWSCtrl.activatePutaway(putawayWorksheet.name, putawayWorksheet.worksheetDetails)
-    }
-
-    //@ts-ignore
-    const bizplaceId: Bizplace = arrivalNotice.bizplace.id
-    //@ts-ignore
-    await generateGoodsReceivalNote({ refNo: arrivalNoticeNo, customer: bizplaceId }, domain, user, tx)
-
-    const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
-    if (context.header && context.header.referer) {
-      worksheetController.notifyToOfficeAdmin({
-        title: `Unloading Completed (${arrivalNotice.bizplace.name}, ${arrivalNotice.name})`,
-        body: `${arrivalNotice.name} is ready for putaway`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      })
-    }
-  }
-}
-
-export async function completeUnloading(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  arrivalNoticeNo: string,
-  unloadingWorksheetDetails: Partial<WorksheetDetail>[]
-): Promise<void> {
-  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
-  await worksheetController.completeUnloading(arrivalNoticeNo, unloadingWorksheetDetails)
-}

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

@@ -1,21 +0,0 @@
-import { activateUnloadingResolver } from './activate-unloading'
-import { completeProductScanUnloadResolver } from './complete-product-scan-unload'
-import { completeUnloadingResolver } from './complete-unloading'
-import { completeUnloadingPartiallyResolver } from './complete-unloading-partially'
-import { scanProductUnloadResolver } from './scan-product-unload'
-import { scanSerialNumberUnloadResolver } from './scan-serial-number-unload'
-import { undoSerialNumberUnloadResolver } from './undo-serial-number-unload'
-import { undoUnloadingResolver } from './undo-unloading'
-import { unloadResolver } from './unload'
-
-export const Mutations = {
-  ...activateUnloadingResolver,
-  ...scanProductUnloadResolver,
-  ...scanSerialNumberUnloadResolver,
-  ...unloadResolver,
-  ...undoUnloadingResolver,
-  ...undoSerialNumberUnloadResolver,
-  ...completeProductScanUnloadResolver,
-  ...completeUnloadingResolver,
-  ...completeUnloadingPartiallyResolver
-}