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

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

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

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

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

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

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

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

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

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

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

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

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