@things-factory/worksheet-base 4.3.2 → 4.4.0-alpha.0

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

@@ -1,5 +1,3 @@
-import { IsNull, In } from 'typeorm'
-
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 import { Product, ProductDetail } from '@things-factory/product-base'
 import {
@@ -8,22 +6,11 @@ import {
   InventoryItem,
   INVENTORY_STATUS,
   InventoryNoGenerator,
-  INVENTORY_ITEM_SOURCE,
-  Tote,
-  TOTE_STATUS
+  INVENTORY_ITEM_SOURCE
 } from '@things-factory/warehouse-base'
-import {
-  ReleaseGood,
-  OrderInventory,
-  ORDER_INVENTORY_STATUS,
-  ORDER_STATUS,
-  OrderTote,
-  OrderToteItem,
-  OrderNoGenerator
-} from '@things-factory/sales-base'
+import { ReleaseGood, OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS } 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(
@@ -75,8 +62,7 @@ export class SortingWorksheetController extends VasWorksheetController {
     taskNo: string,
     releaseGoodNo: string,
     productBarcode: string,
-    serialNumber: string,
-    toteNo: string
+    serialNumber: string
   ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
@@ -89,8 +75,6 @@ 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',
@@ -220,17 +204,6 @@ export class SortingWorksheetController extends VasWorksheetController {
               } else {
                 await this.updateOrderTargets([matchingOI])
               }
-
-              if (toteNo) {
-                await this.toteScanning(
-                  toteNo,
-                  matchingOI.orderProduct,
-                  matchingOI,
-                  1,
-                  releaseGood,
-                  matchingOI.bizplace
-                )
-              }
             }
           })
         )
@@ -243,8 +216,7 @@ export class SortingWorksheetController extends VasWorksheetController {
     releaseGoodNo: string,
     productId: string,
     sortingQty: number,
-    serialNumber: string,
-    toteNo: string
+    serialNumber: string
   ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
@@ -257,8 +229,6 @@ 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',
@@ -324,17 +294,6 @@ 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
@@ -379,50 +338,34 @@ export class SortingWorksheetController extends VasWorksheetController {
   }
 
   async completeOrderSorting(releaseGoodNo: string): Promise<ReleaseGood> {
-    try {
-      let releaseGood: ReleaseGood = await this.findRefOrder(
-        ReleaseGood,
-        {
-          domain: this.domain,
-          name: releaseGoodNo,
-          status: ORDER_STATUS.SORTING
-        },
-        ['bizplace', 'orderInventories']
-      )
-
-      if (!releaseGood) {
-        throw new Error('Order is already sorted')
-      }
-
-      const foundNotSealedOrderTote = await this.trxMgr
-        .getRepository(OrderTote)
-        .findOne({ where: { releaseGood, closedDate: IsNull() } })
-
-      if (foundNotSealedOrderTote) {
-        throw new Error('Please seal the tote(s) before proceeding')
-      }
-
-      releaseGood.status = ORDER_STATUS.READY_TO_LOAD
-      releaseGood.updater = this.user
-      await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
+    let releaseGood: ReleaseGood = await this.findRefOrder(
+      ReleaseGood,
+      {
+        domain: this.domain,
+        name: releaseGoodNo,
+        status: ORDER_STATUS.SORTING
+      },
+      ['bizplace', 'orderInventories']
+    )
 
-      let inventoryItems: InventoryItem = await this.trxMgr
-        .getRepository(InventoryItem)
-        .find({ where: { outboundOrderId: releaseGood.id } })
+    releaseGood.status = ORDER_STATUS.READY_TO_LOAD
+    releaseGood.updater = this.user
+    await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
 
-      if (inventoryItems.length > 0) {
-        inventoryItems.forEach((itm: InventoryItem) => {
-          itm.status = INVENTORY_STATUS.TERMINATED
-          itm.updater = this.user
-        })
+    let inventoryItems: InventoryItem = await this.trxMgr
+      .getRepository(InventoryItem)
+      .find({ where: { outboundOrderId: releaseGood.id } })
 
-        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
-      }
+    if (inventoryItems.length > 0) {
+      inventoryItems.forEach((itm: InventoryItem) => {
+        itm.status = INVENTORY_STATUS.TERMINATED
+        itm.updater = this.user
+      })
 
-      return releaseGood
-    } catch (e) {
-      throw e
+      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
     }
+
+    return releaseGood
   }
 
   async completeWorksheetSorting(taskNo: string): Promise<Worksheet> {
@@ -440,16 +383,6 @@ 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
@@ -465,77 +398,4 @@ 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/controllers/render-grn.ts

@@ -52,25 +52,25 @@ export async function renderGRN({ grnNo, timezoneOffSet }, context: any) {
   })
 
   const qbReducedInventory = getRepository(ReducedInventoryHistory)
-    .createQueryBuilder('ivh')
-    .select('product_id', 'productId')
-    .addSelect('batch_id', 'batchId')
-    .addSelect('reusable_pallet_id', 'reusablePalletId')
-    .addSelect('packing_type', 'packingType')
-    .addSelect('sum(qty)', 'qty')
-    .addSelect('sum(uom_value)', 'uomValue')
-    .addSelect('uom', 'uom')
-    .addSelect('count(distinct pallet_id)', 'pallet')
-    .addSelect(`string_agg(distinct expiration_date::varchar,', ' order by expiration_date::varchar)`, 'expiryDate')
-    .addSelect(`string_agg(distinct pallet_id::varchar,', ' order by pallet_id::varchar)`, 'palletId')
-    .where('ivh.domain_id = :domainId', { domainId: domain.id })
-    .andWhere('ivh.ref_order_id = :refOrderId', { refOrderId: foundGAN.id })
+    .createQueryBuilder(`ivh`)
+    .select(`product_id`, `productId`)
+    .addSelect(`batch_id`, `batchId`)
+    .addSelect(`reusable_pallet_id`, `reusablePalletId`)
+    .addSelect(`packing_type`, `packingType`)
+    .addSelect(`sum(qty)`, `qty`)
+    .addSelect(`sum(uom_value)`, `uomValue`)
+    .addSelect(`uom`, `uom`)
+    .addSelect(`count(distinct pallet_id)`, `pallet`)
+    .addSelect(`string_agg(distinct expiration_date::varchar,', ' order by expiration_date::varchar)`, `expiryDate`)
+    .addSelect(`string_agg(distinct pallet_id::varchar,', ' order by pallet_id::varchar)`, `palletId`)
+    .where(`ivh.domain_id = :domainId`, { domainId: domain.id })
+    .andWhere(`ivh.ref_order_id = :refOrderId`, { refOrderId: foundGAN.id })
     .andWhere(`ivh.transaction_type = 'UNLOADING'`)
-    .groupBy('reusable_pallet_id')
-    .addGroupBy('product_id')
-    .addGroupBy('batch_id')
-    .addGroupBy('packing_type')
-    .addGroupBy('uom')
+    .groupBy(`reusable_pallet_id`)
+    .addGroupBy(`product_id`)
+    .addGroupBy(`batch_id`)
+    .addGroupBy(`packing_type`)
+    .addGroupBy(`uom`)
     .getRawMany()
 
   // 5. find domain contact point

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

@@ -3,7 +3,6 @@ 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) {
@@ -43,7 +42,6 @@ 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')
@@ -72,7 +70,6 @@ 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 }) => {
@@ -89,15 +86,6 @@ 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,
@@ -110,8 +98,6 @@ 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
-    const worksheetDetails = await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
+    await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
     const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
     const releaseGood: ReleaseGood = await worksheetController.findRefOrder(
       ReleaseGood,
@@ -18,7 +18,14 @@ export const loadingResolver = {
     )
 
     const loadingWorksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-    let targetInventories: OrderInventory[] = worksheetDetails.map(itm => itm.targetInventory)
+    let targetInventories: OrderInventory[] = []
+    for (let worksheetDetail of loadedWorksheetDetails) {
+      worksheetDetail = await loadingWorksheetController.findWorksheetDetailByName(worksheetDetail.name, [
+        'targetInventory'
+      ])
+      const targetInventory = worksheetDetail.targetInventory
+      targetInventories.push(targetInventory)
+    }
 
     const bizplace: Bizplace = releaseGood.bizplace
     orderInfo = {
@@ -34,9 +41,9 @@ export async function loading(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  worksheetDetails: Partial<WorksheetDetail & { loadedQty: number } & { toteName: string }>[],
+  worksheetDetails: Partial<WorksheetDetail & { loadedQty: number }>[],
   releaseGoodNo: string
-): Promise<any> {
+): Promise<void> {
   const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  return await worksheetController.loading(releaseGoodNo, worksheetDetails)
+  await worksheetController.loading(releaseGoodNo, worksheetDetails)
 }

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

@@ -1,13 +1,6 @@
 import { Equal, getRepository, In, Not, SelectQueryBuilder } from 'typeorm'
 
-import {
-  ORDER_STATUS,
-  ORDER_INVENTORY_STATUS,
-  OrderInventory,
-  ReleaseGood,
-  OrderTote,
-  OrderToteItem
-} from '@things-factory/sales-base'
+import { ORDER_STATUS, ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
 
@@ -34,9 +27,7 @@ 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 })
 
@@ -50,10 +41,6 @@ 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,
@@ -61,7 +48,7 @@ export const loadingWorksheetResolver = {
       WORKSHEET_TYPE.LOADING,
       releaseGood
     )
-    let foundWSD: any[] = await getRepository(WorksheetDetail).find({
+    const foundWSD: WorksheetDetail[] = await getRepository(WorksheetDetail).find({
       where: {
         domain,
         worksheet: foundWorksheet,
@@ -70,50 +57,21 @@ export const loadingWorksheetResolver = {
       },
       relations: [
         'targetInventory',
-        'targetInventory.orderProduct',
         'targetInventory.inventory',
         'targetInventory.inventory.location',
         'targetInventory.inventory.product'
       ]
     })
 
-    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) => {
+    return {
+      worksheetInfo: {
+        releaseGood,
+        bizplaceName: releaseGood.bizplace.name,
+        startedAt: foundWorksheet.startedAt,
+        refNo: releaseGood.refNo,
+        ownCollection: releaseGood.ownTransport
+      },
+      worksheetDetailInfos: foundWSD.map(async (loadingWSD: WorksheetDetail) => {
         const targetInventory: OrderInventory = loadingWSD.targetInventory
         const inventory: Inventory = targetInventory.inventory
         return {
@@ -129,20 +87,9 @@ export const loadingWorksheetResolver = {
           targetName: targetInventory.name,
           packingType: inventory.packingType,
           packingSize: inventory.packingSize,
-          inventory: targetInventory.inventory,
-          toteName: loadingWSD.toteName
+          inventory: targetInventory.inventory
         }
       })
-
-    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,6 +11,7 @@ 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'
@@ -166,7 +167,6 @@ 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.filter(wsd=>wsd.status != 'MISSING').map((wsd: WorksheetDetail) => wsd.targetInventory)
+  const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
 
   const sellercraft: Sellercraft = await tx
     .getRepository(Sellercraft)

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

@@ -248,20 +248,18 @@ export async function completePicking(
     })
 
     if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
-      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 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)
     } else {
       const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
       let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(

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

@@ -11,7 +11,6 @@ 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,
@@ -26,6 +25,5 @@ export const Mutations = {
   ...completeBatchPickingResolver,
   ...assignPickingWorkerResolver,
   ...fetchAndAssignPickingTaskResolver,
-  ...undoSerialNumberPickingResolver,
-  ...sealToteResolver
+  ...undoSerialNumberPickingResolver
 }

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

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