@things-factory/worksheet-base 4.3.60 → 4.3.64

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

@@ -16,7 +16,8 @@ import {
   OrderToteItem,
   OrderToteSeal,
   OrderVas,
-  ReleaseGood
+  ReleaseGood,
+  GenerateBatchPickInfo
 } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import {
@@ -82,108 +83,86 @@ export class PickingWorksheetController extends VasWorksheetController {
     return worksheet
   }
 
-  async generateBatchPickingWorksheet(releaseGoodNos: [string], partnerBizplaceId: string): Promise<Worksheet> {
-    let releaseGoods: ReleaseGood[] = await this.trxMgr.getRepository(ReleaseGood).find({
-      where: { domain: this.domain, name: In(releaseGoodNos), status: ORDER_STATUS.PENDING_WORKSHEET },
-      relations: [
-        'orderProducts',
-        'orderProducts.product',
-        'orderInventories',
-        'orderInventories.inventory',
-        'bizplace',
-        'bizplace.domain'
-      ]
-    })
+  async generateBatchPickingWorksheet(releaseGoodWithBiz: [GenerateBatchPickInfo[]]): Promise<Worksheet[]> {
+    let worksheets = []
+
+    for (let i = 0; i < releaseGoodWithBiz.length; i++) {
+      let releaseGoodNos = releaseGoodWithBiz[i].map(itm => itm.releaseGoodNo)
+
+      let releaseGoods: ReleaseGood[] = await this.trxMgr.getRepository(ReleaseGood).find({
+        where: { domain: this.domain, name: In(releaseGoodNos), status: ORDER_STATUS.PENDING_WORKSHEET },
+        relations: [
+          'orderProducts',
+          'orderProducts.product',
+          'orderInventories',
+          'orderInventories.inventory',
+          'bizplace',
+          'bizplace.domain'
+        ]
+      })
 
-    const partnerBizplace: Bizplace = await this.trxMgr.getRepository(Bizplace).findOne(partnerBizplaceId)
+      let orderInventories: OrderInventory[] = []
+      releaseGoods.map((releaseGood: ReleaseGood) => {
+        const foundOIs: OrderInventory[] = releaseGood.orderInventories
+        foundOIs.map((oi: OrderInventory) => {
+          orderInventories.push(oi)
+        })
+      })
 
-    let orderInventories: OrderInventory[] = []
-    releaseGoods.map((releaseGood: ReleaseGood) => {
-      const foundOIs: OrderInventory[] = releaseGood.orderInventories
-      foundOIs.map((oi: OrderInventory) => {
-        orderInventories.push(oi)
+      const worksheetSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+        where: {
+          domain: this.domain,
+          name: TASK_NUMBER_SETTING_KEY.TASK_NO_RULE
+        }
       })
-    })
+      if (!worksheetSetting) throw new Error(this.ERROR_MSG.FIND.NO_RESULT('task number rule'))
 
-    const worksheetSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
-      where: {
+      let worksheet: Worksheet = new Worksheet()
+      worksheet.name = WorksheetNoGenerator.generate(WORKSHEET_TYPE.BATCH_PICKING)
+      worksheet.type = WORKSHEET_TYPE.BATCH_PICKING
+      worksheet.taskNo = await generateId({
         domain: this.domain,
-        name: TASK_NUMBER_SETTING_KEY.TASK_NO_RULE
-      }
-    })
-    if (!worksheetSetting) throw new Error(this.ERROR_MSG.FIND.NO_RESULT('task number rule'))
-
-    let worksheet: Worksheet = new Worksheet()
-    worksheet.name = WorksheetNoGenerator.generate(WORKSHEET_TYPE.BATCH_PICKING)
-    worksheet.type = WORKSHEET_TYPE.BATCH_PICKING
-    worksheet.taskNo = await generateId({
-      domain: this.domain,
-      type: TASK_NUMBER_RULE_TYPE.TASK_NO,
-      seed: {}
-    })
-    worksheet.status = WORKSHEET_STATUS.DEACTIVATED
-    worksheet.bizplace = partnerBizplace
-    worksheet.domain = this.domain
-    worksheet.creator = this.user
-    worksheet.updater = this.user
-    worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
-
-    if (orderInventories.some((oi: OrderInventory) => oi.inventory?.id)) {
-      const hasInventoryOIs: OrderInventory[] = orderInventories.filter(
-        (orderInventory: OrderInventory) => orderInventory.inventory !== null
-      )
-
-      worksheet.worksheetDetails = await this.createWorksheetDetails(
-        worksheet,
-        WORKSHEET_TYPE.BATCH_PICKING,
-        hasInventoryOIs
-      )
-    }
-
-    orderInventories.forEach((oi: OrderInventory) => {
-      oi.refWorksheetId = worksheet.id
-      oi.status = oi.inventory?.id ? ORDER_INVENTORY_STATUS.READY_TO_PICK : ORDER_INVENTORY_STATUS.PENDING_SPLIT
-      oi.updater = this.user
-    })
-    await this.updateOrderTargets(orderInventories)
+        type: TASK_NUMBER_RULE_TYPE.TASK_NO,
+        seed: {}
+      })
+      worksheet.status = WORKSHEET_STATUS.DEACTIVATED
+      worksheet.bizplace = releaseGoodWithBiz[i][0].bizplaceId
+      worksheet.domain = this.domain
+      worksheet.creator = this.user
+      worksheet.updater = this.user
+      worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
+
+      if (orderInventories.some((oi: OrderInventory) => oi.inventory?.id)) {
+        const hasInventoryOIs: OrderInventory[] = orderInventories.filter(
+          (orderInventory: OrderInventory) => orderInventory.inventory !== null
+        )
 
-    releaseGoods = releaseGoods.map((releaseGood: ReleaseGood) => {
-      return {
-        ...releaseGood,
-        status: ORDER_STATUS.READY_TO_PICK,
-        updater: this.user
+        worksheet.worksheetDetails = await this.createWorksheetDetails(
+          worksheet,
+          WORKSHEET_TYPE.BATCH_PICKING,
+          hasInventoryOIs
+        )
       }
-    })
-    await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
 
-    //asynchronously save packageId if found
-    Promise.all(
-      releaseGoods.map(async ro => {
-        if (ro?.packageId == null || ro?.packageId.trim() == '') {
-          const sellercraft: Sellercraft = await getRepository(Sellercraft).findOne({ domain: ro.bizplace.domain })
-          if (sellercraft) {
-            try {
-              await getConnection().transaction(async trx => {
-                const sellercraftCtrl: SellercraftController = new SellercraftController(trx, this.domain, this.user)
-                let packageInfo = await sellercraftCtrl.packOrder(sellercraft, {
-                  ...ro,
-                  orderProducts: ro.orderProducts
-                })
-
-                await trx.getRepository(ReleaseGood).update({ id: ro.id }, { packageId: packageInfo.packageId })
-              })
-            } catch (error) {
-              logger.error(
-                `picking-worksheet-controller:generateBatchPickingWorksheet[packageId][refNo: ${ro.refNo}, refNo2: ${
-                  ro.refNo2
-                }]: ${JSON.stringify(error)}`
-              )
-            }
-          }
+      orderInventories.forEach((oi: OrderInventory) => {
+        oi.refWorksheetId = worksheet.id
+        oi.status = oi.inventory?.id ? ORDER_INVENTORY_STATUS.READY_TO_PICK : ORDER_INVENTORY_STATUS.PENDING_SPLIT
+        oi.updater = this.user
+      })
+      await this.updateOrderTargets(orderInventories)
+
+      releaseGoods = releaseGoods.map((releaseGood: ReleaseGood) => {
+        return {
+          ...releaseGood,
+          status: ORDER_STATUS.READY_TO_PICK,
+          updater: this.user
         }
       })
-    )
-    return worksheet
+      await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
+
+      worksheets.push(worksheet)
+    }
+    return worksheets
   }
 
   async generateBatchPickingWorksheetDetail(
@@ -443,7 +422,8 @@ export class PickingWorksheetController extends VasWorksheetController {
     cartonId: string,
     binLocation?: string,
     serialNumber?: string,
-    toteNo?: string
+    toteNo?: string,
+    pickingQty?: number
   ): Promise<OrderInventory> {
     try {
       let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
@@ -485,7 +465,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       const packingType: string = inventory.packingType
       const packingSize: number = inventory.packingSize
 
-      let pickedQty: number = 1
+      let pickedQty: number = pickingQty ? pickingQty : 1
       const releaseQty: number = targetInventory.releaseQty
 
       targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
@@ -510,14 +490,16 @@ export class PickingWorksheetController extends VasWorksheetController {
             parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
         )
 
-        pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
-        if (pickedQty + targetInventory.pickedQty > releaseQty) {
-          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
-        }
+        let childQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
+        pickedQty *= childQty
       } else if (!foundProductDetail) {
         throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
       }
 
+      if (pickedQty + targetInventory.pickedQty > releaseQty) {
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
+      }
+
       if (product?.isRequireSerialNumberScanningOutbound) {
         if (!serialNumber || serialNumber == '') {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
@@ -869,7 +851,8 @@ export class PickingWorksheetController extends VasWorksheetController {
     cartonId: string,
     productBarcode: string,
     inventory: any,
-    binLocationName: string
+    binLocationName: string,
+    pickingQty: number
   ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: { domain: this.domain, taskNo, type: worksheetType, status: WORKSHEET_STATUS.EXECUTING },
@@ -893,7 +876,7 @@ export class PickingWorksheetController extends VasWorksheetController {
     const batchId: string = inventory.batchId
     const packingType: string = inventory.packingType
     const packingSize: number = inventory.packingSize
-    let pickedQty: number = 1
+    let pickedQty: number = pickingQty ? pickingQty : 1
 
     const targetInventories: OrderInventory[] = worksheetDetails
       .map((wsd: WorksheetDetail) => wsd.targetInventory)
@@ -926,7 +909,8 @@ export class PickingWorksheetController extends VasWorksheetController {
           this.ERROR_MSG.FIND.NO_RESULT(`Packing Type ( ${packingType}) or Packing Size (${packingSize})`)
         )
 
-      pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
+      let childQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
+      pickedQty *= childQty
     }
 
     const sumOfReleaseQty: number = targetInventories
@@ -1042,15 +1026,6 @@ export class PickingWorksheetController extends VasWorksheetController {
         itm.updater = this.user
       })
 
-      // let inventoryLists = InventoryItems.filter(
-      //   (value, index, self) => index === self.findIndex(itm => itm.inventory.id === value.inventory.id)
-      // )
-
-      // inventoryLists.forEach((itm: Inventory) => {
-      //   if (itm.inventory.qty - itm.releaseQty == 0)
-      //     this.transactionInventory(itm, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
-      // })
-
       await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
     }
 

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

@@ -87,6 +87,7 @@ export class ReturningWorksheetController extends VasWorksheetController {
     const releaseGood: ReleaseGood = worksheet.releaseGood
     let targetInventory: OrderInventory = worksheetDetail.targetInventory
     let inventory: Inventory = targetInventory.inventory
+    let location: Location = inventory.location
 
     const originLocation: Location = inventory.location
     const originPalletId: string = inventory.palletId
@@ -95,6 +96,17 @@ export class ReturningWorksheetController extends VasWorksheetController {
       where: { domain: this.domain, name: toLocationName },
       relations: ['warehouse']
     })
+
+    if (worksheet.type === 'WAREHOUSE_RETURN' && releaseGood.recall) {
+      if (
+        ![LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE].some(l => {
+          return l === toLocation.type
+        })
+      ) {
+        throw new Error('Location should be assigned only to Quarantine or Reserve Zone')
+      }
+    }
+
     if (!toLocation) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(toLocationName))
 
     const isPalletDiff: boolean = originPalletId !== palletId
@@ -158,6 +170,7 @@ export class ReturningWorksheetController extends VasWorksheetController {
       const releaseGood: ReleaseGood = worksheet.releaseGood
       let targetInventory: OrderInventory = worksheetDetail.targetInventory
       let inventory: Inventory = targetInventory.inventory
+      let invLocation: Location = inventory.location
 
       if (inventory.cartonId !== cartonId) {
         throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('cartonId', cartonId, inventory.cartonId))
@@ -178,6 +191,16 @@ export class ReturningWorksheetController extends VasWorksheetController {
         relations: ['warehouse']
       })
 
+      if (worksheet.type === 'WAREHOUSE_RETURN' && releaseGood.recall) {
+        if (
+          ![LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE].some(l => {
+            return l === location.type
+          })
+        ) {
+          throw new Error('Location should be assigned only to Quarantine or Reserve Zone')
+        }
+      }
+
       if (!location) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(toLocationName))
       const warehouse: Warehouse = location.warehouse
       const zone: string = warehouse.zone

package/server/entities/worksheet-detail.ts

@@ -12,6 +12,10 @@ import { Worksheet } from './worksheet'
   (worksheetDetail: WorksheetDetail) => [worksheetDetail.domain, worksheetDetail.bizplace, worksheetDetail.name],
   { unique: true }
 )
+@Index(
+  'ix_worksheet-detail_1',
+  (worksheetDetail: WorksheetDetail) => [worksheetDetail.targetInventory]
+)
 export class WorksheetDetail {
   @PrimaryGeneratedColumn('uuid')
   id: string

package/server/graphql/resolvers/worksheet/find-release-orders-by-task-no.ts

@@ -1,54 +1,17 @@
 import { EntityManager, SelectQueryBuilder } from 'typeorm'
 
-import {
-  ORDER_STATUS, ORDER_INVENTORY_STATUS,
-  OrderInventory as OrderInventoryEntity,
-  ReleaseGood as ReleaseGoodEntity
-} from '@things-factory/sales-base'
+import { OrderInventory as OrderInventoryEntity, ReleaseGood as ReleaseGoodEntity } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Location } from '@things-factory/warehouse-base'
 
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
 
 export const findReleaseOrdersByTaskNoResolver = {
   async findReleaseOrdersByTaskNo(_: any, { taskNo }, context: any) {
     const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
     let task = await tx.getRepository(WorksheetEntity).findOne({
-      where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
+      where: { taskNo }
     })
 
-    // Find Task based on Bin
-    if (!task) {
-      const binLocation: Location = await tx.getRepository(Location).findOne({
-        where: { domain, name: taskNo }
-      })
-
-      const qb: SelectQueryBuilder<OrderInventoryEntity> = tx.getRepository(OrderInventoryEntity).createQueryBuilder('orderInventory')
-
-      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
-        .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
-        .innerJoinAndSelect('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
-        .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.SORTING]
-        })
-        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
-        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.SORTING })
-
-      const orderInventoryByBin = await qb.getRawOne()
-      if (orderInventoryByBin?.releaseGood_id) {
-        taskNo = orderInventoryByBin.ws_task_no
-        task = await tx.getRepository(WorksheetEntity).findOne({
-          where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
-        })
-      } else {
-        throw new Error(`Bin do not have any batch picking order.`)
-      }
-    }
-
     if (!task) throw new Error('Unable to find task no.')
 
     const qb: SelectQueryBuilder<WorksheetEntity> = tx
@@ -63,9 +26,6 @@ export const findReleaseOrdersByTaskNoResolver = {
       .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
       .where('domain.id = :domainId', { domainId: domain.id })
       .andWhere('ws.taskNo = :taskNo', { taskNo: taskNo })
-      .andWhere('ws.type = :worksheetType', { worksheetType: WORKSHEET_TYPE.SORTING })
-      .andWhere('ws.status = :worksheetStatus', { worksheetStatus: WORKSHEET_STATUS.EXECUTING })
-      .andWhere('rg.status = :roStatus', { roStatus: ORDER_STATUS.SORTING })
       .groupBy('rg.id')
       .addGroupBy('rg.name')
       .addGroupBy('rg.status')

package/server/graphql/resolvers/worksheet/find-sorting-release-orders-by-task-no.ts

@@ -0,0 +1,80 @@
+import { EntityManager, SelectQueryBuilder } from 'typeorm'
+
+import {
+    ORDER_INVENTORY_STATUS,
+    ORDER_STATUS,
+    OrderInventory as OrderInventoryEntity,
+    ReleaseGood as ReleaseGoodEntity
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Location } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
+
+export const findSortingReleaseOrdersByTaskNoResolver = {
+    async findSortingReleaseOrdersByTaskNo(_: any, { taskNo }, context: any) {
+        const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+        let task = await tx.getRepository(WorksheetEntity).findOne({
+            where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
+        })
+
+        // Find Task based on Bin
+        if (!task) {
+            const binLocation: Location = await tx.getRepository(Location).findOne({
+                where: { domain, name: taskNo }
+            })
+
+            const qb: SelectQueryBuilder<OrderInventoryEntity> = tx
+                .getRepository(OrderInventoryEntity)
+                .createQueryBuilder('orderInventory')
+
+            qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+                .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
+                .innerJoinAndSelect('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
+                .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.SORTING]
+                })
+                .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+                .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.SORTING })
+
+            const orderInventoryByBin = await qb.getRawOne()
+            if (orderInventoryByBin?.releaseGood_id) {
+                taskNo = orderInventoryByBin.ws_task_no
+                task = await tx.getRepository(WorksheetEntity).findOne({
+                    where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
+                })
+            } else {
+                throw new Error(`Bin do not have any batch picking order.`)
+            }
+        }
+
+        if (!task) throw new Error('Unable to find task no.')
+
+        const qb: SelectQueryBuilder<WorksheetEntity> = tx
+            .getRepository(WorksheetEntity)
+            .createQueryBuilder('ws')
+            .select('rg.id as id')
+            .addSelect('rg.name as name')
+            .addSelect('rg.status as status')
+            .innerJoin(Domain, 'domain', 'ws.domain_id = domain.id')
+            .innerJoin(WorksheetDetailEntity, 'wsd', 'ws.id = wsd.worksheet_id')
+            .innerJoin(OrderInventoryEntity, 'oi', 'oi.id = wsd.target_inventory_id')
+            .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
+            .where('domain.id = :domainId', { domainId: domain.id })
+            .andWhere('ws.taskNo = :taskNo', { taskNo: taskNo })
+            .andWhere('ws.type = :worksheetType', { worksheetType: WORKSHEET_TYPE.SORTING })
+            .andWhere('ws.status = :worksheetStatus', { worksheetStatus: WORKSHEET_STATUS.EXECUTING })
+            .andWhere('rg.status = :roStatus', { roStatus: ORDER_STATUS.SORTING })
+            .groupBy('rg.id')
+            .addGroupBy('rg.name')
+            .addGroupBy('rg.status')
+            .orderBy('rg.createdAt', 'ASC')
+
+        const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
+        return { releaseGoods, taskNo }
+    }
+}

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

@@ -1,14 +1,14 @@
 import { User } from '@things-factory/auth-base'
-import { OrderInventory } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
+import { OrderInventory, GenerateBatchPickInfo } from '@things-factory/sales-base'
+import { Domain, ObjectRef } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers/'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const generateBatchPickingWorksheetResolver = {
-  async generateBatchPickingWorksheet(_: any, { releaseGoodNos, partnerBizplaceId }, context: any) {
+  async generateBatchPickingWorksheet(_: any, { releaseGoodWithBiz }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generateBatchPickingWorksheet(tx, domain, user, releaseGoodNos, partnerBizplaceId)
+    return await generateBatchPickingWorksheet(tx, domain, user, releaseGoodWithBiz)
   }
 }
 
@@ -16,9 +16,8 @@ export async function generateBatchPickingWorksheet(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  releaseGoodNos: [string],
-  partnerBizplaceId: string
-): Promise<Worksheet> {
+  releaseGoodWithBiz: [[GenerateBatchPickInfo]]
+): Promise<Worksheet[]> {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  return await worksheetController.generateBatchPickingWorksheet(releaseGoodNos, partnerBizplaceId)
+  return await worksheetController.generateBatchPickingWorksheet(releaseGoodWithBiz)
 }

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-release-good-worksheet.ts

@@ -8,11 +8,7 @@ import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { PickingWorksheetController } from '../../../../controllers/'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
-import {
-  Inventory,
-  InventoryUtil,
-  INVENTORY_TRANSACTION_TYPE
-} from '@things-factory/warehouse-base'
+import { Inventory, InventoryUtil, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
 
 export const generateReleaseGoodWorksheetResolver = {
   async generateReleaseGoodWorksheet(_: any, { releaseGoodNo }, context: any) {
@@ -30,14 +26,11 @@ export async function generatePickingWorksheet(
   try {
     const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
 
-    let releaseGood: ReleaseGood = await worksheetController.findRefOrder(
-      ReleaseGood,
-      {
-        domain: domain,
-        name: releaseGoodNo,
-        status: ORDER_STATUS.PENDING_WORKSHEET
-      }
-    )
+    let releaseGood: ReleaseGood = await worksheetController.findRefOrder(ReleaseGood, {
+      domain: domain,
+      name: releaseGoodNo,
+      status: ORDER_STATUS.PENDING_WORKSHEET
+    })
 
     let worksheet: Worksheet = new Worksheet()
 
@@ -56,11 +49,13 @@ export async function generatePickingWorksheet(
       for (let idx = 0; idx < orderInventories.length; idx++) {
         let orderInventory = orderInventories[idx]
         if (orderInventory.releaseQty <= 0 || (orderInventory.uomValue != null && orderInventory.uomValue <= 0)) {
-          throw new Error(`Invalid data for ${releaseGoodNo}. Please contact support.`);
+          throw new Error(`Invalid data for ${releaseGoodNo}. Please contact support.`)
         }
         orderInventory.uomValue = orderInventory.uomValue > 0 ? orderInventory.uomValue : 0
 
-        let inventory: Inventory = await tx.getRepository(Inventory).findOne({ where: { id: orderInventory.inventory.id } })
+        let inventory: Inventory = await tx
+          .getRepository(Inventory)
+          .findOne({ where: { id: orderInventory.inventory.id } })
 
         await inventoryUtil.transactionInventory(
           {
@@ -71,16 +66,17 @@ export async function generatePickingWorksheet(
             lockedUomValue: Math.round((inventory.lockedUomValue - orderInventory.releaseUomValue) * 100) / 100
           },
           releaseGood,
-          - orderInventory.releaseQty,
-          - orderInventory.releaseUomValue,
+          -orderInventory.releaseQty,
+          -orderInventory.releaseUomValue,
           INVENTORY_TRANSACTION_TYPE.DIRECT_DEDUCTION
         )
 
-        await tx.getRepository(OrderInventory).save({ id: orderInventory.id, status: ORDER_INVENTORY_STATUS.TERMINATED })
+        await tx
+          .getRepository(OrderInventory)
+          .update({ id: orderInventory.id }, { status: ORDER_INVENTORY_STATUS.TERMINATED })
       }
 
-      await tx.getRepository(ReleaseGood).save({ id: releaseGood.id, status: ORDER_STATUS.DONE })
-
+      await tx.getRepository(ReleaseGood).update({ id: releaseGood.id }, { status: ORDER_STATUS.DONE })
     } else {
       worksheet = await worksheetController.generatePickingWorksheet(releaseGoodNo)
     }

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

@@ -11,6 +11,7 @@ import { deliveryOrderByWorksheetResolver } from './delivery-order-by-worksheet'
 import { fetchDeliveryOrderROResolver } from './fetch-delivery-order-ro'
 import { fetchSellercraftAirwayBillResolver } from './fetch-sellercraft-airway-bill'
 import { findReleaseOrdersByTaskNoResolver } from './find-release-orders-by-task-no'
+import { findSortingReleaseOrdersByTaskNoResolver } from './find-sorting-release-orders-by-task-no'
 import { Mutations as GenerateWorksheetMutations } from './generate-worksheet'
 import { havingVasResolver } from './having-vas'
 import { Mutations as InspectMutations } from './inspecting'
@@ -99,6 +100,7 @@ export const Query = {
   ...myPickingAssignmentStatusResolver,
   ...recommendPutawayLocationResolver,
   ...sortingWorksheetResolver,
+  ...findSortingReleaseOrdersByTaskNoResolver,
   ...findReleaseOrdersByTaskNoResolver,
   ...fetchDeliveryOrderROResolver
 }