@things-factory/worksheet-base 4.2.12 → 4.3.0

package/server/controllers/outbound/sorting-worksheet-controller.ts

@@ -1,3 +1,5 @@
+import { IsNull, In } from 'typeorm'
+
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 import { Product, ProductDetail } from '@things-factory/product-base'
 import {
@@ -6,11 +8,22 @@ import {
   InventoryItem,
   INVENTORY_STATUS,
   InventoryNoGenerator,
-  INVENTORY_ITEM_SOURCE
+  INVENTORY_ITEM_SOURCE,
+  Tote,
+  TOTE_STATUS
 } from '@things-factory/warehouse-base'
-import { ReleaseGood, OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '@things-factory/sales-base'
+import {
+  ReleaseGood,
+  OrderInventory,
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderTote,
+  OrderToteItem,
+  OrderNoGenerator
+} from '@things-factory/sales-base'
 import { Worksheet, WorksheetDetail } from '../../entities'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
+import { temporaryGetRemainInventoryAmount } from 'server/graphql/resolvers/worksheet/vas-transactions/common-utils'
 
 export class SortingWorksheetController extends VasWorksheetController {
   async generateSortingWorksheet(
@@ -62,7 +75,8 @@ export class SortingWorksheetController extends VasWorksheetController {
     taskNo: string,
     releaseGoodNo: string,
     productBarcode: string,
-    serialNumber: string
+    serialNumber: string,
+    toteNo: string
   ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
@@ -75,6 +89,8 @@ export class SortingWorksheetController extends VasWorksheetController {
         'worksheetDetails',
         'worksheetDetails.targetInventory',
         'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.orderProduct',
+        'worksheetDetails.targetInventory.bizplace',
         'worksheetDetails.targetInventory.inventory',
         'worksheetDetails.targetInventory.inventory.product',
         'worksheetDetails.targetInventory.inventory.product.productDetails',
@@ -204,6 +220,17 @@ export class SortingWorksheetController extends VasWorksheetController {
               } else {
                 await this.updateOrderTargets([matchingOI])
               }
+
+              if (toteNo) {
+                await this.toteScanning(
+                  toteNo,
+                  matchingOI.orderProduct,
+                  matchingOI,
+                  1,
+                  releaseGood,
+                  matchingOI.bizplace
+                )
+              }
             }
           })
         )
@@ -216,7 +243,8 @@ export class SortingWorksheetController extends VasWorksheetController {
     releaseGoodNo: string,
     productId: string,
     sortingQty: number,
-    serialNumber: string
+    serialNumber: string,
+    toteNo: string
   ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
@@ -229,6 +257,8 @@ export class SortingWorksheetController extends VasWorksheetController {
         'worksheetDetails',
         'worksheetDetails.targetInventory',
         'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.orderProduct',
+        'worksheetDetails.targetInventory.bizplace',
         'worksheetDetails.targetInventory.inventory',
         'worksheetDetails.targetInventory.inventory.product',
         'worksheetDetails.targetInventory.inventory.product.productDetails',
@@ -294,6 +324,17 @@ export class SortingWorksheetController extends VasWorksheetController {
             }
           }
 
+          if (toteNo) {
+            await this.toteScanning(
+              toteNo,
+              matchingOI.orderProduct,
+              matchingOI,
+              sortingQty,
+              releaseGood,
+              matchingOI.bizplace
+            )
+          }
+
           if (releaseQty != matchingOI?.sortedQty && sortingQty != 0) {
             if (product?.isRequireSerialNumberScanningOutbound) {
               matchingOI.sortedQty += sortingQty
@@ -338,34 +379,50 @@ export class SortingWorksheetController extends VasWorksheetController {
   }
 
   async completeOrderSorting(releaseGoodNo: string): Promise<ReleaseGood> {
-    let releaseGood: ReleaseGood = await this.findRefOrder(
-      ReleaseGood,
-      {
-        domain: this.domain,
-        name: releaseGoodNo,
-        status: ORDER_STATUS.SORTING
-      },
-      ['bizplace', 'orderInventories']
-    )
+    try {
+      let releaseGood: ReleaseGood = await this.findRefOrder(
+        ReleaseGood,
+        {
+          domain: this.domain,
+          name: releaseGoodNo,
+          status: ORDER_STATUS.SORTING
+        },
+        ['bizplace', 'orderInventories']
+      )
 
-    releaseGood.status = ORDER_STATUS.READY_TO_LOAD
-    releaseGood.updater = this.user
-    await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
+      if (!releaseGood) {
+        throw new Error('Order is already sorted')
+      }
 
-    let inventoryItems: InventoryItem = await this.trxMgr
-      .getRepository(InventoryItem)
-      .find({ where: { outboundOrderId: releaseGood.id } })
+      const foundNotSealedOrderTote = await this.trxMgr
+        .getRepository(OrderTote)
+        .findOne({ where: { releaseGood, closedDate: IsNull() } })
 
-    if (inventoryItems.length > 0) {
-      inventoryItems.forEach((itm: InventoryItem) => {
-        itm.status = INVENTORY_STATUS.TERMINATED
-        itm.updater = this.user
-      })
+      if (foundNotSealedOrderTote) {
+        throw new Error('Please seal the tote(s) before proceeding')
+      }
 
-      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
-    }
+      releaseGood.status = ORDER_STATUS.READY_TO_LOAD
+      releaseGood.updater = this.user
+      await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
+
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: releaseGood.id } })
+
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
+          itm.status = INVENTORY_STATUS.TERMINATED
+          itm.updater = this.user
+        })
+
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
 
-    return releaseGood
+      return releaseGood
+    } catch (e) {
+      throw e
+    }
   }
 
   async completeWorksheetSorting(taskNo: string): Promise<Worksheet> {
@@ -383,6 +440,16 @@ export class SortingWorksheetController extends VasWorksheetController {
       ]
     })
 
+    let releaseGoodIds = worksheet.worksheetDetails.map(itm => itm.targetInventory.releaseGood.id)
+
+    const foundNotSealedOrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { releaseGood: In(releaseGoodIds), closedDate: IsNull() } })
+
+    if (foundNotSealedOrderTote) {
+      throw new Error('Please seal the tote(s) before proceeding')
+    }
+
     this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
     const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
@@ -398,4 +465,77 @@ export class SortingWorksheetController extends VasWorksheetController {
 
     return worksheet
   }
+
+  private async toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace) {
+    //1. find tote
+    let foundTote: Tote = await this.trxMgr
+      .getRepository(Tote)
+      .findOne({ where: { bizplace, name: toteNo, deletedAt: IsNull() } })
+
+    if (foundTote?.status == TOTE_STATUS.DAMAGED) {
+      throw new Error('Tote is damaged')
+    }
+
+    if (foundTote?.status == TOTE_STATUS.DISPATCHED) {
+      throw new Error('Tote is dispatched')
+    }
+
+    //2. find order tote
+    let foundOrderTote: OrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { domain: this.domain, name: toteNo, releaseGood } })
+
+    //if order tote not found the create one, if tote not found means it's tote box
+    //create order tote item
+    if (!foundOrderTote) {
+      const orderTote = await this.trxMgr.getRepository(OrderTote).save({
+        name: toteNo,
+        domain: this.domain,
+        releaseGood,
+        tote: foundTote ? foundTote : null,
+        updater: this.user
+      })
+
+      const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+        domain: this.domain,
+        name: OrderNoGenerator.orderToteItem(),
+        orderProduct: targetProduct,
+        orderInventory: targetInventory,
+        orderTote,
+        qty: pickedQty,
+        updater: this.user
+      })
+    } else {
+      if (foundOrderTote.closedDate) {
+        throw new Error('Tote has been sealed, please try another tote!')
+      }
+
+      //if found order tote then check if order tote item exist
+      const foundOrderToteItem: OrderToteItem = await this.trxMgr.getRepository(OrderToteItem).findOne({
+        domain: this.domain,
+        orderProduct: targetProduct,
+        orderInventory: targetInventory,
+        orderTote: foundOrderTote
+      })
+
+      //if not order tote item doesnt exist then create one
+      if (!foundOrderToteItem) {
+        const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+          domain: this.domain,
+          name: OrderNoGenerator.orderToteItem(),
+          orderProduct: targetProduct,
+          orderInventory: targetInventory,
+          orderTote: foundOrderTote,
+          qty: pickedQty,
+          updater: this.user
+        })
+      } else {
+        //if found order tote item found then add the quantity
+        const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+          ...foundOrderToteItem,
+          qty: foundOrderToteItem.qty + pickedQty
+        })
+      }
+    }
+  }
 }

package/server/graphql/resolvers/worksheet/batch-picking-worksheet.ts

@@ -3,6 +3,7 @@ import { getRepository, SelectQueryBuilder } from 'typeorm'
 import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { InventoryChange } from '@things-factory/warehouse-base'
 
 export const batchPickingWorksheetResolver = {
   async batchPickingWorksheet(_: any, { taskNo, locationSortingRules }, context: any) {
@@ -42,6 +43,7 @@ export const batchPickingWorksheetResolver = {
       .addSelect('LOC.column', 'column')
       .addSelect('LOC.shelf', 'shelf')
       .addSelect('BIN_LOC.name', 'binLocationName')
+      .addSelect('WSD.status', 'status')
       .leftJoin('WSD.targetInventory', 'T_INV')
       .leftJoin('T_INV.inventory', 'INV')
       .leftJoin('T_INV.product', 'PROD')
@@ -70,6 +72,7 @@ export const batchPickingWorksheetResolver = {
       .addGroupBy('LOC.column')
       .addGroupBy('LOC.row')
       .addGroupBy('LOC.shelf')
+      .addGroupBy('WSD.status')
 
     if (locationSortingRules?.length > 0) {
       locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
@@ -86,6 +89,15 @@ export const batchPickingWorksheetResolver = {
         partnerDomainId: worksheet.bizplace?.domain.id
       },
       worksheetDetailInfos: items.map(async (item: any) => {
+        const inventoryChangesCount: number = await getRepository(InventoryChange).count({
+          where: {
+            inventory: item.inventoryId,
+            status: 'PENDING',
+            transactionType: 'MISSING'
+          },
+          relations: ['inventory', 'product']
+        })
+
         return {
           palletId: item?.palletId,
           cartonId: item?.cartonId,
@@ -98,6 +110,8 @@ export const batchPickingWorksheetResolver = {
           },
           qty: item?.qty,
           releaseQty: item.releaseQty,
+          hasMissingInventoryChanges: inventoryChangesCount > 0 ? true : false,
+          status: item.status,
           pickedQty: item.pickedQty,
           packingType: item?.packingType,
           packingSize: item?.packingSize,

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

@@ -9,7 +9,7 @@ import { WorksheetDetail } from '../../../../entities'
 export const loadingResolver = {
   async loading(_: any, { loadedWorksheetDetails, releaseGoodNo, orderInfo }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
+    const worksheetDetails = await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
     const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
     const releaseGood: ReleaseGood = await worksheetController.findRefOrder(
       ReleaseGood,
@@ -18,14 +18,7 @@ export const loadingResolver = {
     )
 
     const loadingWorksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-    let targetInventories: OrderInventory[] = []
-    for (let worksheetDetail of loadedWorksheetDetails) {
-      worksheetDetail = await loadingWorksheetController.findWorksheetDetailByName(worksheetDetail.name, [
-        'targetInventory'
-      ])
-      const targetInventory = worksheetDetail.targetInventory
-      targetInventories.push(targetInventory)
-    }
+    let targetInventories: OrderInventory[] = worksheetDetails.map(itm => itm.targetInventory)
 
     const bizplace: Bizplace = releaseGood.bizplace
     orderInfo = {
@@ -41,9 +34,9 @@ export async function loading(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  worksheetDetails: Partial<WorksheetDetail & { loadedQty: number }>[],
+  worksheetDetails: Partial<WorksheetDetail & { loadedQty: number } & { toteName: string }>[],
   releaseGoodNo: string
-): Promise<void> {
+): Promise<any> {
   const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  await worksheetController.loading(releaseGoodNo, worksheetDetails)
+  return await worksheetController.loading(releaseGoodNo, worksheetDetails)
 }

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

@@ -1,6 +1,13 @@
 import { Equal, getRepository, In, Not, SelectQueryBuilder } from 'typeorm'
 
-import { ORDER_STATUS, ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import {
+  ORDER_STATUS,
+  ORDER_INVENTORY_STATUS,
+  OrderInventory,
+  ReleaseGood,
+  OrderTote,
+  OrderToteItem
+} from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
 
@@ -27,7 +34,9 @@ export const loadingWorksheetResolver = {
         .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
         .innerJoinAndSelect('bizplace.domain', 'domain')
         .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
-        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', { orderInventoryStatus: [ORDER_INVENTORY_STATUS.LOADING, ORDER_INVENTORY_STATUS.LOADED] })
+        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
+          orderInventoryStatus: [ORDER_INVENTORY_STATUS.LOADING, ORDER_INVENTORY_STATUS.LOADED]
+        })
         .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
         .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.LOADING })
 
@@ -41,6 +50,10 @@ export const loadingWorksheetResolver = {
 
     if (!releaseGood) throw new Error(`Release good doesn't exists.`)
 
+    let [orderTotes, orderTotesTotal]: OrderTote = await getRepository(OrderTote).findAndCount({
+      where: { releaseGood: releaseGood.id }
+    })
+
     const foundWorksheet: Worksheet = await fetchExecutingWorksheet(
       domain,
       releaseGood.bizplace,
@@ -48,7 +61,7 @@ export const loadingWorksheetResolver = {
       WORKSHEET_TYPE.LOADING,
       releaseGood
     )
-    const foundWSD: WorksheetDetail[] = await getRepository(WorksheetDetail).find({
+    let foundWSD: any[] = await getRepository(WorksheetDetail).find({
       where: {
         domain,
         worksheet: foundWorksheet,
@@ -57,21 +70,50 @@ export const loadingWorksheetResolver = {
       },
       relations: [
         'targetInventory',
+        'targetInventory.orderProduct',
         'targetInventory.inventory',
         'targetInventory.inventory.location',
         'targetInventory.inventory.product'
       ]
     })
 
-    return {
-      worksheetInfo: {
-        releaseGood,
-        bizplaceName: releaseGood.bizplace.name,
-        startedAt: foundWorksheet.startedAt,
-        refNo: releaseGood.refNo,
-        ownCollection: releaseGood.ownTransport
-      },
-      worksheetDetailInfos: foundWSD.map(async (loadingWSD: WorksheetDetail) => {
+    if (orderTotesTotal > 0) {
+      let [toteItems, toteItemsTotal]: OrderToteItem = await getRepository(OrderToteItem).findAndCount({
+        where: { orderTote: In(orderTotes.map(itm => itm.id)) },
+        relations: ['orderTote', 'orderInventory']
+      })
+
+      let toteWsd = []
+
+      for (let i = 0; i < toteItemsTotal; i++) {
+        let wsdIndex = foundWSD.findIndex(
+          itm => !itm?.toteName && itm.targetInventory.id == toteItems[i].orderInventory.id
+        )
+
+        if (wsdIndex >= 0) {
+          let filterWSD: any = JSON.parse(JSON.stringify(foundWSD[wsdIndex]))
+          let uomValue =
+            Math.round((filterWSD.targetInventory.releaseUomValue / filterWSD.targetInventory.releaseQty) * 100) / 100
+
+          foundWSD[wsdIndex].targetInventory.releaseQty -= toteItems[i].qty
+          foundWSD[wsdIndex].targetInventory.pickedQty -= toteItems[i].qty
+          foundWSD[wsdIndex].targetInventory.releaseUomValue = foundWSD[wsdIndex].targetInventory.releaseQty * uomValue
+
+          filterWSD.targetInventory.releaseQty = toteItems[i].qty
+          filterWSD.targetInventory.pickedQty = toteItems[i].qty
+          filterWSD.targetInventory.releaseUomValue = toteItems[i].qty * uomValue
+          filterWSD.toteName = toteItems[i].orderTote.name
+          toteWsd.push(filterWSD)
+        }
+      }
+
+      foundWSD = foundWSD.concat(toteWsd)
+      foundWSD.sort((a, b) => (a.toteName > b.toteName ? 1 : -1))
+    }
+
+    let worksheetDetailInfos = foundWSD
+      .filter(itm => itm.targetInventory.releaseQty > 0)
+      .map((loadingWSD: any) => {
         const targetInventory: OrderInventory = loadingWSD.targetInventory
         const inventory: Inventory = targetInventory.inventory
         return {
@@ -87,9 +129,20 @@ export const loadingWorksheetResolver = {
           targetName: targetInventory.name,
           packingType: inventory.packingType,
           packingSize: inventory.packingSize,
-          inventory: targetInventory.inventory
+          inventory: targetInventory.inventory,
+          toteName: loadingWSD.toteName
         }
       })
+
+    return {
+      worksheetInfo: {
+        releaseGood,
+        bizplaceName: releaseGood.bizplace.name,
+        startedAt: foundWorksheet.startedAt,
+        refNo: releaseGood.refNo,
+        ownCollection: releaseGood.ownTransport
+      },
+      worksheetDetailInfos
     }
   }
 }

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

@@ -11,7 +11,6 @@ import {
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
-import { ProductDetail } from '@things-factory/product-base'
 
 import { WORKSHEET_TYPE } from '../../../constants'
 import { SellercraftController } from '../../../controllers'
@@ -167,6 +166,7 @@ export const packingWorksheetResolver = {
           shippingProvider: shippingProvider ? shippingProvider : '',
           trackingNo: trackingNo ? trackingNo : '',
           airwayBill: releaseGood?.airwayBill,
+          checkedRemarkBy: releaseGood?.checkedRemarkBy,
           invoice: releaseGood?.invoice,
           platform: marketplaceOrder ? marketplaceOrder.marketplaceStore.platform : 'operato',
           marketplaceStoreId: marketplaceOrder ? marketplaceOrder.marketplaceStore.id : '',

package/server/graphql/resolvers/worksheet/picking/complete-batch-picking.ts

@@ -42,7 +42,7 @@ export async function completeBatchPicking(
   const worksheet = await pickingWSCtrl.completeBatchPicking(taskNo)
 
   const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-  const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+  const targetInventories: OrderInventory[] = worksheetDetails.filter(wsd=>wsd.status != 'MISSING').map((wsd: WorksheetDetail) => wsd.targetInventory)
 
   const sellercraft: Sellercraft = await tx
     .getRepository(Sellercraft)

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

@@ -248,18 +248,20 @@ export async function completePicking(
     })
 
     if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
-      const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-      let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
-        releaseGoodNo,
-        pickedTargetInventories
-      )
-
-      if (!loadingWorksheet.worksheetDetails?.length) {
-        loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+      if(pickedTargetInventories.length>0){
+        const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+        let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
+          releaseGoodNo,
+          pickedTargetInventories
+        )
+  
+        if (!loadingWorksheet.worksheetDetails?.length) {
+          loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+        }
+  
+        const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+        await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
       }
-
-      const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
-      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
     } else {
       const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
       let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(

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

@@ -11,6 +11,7 @@ import { scanProductPickingResolver } from './scan-product-picking'
 import { scanProductBatchPickingResolver } from './scan-product-batch-picking'
 import { undoPickingAssigmentResolver } from './undo-picking-assignment'
 import { undoSerialNumberPickingResolver } from './undo-serial-number-picking'
+import { sealToteResolver } from './seal-tote'
 
 export const Mutations = {
   ...assignPickingInventoriesResolver,
@@ -25,5 +26,6 @@ export const Mutations = {
   ...completeBatchPickingResolver,
   ...assignPickingWorkerResolver,
   ...fetchAndAssignPickingTaskResolver,
-  ...undoSerialNumberPickingResolver
+  ...undoSerialNumberPickingResolver,
+  ...sealToteResolver
 }

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

@@ -4,9 +4,25 @@ import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const pickingResolver = {
-  async picking(_: any, { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber }, context: any) {
+  async picking(
+    _: any,
+    { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber, toteNo },
+    context: any
+  ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await picking(tx, domain, user, worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber)
+    await picking(
+      tx,
+      domain,
+      user,
+      worksheetDetailName,
+      worksheetType,
+      palletId,
+      locationName,
+      releaseQty,
+      binLocation,
+      serialNumber,
+      toteNo
+    )
   }
 }
 
@@ -20,8 +36,18 @@ export async function picking(
   locationName: string,
   releaseQty: number,
   binLocation?: string,
-  serialNumber?: string
+  serialNumber?: string,
+  toteNo?: string
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.picking(worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber)
+  await worksheetController.picking(
+    worksheetDetailName,
+    worksheetType,
+    palletId,
+    locationName,
+    releaseQty,
+    binLocation,
+    serialNumber,
+    toteNo
+  )
 }

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

@@ -6,7 +6,7 @@ import { PickingWorksheetController } from '../../../../controllers'
 export const scanProductPickingResolver = {
   async scanProductPicking(
     _: any,
-    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber },
+    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, toteNo },
     context: any
   ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
@@ -19,7 +19,8 @@ export const scanProductPickingResolver = {
       productBarcode,
       cartonId,
       binLocation,
-      serialNumber
+      serialNumber,
+      toteNo
     )
   }
 }
@@ -33,7 +34,8 @@ export async function scanProductPicking(
   productBarcode: string,
   cartonId: string,
   binLocation?: string,
-  serialNumber?: string
+  serialNumber?: string,
+  toteNo?: string
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   await worksheetController.scanProductPicking(
@@ -42,6 +44,7 @@ export async function scanProductPicking(
     productBarcode,
     cartonId,
     binLocation,
-    serialNumber
+    serialNumber,
+    toteNo
   )
 }

package/server/graphql/resolvers/worksheet/picking/seal-tote.ts

@@ -0,0 +1,25 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const sealToteResolver = {
+  async sealTote(_: any, { sealNo, toteNo, orderNo }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await sealTote(tx, domain, user, sealNo, toteNo, orderNo)
+  }
+}
+
+async function sealTote(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  sealNo: string,
+  toteNo: string,
+  orderNo: string
+): Promise<void> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.sealTote(sealNo, toteNo, orderNo)
+}