@things-factory/operato-wms 4.3.757 → 4.3.759

package/server/graphql/resolvers/outbound/load-by-qty.ts

@@ -65,97 +65,214 @@ export const loadByQty = {
 
       const updatedOrderInventories: OrderInventory[] = []
       for (const wsd of updatedWorksheetDetails) {
-        //find the respective wsd and oi to update
-        const foundWorksheetDetail: WorksheetDetail = worksheet.worksheetDetails.find(
-          foundWsd => foundWsd.name === wsd.name
-        )
-        let orderInventory = orderInventories.find(oi => oi.id === foundWorksheetDetail.targetInventory.id)
+        // Check if this is combined data with multiple order inventory references
+        // (from bin scan flow with combineSameProductsWithAllRefs)
+        if (wsd.allRelatedOrderInvs && wsd.allRelatedOrderInvs.length > 0) {
+          // Combined mode: distribute loadedQty across multiple order inventories (FIFO)
+          let remainingLoadQty = wsd.loadedQty
 
-        //validate oi status and do is not yet generated
-        if (orderInventory.status === ORDER_INVENTORY_STATUS.LOADED || orderInventory.deliveryOrderId !== null) {
-          continue
-        }
+          for (const ref of wsd.allRelatedOrderInvs) {
+            if (remainingLoadQty <= 0) break
+
+            let orderInventory = orderInventories.find(oi => oi.id === ref.id)
+            if (!orderInventory) continue
+
+            const foundWorksheetDetail = worksheet.worksheetDetails.find(
+              foundWsd => foundWsd.targetInventory.id === orderInventory.id
+            )
+            if (!foundWorksheetDetail) continue
+
+            // Skip if already loaded or DO generated
+            if (orderInventory.status === ORDER_INVENTORY_STATUS.LOADED || orderInventory.deliveryOrderId !== null) {
+              continue
+            }
+
+            // Calculate how much to load from this order inventory
+            const availableQty = orderInventory.pickedQty
+            const qtyToLoad = Math.min(remainingLoadQty, availableQty)
+            remainingLoadQty -= qtyToLoad
+
+            if (qtyToLoad === orderInventory.releaseQty) {
+              // Full load - mark as LOADED
+              orderInventory = {
+                ...orderInventory,
+                status: ORDER_INVENTORY_STATUS.LOADED,
+                updater: user,
+                updatedAt: new Date()
+              }
+
+              await tx.getRepository(WorksheetDetail).update(foundWorksheetDetail.id, {
+                status: WORKSHEET_STATUS.DONE,
+                updater: user,
+                updatedAt: new Date()
+              })
+            } else if (qtyToLoad < orderInventory.releaseQty && qtyToLoad > 0) {
+              // Partial load - split order inventory
+              const remainingOiQty = orderInventory.releaseQty - qtyToLoad
+              const newOrderInventory = tx.getRepository(OrderInventory).create({
+                ...orderInventory,
+                id: undefined,
+                name: OrderNoGenerator.orderInventory(),
+                releaseQty: remainingOiQty,
+                releaseUomValue: (orderInventory.releaseUomValue / orderInventory.releaseQty) * remainingOiQty,
+                pickedQty: orderInventory.pickedQty - qtyToLoad,
+                sortedQty: orderInventory.sortedQty === 0 ? 0 : orderInventory.sortedQty - qtyToLoad,
+                status: orderInventory.status,
+                updater: user,
+                updatedAt: new Date()
+              })
+
+              await tx.getRepository(OrderInventory).save(newOrderInventory)
 
-        // compare with sort qty
-        if (wsd.loadedQty > orderInventory.pickedQty) {
-          throw new Error('Load qty is more than picked qty for sku ' + wsd.productSku)
-        } else if (wsd.loadedQty == orderInventory.releaseQty) {
-          //compare load qty to release, if order is partially picked, has to split oi
-
-          //update oi
-          orderInventory = {
-            ...orderInventory,
-            status: ORDER_INVENTORY_STATUS.LOADED,
-            updater: user,
-            updatedAt: new Date()
+              const newWorksheetDetail = tx.getRepository(WorksheetDetail).create({
+                ...foundWorksheetDetail,
+                id: undefined,
+                name: `LOAD-DETAIL-` + uuidv4(),
+                worksheet: worksheet,
+                targetInventory: newOrderInventory,
+                status: WORKSHEET_STATUS.EXECUTING,
+                updater: user,
+                updatedAt: new Date()
+              })
+
+              await tx.getRepository(WorksheetDetail).save(newWorksheetDetail)
+
+              orderInventory = {
+                ...orderInventory,
+                status: ORDER_INVENTORY_STATUS.LOADED,
+                releaseUomValue: (orderInventory.releaseUomValue / orderInventory.releaseQty) * qtyToLoad,
+                releaseQty: qtyToLoad,
+                pickedQty: qtyToLoad,
+                sortedQty: qtyToLoad,
+                updater: user,
+                updatedAt: new Date()
+              }
+
+              await tx.getRepository(WorksheetDetail).update(foundWorksheetDetail.id, {
+                status: WORKSHEET_STATUS.DONE,
+                updater: user,
+                updatedAt: new Date()
+              })
+            } else {
+              // qtyToLoad is 0, skip this order inventory
+              continue
+            }
+
+            const inventory = await tx.getRepository(Inventory).findOne({
+              where: { id: orderInventory.inventoryId }
+            })
+
+            await generateInventoryHistory(inventory, releaseGood, INVENTORY_TRANSACTION_TYPE.LOADING, 0, 0, user, tx)
+            updatedOrderInventories.push(orderInventory)
           }
 
-          //update wsd
-          await tx.getRepository(WorksheetDetail).update(foundWorksheetDetail.id, {
-            status: WORKSHEET_STATUS.DONE,
-            updater: user,
-            updatedAt: new Date()
-          })
-        } else if (wsd.loadedQty < orderInventory.releaseQty) {
-          //split oi
-          //create new order inventory with remaining quantity
-          const remainingQty = orderInventory.releaseQty - wsd.loadedQty
-          const newOrderInventory = tx.getRepository(OrderInventory).create({
-            ...orderInventory,
-            id: undefined,
-            name: OrderNoGenerator.orderInventory(),
-            releaseQty: remainingQty,
-            releaseUomValue: (orderInventory.releaseUomValue / orderInventory.releaseQty) * remainingQty,
-            pickedQty: orderInventory.pickedQty - wsd.loadedQty,
-            sortedQty: orderInventory.sortedQty === 0 ? 0 : orderInventory.sortedQty - wsd.loadedQty,
-            status: orderInventory.status,
-            updater: user,
-            updatedAt: new Date()
-          })
+          // Validate that all requested quantity was loaded
+          if (remainingLoadQty > 0) {
+            console.warn(`Could not fully distribute loadedQty for SKU ${wsd.productSku}. Remaining: ${remainingLoadQty}`)
+          }
+        } else {
+          // Standard mode: single order inventory reference
+          // Support both:
+          // 1. Match by worksheetDetail name (when using LOADING_WORKSHEET_V2 query)
+          // 2. Match by relatedOrderInv.id (when name is null)
+          let foundWorksheetDetail: WorksheetDetail
+          let orderInventory: OrderInventory
 
-          await tx.getRepository(OrderInventory).save(newOrderInventory)
-
-          //create new worksheet detail for the new order inventory
-          const newWorksheetDetail = tx.getRepository(WorksheetDetail).create({
-            ...foundWorksheetDetail,
-            id: undefined,
-            name: `LOAD-DETAIL-` + uuidv4(),
-            worksheet: worksheet,
-            targetInventory: newOrderInventory,
-            status: WORKSHEET_STATUS.EXECUTING,
-            updater: user,
-            updatedAt: new Date()
-          })
+          if (wsd.name) {
+            foundWorksheetDetail = worksheet.worksheetDetails.find(foundWsd => foundWsd.name === wsd.name)
+            if (foundWorksheetDetail) {
+              orderInventory = orderInventories.find(oi => oi.id === foundWorksheetDetail.targetInventory.id)
+            }
+          }
 
-          await tx.getRepository(WorksheetDetail).save(newWorksheetDetail)
-
-          //update current order inventory to loaded with loaded quantity
-          orderInventory = {
-            ...orderInventory,
-            status: ORDER_INVENTORY_STATUS.LOADED,
-            releaseUomValue: (orderInventory.releaseUomValue / orderInventory.releaseQty) * wsd.loadedQty,
-            releaseQty: wsd.loadedQty,
-            pickedQty: wsd.loadedQty,
-            sortedQty: wsd.loadedQty,
-            updater: user,
-            updatedAt: new Date()
+          if (!foundWorksheetDetail && wsd.relatedOrderInv?.id) {
+            orderInventory = orderInventories.find(oi => oi.id === wsd.relatedOrderInv.id)
+            if (orderInventory) {
+              foundWorksheetDetail = worksheet.worksheetDetails.find(
+                foundWsd => foundWsd.targetInventory.id === orderInventory.id
+              )
+            }
           }
 
-          //update current wsd
-          await tx.getRepository(WorksheetDetail).update(foundWorksheetDetail.id, {
-            status: WORKSHEET_STATUS.DONE,
-            updater: user,
-            updatedAt: new Date()
-          })
-        }
+          if (!foundWorksheetDetail || !orderInventory) {
+            console.warn(`Could not find worksheet detail or order inventory for item: ${JSON.stringify({ name: wsd.name, relatedOrderInvId: wsd.relatedOrderInv?.id, productSku: wsd.productSku })}`)
+            continue
+          }
+
+          if (orderInventory.status === ORDER_INVENTORY_STATUS.LOADED || orderInventory.deliveryOrderId !== null) {
+            continue
+          }
+
+          if (wsd.loadedQty > orderInventory.pickedQty) {
+            throw new Error('Load qty is more than picked qty for sku ' + wsd.productSku)
+          } else if (wsd.loadedQty == orderInventory.releaseQty) {
+            orderInventory = {
+              ...orderInventory,
+              status: ORDER_INVENTORY_STATUS.LOADED,
+              updater: user,
+              updatedAt: new Date()
+            }
+
+            await tx.getRepository(WorksheetDetail).update(foundWorksheetDetail.id, {
+              status: WORKSHEET_STATUS.DONE,
+              updater: user,
+              updatedAt: new Date()
+            })
+          } else if (wsd.loadedQty < orderInventory.releaseQty) {
+            const remainingQty = orderInventory.releaseQty - wsd.loadedQty
+            const newOrderInventory = tx.getRepository(OrderInventory).create({
+              ...orderInventory,
+              id: undefined,
+              name: OrderNoGenerator.orderInventory(),
+              releaseQty: remainingQty,
+              releaseUomValue: (orderInventory.releaseUomValue / orderInventory.releaseQty) * remainingQty,
+              pickedQty: orderInventory.pickedQty - wsd.loadedQty,
+              sortedQty: orderInventory.sortedQty === 0 ? 0 : orderInventory.sortedQty - wsd.loadedQty,
+              status: orderInventory.status,
+              updater: user,
+              updatedAt: new Date()
+            })
 
-        const inventory = await tx.getRepository(Inventory).findOne({
-          where: { id: orderInventory.inventoryId }
-        })
+            await tx.getRepository(OrderInventory).save(newOrderInventory)
 
-        // generate inventory history
-        await generateInventoryHistory(inventory, releaseGood, INVENTORY_TRANSACTION_TYPE.LOADING, 0, 0, user, tx)
-        updatedOrderInventories.push(orderInventory)
+            const newWorksheetDetail = tx.getRepository(WorksheetDetail).create({
+              ...foundWorksheetDetail,
+              id: undefined,
+              name: `LOAD-DETAIL-` + uuidv4(),
+              worksheet: worksheet,
+              targetInventory: newOrderInventory,
+              status: WORKSHEET_STATUS.EXECUTING,
+              updater: user,
+              updatedAt: new Date()
+            })
+
+            await tx.getRepository(WorksheetDetail).save(newWorksheetDetail)
+
+            orderInventory = {
+              ...orderInventory,
+              status: ORDER_INVENTORY_STATUS.LOADED,
+              releaseUomValue: (orderInventory.releaseUomValue / orderInventory.releaseQty) * wsd.loadedQty,
+              releaseQty: wsd.loadedQty,
+              pickedQty: wsd.loadedQty,
+              sortedQty: wsd.loadedQty,
+              updater: user,
+              updatedAt: new Date()
+            }
+
+            await tx.getRepository(WorksheetDetail).update(foundWorksheetDetail.id, {
+              status: WORKSHEET_STATUS.DONE,
+              updater: user,
+              updatedAt: new Date()
+            })
+          }
+
+          const inventory = await tx.getRepository(Inventory).findOne({
+            where: { id: orderInventory.inventoryId }
+          })
+
+          await generateInventoryHistory(inventory, releaseGood, INVENTORY_TRANSACTION_TYPE.LOADING, 0, 0, user, tx)
+          updatedOrderInventories.push(orderInventory)
+        }
       }
 
       if (updatedOrderInventories.length < 1) {

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

@@ -163,6 +163,10 @@ export const loadingWorksheetv2 = {
     if (filter === FILTER_TYPES.LOADING) {
       if (shouldFilterBySortedQty(releaseGood.status, disableQc)) {
         qb.andWhere('targetInventory.sortedQty > 0')
+        // Exclude LOADED items - they should only appear in LOADED tab
+        qb.andWhere('targetInventory.status <> :loadedStatus', {
+          loadedStatus: ORDER_INVENTORY_STATUS.LOADED
+        })
       } else {
         qb.andWhere('targetInventory.status IN (:...loadingStatus)', {
           loadingStatus: [ORDER_INVENTORY_STATUS.SORTING, ORDER_INVENTORY_STATUS.LOADING]

package/server/graphql/resolvers/outbound/undo-load.ts

@@ -1,5 +1,5 @@
-import { EntityManager } from 'typeorm'
-import { DeliveryOrder, ReleaseGood, OrderInventory, ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
+import { EntityManager, In } from 'typeorm'
+import { DeliveryOrder, OrderInventory, ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
 import { generateInventoryHistory, Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
@@ -19,63 +19,135 @@ export const undoLoad = {
     }
 
     const releaseGood = deliveryOrder.releaseGood
+    const doInventories = deliveryOrder.orderInventories
 
-    for (const doInventory of deliveryOrder.orderInventories) {
-      const worksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-        where: { targetInventory: doInventory, type: WORKSHEET_TYPE.LOADING, status: WORKSHEET_STATUS.DONE }
-      })
-      //find if the oi is splitted and not yet loaded
-      const previousOi: OrderInventory = releaseGood.orderInventories.find(
-        roInventory =>
-          roInventory.id !== doInventory.id &&
-          roInventory.inventoryId === doInventory.inventoryId &&
-          roInventory.productId === doInventory.productId &&
-          roInventory.productDetailId === doInventory.productDetailId &&
-          roInventory.status === ORDER_INVENTORY_STATUS.LOADING
-      )
+    if (!doInventories.length) {
+      await tx.getRepository(DeliveryOrder).delete(deliveryOrder.id)
+      return true
+    }
+
+    // OPTIMIZATION 1: Batch fetch all worksheet details in one query instead of N queries
+    const doInventoryIds = doInventories.map(oi => oi.id)
+    const worksheetDetails = await tx.getRepository(WorksheetDetail).find({
+      where: {
+        targetInventory: { id: In(doInventoryIds) },
+        type: WORKSHEET_TYPE.LOADING,
+        status: WORKSHEET_STATUS.DONE
+      }
+    })
+
+    // Create a map for O(1) lookup of worksheet details by targetInventory.id
+    const wsdByTargetId = new Map<string, WorksheetDetail>()
+    worksheetDetails.forEach((wsd: WorksheetDetail) => {
+      const targetInvId = (wsd as any).targetInventory?.id
+      if (targetInvId) {
+        wsdByTargetId.set(targetInvId, wsd)
+      }
+    })
+
+    // OPTIMIZATION 2: Create a map for O(1) lookup of previous (split) order inventories
+    // Key: inventoryId_productId_productDetailId, Value: OrderInventory with LOADING status
+    const previousOiMap = new Map<string, OrderInventory>()
+    const doInventoryIdSet = new Set(doInventoryIds)
+    releaseGood.orderInventories.forEach(roInventory => {
+      if (!doInventoryIdSet.has(roInventory.id) && roInventory.status === ORDER_INVENTORY_STATUS.LOADING) {
+        const key = `${roInventory.inventoryId}_${roInventory.productId}_${roInventory.productDetailId}`
+        previousOiMap.set(key, roInventory)
+      }
+    })
+
+    // Categorize order inventories for batch processing
+    const toTerminate: { doInventory: OrderInventory; previousOi: OrderInventory; wsd: WorksheetDetail }[] = []
+    const toRevert: { doInventory: OrderInventory; wsd: WorksheetDetail }[] = []
+
+    for (const doInventory of doInventories) {
+      const worksheetDetail = wsdByTargetId.get(doInventory.id)
+      const lookupKey = `${doInventory.inventoryId}_${doInventory.productId}_${doInventory.productDetailId}`
+      const previousOi = previousOiMap.get(lookupKey)
 
       if (previousOi) {
-        //combine previously splitted oi
-        await tx.getRepository(OrderInventory).update(previousOi.id, {
-          releaseQty: previousOi.releaseQty + doInventory.releaseQty,
-          pickedQty: previousOi.pickedQty + doInventory.pickedQty,
-          sortedQty: previousOi.sortedQty + doInventory.sortedQty,
-          releaseUomValue: previousOi.releaseUomValue + doInventory.releaseUomValue,
-          updater: user,
-          updatedAt: new Date()
-        })
-
-        //terminate splitted oi
-        await tx.getRepository(OrderInventory).update(doInventory.id, {
+        toTerminate.push({ doInventory, previousOi, wsd: worksheetDetail })
+      } else {
+        toRevert.push({ doInventory, wsd: worksheetDetail })
+      }
+    }
+
+    // OPTIMIZATION 3: Batch update operations
+    const now = new Date()
+
+    // Process terminations (split order inventories)
+    if (toTerminate.length > 0) {
+      // Update previous OIs with combined quantities - must be done individually due to different values
+      await Promise.all(
+        toTerminate.map(({ doInventory, previousOi }) =>
+          tx.getRepository(OrderInventory).update(previousOi.id, {
+            releaseQty: previousOi.releaseQty + doInventory.releaseQty,
+            pickedQty: previousOi.pickedQty + doInventory.pickedQty,
+            sortedQty: previousOi.sortedQty + doInventory.sortedQty,
+            releaseUomValue: previousOi.releaseUomValue + doInventory.releaseUomValue,
+            updater: user,
+            updatedAt: now
+          })
+        )
+      )
+
+      // Batch terminate the DO inventories
+      const terminateIds = toTerminate.map(t => t.doInventory.id)
+      await tx.getRepository(OrderInventory).update(
+        { id: In(terminateIds) },
+        {
           deliveryOrder: null,
           status: ORDER_INVENTORY_STATUS.TERMINATED,
-          updatedAt: new Date(),
+          updatedAt: now,
           updater: user
-        })
-        //delete wsd
-        await tx.getRepository(WorksheetDetail).delete({ id: worksheetDetail.id, status: WORKSHEET_STATUS.DONE })
-      } else {
-        //undo oi and wsd
-        await tx.getRepository(OrderInventory).update(doInventory.id, {
+        }
+      )
+
+      // Batch delete worksheet details
+      const wsdToDeleteIds = toTerminate.filter(t => t.wsd?.id).map(t => t.wsd.id)
+      if (wsdToDeleteIds.length > 0) {
+        await tx.getRepository(WorksheetDetail).delete({ id: In(wsdToDeleteIds) })
+      }
+    }
+
+    // Process reversions (non-split order inventories)
+    if (toRevert.length > 0) {
+      // Batch update order inventories to LOADING status
+      const revertOiIds = toRevert.map(r => r.doInventory.id)
+      await tx.getRepository(OrderInventory).update(
+        { id: In(revertOiIds) },
+        {
           deliveryOrder: null,
           status: ORDER_INVENTORY_STATUS.LOADING,
           loadedAt: null,
           loadedByUser: null,
           loadedBy: null,
           updater: user
-        })
-        await tx.getRepository(WorksheetDetail).update(worksheetDetail.id, {
-          status: WORKSHEET_STATUS.EXECUTING,
-          updater: user,
-          updatedAt: new Date()
-        })
-      }
+        }
+      )
 
-      //generate inventory history
-      let inventory: Inventory = doInventory.inventory
-      await generateInventoryHistory(inventory, releaseGood, INVENTORY_TRANSACTION_TYPE.UNDO_LOADING, 0, 0, this.user)
+      // Batch update worksheet details to EXECUTING status
+      const wsdToUpdateIds = toRevert.filter(r => r.wsd?.id).map(r => r.wsd.id)
+      if (wsdToUpdateIds.length > 0) {
+        await tx.getRepository(WorksheetDetail).update(
+          { id: In(wsdToUpdateIds) },
+          {
+            status: WORKSHEET_STATUS.EXECUTING,
+            updater: user,
+            updatedAt: now
+          }
+        )
+      }
     }
 
+    // OPTIMIZATION 4: Generate inventory histories in parallel
+    await Promise.all(
+      doInventories.map(doInventory => {
+        const inventory: Inventory = doInventory.inventory
+        return generateInventoryHistory(inventory, releaseGood, INVENTORY_TRANSACTION_TYPE.UNDO_LOADING, 0, 0, user, tx)
+      })
+    )
+
     await tx.getRepository(DeliveryOrder).delete(deliveryOrder.id)
 
     return true

package/server/graphql/resolvers/route-label/route-label.ts

@@ -1,11 +1,13 @@
 import { EntityManager, In } from 'typeorm'
 import { Domain } from '@things-factory/biz-base'
-import { WORKSHEET_STATUS } from '@things-factory/worksheet-base'
 import { User } from '@things-factory/auth-base'
 
 import { RouteLabelSequenceCounter } from '../../../entities/route-label-sequence-counter'
 import { RouteLabelSequenceLog } from '../../../entities/route-label-sequence-log'
 
+// Statuses to exclude from route label printing
+const EXCLUDED_RO_STATUSES = ['DONE', 'PENDING_CANCEL', 'CANCELLED']
+
 function ensureSeqField(field: string) {
   if (!['refNo', 'refNo2', 'refNo3'].includes(field)) {
     throw new Error('Invalid sequence field. Allowed: refNo, refNo2, refNo3')
@@ -43,7 +45,7 @@ export const routeLabelReleaseGoodsInExecutingWorksheet = {
 
     const rows = await tx.query(
       `
-      select distinct
+      select
         rg.id as "id",
         rg.name as "name",
         rg.ref_no as "refNo",
@@ -54,19 +56,14 @@ export const routeLabelReleaseGoodsInExecutingWorksheet = {
         rg.store_name as "storeName",
         rg.stop_id as "stopId",
         rg.created_at as "createdAt"
-      from worksheets ws
-      inner join worksheet_details wsd on wsd.worksheet_id = ws.id
-      inner join order_inventories oi on oi.id = wsd.target_inventory_id
-      inner join release_goods rg on rg.id = oi.release_good_id
-      where ws.domain_id = $1
-        and ws.type = $2
-        and ws.status = $3
-        and rg.domain_id = $1
-        and rg.bizplace_id = $4
+      from release_goods rg
+      where rg.domain_id = $1
+        and rg.bizplace_id = $2
+        and rg.status not in ($3, $4, $5)
         ${filterRefNo}
       order by rg.created_at desc
       `,
-      [domain.id, worksheetType, WORKSHEET_STATUS.EXECUTING, partnerId]
+      [domain.id, partnerId, ...EXCLUDED_RO_STATUSES]
     )
 
     const releaseGoods = rows || []

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

@@ -58,9 +58,11 @@ export const zonePicking = {
       let worksheetDetails = worksheet.worksheetDetails
       let oiIds = worksheetDetails.map(wsd => wsd.targetInventory.id)
 
+      // Use pessimistic lock to prevent race conditions with concurrent requests
       const targetInventories: OrderInventory[] = await tx
         .getRepository(OrderInventory)
         .createQueryBuilder('oi')
+        .setLock('pessimistic_write')
         .innerJoinAndSelect('oi.inventory', 'i', 'i.id = oi.inventory_id')
         .where('oi.id IN(:...oiIds)', { oiIds: oiIds })
         .andWhere('i.carton_id = :cartonId', { cartonId: cartonId })
@@ -136,6 +138,10 @@ export const zonePicking = {
         oi => oi.productId === product.id && oi.productDetailId === productDetail.id
       )
 
+      // Track processed OI and inventory IDs to prevent duplicate processing within this transaction
+      const processedOiIds: Set<string> = new Set()
+      const processedInventoryDeductions: Map<string, number> = new Map()
+
       //update all oi
       for (const oi of productOrderInventory) {
         let targetInventory: OrderInventory = oi
@@ -145,6 +151,12 @@ export const zonePicking = {
         const releaseGood: ReleaseGood = targetInventory.releaseGood
         if (pickedQty <= 0) break
 
+        // Skip if this OI was already processed in this transaction
+        if (processedOiIds.has(targetInventory.id)) {
+          console.warn(`Skipping duplicate OI processing: ${targetInventory.id}`)
+          continue
+        }
+
         // validation to prevent picking if the inventory is involved in cycle count
         let inventoryCheckItem: InventoryCheckItem = await tx.getRepository(InventoryCheckItem).findOne({
           where: {
@@ -173,6 +185,19 @@ export const zonePicking = {
           targetReleaseQty > targetPickedQty &&
           pickedQty > 0
         ) {
+          // Re-verify OI status from database to prevent race condition
+          const freshOiStatus = await tx
+            .getRepository(OrderInventory)
+            .createQueryBuilder('oi')
+            .select('oi.status')
+            .where('oi.id = :id', { id: targetInventory.id })
+            .getRawOne()
+
+          if (freshOiStatus?.oi_status !== ORDER_INVENTORY_STATUS.PROCESSING) {
+            console.warn(`OI ${targetInventory.id} status changed to ${freshOiStatus?.oi_status}, skipping`)
+            continue
+          }
+
           let remainingAssignedQty: number = pickedQty - (targetReleaseQty - targetPickedQty) // -1, 0, 1
           const gapQtyRemaining: number = targetReleaseQty - targetPickedQty // > 0
 
@@ -194,7 +219,11 @@ export const zonePicking = {
 
           if (targetInventory.pickedQty == targetReleaseQty) {
             //update oi and wsd to done if pickedQty matches releaseQty
-            const leftQty: number = inventory.qty - targetInventory.releaseQty
+            // Account for any previous deductions to this inventory in this transaction
+            const previousDeduction = processedInventoryDeductions.get(inventory.id) || 0
+            const adjustedInventoryQty = inventory.qty - previousDeduction
+            const leftQty: number = adjustedInventoryQty - targetInventory.releaseQty
+
             if (leftQty < 0) {
               throw new Error(
                 wsController.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`)
@@ -209,6 +238,9 @@ export const zonePicking = {
             targetInventory.status = ORDER_INVENTORY_STATUS.PICKED
             await updateOrderInventories(tx, targetInventory)
 
+            // Mark this OI as processed
+            processedOiIds.add(targetInventory.id)
+
             //update loading wsd if exist
             let loadingWorksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
               where: { type: WORKSHEET_TYPE.LOADING, targetInventory: targetInventory }
@@ -242,8 +274,13 @@ export const zonePicking = {
               .returning(['qty'])
               .execute()
 
+            // Track the deduction for this inventory
+            processedInventoryDeductions.set(
+              inventory.id,
+              previousDeduction + targetInventory.releaseQty
+            )
+
             console.time('inv history')
-            //slow
             await generateInventoryHistory(
               inventory,
               releaseGood,
@@ -275,6 +312,8 @@ export const zonePicking = {
           } else {
             //updates oi if pickedQty != releaseQty
             await updateOrderInventories(tx, targetInventory)
+            // Mark this OI as processed even for partial picks
+            processedOiIds.add(targetInventory.id)
           }
           //deduct pickedQty for the next oi
           pickedQty = pickedQty - (targetReleaseQty - targetPickedQty)