@things-factory/worksheet-base 5.0.0-alpha.25 → 5.0.0-alpha.28

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

@@ -9,9 +9,9 @@ import { PackingWorksheetController, SellercraftController } from '../../../../c
 import { Worksheet } from '../../../../entities'
 
 export const packingResolver = {
-  async packing(_: any, { worksheetDetailName, releaseQty }, context: any) {
+  async packing(_: any, { worksheetDetailName, releaseQty, serialNumber }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await packing(tx, domain, user, worksheetDetailName, releaseQty)
+    await packing(tx, domain, user, worksheetDetailName, releaseQty, serialNumber)
   }
 }
 
@@ -20,10 +20,11 @@ export async function packing(
   domain: Domain,
   user: User,
   worksheetDetailName: string,
-  releaseQty: number
+  releaseQty: number,
+  serialNumber: string
 ) {
   const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-  const worksheetDetail = await worksheetController.packing(worksheetDetailName, releaseQty)
+  const worksheetDetail = await worksheetController.packing(worksheetDetailName, releaseQty, serialNumber)
 
   let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
   const worksheet: Worksheet = worksheetDetail.worksheet

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

@@ -9,9 +9,9 @@ import { PackingWorksheetController, SellercraftController } from '../../../../c
 import { Worksheet } from '../../../../entities'
 
 export const scanProductPackingResolver = {
-  async scanProductPacking(_: any, { worksheetDetailName, productBarcode }, context: any) {
+  async scanProductPacking(_: any, { worksheetDetailName, productBarcode, serialNumber }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await scanProductPacking(tx, domain, user, worksheetDetailName, productBarcode)
+    await scanProductPacking(tx, domain, user, worksheetDetailName, productBarcode, serialNumber)
   }
 }
 
@@ -20,10 +20,15 @@ export async function scanProductPacking(
   domain: Domain,
   user: User,
   worksheetDetailName: string,
-  productBarcode: string
+  productBarcode: string,
+  serialNumber?: string
 ) {
   const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-  const worksheetDetail = await worksheetController.scanProductPacking(worksheetDetailName, productBarcode)
+  const worksheetDetail = await worksheetController.scanProductPacking(
+    worksheetDetailName,
+    productBarcode,
+    serialNumber
+  )
 
   let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
   const worksheet: Worksheet = worksheetDetail.worksheet

package/server/graphql/resolvers/worksheet/packing/undo-serial-number-packing.ts

@@ -0,0 +1,24 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PackingWorksheetController } from '../../../../controllers'
+
+export const undoSerialNumberPackingResolver = {
+  async undoSerialNumberPacking(_: any, { worksheetDetailName, inventoryItemId }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await undoSerialNumberPacking(tx, domain, user, worksheetDetailName, inventoryItemId)
+  }
+}
+
+async function undoSerialNumberPacking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inventoryItemId: string
+): Promise<void> {
+  const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+  await worksheetController.undoSerialNumberPacking(worksheetDetailName, inventoryItemId)
+}

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

@@ -20,164 +20,186 @@ import { fetchExecutingWorksheet } from '../../../utils'
 
 export const packingWorksheetResolver = {
   async packingWorksheet(_: any, { releaseGoodNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: {
-        domain,
-        name: releaseGoodNo
-      },
-      relations: ['bizplace', 'bizplace.domain']
-    })
-
-    // Find Release Order based on Bin
-    if (!releaseGood) {
-      const binLocation: Location = await tx.getRepository(Location).findOne({
-        where: { domain, name: releaseGoodNo }
+    try {
+      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: {
+          domain,
+          name: releaseGoodNo
+        },
+        relations: ['bizplace', 'bizplace.domain']
       })
 
-      const qb: SelectQueryBuilder<OrderInventory> = tx
-        .getRepository(OrderInventory)
-        .createQueryBuilder('orderInventory')
-      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
-        .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.PACKING, ORDER_INVENTORY_STATUS.PACKED]
+      // Find Release Order based on Bin
+      if (!releaseGood) {
+        const binLocation: Location = await tx.getRepository(Location).findOne({
+          where: { domain, name: releaseGoodNo }
         })
-        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
-        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.PACKING })
 
-      const orderInventoryByBin = await qb.getOne()
-      if (orderInventoryByBin?.releaseGood) {
-        releaseGoodNo = orderInventoryByBin.releaseGood.name
-        releaseGood = orderInventoryByBin.releaseGood
+        if (binLocation) {
+          const qb: SelectQueryBuilder<OrderInventory> = tx
+            .getRepository(OrderInventory)
+            .createQueryBuilder('orderInventory')
+
+          qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+            .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
+            .innerJoinAndSelect('bizplace.domain', 'domain')
+            .innerJoinAndSelect(
+              'worksheets',
+              'ws',
+              `orderInventory.release_good_id = ws.release_good_id AND ws.type = 'PACKING' AND ws.status = 'EXECUTING'`
+            )
+            .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
+            .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
+              orderInventoryStatus: [
+                ORDER_INVENTORY_STATUS.READY_TO_PACK,
+                ORDER_INVENTORY_STATUS.PACKING,
+                ORDER_INVENTORY_STATUS.PACKED
+              ]
+            })
+            .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+            .andWhere('releaseGood.status IN (:...status)', {
+              status: [ORDER_STATUS.READY_TO_PACK, ORDER_STATUS.PACKING]
+            })
+
+          const orderInventoryByBin = await qb.getOne()
+          if (orderInventoryByBin?.releaseGood) {
+            releaseGoodNo = orderInventoryByBin.releaseGood.name
+            releaseGood = orderInventoryByBin.releaseGood
+          } else {
+            throw new Error(`Bin do not have any existing order.`)
+          }
+        }
       }
-    }
 
-    if (!releaseGood) throw new Error(`Release good dosen't exist.`)
-
-    const worksheet: Worksheet = await fetchExecutingWorksheet(
-      domain,
-      releaseGood.bizplace,
-      [
-        'bizplace',
-        'bizplace.domain',
-        'releaseGood',
-        'releaseGood.domain',
-        'worksheetDetails',
-        'worksheetDetails.targetInventory',
-        'worksheetDetails.targetInventory.binLocation',
-        'worksheetDetails.targetInventory.inventory',
-        'worksheetDetails.targetInventory.inventory.location',
-        'worksheetDetails.targetInventory.inventory.product',
-        'worksheetDetails.targetInventory.inventory.product.productDetails',
-        'worksheetDetails.toLocation'
-      ],
-      WORKSHEET_TYPE.PACKING,
-      releaseGood
-    )
-
-    let marketplaceOrder: MarketplaceOrder
-    let marketplaceOrderItems: MarketplaceOrderItem[] = []
-    let marketplaceStore
-    let trackingNo: string
-    let shippingProvider: string
-    let marketplaceStatus: string
-
-    if (releaseGood.type === 'b2c') {
-      const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-        domain: worksheet.bizplace.domain,
-        status: SellercraftStatus.ACTIVE
-      })
+      if (!releaseGood) throw new Error(`Release good do not exist.`)
 
-      if (sellercraft) {
-        if (!releaseGood?.airwayBill) {
-          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-          releaseGood = await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
-        }
-        trackingNo = releaseGood?.trackingNo
-        shippingProvider = releaseGood?.transporter
-        marketplaceStatus = releaseGood?.marketplaceOrderStatus
-      } else {
-        marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-          where: { orderNo: releaseGood.refNo },
-          relations: [
-            'domain',
-            'marketplaceStore',
-            'marketplaceOrderItems',
-            'marketplaceOrderItems.marketplaceOrderShippingItems',
-            'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
-          ]
+      const worksheet: Worksheet = await fetchExecutingWorksheet(
+        domain,
+        releaseGood.bizplace,
+        [
+          'bizplace',
+          'bizplace.domain',
+          'releaseGood',
+          'releaseGood.domain',
+          'worksheetDetails',
+          'worksheetDetails.targetInventory',
+          'worksheetDetails.targetInventory.binLocation',
+          'worksheetDetails.targetInventory.inventory',
+          'worksheetDetails.targetInventory.inventory.location',
+          'worksheetDetails.targetInventory.inventory.product',
+          'worksheetDetails.targetInventory.inventory.product.productDetails',
+          'worksheetDetails.toLocation'
+        ],
+        WORKSHEET_TYPE.PACKING,
+        releaseGood
+      )
+
+      let marketplaceOrder: MarketplaceOrder
+      let marketplaceOrderItems: MarketplaceOrderItem[] = []
+      let marketplaceStore
+      let trackingNo: string
+      let shippingProvider: string
+      let marketplaceStatus: string
+
+      if (releaseGood.type === 'b2c') {
+        const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+          domain: worksheet.bizplace.domain,
+          status: SellercraftStatus.ACTIVE
         })
 
-        if (!marketplaceOrder) {
-          throw new Error('Failed to retrieve ecommerce information, kindly contact our support team for this issue.')
-        }
-
-        let marketplaceOrderShipping: MarketplaceOrderShipping
-        if (marketplaceOrder.isSplitted) {
-          marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
-            where: { subOrderNoRef: worksheet.releaseGood.refNo2 }
-          })
+        if (sellercraft) {
+          if (!releaseGood?.airwayBill) {
+            const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+            releaseGood = await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+          }
+          trackingNo = releaseGood?.trackingNo
+          shippingProvider = releaseGood?.transporter
+          marketplaceStatus = releaseGood?.marketplaceOrderStatus
         } else {
-          marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
-            where: { orderNoRef: worksheet.releaseGood.refNo }
+          marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+            where: { orderNo: releaseGood.refNo },
+            relations: [
+              'domain',
+              'marketplaceStore',
+              'marketplaceOrderItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+            ]
           })
-        }
 
-        trackingNo = marketplaceOrderShipping.ownTrackingNo
-          ? marketplaceOrderShipping.ownTrackingNo
-          : marketplaceOrderShipping.trackingNo
-        shippingProvider = marketplaceOrderShipping.ownTransporter
-          ? marketplaceOrderShipping.ownTransporter
-          : marketplaceOrderShipping.transporter
-
-        marketplaceStore = marketplaceOrder?.marketplaceStore
-        marketplaceStatus = marketplaceOrder?.status
+          if (!marketplaceOrder) {
+            throw new Error('Failed to retrieve ecommerce information, kindly contact our support team for this issue.')
+          }
+
+          let marketplaceOrderShipping: MarketplaceOrderShipping
+          if (marketplaceOrder.isSplitted) {
+            marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+              where: { subOrderNoRef: worksheet.releaseGood.refNo2 }
+            })
+          } else {
+            marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+              where: { orderNoRef: worksheet.releaseGood.refNo }
+            })
+          }
+
+          trackingNo = marketplaceOrderShipping.ownTrackingNo
+            ? marketplaceOrderShipping.ownTrackingNo
+            : marketplaceOrderShipping.trackingNo
+          shippingProvider = marketplaceOrderShipping.ownTransporter
+            ? marketplaceOrderShipping.ownTransporter
+            : marketplaceOrderShipping.transporter
+
+          marketplaceStore = marketplaceOrder?.marketplaceStore
+          marketplaceStatus = marketplaceOrder?.status
+        }
       }
-    }
 
-    return {
-      worksheetInfo: {
-        releaseGood,
-        bizplaceName: releaseGood.bizplace.name,
-        refNo: releaseGood.refNo,
-        refNo2: releaseGood.refNo2,
-        refNo3: releaseGood.refNo3,
-        partnerDomainId: releaseGood.bizplace?.domain.id,
-        startedAt: worksheet.startedAt,
-        shippingProvider: shippingProvider ? shippingProvider : '',
-        trackingNo: trackingNo ? trackingNo : '',
-        airwayBill: releaseGood?.airwayBill,
-        invoice: releaseGood?.invoice,
-        platform: marketplaceOrder ? marketplaceOrder.marketplaceStore.platform : 'operato',
-        marketplaceStoreId: marketplaceOrder ? marketplaceOrder.marketplaceStore.id : '',
-        marketplaceStatus: marketplaceStatus ? marketplaceStatus : '',
-        marketplaceOrder: marketplaceOrder ? marketplaceOrder : ''
-      },
-      worksheetDetailInfos: worksheet.worksheetDetails.map(async (packingWSD: WorksheetDetail) => {
-        const targetInventory: OrderInventory = packingWSD.targetInventory
-        const inventory: Inventory = targetInventory.inventory
-        return {
-          name: packingWSD.name,
-          palletId: inventory.palletId,
-          cartonId: inventory.cartonId,
-          batchId: inventory.batchId,
-          batchIdRef: inventory.batchIdRef,
-          product: inventory.product,
-          sku: inventory.product.sku,
-          releaseQty: targetInventory.releaseQty,
-          packedQty: targetInventory.packedQty,
-          status: packingWSD.status,
-          description: packingWSD.description,
-          targetName: targetInventory.name,
-          packingType: inventory.packingType,
-          packingSize: inventory.packingSize,
-          binLocation: targetInventory?.binLocation,
-          location: inventory.location
-        }
-      })
+      return {
+        worksheetInfo: {
+          releaseGood,
+          bizplaceName: releaseGood.bizplace.name,
+          refNo: releaseGood.refNo,
+          refNo2: releaseGood.refNo2,
+          refNo3: releaseGood.refNo3,
+          partnerDomainId: releaseGood.bizplace?.domain.id,
+          startedAt: worksheet.startedAt,
+          shippingProvider: shippingProvider ? shippingProvider : '',
+          trackingNo: trackingNo ? trackingNo : '',
+          airwayBill: releaseGood?.airwayBill,
+          invoice: releaseGood?.invoice,
+          platform: marketplaceOrder ? marketplaceOrder.marketplaceStore.platform : 'operato',
+          marketplaceStoreId: marketplaceOrder ? marketplaceOrder.marketplaceStore.id : '',
+          marketplaceStatus: marketplaceStatus ? marketplaceStatus : '',
+          marketplaceOrder: marketplaceOrder ? marketplaceOrder : ''
+        },
+        worksheetDetailInfos: worksheet.worksheetDetails.map(async (packingWSD: WorksheetDetail) => {
+          const targetInventory: OrderInventory = packingWSD.targetInventory
+          const inventory: Inventory = targetInventory.inventory
+          return {
+            name: packingWSD.name,
+            palletId: inventory.palletId,
+            cartonId: inventory.cartonId,
+            batchId: inventory.batchId,
+            batchIdRef: inventory.batchIdRef,
+            product: inventory.product,
+            sku: inventory.product.sku,
+            releaseQty: targetInventory.releaseQty,
+            packedQty: targetInventory.packedQty,
+            status: packingWSD.status,
+            description: packingWSD.description,
+            targetName: targetInventory.name,
+            packingType: inventory.packingType,
+            packingSize: inventory.packingSize,
+            binLocation: targetInventory?.binLocation,
+            location: inventory.location,
+            relatedOrderInv: targetInventory
+          }
+        })
+      }
+    } catch (error) {
+      console.error(error)
+      throw error
     }
   }
 }

package/server/graphql/resolvers/worksheet/picking/assign-picking-worker.ts

@@ -7,7 +7,7 @@ import { Worksheet } from '../../../../entities'
 export const assignPickingWorkerResolver = {
   async assignPickingWorker(
     _parentObj: void,
-    { worksheetId, userId }: { worksheetId: string; userId: string },
+    { worksheetId, userId }: { worksheetId: [string]; userId: string },
     context: any
   ): Promise<void> {
     const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
@@ -17,16 +17,20 @@ export const assignPickingWorkerResolver = {
 
     if (!assignee) throw new Error('failed to find target user')
 
-    const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-      id: worksheetId,
-      type: WORKSHEET_TYPE.PICKING
-    })
+    await Promise.all(worksheetId.map(async (worksheetId)=>{
+      const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+        id: worksheetId,
+      },{where: [{
+        type:WORKSHEET_TYPE.BATCH_PICKING
+      },{type:WORKSHEET_TYPE.PICKING}]})
+  
+      if (!worksheet) throw new Error('failed to find target picking worksheet')
+      if (worksheet.status !== WORKSHEET_STATUS.DEACTIVATED)
+        throw new Error(`current status of worksheet is not able to assign worker`)
+  
+      worksheet.assignee = assignee
+      await tx.getRepository(Worksheet).save(worksheet)
 
-    if (!worksheet) throw new Error('failed to find target picking worksheet')
-    if (worksheet.status !== WORKSHEET_STATUS.DEACTIVATED)
-      throw new Error(`current status of worksheet is not able to assign worker`)
-
-    worksheet.assignee = assignee
-    await tx.getRepository(Worksheet).save(worksheet)
+    }))
   }
 }

package/server/graphql/resolvers/worksheet/picking/picking-assignment-status-by-user.ts

@@ -1,5 +1,4 @@
 import { getDomainUsers, User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
 import { Domain } from '@things-factory/shell'
 import { FindManyOptions, getRepository, ILike, In } from 'typeorm'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
@@ -10,7 +9,7 @@ type AssignmentStatusByUserType = { user: User; pending?: Worksheet[]; picking?:
 export const pickingAssignmentStatusByUsersResolver = {
   async pickingAssignmentStatusByUsers(
     _: void,
-    { bizplaceId, name, email }: { bizplaceId: string; name?: string; email?: string },
+    { name, email }: { name?: string; email?: string },
     context: any
   ): Promise<AssignmentStatusByUserType[]> {
     const { domain }: { domain: Domain } = context.state
@@ -19,20 +18,19 @@ export const pickingAssignmentStatusByUsersResolver = {
     const domainUserIds: string[] = domainUsers
       .filter((user: User) => user.userType === 'user')
       .map((user: User) => user.id)
+
     const findOneOption: FindManyOptions<User> = { where: { id: In(domainUserIds) } }
     if (name) findOneOption.where.name = ILike(`%${name}%`)
     if (email) findOneOption.where.email = ILike(`%${email}%`)
 
     const users: User[] = await getRepository(User).find(findOneOption)
 
-    const bizplace: Bizplace = await getRepository(Bizplace).findOne(bizplaceId)
     const assignedPickingWorksheets: Worksheet[] = await getRepository(Worksheet).find({
       where: {
-        domain,
-        bizplace,
-        type: WORKSHEET_TYPE.PICKING,
+        type: In([WORKSHEET_TYPE.PICKING, WORKSHEET_TYPE.BATCH_PICKING]),
         status: In([WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]),
-        assignee: In(users.map((u: User) => u.id))
+        assignee: In(users.map((u: User) => u.id)),
+        domain
       },
       relations: ['assignee']
     })

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

@@ -4,9 +4,9 @@ import { EntityManager } from 'typeorm'
 import { SortingWorksheetController } from '../../../../controllers'
 
 export const scanProductSortingResolver = {
-  async scanProductSorting(_: any, { taskNo, releaseGoodNo, productBarcode }, context: any) {
+  async scanProductSorting(_: any, { taskNo, releaseGoodNo, productBarcode, serialNumber }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await scanProductSorting(tx, domain, user, taskNo, releaseGoodNo, productBarcode)
+    await scanProductSorting(tx, domain, user, taskNo, releaseGoodNo, productBarcode, serialNumber)
   }
 }
 
@@ -16,8 +16,9 @@ export async function scanProductSorting(
   user: User,
   taskNo: string,
   releaseGoodNo: string,
-  productBarcode?: string
+  productBarcode?: string,
+  serialNumber?: string
 ) {
   const worksheetController: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  await worksheetController.scanProductSorting(taskNo, releaseGoodNo, productBarcode)
+  await worksheetController.scanProductSorting(taskNo, releaseGoodNo, productBarcode, serialNumber)
 }

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

@@ -4,9 +4,9 @@ import { EntityManager } from 'typeorm'
 import { SortingWorksheetController } from '../../../../controllers'
 
 export const sortingProductResolver = {
-  async sortingProduct(_: any, { taskNo, releaseGoodNo, productId, sortingQty }, context: any) {
+  async sortingProduct(_: any, { taskNo, releaseGoodNo, productId, sortingQty, serialNumber }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await sortingProduct(tx, domain, user, taskNo, releaseGoodNo, productId, sortingQty)
+    await sortingProduct(tx, domain, user, taskNo, releaseGoodNo, productId, sortingQty, serialNumber)
   }
 }
 
@@ -17,8 +17,9 @@ export async function sortingProduct(
   taskNo: string,
   releaseGoodNo: string,
   productId: string,
-  sortingQty: number
+  sortingQty: number,
+  serialNumber?: string
 ) {
   const worksheetController: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  await worksheetController.sortingProduct(taskNo, releaseGoodNo, productId, sortingQty)
+  await worksheetController.sortingProduct(taskNo, releaseGoodNo, productId, sortingQty, serialNumber)
 }

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

@@ -26,22 +26,26 @@ export const sortingWorksheetResolver = {
     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')
@@ -67,12 +71,14 @@ export const sortingWorksheetResolver = {
           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-detail/generate-batch-picking-worksheet-details-by-bulk.ts

@@ -1,20 +1,19 @@
-import { Product } from '@things-factory/product-base'
-import { OrderInventory, OrderNoGenerator, ORDER_INVENTORY_STATUS, ORDER_TYPES } from '@things-factory/sales-base'
-import { Inventory } from '@things-factory/warehouse-base'
+import { EntityManager, getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { ORDER_INVENTORY_STATUS, ORDER_TYPES, OrderInventory, OrderNoGenerator } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
-import { EntityManager, In, getRepository } from 'typeorm'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
-import { WorksheetNoGenerator, inventoriesByStrategy } from '../../../utils'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { generateBatchPickingWorksheetDetailsResolver } from './generate-batch-picking-worksheet-details'
-import orderBy from 'lodash/orderBy'
+import { inventoriesByStrategy, WorksheetNoGenerator } from '../../../utils'
 
 export const generateBatchPickingWorksheetDetailsByBulkResolver = {
   async generateBatchPickingWorksheetDetailsByBulk(
     _: any,
-    { worksheetId, bizplaceId, selectedItems, pickingStrategy },
+    { worksheetId, bizplaceId, selectedItems },
     context: any
   ): Promise<Boolean> {
     const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
@@ -50,7 +49,7 @@ export const generateBatchPickingWorksheetDetailsByBulkResolver = {
       })
 
       await Promise.all(
-        selectedItems.map(async (oi: OrderInventory) => {
+        selectedItems.map(async (oi: OrderInventory & { pickingStrategy: string }) => {
           try {
             let pOrderInventories = tx.getRepository(OrderInventory).find({
               where: {
@@ -72,7 +71,6 @@ export const generateBatchPickingWorksheetDetailsByBulkResolver = {
                 ...oi,
                 worksheetId: worksheet.id,
                 bizplaceId,
-                pickingStrategy,
                 locationSortingRules: inventoryAssignmentSetting ? JSON.parse(inventoryAssignmentSetting.value) : false
               },
               domain,