@things-factory/worksheet-base 4.3.753 → 4.3.755

package/server/controllers/render-ro-do.ts

@@ -1,46 +1,27 @@
 import FormData from 'form-data'
 import fetch from 'node-fetch'
-import {
-  EntityManager,
-  getManager,
-  getRepository
-} from 'typeorm'
+import { EntityManager, getManager, getRepository, In } from 'typeorm'
 
-import {
-  Attachment,
-  STORAGE
-} from '@things-factory/attachment-base'
-import {
-  Partner,
-  User
-} from '@things-factory/auth-base'
-import {
-  Bizplace,
-  ContactPoint
-} from '@things-factory/biz-base'
+import { Attachment, STORAGE } from '@things-factory/attachment-base'
+import { Partner, User } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
 import { config } from '@things-factory/env'
 import { ProductDetail } from '@things-factory/product-base'
 import {
   DeliveryOrder,
   ORDER_STATUS,
   OrderInventory,
-  ReleaseGood, OrderProduct
+  OrderTote,
+  OrderToteItem,
+  OrderToteSeal,
+  ReleaseGood,
+  OrderProduct
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import {
-  Inventory,
-  Pallet
-} from '@things-factory/warehouse-base'
+import { Inventory, Pallet } from '@things-factory/warehouse-base'
 
-import {
-  TEMPLATE_TYPE,
-  WORKSHEET_STATUS,
-  WORKSHEET_TYPE
-} from '../constants'
-import {
-  Worksheet,
-  WorksheetDetail
-} from '../entities'
+import { TEMPLATE_TYPE, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../constants'
+import { Worksheet, WorksheetDetail } from '../entities'
 import { DateTimeConverter } from '../utils/datetime-util'
 
 const REPORT_API_URL = config.get('reportApiUrl', 'http://localhost:8888/rest/report/show_html')
@@ -166,6 +147,55 @@ export async function renderRODO({ doNo }, context: any) {
 
   const foundWSD: WorksheetDetail[] = await wdQb.getMany()
 
+  // Find order tote items linked to the order inventories in this DO
+  const foundOrderToteItems: OrderToteItem[] =
+    orderInvIds.length > 0
+      ? await getRepository(OrderToteItem).find({
+          where: {
+            domain,
+            orderInventory: In(orderInvIds)
+          },
+          relations: [
+            'orderTote',
+            'orderTote.tote',
+            'orderTote.orderToteSeals',
+            'orderInventory',
+            'orderInventory.product'
+          ]
+        })
+      : []
+
+  // Create a map of orderInventoryId -> OrderToteItem[] for quick lookup (multiple items can be in same tote)
+  const toteItemMap = new Map<string, OrderToteItem[]>()
+  foundOrderToteItems.forEach(item => {
+    if (item.orderInventory?.id) {
+      const existing = toteItemMap.get(item.orderInventory.id) || []
+      existing.push(item)
+      toteItemMap.set(item.orderInventory.id, existing)
+    }
+  })
+
+  // Extract unique order totes from order tote items (eliminates separate query)
+  const uniqueOrderTotes: OrderTote[] = [
+    ...new Map(
+      foundOrderToteItems
+        .filter(item => item.orderTote?.id)
+        .map(item => [item.orderTote.id, item.orderTote])
+    ).values()
+  ]
+
+  // Create a map of tote name -> count for total tote qty calculation
+  const toteCountMap = new Map<string, number>()
+  uniqueOrderTotes.forEach(tote => {
+    const toteName = tote.tote?.name || tote.name
+    if (toteName) {
+      toteCountMap.set(toteName, (toteCountMap.get(toteName) || 0) + 1)
+    }
+  })
+
+  // Calculate total tote qty
+  const totalToteQty = uniqueOrderTotes.length
+
   const foundTemplate: Attachment = await getRepository(Attachment).findOne({
     where: { domain, category: TEMPLATE_TYPE.DO_TEMPLATE }
   })
@@ -196,8 +226,15 @@ export async function renderRODO({ doNo }, context: any) {
   }
 
   let productList: any[] = []
-  productList = foundWSD
-    .map((wsd: WorksheetDetail) => {
+
+  // Check if there are totes - if yes, group by tote; if no, use original logic
+  const hasTotes = uniqueOrderTotes.length > 0 && foundOrderToteItems.length > 0
+
+  if (hasTotes) {
+    // Group products by tote
+    const toteProductMap = new Map<string, any[]>()
+
+    foundWSD.forEach((wsd: WorksheetDetail) => {
       const targetInventory: OrderInventory = wsd.targetInventory
       const inventory: Inventory = targetInventory.inventory
       const productDetails: ProductDetail[] = inventory.product.productDetails
@@ -205,110 +242,281 @@ export async function renderRODO({ doNo }, context: any) {
       const matchedProductDetail: ProductDetail = productDetails.find(
         productDetail => productDetail.packingType === inventory.packingType
       )
-      return {
-        product_name:
-          wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
-            ? `${inventory.product.name} (${inventory.product.description})`
-            : `${wsd.targetInventory.product.name} (${wsd.targetInventory.product.description})`,
-        product_desc:
-          wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
-            ? `${inventory.product?.description || ''}`
-            : `${wsd.targetInventory.product.description || ''}`,
-        product_nameOnly:
-          wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
-            ? `${inventory.product.name}`
-            : `${wsd.targetInventory.product.name}`,
-        product_sku:
+
+      // Get tote information for this order inventory
+      const toteItems = toteItemMap.get(targetInventory.id) || []
+
+      if (toteItems.length > 0) {
+        // Group by tote name
+        toteItems.forEach(toteItem => {
+          const toteName = toteItem.orderTote?.tote?.name || toteItem.orderTote?.name || ''
+
+          if (!toteProductMap.has(toteName)) {
+            toteProductMap.set(toteName, [])
+          }
+
+          const productSku =
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? inventory.product.sku
+              : wsd.targetInventory.product.sku
+          const productName =
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? `${inventory.product.name} (${inventory.product.description})`
+              : `${wsd.targetInventory.product.name} (${wsd.targetInventory.product.description})`
+
+          toteProductMap.get(toteName).push({
+            tote_name: toteName,
+            product_sku: productSku,
+            product_name: productName,
+            product_qty: toteItem.qty || targetInventory.releaseQty,
+            product_type: inventory.packingType,
+            targetInventoryId: targetInventory.id,
+            wsd: wsd,
+            inventory: inventory,
+            productDetails: productDetails,
+            orderProduct: orderProduct,
+            matchedProductDetail: matchedProductDetail
+          })
+        })
+      } else {
+        // No tote assigned - add to a special "NO_TOTE" group
+        const toteName = 'NO_TOTE'
+        if (!toteProductMap.has(toteName)) {
+          toteProductMap.set(toteName, [])
+        }
+
+        const productSku =
           wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
-            ? `${inventory.product.sku}`
-            : `${wsd.targetInventory.product.sku}`,
-        product_type: inventory.packingType,
-        product_size: matchedProductDetail ? matchedProductDetail.packingSize : inventory.packingSize,
-        product_batch: inventory.batchId,
-        product_volume: matchedProductDetail ? matchedProductDetail.volume : 0,
-        product_batch_ref: inventory.batchIdRef,
-        product_qty: targetInventory.releaseQty,
-        product_weight: targetInventory.releaseWeight,
-        product_gross_weight: inventory.product.grossWeight,
-        product_uom_value: targetInventory.releaseUomValue,
-        product_uom: inventory.uom,
-        product_brand_sku:
+            ? inventory.product.sku
+            : wsd.targetInventory.product.sku
+        const productName =
           wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
-            ? `${inventory.product?.brandSku || ''}`
-            : `${wsd.targetInventory.product?.brandSku || ''}`,
-        remark: targetInventory.remark,
-        inventory_remark: inventory.remark,
-        cross_docking: targetInventory.crossDocking,
-        pallet: inventory?.reusablePallet && inventory?.reusablePallet?.name ? inventory.reusablePallet.name : '',
-        avgSellingPrice:
-          orderProduct?.sellingPrice > 0 && orderProduct?.releaseQty > 0
-            ? orderProduct?.sellingPrice / orderProduct?.releaseQty
-            : 0,
-        expiry_date: inventory?.expirationDate ? inventory?.expirationDate : ''
+            ? `${inventory.product.name} (${inventory.product.description})`
+            : `${wsd.targetInventory.product.name} (${wsd.targetInventory.product.description})`
+
+        toteProductMap.get(toteName).push({
+          tote_name: '',
+          product_sku: productSku,
+          product_name: productName,
+          product_qty: targetInventory.releaseQty,
+          product_type: inventory.packingType,
+          targetInventoryId: targetInventory.id,
+          wsd: wsd,
+          inventory: inventory,
+          productDetails: productDetails,
+          orderProduct: orderProduct,
+          matchedProductDetail: matchedProductDetail
+        })
       }
     })
-    .reduce((newItem, item) => {
-      var foundItem = newItem.find(
-        newItem =>
-          newItem.product_sku === item.product_sku &&
-          newItem.product_name === item.product_name &&
-          newItem.product_type === item.product_type &&
-          newItem.product_batch === item.product_batch &&
-          newItem.product_batch_ref === item.product_batch_ref &&
-          newItem.cross_docking === item.cross_docking &&
-          newItem.pallet === item.pallet
-      )
-      if (!foundItem) {
-        foundItem = {
-          product_sku: item.product_sku,
-          product_name: item.product_name,
-          product_type: item.product_type,
-          product_size: item.product_size,
-          product_batch: item.product_batch,
-          product_batch_ref: item.product_batch_ref,
-          product_qty: item.product_qty,
-          product_weight: item.product_weight,
-          product_gross_weight: item.product_gross_weight,
-          product_uom_value: item.product_uom_value,
-          product_uom: item.product_uom,
-          product_desc: item.product_desc,
-          product_nameOnly: item.product_nameOnly,
-          product_brand_sku: item.product_brand_sku,
-          remark: item.remark,
-          inventory_remark: item.inventory_remark,
-          expiry_date: item.expiry_date,
-          palletQty: 1,
-          cross_docking: item.cross_docking,
-          pallet: item.pallet,
-          avgSellingPrice: item.avgSellingPrice,
-          product_volume: item.product_volume,
+
+    // Process each tote group
+    toteProductMap.forEach((products, toteName) => {
+      // Group products within each tote by sku, name, type
+      const groupedProducts = new Map<string, any>()
+
+      products.forEach(product => {
+        const key = `${product.product_sku}_${product.product_name}_${product.product_type}`
+
+        if (!groupedProducts.has(key)) {
+          groupedProducts.set(key, {
+            tote_name: product.tote_name,
+            product_sku: product.product_sku,
+            product_name: product.product_name,
+            product_qty: 0,
+            product_type: product.product_type,
+            no_of_tote: 0, // Count of items of this product in this tote
+            wsd: product.wsd,
+            inventory: product.inventory,
+            productDetails: product.productDetails,
+            orderProduct: product.orderProduct,
+            matchedProductDetail: product.matchedProductDetail
+          })
         }
 
-        newItem.push(foundItem)
-        return newItem
-      } else {
-        return newItem.map(ni => {
-          if (
-            ni.product_sku === item.product_sku &&
-            ni.product_name === item.product_name &&
-            ni.product_batch === item.product_batch &&
-            ni.product_batch_ref === item.product_batch_ref &&
-            ni.cross_docking === item.cross_docking &&
-            ni.pallet === item.pallet
-          ) {
-            return {
-              ...ni,
-              palletQty: ni.palletQty + 1,
-              product_qty: ni.product_qty + item.product_qty,
-              product_weight: ni.product_weight + item.product_weight,
-              product_uom_value: ni.product_uom_value + item.product_uom_value
-            }
-          } else {
-            return ni
-          }
+        const existing = groupedProducts.get(key)
+        existing.product_qty += product.product_qty
+        existing.no_of_tote += 1 // Increment count for each occurrence in this tote
+      })
+
+      // Add grouped products to productList
+      groupedProducts.forEach(product => {
+        const wsd = product.wsd
+        const inventory = product.inventory
+        const productDetails = product.productDetails
+        const orderProduct = product.orderProduct
+        const matchedProductDetail = product.matchedProductDetail
+        const targetInventory = wsd.targetInventory
+
+        productList.push({
+          tote_name: product.tote_name,
+          product_sku: product.product_sku,
+          product_name: product.product_name,
+          product_qty: product.product_qty,
+          product_type: product.product_type,
+          no_of_tote: product.no_of_tote,
+          product_desc:
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? `${inventory.product?.description || ''}`
+              : `${wsd.targetInventory.product.description || ''}`,
+          product_nameOnly:
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? `${inventory.product.name}`
+              : `${wsd.targetInventory.product.name}`,
+          product_size: matchedProductDetail ? matchedProductDetail.packingSize : inventory.packingSize,
+          product_batch: inventory.batchId,
+          product_volume: matchedProductDetail ? matchedProductDetail.volume : 0,
+          product_batch_ref: inventory.batchIdRef,
+          product_weight: targetInventory.releaseWeight,
+          product_gross_weight: inventory.product.grossWeight,
+          product_uom_value: targetInventory.releaseUomValue,
+          product_uom: inventory.uom,
+          product_brand_sku:
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? `${inventory.product?.brandSku || ''}`
+              : `${wsd.targetInventory.product?.brandSku || ''}`,
+          remark: targetInventory.remark,
+          inventory_remark: inventory.remark,
+          cross_docking: targetInventory.crossDocking,
+          pallet: inventory?.reusablePallet && inventory?.reusablePallet?.name ? inventory.reusablePallet.name : '',
+          avgSellingPrice:
+            orderProduct?.sellingPrice > 0 && orderProduct?.releaseQty > 0
+              ? orderProduct?.sellingPrice / orderProduct?.releaseQty
+              : 0,
+          expiry_date: inventory?.expirationDate ? inventory?.expirationDate : ''
         })
+      })
+    })
+  } else {
+    // Original logic when no totes
+    productList = foundWSD
+      .map((wsd: WorksheetDetail) => {
+        const targetInventory: OrderInventory = wsd.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+        const productDetails: ProductDetail[] = inventory.product.productDetails
+        const orderProduct: OrderProduct = targetInventory.orderProduct
+        const matchedProductDetail: ProductDetail = productDetails.find(
+          productDetail => productDetail.packingType === inventory.packingType
+        )
+        return {
+          product_name:
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? `${inventory.product.name} (${inventory.product.description})`
+              : `${wsd.targetInventory.product.name} (${wsd.targetInventory.product.description})`,
+          product_desc:
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? `${inventory.product?.description || ''}`
+              : `${wsd.targetInventory.product.description || ''}`,
+          product_nameOnly:
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? `${inventory.product.name}`
+              : `${wsd.targetInventory.product.name}`,
+          product_sku:
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? `${inventory.product.sku}`
+              : `${wsd.targetInventory.product.sku}`,
+          product_type: inventory.packingType,
+          product_size: matchedProductDetail ? matchedProductDetail.packingSize : inventory.packingSize,
+          product_batch: inventory.batchId,
+          product_volume: matchedProductDetail ? matchedProductDetail.volume : 0,
+          product_batch_ref: inventory.batchIdRef,
+          product_qty: targetInventory.releaseQty,
+          product_weight: targetInventory.releaseWeight,
+          product_gross_weight: inventory.product.grossWeight,
+          product_uom_value: targetInventory.releaseUomValue,
+          product_uom: inventory.uom,
+          product_brand_sku:
+            wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+              ? `${inventory.product?.brandSku || ''}`
+              : `${wsd.targetInventory.product?.brandSku || ''}`,
+          remark: targetInventory.remark,
+          inventory_remark: inventory.remark,
+          cross_docking: targetInventory.crossDocking,
+          pallet: inventory?.reusablePallet && inventory?.reusablePallet?.name ? inventory.reusablePallet.name : '',
+          avgSellingPrice:
+            orderProduct?.sellingPrice > 0 && orderProduct?.releaseQty > 0
+              ? orderProduct?.sellingPrice / orderProduct?.releaseQty
+              : 0,
+          expiry_date: inventory?.expirationDate ? inventory?.expirationDate : ''
+        }
+      })
+      .reduce((newItem, item) => {
+        var foundItem = newItem.find(
+          newItem =>
+            newItem.product_sku === item.product_sku &&
+            newItem.product_name === item.product_name &&
+            newItem.product_type === item.product_type &&
+            newItem.product_batch === item.product_batch &&
+            newItem.product_batch_ref === item.product_batch_ref &&
+            newItem.cross_docking === item.cross_docking &&
+            newItem.pallet === item.pallet
+        )
+        if (!foundItem) {
+          foundItem = {
+            product_sku: item.product_sku,
+            product_name: item.product_name,
+            product_type: item.product_type,
+            product_size: item.product_size,
+            product_batch: item.product_batch,
+            product_batch_ref: item.product_batch_ref,
+            product_qty: item.product_qty,
+            product_weight: item.product_weight,
+            product_gross_weight: item.product_gross_weight,
+            product_uom_value: item.product_uom_value,
+            product_uom: item.product_uom,
+            product_desc: item.product_desc,
+            product_nameOnly: item.product_nameOnly,
+            product_brand_sku: item.product_brand_sku,
+            remark: item.remark,
+            inventory_remark: item.inventory_remark,
+            expiry_date: item.expiry_date,
+            palletQty: 1,
+            cross_docking: item.cross_docking,
+            pallet: item.pallet,
+            avgSellingPrice: item.avgSellingPrice,
+            product_volume: item.product_volume
+          }
+
+          newItem.push(foundItem)
+          return newItem
+        } else {
+          return newItem.map(ni => {
+            if (
+              ni.product_sku === item.product_sku &&
+              ni.product_name === item.product_name &&
+              ni.product_batch === item.product_batch &&
+              ni.product_batch_ref === item.product_batch_ref &&
+              ni.cross_docking === item.cross_docking &&
+              ni.pallet === item.pallet
+            ) {
+              return {
+                ...ni,
+                palletQty: ni.palletQty + 1,
+                product_qty: ni.product_qty + item.product_qty,
+                product_weight: ni.product_weight + item.product_weight,
+                product_uom_value: ni.product_uom_value + item.product_uom_value
+              }
+            } else {
+              return ni
+            }
+          })
+        }
+      }, [])
+  }
+
+  // Sort productList by tote_name in ascending order if totes exist
+  if (hasTotes) {
+    productList.sort((a, b) => {
+      const toteNameA = (a.tote_name || '').trim()
+      const toteNameB = (b.tote_name || '').trim()
+
+      // Sort by tote_name first (ascending), then by product_sku (ascending)
+      if (toteNameA !== toteNameB) {
+        return toteNameA.localeCompare(toteNameB, undefined, { numeric: true, sensitivity: 'base' })
       }
-    }, [])
+      return (a.product_sku || '').localeCompare(b.product_sku || '', undefined, { numeric: true, sensitivity: 'base' })
+    })
+  }
 
   const data = {
     logo_url: logo,
@@ -440,7 +648,7 @@ export async function renderRODO({ doNo }, context: any) {
         product_uom_value: `${Math.round(prod.product_uom_value * 100) / 100} ${prod.product_uom}`,
         selling_price:
           prod?.avgSellingPrice > 0 ? parseFloat((prod?.avgSellingPrice * prod.product_qty).toFixed(2)) : 0,
-        product_volume: (Math.round(prod.product_volume * prod.product_qty * 10000)/10000).toFixed(4),
+        product_volume: (Math.round(prod.product_volume * prod.product_qty * 10000) / 10000).toFixed(4),
         remark: prod?.remark
           ? prod.remark
           : prod.cross_docking
@@ -453,16 +661,50 @@ export async function renderRODO({ doNo }, context: any) {
         inventory_remark: prod?.inventory_remark ? prod.inventory_remark : '',
         batch_id_ref: prod.product_batch_ref,
         product_serial_number:
-        foundInventoryItem.length === 0 || !foundInventoryItem.some(item => item.sku === prod.product_sku) ? '' 
-        : foundInventoryItem.filter(item => item.sku === prod.product_sku)
-        .map((item: any, idx) => item.serial_number)
-        .join(', '),
-          }
+          foundInventoryItem.length === 0 || !foundInventoryItem.some(item => item.sku === prod.product_sku)
+            ? ''
+            : foundInventoryItem
+                .filter(item => item.sku === prod.product_sku)
+                .map((item: any, idx) => item.serial_number)
+                .join(', ')
+      }
     }),
     serialNumber:
       foundInventoryItem.map((item: any, idx) => {
         return { ...item, delivery_to: foundDO.to }
-      }) || ''
+      }) || '',
+    order_tote_items: foundOrderToteItems.map(item => {
+      // Get product information from orderInventory or orderProduct
+      const productFromInventory = item.orderInventory?.product || item.orderInventory?.inventory?.product
+      const product = productFromInventory
+
+      // Get packingType from orderInventory.inventory or item itself
+      const packingType = item.orderInventory?.inventory?.packingType
+
+      // Get tote information
+      const toteName = item.orderTote?.tote?.name || item.orderTote?.name || ''
+
+      // Get seals for this tote and join by comma
+      const seals = item.orderTote?.orderToteSeals || []
+      const sealNames = seals.map((seal: OrderToteSeal) => seal.name).filter(Boolean)
+      const sealsString = sealNames.length > 0 ? sealNames.join(', ') : null
+
+      return {
+        id: item.id,
+        name: item.name,
+        tote_id: item.orderTote?.id,
+        tote_name: toteName,
+        order_tote_id: item.orderTote?.id,
+        product_qty: item.qty,
+        product_sku: product?.sku,
+        product_brand_sku: product?.brandSku,
+        product_name: product?.name,
+        product_type: packingType,
+        closed_date: item.orderTote?.closedAt,
+        seals: sealsString
+      }
+    }),
+    total_tote_qty: totalToteQty
   } //.. make data from do
   const formData = new FormData()
 

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

@@ -20,7 +20,9 @@ export const findSortingReleaseOrdersByTaskNoResolver = {
     const { domain, tx, user }: { domain: Domain; tx: EntityManager; user: User } = context.state
 
     let selectedReleaseGood = null
-    let ws = await tx.getRepository(WorksheetEntity).createQueryBuilder('ws')
+    let ws = await tx
+      .getRepository(WorksheetEntity)
+      .createQueryBuilder('ws')
       .addSelect('rg.name', 'release_good_name')
       .addSelect('rg.status', 'release_good_status')
       .innerJoin('worksheet_details', 'wd', `ws.id = wd.worksheet_id`)
@@ -36,7 +38,7 @@ export const findSortingReleaseOrdersByTaskNoResolver = {
 
     if (ws) {
       if (ws.release_good_status == 'LOADING' || ws.release_good_status == 'DONE') {
-        throw new Error(`Release Good already sorted`);
+        throw new Error(`Release Good already sorted`)
       }
 
       selectedReleaseGood = ws.release_good_name
@@ -60,7 +62,11 @@ export const findSortingReleaseOrdersByTaskNoResolver = {
           .createQueryBuilder('orderInventory')
 
         qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
-          .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
+          .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')
@@ -155,6 +161,46 @@ export const findSortingReleaseOrdersByTaskNoResolver = {
 
     const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
 
+    if (releaseGoods.length > 0) {
+      // Get counts for all release goods in a single query (avoids N+1 problem)
+      const releaseGoodIds = releaseGoods.map(rg => rg.id)
+      const countsResult = await tx
+        .getRepository(OrderInventoryEntity)
+        .createQueryBuilder('orderInventory')
+        .innerJoin(WorksheetDetailEntity, 'wsd', 'orderInventory.id = wsd.target_inventory_id')
+        .innerJoin(WorksheetEntity, 'ws', 'wsd.worksheet_id = ws.id')
+        .select('orderInventory.release_good_id', 'releaseGoodId')
+        .addSelect('COUNT(*)', 'total')
+        .addSelect(
+          'SUM(CASE WHEN orderInventory.sortedQty = orderInventory.releaseQty THEN 1 ELSE 0 END)',
+          'completed'
+        )
+        .where('orderInventory.release_good_id IN (:...releaseGoodIds)', { releaseGoodIds })
+        .andWhere('orderInventory.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 })
+        .groupBy('orderInventory.release_good_id')
+        .getRawMany()
+
+      // Build a map for quick lookup
+      const countsById = new Map(
+        countsResult.map(c => [
+          c.releaseGoodId,
+          { total: parseInt(c.total) || 0, completed: parseInt(c.completed) || 0 }
+        ])
+      )
+
+      // Assign itemCounts to each release good
+      for (const releaseGood of releaseGoods) {
+        const counts = countsById.get(releaseGood.id) || { total: 0, completed: 0 }
+        releaseGood['itemCounts'] = {
+          total: counts.total,
+          pending: counts.total - counts.completed
+        }
+      }
+    }
+
     return { releaseGoods, taskNo, selectedReleaseGood }
   }
 }

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

@@ -24,7 +24,7 @@ import { havingVasResolver } from './having-vas'
 import { Mutations as InspectMutations } from './inspecting'
 import { inventoriesByPalletResolver } from './inventories-by-pallet'
 import { loadedInventories } from './loaded-inventories'
-import { Mutations as LoadingMutations } from './loading'
+import { Mutations as LoadingMutations, Query as LoadingQuery } from './loading'
 import { loadingWorksheetResolver } from './loading-worksheet'
 import { notTallyTargetInventoriesResolver } from './not-tally-target-inventories'
 import { Mutations as PackingMutations } from './packing'
@@ -115,7 +115,8 @@ export const Query = {
   ...findSortingReleaseOrdersByTaskNoResolver,
   ...findReleaseOrdersByTaskNoResolver,
   ...fetchDeliveryOrderROResolver,
-  ...putawayReplenishmentWorksheetResolver
+  ...putawayReplenishmentWorksheetResolver,
+  ...LoadingQuery
 }
 
 export const Mutation = {