@things-factory/worksheet-base 4.3.770 → 4.3.772

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

@@ -440,19 +440,17 @@ export class UnloadingWorksheetController extends VasWorksheetController {
       foundInventory = await this.trxMgr.getRepository(Inventory).save(newInventory)
 
       //refer to scanUnload
-      newInventory = await this.transactionInventory(
-        newInventory,
+      await generateInventoryHistory(
+        foundInventory,
         Boolean(arrivalNotice) ? arrivalNotice : returnOrder,
-        newInventory.qty,
-        newInventory.uomValue,
-        INVENTORY_TRANSACTION_TYPE.UNLOADING
+        INVENTORY_TRANSACTION_TYPE.UNLOADING,
+        foundInventory.qty,
+        foundInventory.uomValue,
+        this.user,
+        this.trxMgr
       )
     } else {
-      const updatedQty: number = foundInventory.qty + qty
-      foundInventory.expirationDate = foundInventory.expirationDate ? new Date(foundInventory.expirationDate) : null
-      foundInventory.manufactureDate = foundInventory?.manufactureDate ? new Date(foundInventory?.manufactureDate) : null
-      foundInventory.qty = updatedQty
-      foundInventory.uomValue +=
+      const addUomValue: number =
         Math.round(
           qty *
             (Boolean(arrivalNotice)
@@ -460,20 +458,39 @@ 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(
+      const updateFields: any = {
+        qty: () => `"qty" + :addQty::numeric`,
+        uomValue: () => `"uom_value" + :addUomValue::numeric`,
+        updater: this.user,
+        updatedAt: new Date()
+      }
+      if (conditionOfGoods) {
+        updateFields.conditionOfGoods = conditionOfGoods
+      }
+      await this.trxMgr.getRepository(Inventory).createQueryBuilder()
+        .update(Inventory).set(updateFields)
+        .setParameter('addQty', qty)
+        .setParameter('addUomValue', addUomValue)
+        .where('id = :id', { id: foundInventory.id }).execute()
+
+      // Update in-memory for downstream
+      foundInventory.qty += qty
+      foundInventory.uomValue += addUomValue
+      if (conditionOfGoods) foundInventory.conditionOfGoods = conditionOfGoods
+
+      await generateInventoryHistory(
         foundInventory,
         Boolean(arrivalNotice) ? arrivalNotice : returnOrder,
+        INVENTORY_TRANSACTION_TYPE.UNLOADING,
         foundInventory.qty,
         foundInventory.uomValue,
-        INVENTORY_TRANSACTION_TYPE.UNLOADING
+        this.user,
+        this.trxMgr
       )
 
       if (arrivalNotice) targetProduct.actualPackQty = targetProduct.actualPackQty + qty
       else if (returnOrder) targetInventory.actualPackQty = targetInventory.actualPackQty + qty
-      foundInventory = await this.trxMgr.getRepository(Inventory).save(foundInventory)
     }
 
     let inventoryItem: InventoryItem = new InventoryItem()
@@ -770,14 +787,20 @@ export class UnloadingWorksheetController extends VasWorksheetController {
     let foundInventory: Inventory = await invQb.getOne()
     if (!foundInventory) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(foundInventory.palletId))
 
+    await this.trxMgr.getRepository(Inventory).update(
+      { id: foundInventory.id },
+      { status: INVENTORY_STATUS.UNLOADED, updater: this.user }
+    )
     foundInventory.status = INVENTORY_STATUS.UNLOADED
 
-    foundInventory = await this.transactionInventory(
+    await generateInventoryHistory(
       foundInventory,
       Boolean(arrivalNotice) ? arrivalNotice : returnOrder,
+      INVENTORY_TRANSACTION_TYPE.UNLOADING,
       foundInventory.qty,
       foundInventory.uomValue,
-      INVENTORY_TRANSACTION_TYPE.UNLOADING
+      this.user,
+      this.trxMgr
     )
   }
 
@@ -888,14 +911,23 @@ export class UnloadingWorksheetController extends VasWorksheetController {
         await this.trxMgr.getRepository(Inventory).save(inventory)
 
         if (inventory.qty == 0) {
+          await this.trxMgr.getRepository(Inventory).createQueryBuilder()
+            .update(Inventory).set({
+              lastSeq: () => `"last_seq" + 1`,
+              status: INVENTORY_STATUS.DELETED,
+              updater: this.user, updatedAt: new Date()
+            })
+            .where('id = :id', { id: inventory.id }).execute()
           inventory.lastSeq++
           inventory.status = INVENTORY_STATUS.DELETED
-          inventory = await this.transactionInventory(
+          await generateInventoryHistory(
             inventory,
             Boolean(orderType === ORDER_TYPES.ARRIVAL_NOTICE) ? arrivalNotice : returnOrder,
+            INVENTORY_TRANSACTION_TYPE.UNDO_UNLOADING,
             -inventory.qty,
             -inventory.uomValue,
-            INVENTORY_TRANSACTION_TYPE.UNDO_UNLOADING
+            this.user,
+            this.trxMgr
           )
           inventory.qty = 0
           inventory.uomValue = 0
@@ -909,14 +941,23 @@ export class UnloadingWorksheetController extends VasWorksheetController {
           await this.trxMgr.getRepository(Inventory).delete({ id: inventory.id })
         }
       } else {
+        await this.trxMgr.getRepository(Inventory).createQueryBuilder()
+          .update(Inventory).set({
+            lastSeq: () => `"last_seq" + 1`,
+            status: INVENTORY_STATUS.DELETED,
+            updater: this.user, updatedAt: new Date()
+          })
+          .where('id = :id', { id: inventory.id }).execute()
         inventory.lastSeq++
         inventory.status = INVENTORY_STATUS.DELETED
-        inventory = await this.transactionInventory(
+        await generateInventoryHistory(
           inventory,
           Boolean(orderType === ORDER_TYPES.ARRIVAL_NOTICE) ? arrivalNotice : returnOrder,
+          INVENTORY_TRANSACTION_TYPE.UNDO_UNLOADING,
           -inventory.qty,
           -inventory.uomValue,
-          INVENTORY_TRANSACTION_TYPE.UNDO_UNLOADING
+          this.user,
+          this.trxMgr
         )
         inventory.qty = 0
         inventory.uomValue = 0
@@ -1096,12 +1137,14 @@ export class UnloadingWorksheetController extends VasWorksheetController {
       }
 
       for (const inventory of inventories) {
-        await this.transactionInventory(
+        await generateInventoryHistory(
           inventory,
           arrivalNotice,
+          INVENTORY_TRANSACTION_TYPE.UNLOADING,
           inventory.qty,
           inventory.uomValue,
-          INVENTORY_TRANSACTION_TYPE.UNLOADING
+          this.user,
+          this.trxMgr
         )
       }
     } catch (e) {

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

@@ -18,6 +18,7 @@ import {
 } from '@things-factory/sales-base'
 import { webhookHandler, WebhookEventsEnum } from '@things-factory/integration-base'
 import {
+  generateInventoryHistory,
   Inventory,
   INVENTORY_ITEM_SOURCE,
   INVENTORY_STATUS,
@@ -296,7 +297,7 @@ export class PackingWorksheetController extends VasWorksheetController {
           await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
         }
 
-        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
+        await generateInventoryHistory(inventory, releaseGood, INVENTORY_TRANSACTION_TYPE.PACKING, 0, 0, this.user, this.trxMgr)
 
         worksheetDetail.status = WORKSHEET_STATUS.DONE
       }
@@ -484,7 +485,7 @@ export class PackingWorksheetController extends VasWorksheetController {
 
       if (orderInventory.packedQty === releaseQty) {
         orderInventory.status = ORDER_INVENTORY_STATUS.PACKED
-        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
+        await generateInventoryHistory(inventory, releaseGood, INVENTORY_TRANSACTION_TYPE.PACKING, 0, 0, this.user, this.trxMgr)
         await this.trxMgr.getRepository(WorksheetDetail).update(
           { targetInventory: { id: orderInventory.id }, type: 'PACKING' },
           {

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`))
 
@@ -1371,10 +1414,31 @@ export class PickingWorksheetController extends VasWorksheetController {
         if (!toLocation) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName))
 
         if (fromLocation.id !== toLocation.id) {
+          await this.trxMgr
+            .getRepository(Inventory)
+            .update(
+              { id: inventory.id },
+              {
+                location: toLocation,
+                warehouse: toLocation.warehouse,
+                zone: toLocation.zone,
+                updater: this.user
+              }
+            )
+
           inventory.location = toLocation
           inventory.warehouse = toLocation.warehouse
           inventory.zone = toLocation.zone
-          inventory = await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.RELOCATE)
+
+          await generateInventoryHistory(
+            inventory,
+            releaseGood,
+            INVENTORY_TRANSACTION_TYPE.RELOCATE,
+            0,
+            0,
+            this.user,
+            this.trxMgr
+          )
         }
       }
     } catch (error) {
@@ -1426,6 +1490,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 +1554,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 +1569,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()
@@ -1521,10 +1599,31 @@ export class PickingWorksheetController extends VasWorksheetController {
         if (!toLocation) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName))
 
         if (fromLocation.id !== toLocation.id) {
+          await this.trxMgr
+            .getRepository(Inventory)
+            .update(
+              { id: inventory.id },
+              {
+                location: toLocation,
+                warehouse: toLocation.warehouse,
+                zone: toLocation.zone,
+                updater: this.user
+              }
+            )
+
           inventory.location = toLocation
           inventory.warehouse = toLocation.warehouse
           inventory.zone = toLocation.zone
-          await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.RELOCATE)
+
+          await generateInventoryHistory(
+            inventory,
+            releaseGood,
+            INVENTORY_TRANSACTION_TYPE.RELOCATE,
+            0,
+            0,
+            this.user,
+            this.trxMgr
+          )
         }
       }
     }
@@ -1599,6 +1698,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 +1782,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 +1797,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 +2074,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 +2096,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 +2683,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 +2798,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()