@things-factory/worksheet-base 4.3.769 → 4.3.771

package/server/controllers/inbound/unloading-worksheet-controller.ts

@@ -164,6 +164,7 @@ export class UnloadingWorksheetController extends VasWorksheetController {
       expirationDate: inventory?.expirationDate ? new Date(inventory.expirationDate) : undefined,
       status: INVENTORY_STATUS.UNLOADED,
       qty: qty,
+      conditionOfGoods: inventory?.conditionOfGoods,
       manufactureDate: inventory?.manufactureDate ? new Date(inventory.manufactureDate) : undefined,
     }
 
@@ -357,6 +358,12 @@ export class UnloadingWorksheetController extends VasWorksheetController {
       })
     }
 
+    if (inventory?.conditionOfGoods) {
+      invQb.andWhere('INV.condition_of_goods = :conditionOfGoods', {
+        conditionOfGoods: inventory.conditionOfGoods
+      })
+    }
+
     if (inventory?.cartonId) invQb.andWhere('INV.carton_id = :cartonId', { cartonId: inventory.cartonId })
     else invQb.andWhere('INV.pallet_id = :palletId', { palletId: inventory.palletId })
 
@@ -375,6 +382,7 @@ export class UnloadingWorksheetController extends VasWorksheetController {
           targetProduct.packQty
         : 0
       : null
+    const conditionOfGoods: string = inventory?.conditionOfGoods
 
     if (!foundInventory) {
       let newInventory: Partial<Inventory> = new Inventory()
@@ -413,6 +421,7 @@ export class UnloadingWorksheetController extends VasWorksheetController {
       newInventory.location = location
       newInventory.zone = zone
       newInventory.status = INVENTORY_STATUS.CHECKED
+      newInventory.conditionOfGoods = conditionOfGoods
       newInventory.creator = this.user
 
       if (inventory?.expirationDate) {
@@ -451,6 +460,7 @@ export class UnloadingWorksheetController extends VasWorksheetController {
               : targetInventory.returnUomValue / targetInventory.returnQty) *
             1000
         ) / 1000
+      foundInventory.conditionOfGoods = conditionOfGoods ?? foundInventory.conditionOfGoods // DEFAULT BACK TO PREVIOUS INVENTORY'S CONDITION OF GOODS
 
       //refer to scanUnload
       foundInventory = await this.transactionInventory(
@@ -593,6 +603,12 @@ export class UnloadingWorksheetController extends VasWorksheetController {
       })
     }
 
+    if (inventory?.conditionOfGoods) {
+      invQb.andWhere('INV.condition_of_goods = :conditionOfGoods', {
+        conditionOfGoods: inventory.conditionOfGoods
+      })
+    }
+
     if (inventory?.cartonId) invQb.andWhere('INV.carton_id = :cartonId', { cartonId: inventory.cartonId })
     else invQb.andWhere('INV.pallet_id = :palletId', { palletId: inventory.palletId })
 
@@ -611,6 +627,7 @@ export class UnloadingWorksheetController extends VasWorksheetController {
           targetProduct.packQty
         : 0
       : null
+    const conditionOfGoods: string = inventory?.conditionOfGoods
 
     if (!foundInventory) {
       let newInventory: Partial<Inventory> = new Inventory()
@@ -649,6 +666,7 @@ export class UnloadingWorksheetController extends VasWorksheetController {
       newInventory.location = location
       newInventory.zone = zone
       newInventory.status = INVENTORY_STATUS.CHECKED
+      newInventory.conditionOfGoods = conditionOfGoods
       newInventory.creator = this.user
 
       if (inventory?.expirationDate) {
@@ -679,6 +697,8 @@ export class UnloadingWorksheetController extends VasWorksheetController {
             1000
         ) / 1000
       foundInventory.productDetail = productDetail
+      foundInventory.conditionOfGoods = conditionOfGoods ?? foundInventory.conditionOfGoods // DEFAULT BACK TO PREVIOUS INVENTORY'S CONDITION OF GOODS
+
       if (arrivalNotice) targetProduct.actualPackQty = targetProduct.actualPackQty + qty
       else if (returnOrder) targetInventory.actualPackQty = targetInventory.actualPackQty + qty
 

package/server/controllers/index.ts

@@ -1,6 +1,7 @@
 export * from './render-ro-do'
 export * from './render-grn'
 export * from './render-manual-do'
+export * from './render-packing-label'
 export * from './render-elccl-grn'
 export * from './render-job-sheet'
 export * from './render-kimeda-grn'

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

@@ -1,13 +1,17 @@
 import { Equal, In, Not, IsNull } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
 
 import { Bizplace } from '@things-factory/biz-base'
 import {
   DeliveryOrder,
+  LoadingPackages,
+  LoadingPackageItems,
   ORDER_INVENTORY_STATUS,
   ORDER_STATUS,
   ORDER_TYPES,
   OrderInventory,
   OrderNoGenerator,
+  OrderProduct,
   OrderTote,
   OrderToteItem,
   OrderVas,
@@ -443,4 +447,67 @@ export class LoadingWorksheetController extends VasWorksheetController {
 
     return completeWorksheet
   }
+
+  async createGroupLoadingPackages(
+    releaseGood: ReleaseGood,
+    groupedItems: Array<{ orderProductId: string; groupQty: number }>
+  ): Promise<LoadingPackages> {
+    // Create LoadingPackages
+    const loadingPackageName = OrderNoGenerator.loadingPackage()
+    const loadingPackage: LoadingPackages = await this.trxMgr.getRepository(LoadingPackages).save({
+      name: loadingPackageName,
+      domain: this.domain,
+      bizplace: releaseGood.bizplace,
+      releaseGood: releaseGood,
+      status: ORDER_STATUS.DONE,
+      creator: this.user,
+      updater: this.user
+    })
+
+    // Create LoadingPackageItems for each grouped item
+    const loadingPackageItems: LoadingPackageItems[] = []
+
+    for (const groupedItem of groupedItems) {
+      // Validate groupQty
+      if (groupedItem.groupQty == null || isNaN(groupedItem.groupQty)) {
+        throw new Error('Invalid group quantity')
+      }
+      if (groupedItem.groupQty <= 0) {
+        throw new Error('Group quantity must be greater than zero')
+      }
+
+      // Fetch the OrderProduct directly
+      const orderProduct: OrderProduct | null = await this.trxMgr.getRepository(OrderProduct).findOne({
+        where: { id: groupedItem.orderProductId, domain: this.domain, releaseGood: releaseGood },
+        relations: ['productDetail']
+      })
+
+      if (!orderProduct) {
+        throw new Error(`Order product not found: ${groupedItem.orderProductId}`)
+      }
+
+      const loadingPackageItemName = OrderNoGenerator.loadingPackageItem()
+      loadingPackageItems.push({
+        name: loadingPackageItemName,
+        domain: this.domain,
+        bizplace: releaseGood.bizplace,
+        loadingPackage: loadingPackage,
+        orderProduct,
+        packedQty: groupedItem.groupQty,
+        productDetail: orderProduct.productDetail ?? null,
+        status: ORDER_STATUS.DONE,
+        creator: this.user,
+        updater: this.user
+      } as LoadingPackageItems)
+    }
+
+    // Save all loading package items
+    await this.trxMgr.getRepository(LoadingPackageItems).save(loadingPackageItems)
+
+    // Reload with relations
+    return await this.trxMgr.getRepository(LoadingPackages).findOne({
+      where: { id: loadingPackage.id },
+      relations: ['loadingPackageItems', 'loadingPackageItems.orderProduct']
+    })
+  }
 }

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

@@ -795,10 +795,28 @@ export class PickingWorksheetController extends VasWorksheetController {
       newTargetInventory.updater = this.user
       newTargetInventory = await this.trxMgr.getRepository(OrderInventory).save(newTargetInventory)
 
-      // Update locked qty and uomValue of inventory
-      inventory.lockedQty = targetInventory.releaseQty + (inventory.lockedQty || 0)
-      inventory.lockedUomValue = targetInventory.releaseUomValue + (inventory.lockedUomValue || 0)
-      await this.updateInventory(inventory)
+      // Atomic update of locked qty and uomValue of inventory
+      const lockResult = await this.trxMgr
+        .getRepository(Inventory)
+        .createQueryBuilder()
+        .update(Inventory)
+        .set({
+          lockedQty: () => `COALESCE("locked_qty", 0) + :releaseQty::numeric`,
+          lockedUomValue: () => `COALESCE("locked_uom_value", 0) + :releaseUomValue::numeric`,
+          updater: this.user,
+          updatedAt: new Date()
+        })
+        .setParameter('releaseQty', targetInventory.releaseQty)
+        .setParameter('releaseUomValue', targetInventory.releaseUomValue)
+        .where('id = :id AND qty >= COALESCE(locked_qty, 0) + :newQty', {
+          id: inventory.id,
+          newQty: targetInventory.releaseQty
+        })
+        .execute()
+
+      if (lockResult.affected === 0) {
+        throw new Error(`Insufficient inventory for picking assignment`)
+      }
 
       // Create worksheet details
       await this.createWorksheetDetails(worksheet, WORKSHEET_TYPE.PICKING, [newTargetInventory])
@@ -837,12 +855,21 @@ export class PickingWorksheetController extends VasWorksheetController {
       const targetInventory: OrderInventory = worksheetDetail.targetInventory
       targetInventoryIds.push(targetInventory.id)
 
-      let inventory: Inventory = await this.trxMgr
+      // Atomic update of locked qty and uomValue of inventory
+      await this.trxMgr
         .getRepository(Inventory)
-        .findOne({ where: { id: worksheetDetail.targetInventory.inventory.id } })
-      inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty
-      inventory.lockedUomValue = inventory.lockedUomValue - targetInventory.releaseUomValue
-      await this.updateInventory(inventory)
+        .createQueryBuilder()
+        .update(Inventory)
+        .set({
+          lockedQty: () => `GREATEST(COALESCE("locked_qty", 0) - :releaseQty::numeric, 0)`,
+          lockedUomValue: () => `GREATEST(COALESCE("locked_uom_value", 0) - :releaseUomValue::numeric, 0)`,
+          updater: this.user,
+          updatedAt: new Date()
+        })
+        .setParameter('releaseQty', targetInventory.releaseQty)
+        .setParameter('releaseUomValue', targetInventory.releaseUomValue)
+        .where('id = :id', { id: worksheetDetail.targetInventory.inventory.id })
+        .execute()
 
       await this.trxMgr
         .getRepository(OrderProduct)
@@ -1008,6 +1035,14 @@ export class PickingWorksheetController extends VasWorksheetController {
         pickedUomValue = matchingProduct.uomValue
       }
 
+      // validation to prevent decimal quantities for non-decimal products
+      const scanPickProduct: Product = await this.trxMgr.getRepository(Product).findOne({
+        where: { id: worksheetDetailInfos.productId }
+      })
+      if (pickedQty % 1 !== 0 && !scanPickProduct?.isInventoryDecimal) {
+        throw new Error('Decimal quantities are not allowed for this product')
+      }
+
       // //validation to prevent over release
       if (!targetInventory)
         throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `inventory not assigned`))
@@ -1088,14 +1123,14 @@ export class PickingWorksheetController extends VasWorksheetController {
       targetInventory.pickedQty = (targetInventory?.pickedQty || 0) + pickedQty
 
       let updateOiObj = {
-        pickedQty: () => `"picked_qty" + ${pickedQty}`,
+        pickedQty: () => `"picked_qty" + :pickedQty`,
         updatedAt: new Date(),
         updater: this.user,
         pickedBy: this.user.name,
         pickedByUser: this.user,
         pickedAt: new Date(),
         status: () =>
-          `case when release_qty = "picked_qty" + ${pickedQty} then '${ORDER_INVENTORY_STATUS.PICKED}' else status end`
+          `case when release_qty = "picked_qty" + :pickedQty then '${ORDER_INVENTORY_STATUS.PICKED}' else status end`
       }
 
       if (targetInventory.binLocation) {
@@ -1107,6 +1142,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         .createQueryBuilder()
         .update(OrderInventory)
         .set(updateOiObj)
+        .setParameter('pickedQty', pickedQty)
         .where({ id: targetInventory.id })
         .andWhere(`picked_qty + :pickedQty <= release_qty`, { pickedQty })
         .execute()
@@ -1130,12 +1166,12 @@ export class PickingWorksheetController extends VasWorksheetController {
             let releaseUomValue = Math.trunc((pickedUomValue / pickedQty) * releaseQty * 1000) / 1000
 
             let updateInvObj = {
-              qty: () => `"qty" - ${releaseQty}`,
-              lockedQty: () => `"locked_qty" - ${releaseQty}`,
-              uomValue: () => `"uom_value" - ${releaseUomValue}`,
-              lockedUomValue: () => `"locked_uom_value" - ${releaseUomValue}`,
+              qty: () => `"qty" - :deductQty::numeric`,
+              lockedQty: () => `GREATEST("locked_qty" - :deductQty::numeric, 0)`,
+              uomValue: () => `"uom_value" - :deductUomValue::numeric`,
+              lockedUomValue: () => `GREATEST("locked_uom_value" - :deductUomValue::numeric, 0)`,
               status: () =>
-                `case when "qty" - ${releaseQty} <= 0 then '${INVENTORY_STATUS.TERMINATED}' else status end`,
+                `case when "qty" - :deductQty::numeric <= 0 then '${INVENTORY_STATUS.TERMINATED}' else status end`,
               updater: this.user,
               updatedAt: new Date()
             }
@@ -1145,6 +1181,8 @@ export class PickingWorksheetController extends VasWorksheetController {
               .createQueryBuilder()
               .update(Inventory)
               .set(updateInvObj)
+              .setParameter('deductQty', releaseQty)
+              .setParameter('deductUomValue', releaseUomValue)
               .where('id = :id', { id: worksheetDetailInfos.inventoryId })
               .returning(['qty'])
               .execute()
@@ -1254,6 +1292,11 @@ export class PickingWorksheetController extends VasWorksheetController {
       })
       if (!oiValidate) throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
 
+      // validation to prevent decimal quantities for non-decimal products
+      if (pickedQty % 1 !== 0 && !product.isInventoryDecimal) {
+        throw new Error('Decimal quantities are not allowed for this product')
+      }
+
       //validation to prevent over release
       if (inventory.qty <= 0) throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
@@ -1426,6 +1469,16 @@ export class PickingWorksheetController extends VasWorksheetController {
     if (sumOfReleaseQty != releaseQty)
       throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `insufficient picking quantity`))
 
+    // validation to prevent decimal quantities for non-decimal products
+    if (targetInventories.length > 0) {
+      const batchPickProduct: Product = await this.trxMgr.getRepository(Product).findOne({
+        where: { id: targetInventories[0].productId }
+      })
+      if (releaseQty % 1 !== 0 && !batchPickProduct?.isInventoryDecimal) {
+        throw new Error('Decimal quantities are not allowed for this product')
+      }
+    }
+
     for (var i = 0; i < targetInventories.length; i++) {
       let targetInventory: OrderInventory = targetInventories[i]
       let inventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne({
@@ -1480,10 +1533,12 @@ export class PickingWorksheetController extends VasWorksheetController {
       await this.updateOrderTargets([targetInventory])
 
       let updateInvObj = {
-        qty: () => `"qty" - ${targetInventory.releaseQty}`,
-        lockedQty: () => `"locked_qty" - ${targetInventory.releaseQty}`,
-        uomValue: () => `"uom_value" - ${targetInventory.releaseUomValue}`,
-        lockedUomValue: () => `"locked_uom_value" - ${targetInventory.releaseUomValue}`,
+        qty: () => `"qty" - :deductQty::numeric`,
+        lockedQty: () => `GREATEST("locked_qty" - :deductQty::numeric, 0)`,
+        uomValue: () => `"uom_value" - :deductUomValue::numeric`,
+        lockedUomValue: () => `GREATEST("locked_uom_value" - :deductUomValue::numeric, 0)`,
+        status: () =>
+          `case when "qty" - :deductQty::numeric <= 0 then '${INVENTORY_STATUS.TERMINATED}' else status end`,
         updater: this.user,
         updatedAt: new Date()
       }
@@ -1493,6 +1548,8 @@ export class PickingWorksheetController extends VasWorksheetController {
         .createQueryBuilder()
         .update(Inventory)
         .set(updateInvObj)
+        .setParameter('deductQty', targetInventory.releaseQty)
+        .setParameter('deductUomValue', targetInventory.releaseUomValue)
         .where('id = :id', { id: targetInventory.inventory.id })
         .returning(['qty'])
         .execute()
@@ -1599,6 +1656,11 @@ export class PickingWorksheetController extends VasWorksheetController {
 
       pickedQty = matchingProduct.qty
 
+      // validation to prevent decimal quantities for non-decimal products
+      if (pickedQty % 1 !== 0 && !product?.isInventoryDecimal) {
+        throw new Error('Decimal quantities are not allowed for this product')
+      }
+
       const sumOfReleaseQty: number = parseFloat(
         targetInventories
           .map((oi: OrderInventory) => oi.releaseQty)
@@ -1678,10 +1740,12 @@ export class PickingWorksheetController extends VasWorksheetController {
             await this.updateOrderTargets([targetInventory])
 
             let updateInvObj = {
-              qty: () => `"qty" - ${targetInventory.releaseQty}`,
-              lockedQty: () => `"locked_qty" - ${targetInventory.releaseQty}`,
-              uomValue: () => `"uom_value" - ${targetInventory.releaseUomValue}`,
-              lockedUomValue: () => `"locked_uom_value" - ${targetInventory.releaseUomValue}`,
+              qty: () => `"qty" - :deductQty::numeric`,
+              lockedQty: () => `GREATEST("locked_qty" - :deductQty::numeric, 0)`,
+              uomValue: () => `"uom_value" - :deductUomValue::numeric`,
+              lockedUomValue: () => `GREATEST("locked_uom_value" - :deductUomValue::numeric, 0)`,
+              status: () =>
+                `case when "qty" - :deductQty::numeric <= 0 then '${INVENTORY_STATUS.TERMINATED}' else status end`,
               updater: this.user,
               updatedAt: new Date()
             }
@@ -1691,6 +1755,8 @@ export class PickingWorksheetController extends VasWorksheetController {
               .createQueryBuilder()
               .update(Inventory)
               .set(updateInvObj)
+              .setParameter('deductQty', targetInventory.releaseQty)
+              .setParameter('deductUomValue', targetInventory.releaseUomValue)
               .where('id = :id', { id: targetInventory.inventory.id })
               .returning(['qty'])
               .execute()
@@ -1966,6 +2032,14 @@ export class PickingWorksheetController extends VasWorksheetController {
   }
 
   private async updatePickingTransaction(releaseGood, orderInventory, worksheetDetail, inventory, pickedQty) {
+    // validation to prevent decimal quantities for non-decimal products
+    const pickTxProduct: Product = await this.trxMgr.getRepository(Product).findOne({
+      where: { id: orderInventory.productId }
+    })
+    if (pickedQty % 1 !== 0 && !pickTxProduct?.isInventoryDecimal) {
+      throw new Error('Decimal quantities are not allowed for this product')
+    }
+
     const releaseQty: number = orderInventory.releaseQty
 
     orderInventory.pickedQty = (orderInventory?.pickedQty || 0) + pickedQty
@@ -1980,18 +2054,40 @@ export class PickingWorksheetController extends VasWorksheetController {
       orderInventory.pickedByUser = this.user
       orderInventory.pickedAt = new Date()
 
-      inventory.qty -= orderInventory.releaseQty
-      inventory.uomValue = Math.round((inventory.uomValue - orderInventory.releaseUomValue) * 100) / 100
-      inventory.lockedQty = inventory.lockedQty - orderInventory.releaseQty
-      inventory.lockedUomValue = Math.round((inventory.lockedUomValue - orderInventory.releaseUomValue) * 100) / 100
-      inventory = await this.transactionInventory(
+      // Atomic SQL update instead of stale-read pattern
+      await this.trxMgr
+        .getRepository(Inventory)
+        .createQueryBuilder()
+        .update(Inventory)
+        .set({
+          qty: () => `"qty" - :deductQty::numeric`,
+          uomValue: () => `"uom_value" - :deductUomValue::numeric`,
+          lockedQty: () => `GREATEST("locked_qty" - :deductQty::numeric, 0)`,
+          lockedUomValue: () => `GREATEST("locked_uom_value" - :deductUomValue::numeric, 0)`,
+          status: () =>
+            `case when "qty" - :deductQty::numeric <= 0 then '${INVENTORY_STATUS.TERMINATED}' else status end`,
+          updater: this.user,
+          updatedAt: new Date()
+        })
+        .setParameter('deductQty', orderInventory.releaseQty)
+        .setParameter('deductUomValue', orderInventory.releaseUomValue)
+        .where('id = :id', { id: inventory.id })
+        .execute()
+
+      // Generate inventory history separately
+      await generateInventoryHistory(
         inventory,
         releaseGood,
+        INVENTORY_TRANSACTION_TYPE.PICKING,
         -orderInventory.releaseQty,
         -orderInventory.releaseUomValue,
-        INVENTORY_TRANSACTION_TYPE.PICKING
+        this.user,
+        this.trxMgr
       )
 
+      // Re-read inventory for downstream use (status check for TERMINATED)
+      inventory = await this.trxMgr.getRepository(Inventory).findOne({ where: { id: inventory.id } })
+
       worksheetDetail.status = WORKSHEET_STATUS.DONE
       worksheetDetail.updater = this.user
       await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
@@ -2545,20 +2641,37 @@ export class PickingWorksheetController extends VasWorksheetController {
       // update inventory locked qty and uom value
       oi = await transaction.getRepository(OrderInventory).save({ ...oi })
 
-      await transaction.getRepository(Inventory).update(oi.inventory.id, {
-        lockedQty: (oi.inventory?.lockedQty || 0) + oi.releaseQty,
-        lockedUomValue: (oi.inventory?.lockedUomValue || 0) + oi.releaseUomValue,
-        updater: this.user
-      })
+      const lockResult = await transaction
+        .getRepository(Inventory)
+        .createQueryBuilder()
+        .update(Inventory)
+        .set({
+          lockedQty: () => `COALESCE("locked_qty", 0) + :releaseQty::numeric`,
+          lockedUomValue: () => `COALESCE("locked_uom_value", 0) + :releaseUomValue::numeric`,
+          updater: this.user
+        })
+        .setParameter('releaseQty', oi.releaseQty)
+        .setParameter('releaseUomValue', oi.releaseUomValue)
+        .where('id = :id AND qty >= COALESCE(locked_qty, 0) + :newQty', {
+          id: oi.inventory.id,
+          newQty: oi.releaseQty
+        })
+        .execute()
+
+      if (lockResult.affected === 0) {
+        throw new Error(`Insufficient inventory for picking assignment`)
+      }
 
       await transaction
         .getRepository(ProductDetailStock)
         .createQueryBuilder()
         .update(ProductDetailStock)
         .set({
-          unassignedQty: () => `"unassigned_qty" - ${oi.releaseQty}`,
-          unassignedUomValue: () => `"unassigned_uom_value" - ${oi.releaseUomValue}`
+          unassignedQty: () => `GREATEST("unassigned_qty" - :oiReleaseQty::numeric, 0)`,
+          unassignedUomValue: () => `GREATEST("unassigned_uom_value" - :oiReleaseUomValue::numeric, 0)`
         })
+        .setParameter('oiReleaseQty', oi.releaseQty)
+        .setParameter('oiReleaseUomValue', oi.releaseUomValue)
         .where({ productDetail: oi.productDetail.id })
         .execute()
 
@@ -2643,26 +2756,37 @@ export class PickingWorksheetController extends VasWorksheetController {
           releaseUomValue = releaseUomValue - allocatedUomValue
 
           //// Update inventory locked quantity
-          await this.trxMgr
+          const lockResult = await this.trxMgr
             .getRepository(Inventory)
             .createQueryBuilder('inv')
             .update(Inventory)
             .set({
-              lockedUomValue: () => `COALESCE(locked_uom_value,0) + ${allocatedUomValue}`,
-              lockedQty: () => `COALESCE(locked_qty,0) + ${allocatedQty}`
+              lockedUomValue: () => `COALESCE(locked_uom_value,0) + :allocatedUomValue::numeric`,
+              lockedQty: () => `COALESCE(locked_qty,0) + :allocatedQty::numeric`
+            })
+            .setParameter('allocatedUomValue', allocatedUomValue)
+            .setParameter('allocatedQty', allocatedQty)
+            .where('id = :id AND qty >= COALESCE(locked_qty, 0) + :newQty', {
+              id: targetInventory.id,
+              newQty: allocatedQty
             })
-            .where('id = :id', { id: targetInventory.id })
             .execute()
 
+          if (lockResult.affected === 0) {
+            throw new Error(`Insufficient inventory for picking assignment`)
+          }
+
           // update product detail stock deduct unassigned qty and unassigned uom value
           await this.trxMgr
             .getRepository(ProductDetailStock)
             .createQueryBuilder()
             .update(ProductDetailStock)
             .set({
-              unassignedQty: () => `"unassigned_qty" - ${allocatedQty}`,
-              unassignedUomValue: () => `"unassigned_uom_value" - ${allocatedUomValue}`
+              unassignedQty: () => `GREATEST("unassigned_qty" - :deductQty::numeric, 0)`,
+              unassignedUomValue: () => `GREATEST("unassigned_uom_value" - :deductUomValue::numeric, 0)`
             })
+            .setParameter('deductQty', allocatedQty)
+            .setParameter('deductUomValue', allocatedUomValue)
             .where({ productDetail: orderProducts[i].productDetail.id })
             .execute()