@things-factory/operato-hub 4.3.744 → 4.3.745

package/server/routers/api/restful-apis/v1/warehouse/update-release-order-details.ts

@@ -1,15 +1,58 @@
-import { EntityManager, getConnection } from 'typeorm'
+import { EntityManager, getConnection, getRepository, In, SelectQueryBuilder } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
 
 import { restfulApiRouter as router } from '@things-factory/api'
 import { User } from '@things-factory/auth-base'
-import { getMyBizplace } from '@things-factory/biz-base'
-import { ORDER_STATUS, OrderNoGenerator, ReleaseGood, ShippingOrder } from '@things-factory/sales-base'
+import { Bizplace, ContactPoint, getCompanyBizplace, getMyBizplace } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
+  ORDER_STATUS,
+  ORDER_TYPES,
+  OrderNoGenerator,
+  OrderInventory,
+  OrderProduct,
+  ReleaseGood,
+  ShippingOrder
+} from '@things-factory/sales-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS, LOCATION_TYPE, ProductDetailStock } from '@things-factory/warehouse-base'
+import {
+  Worksheet,
+  WorksheetDetail,
+  WORKSHEET_STATUS,
+  WORKSHEET_TYPE,
+  WorksheetNoGenerator
+} from '@things-factory/worksheet-base'
 
 import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
 import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
 
 const debug = require('debug')('things-factory:operato-hub:restful-api:v1:update-release-order-details')
 
+// Allowed statuses for updates (order information only)
+const ALLOWED_STATUSES_FOR_INFO_UPDATE = [
+  ORDER_STATUS.PENDING,
+  ORDER_STATUS.PENDING_RECEIVE,
+  ORDER_STATUS.PENDING_WORKSHEET,
+  ORDER_STATUS.READY_TO_PICK,
+  ORDER_STATUS.PICKING,
+  ORDER_STATUS.READY_TO_LOAD,
+  ORDER_STATUS.LOADING,
+  ORDER_STATUS.READY_TO_PACK,
+  ORDER_STATUS.PACKING
+]
+
+// Allowed statuses for order product updates
+const ALLOWED_STATUSES_FOR_PRODUCT_UPDATE = [
+  ORDER_STATUS.PENDING,
+  ORDER_STATUS.PENDING_RECEIVE,
+  ORDER_STATUS.PENDING_WORKSHEET,
+  ORDER_STATUS.READY_TO_PICK
+]
+
 router.post(
   '/v1/warehouse/update-release-order-details',
   businessMiddleware,
@@ -27,11 +70,12 @@ router.post(
 
         let patch: any = {}
         patch.releaseGood = bodyReq.releaseGood
+        patch.orderProducts = bodyReq.orderProducts || []
 
         if (bodyReq?.shippingOrder) patch.shippingOrder = bodyReq.shippingOrder
         else patch.shippingOrder = null
 
-        context.body = await updateReleaseGoodDetails(tx, domain, patch, user)
+        context.body = await updateReleaseGoodDetails(tx, domain, patch, user, context)
       })
     } catch (e) {
       if (e instanceof ApiError) ApiErrorHandler(context, e)
@@ -40,40 +84,57 @@ router.post(
   }
 )
 
-async function updateReleaseGoodDetails(tx, domain, patch, user) {
-  let { releaseGood, shippingOrder } = patch
-  let status = [ORDER_STATUS.DONE, ORDER_STATUS.CANCELLED, ORDER_STATUS.REJECTED]
-  
+async function updateReleaseGoodDetails(tx: EntityManager, domain: Domain, patch: any, user: User, context: any) {
+  let { releaseGood, shippingOrder, orderProducts: inputOrderProducts } = patch
+
   // Build where clause: prioritize refOrderId over roId
   let whereClause: any = { domain }
   const refOrderId = releaseGood?.refOrderId
   const hasRefOrderId = refOrderId != null && refOrderId !== ''
-  
+  const roId = releaseGood?.roId
+
   if (hasRefOrderId) {
     whereClause.refOrderId = refOrderId
-  } else if (releaseGood?.roId) {
-    whereClause.id = releaseGood.roId
+  } else if (roId) {
+    whereClause.id = roId
   } else {
     throw new ApiError('E04', 'release order: roId or refOrderId is required')
   }
-  
+
   let foundReleaseGood = await tx.getRepository(ReleaseGood).findOne({
     where: whereClause,
-    relations: ['shippingOrder']
+    relations: ['bizplace', 'shippingOrder', 'orderProducts', 'orderProducts.product', 'orderProducts.productDetail']
   })
 
   if (!foundReleaseGood) {
-    const searchId = hasRefOrderId 
-      ? `refOrderId: ${refOrderId}` 
-      : `roId: ${releaseGood?.roId}`
+    const searchId = hasRefOrderId ? `refOrderId: ${refOrderId}` : `roId: ${roId}`
     throw new ApiError('E04', `release order: ${searchId}`)
   }
 
-  if (status.indexOf(foundReleaseGood.status) !== -1) {
-    throw new ApiError('E04', `release order status: ${foundReleaseGood.status}`)
+  // Validate status for order information updates
+  const releaseGoodStatus = (foundReleaseGood as ReleaseGood).status
+  if (!ALLOWED_STATUSES_FOR_INFO_UPDATE.includes(releaseGoodStatus)) {
+    throw new ApiError(
+      'E04',
+      `Release order status "${releaseGoodStatus}" does not allow updates. Allowed statuses: ${ALLOWED_STATUSES_FOR_INFO_UPDATE.join(
+        ', '
+      )}`
+    )
+  }
+
+  // Validate status for order product updates
+  if (inputOrderProducts && inputOrderProducts.length > 0) {
+    if (!ALLOWED_STATUSES_FOR_PRODUCT_UPDATE.includes(releaseGoodStatus)) {
+      throw new ApiError(
+        'E04',
+        `Order product updates are not allowed when release order status is "${releaseGoodStatus}". Order products can only be updated when status is: ${ALLOWED_STATUSES_FOR_PRODUCT_UPDATE.join(
+          ', '
+        )}`
+      )
+    }
   }
 
-  // case to update existing shippingOrder
+  // Update shipping order if provided
   if (shippingOrder !== null) {
     shippingOrder.remark = shippingOrder.exportRemark
     shippingOrder.containerClosureDateTime = shippingOrder.containerClosureDate
@@ -82,11 +143,11 @@ async function updateReleaseGoodDetails(tx, domain, patch, user) {
     delete shippingOrder.exportRemark
   }
 
-  if (foundReleaseGood.shippingOrder && shippingOrder) {
-    await tx.getRepository(ShippingOrder).update(foundReleaseGood.shippingOrder.id, shippingOrder)
-  }
-  // case for new shippingOrder
-  else if (!foundReleaseGood.shippingOrder && shippingOrder) {
+  const releaseGoodEntityForShipping = foundReleaseGood as ReleaseGood
+  const foundShippingOrder = releaseGoodEntityForShipping.shippingOrder as ShippingOrder | null
+  if (foundShippingOrder && shippingOrder) {
+    await tx.getRepository(ShippingOrder).update(foundShippingOrder.id, shippingOrder)
+  } else if (!foundShippingOrder && shippingOrder) {
     let newShippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).save({
       ...shippingOrder,
       name: OrderNoGenerator.shippingOrder(),
@@ -100,11 +161,1043 @@ async function updateReleaseGoodDetails(tx, domain, patch, user) {
     releaseGood.shippingOrder = newShippingOrder
   }
 
-  foundReleaseGood = await tx.getRepository(ReleaseGood).save({
-    ...foundReleaseGood,
-    ...releaseGood,
-    remark: releaseGood?.remark ? releaseGood.remark : null
+  // Update order products if provided
+  if (inputOrderProducts && inputOrderProducts.length > 0) {
+    await updateOrderProducts(tx, foundReleaseGood, inputOrderProducts, domain, user, context)
+  }
+
+  // Update release good fields
+  const updateData: any = {
+    remark: releaseGood?.remark ? releaseGood.remark : null,
+    updater: user
+  }
+
+  const releaseGoodPatch = releaseGood as any
+  if (releaseGoodPatch?.refNo !== undefined) updateData.refNo = releaseGoodPatch.refNo
+  if (releaseGoodPatch?.refNo2 !== undefined) updateData.refNo2 = releaseGoodPatch.refNo2
+  if (releaseGoodPatch?.refNo3 !== undefined) updateData.refNo3 = releaseGoodPatch.refNo3
+  if (releaseGoodPatch?.description !== undefined) updateData.description = releaseGoodPatch.description
+  if (releaseGoodPatch?.truckNo !== undefined) updateData.truckNo = releaseGoodPatch.truckNo
+  if (releaseGoodPatch?.collectionOrderNo !== undefined)
+    updateData.collectionOrderNo = releaseGoodPatch.collectionOrderNo
+  if (releaseGoodPatch?.releaseDate !== undefined) updateData.releaseDate = releaseGoodPatch.releaseDate
+  if (releaseGoodPatch?.ownTransport !== undefined) updateData.ownTransport = releaseGoodPatch.ownTransport
+  if (releaseGoodPatch?.exportOption !== undefined) updateData.exportOption = releaseGoodPatch.exportOption
+  if (releaseGoodPatch?.packingOption !== undefined) updateData.packingOption = releaseGoodPatch.packingOption
+  if (releaseGoodPatch?.courierOption !== undefined) updateData.courierOption = releaseGoodPatch.courierOption
+  if (releaseGoodPatch?.shippingOrder !== undefined) updateData.shippingOrder = releaseGoodPatch.shippingOrder
+
+  const releaseGoodEntityForUpdate = foundReleaseGood as ReleaseGood
+  // Exclude orderProducts relation to prevent TypeORM from syncing and clearing foreign keys
+  const { orderProducts, orderInventories, deliveryOrders, ...releaseGoodWithoutRelations } = releaseGoodEntityForUpdate
+  await tx.getRepository(ReleaseGood).save({
+    ...releaseGoodWithoutRelations,
+    ...updateData
   })
 
-  return foundReleaseGood
+  // Fetch updated release good with relations for response
+  // Query order products separately to ensure we get all of them including newly added ones
+  const releaseGoodId = (foundReleaseGood as ReleaseGood).id
+
+  // Fetch release good basic info
+  const updatedReleaseGood: ReleaseGood | undefined = await tx.getRepository(ReleaseGood).findOne({
+    where: { id: releaseGoodId },
+    relations: ['shippingOrder']
+  })
+
+  if (!updatedReleaseGood) {
+    throw new ApiError('E04', 'Failed to retrieve updated release order')
+  }
+
+  // Fetch all order products separately to ensure we get newly added ones
+  const allOrderProducts = await tx.getRepository(OrderProduct).find({
+    where: { releaseGood: { id: releaseGoodId } },
+    relations: ['product', 'productDetail']
+  })
+
+  // Attach order products to release good
+  updatedReleaseGood.orderProducts = allOrderProducts
+
+  const releaseGoodForResponse = updatedReleaseGood as ReleaseGood
+
+  // Format response - only include necessary fields
+  const resultOrderProducts = (releaseGoodForResponse.orderProducts || []).map((op: OrderProduct) => ({
+    id: op.id,
+    product: {
+      sku: op.product?.sku || null,
+      name: op.product?.name || null
+    },
+    productDetail: {
+      refCode: (op.productDetail as any)?.refCode || null
+    },
+    batchId: op.batchId,
+    packingType: op.packingType,
+    packingSize: op.packingSize,
+    releaseQty: op.releaseQty,
+    releaseUomValue: op.releaseUomValue,
+    uom: op.uom,
+    refItemId: op.refItemId || null,
+    unitPrice: op.unitPrice || null,
+    remark: op.remark || null,
+    status: op.status
+  }))
+
+  const shippingOrderData = releaseGoodForResponse.shippingOrder
+    ? {
+        id: (releaseGoodForResponse.shippingOrder as ShippingOrder).id,
+        name: (releaseGoodForResponse.shippingOrder as ShippingOrder).name,
+        status: (releaseGoodForResponse.shippingOrder as ShippingOrder).status
+      }
+    : null
+
+  const data = {
+    id: releaseGoodForResponse.id,
+    roNo: releaseGoodForResponse.name,
+    refOrderId: releaseGoodForResponse.refOrderId,
+    refNo: releaseGoodForResponse.refNo,
+    refNo2: releaseGoodForResponse.refNo2,
+    refNo3: releaseGoodForResponse.refNo3,
+    description: releaseGoodForResponse.description,
+    truckNo: releaseGoodForResponse.truckNo,
+    collectionOrderNo: releaseGoodForResponse.collectionOrderNo,
+    releaseDate: releaseGoodForResponse.releaseDate,
+    ownTransport: releaseGoodForResponse.ownTransport,
+    exportOption: releaseGoodForResponse.exportOption,
+    packingOption: releaseGoodForResponse.packingOption,
+    courierOption: releaseGoodForResponse.courierOption,
+    status: releaseGoodForResponse.status,
+    remark: releaseGoodForResponse.remark,
+    orderProducts: resultOrderProducts,
+    shippingOrder: shippingOrderData
+  }
+
+  return {
+    responseCode: '200',
+    message: 'success',
+    data
+  }
+}
+
+async function updateOrderProducts(
+  tx: EntityManager,
+  releaseGood: ReleaseGood,
+  inputOrderProducts: any[],
+  domain: Domain,
+  user: User,
+  context: any
+) {
+  // Get existing order products with their order inventories
+  const existingOrderProducts = await tx.getRepository(OrderProduct).find({
+    where: { releaseGood },
+    relations: ['product', 'productDetail', 'orderInventories', 'orderInventories.inventory']
+  })
+
+  // Determine hasOrderInventories by checking if releaseGood has any orderInventories
+  // Check directly on releaseGood by counting orderInventories
+  const orderInventoriesCount = await tx.getRepository(OrderInventory).count({
+    where: { releaseGood }
+  })
+  const hasOrderInventories = orderInventoriesCount > 0
+
+  // Process removals first
+  const orderProductIdsToRemove: string[] = []
+  const orderProductsToUpdate: any[] = []
+  const orderProductsToAdd: any[] = []
+
+  for (const orderProductReq of inputOrderProducts) {
+    if (orderProductReq._action === 'remove') {
+      const matchingOP = findMatchingOrderProduct(existingOrderProducts, orderProductReq)
+      if (!matchingOP) {
+        throw new ApiError(
+          'E04',
+          `Order product not found for removal. Provide id, sku, refCode, batchId, packingType, or refItemId to identify the item.`
+        )
+      }
+      orderProductIdsToRemove.push(matchingOP.id)
+      continue
+    }
+
+    // Try to find existing order product for update
+    const matchingOP = findMatchingOrderProduct(existingOrderProducts, orderProductReq)
+
+    if (matchingOP) {
+      orderProductsToUpdate.push({ existing: matchingOP, request: orderProductReq })
+    } else {
+      orderProductsToAdd.push(orderProductReq)
+    }
+  }
+
+  // Validate: Prevent removing all products from the order
+  // If removing products would leave the order with zero products, throw an error
+  const existingProductCount = existingOrderProducts.length
+  const productsToRemoveCount = orderProductIdsToRemove.length
+  const productsToAddCount = orderProductsToAdd.length
+  const remainingProductCount = existingProductCount - productsToRemoveCount + productsToAddCount
+
+  if (remainingProductCount <= 0) {
+    throw new ApiError(
+      'E04',
+      'Cannot remove all products from the release order. Please use the cancellation API to cancel the entire order instead of removing the final item(s).'
+    )
+  }
+
+  // Remove order products
+  if (orderProductIdsToRemove.length > 0) {
+    await removeOrderProducts(tx, orderProductIdsToRemove, hasOrderInventories)
+  }
+
+  // Update existing order products
+  for (const { existing, request } of orderProductsToUpdate) {
+    await updateExistingOrderProduct(tx, existing, request, releaseGood, domain, user, context, hasOrderInventories)
+  }
+
+  // Add new order products
+  for (const orderProductReq of orderProductsToAdd) {
+    await addNewOrderProduct(tx, orderProductReq, releaseGood, domain, user, context, hasOrderInventories)
+  }
+}
+
+function findMatchingOrderProduct(existingOrderProducts: OrderProduct[], orderProductReq: any): OrderProduct | null {
+  // First try by ID if provided
+  if (orderProductReq.id) {
+    const found = existingOrderProducts.find(op => op.id === orderProductReq.id)
+    if (found) return found
+  }
+
+  // Extract matching fields
+  const sku = orderProductReq.product?.sku || orderProductReq.sku
+  const refCode = orderProductReq.product?.refCode || orderProductReq.productDetail?.refCode || orderProductReq.refCode
+  const batchId = orderProductReq.batchId
+  const packingType = orderProductReq.packingType
+  const refItemId = orderProductReq.refItemId
+
+  // Need at least one matching field (besides id)
+  if (!sku && !refCode && !batchId && !packingType && !refItemId) {
+    return null
+  }
+
+  // Match by provided fields (all provided fields must match)
+  return (
+    existingOrderProducts.find(op => {
+      const matchesSku = !sku || op.product?.sku === sku
+      const matchesRefCode = !refCode || (op.productDetail as any)?.refCode === refCode
+      const matchesBatchId = !batchId || op.batchId === batchId
+      const matchesPackingType = !packingType || op.packingType === packingType
+      const matchesRefItemId = !refItemId || op.refItemId === refItemId
+
+      return matchesSku && matchesRefCode && matchesBatchId && matchesPackingType && matchesRefItemId
+    }) || null
+  )
+}
+
+async function removeOrderProducts(tx: EntityManager, orderProductIds: string[], hasOrderInventories: boolean) {
+  for (const orderProductId of orderProductIds) {
+    const orderProduct = await tx.getRepository(OrderProduct).findOne({
+      where: { id: orderProductId },
+      relations: ['orderInventories', 'orderInventories.inventory']
+    })
+
+    if (!orderProduct) continue
+
+    const orderProductEntity = orderProduct as OrderProduct
+    const orderInventories = (orderProductEntity.orderInventories || []) as OrderInventory[]
+    const releaseQty = orderProductEntity.releaseQty || 0
+    const releaseUomValue = orderProductEntity.releaseUomValue || 0
+
+    if (hasOrderInventories && orderInventories.length > 0) {
+      // Release locked quantities from inventories
+      for (const orderInventory of orderInventories) {
+        const inventory = orderInventory.inventory as Inventory | null
+        if (inventory) {
+          const oiReleaseQty = orderInventory.releaseQty || 0
+          const oiReleaseUomValue = orderInventory.releaseUomValue || 0
+          const inventoryEntity = inventory as Inventory
+          await tx
+            .getRepository(Inventory)
+            .createQueryBuilder()
+            .update(Inventory)
+            .set({
+              lockedQty: () => `COALESCE(locked_qty, 0) - ${oiReleaseQty}`,
+              lockedUomValue: () => `COALESCE(locked_uom_value, 0) - ${oiReleaseUomValue}`,
+              updater: orderProductEntity.updater
+            })
+            .where('id = :id', { id: inventoryEntity.id })
+            .execute()
+        }
+      }
+
+      // Delete order inventories
+      // First, delete any worksheet details that reference these order inventories
+      const oiIds = orderInventories.map(oi => oi.id).filter((id): id is string => !!id)
+      if (oiIds.length > 0) {
+        // Find and delete worksheet details that reference the order inventories to be deleted
+        // Join with OrderInventory to find worksheet details by order inventory IDs
+        const worksheetDetailsToDelete: WorksheetDetail[] = await tx
+          .getRepository(WorksheetDetail)
+          .createQueryBuilder('wsd')
+          .innerJoin('wsd.targetInventory', 'oi')
+          .where('oi.id IN (:...oiIds)', { oiIds })
+          .andWhere('wsd.domain = :domainId', {
+            domainId: orderProductEntity.domain?.id || orderProductEntity.domainId
+          })
+          .getMany()
+
+        if (worksheetDetailsToDelete.length > 0) {
+          const worksheetDetailIds = worksheetDetailsToDelete.map(wsd => wsd.id)
+          await tx.getRepository(WorksheetDetail).delete(worksheetDetailIds)
+        }
+
+        // Now delete the order inventories
+        await tx.getRepository(OrderInventory).delete(oiIds)
+      }
+    } else {
+      // Update ProductDetailStock unassigned quantities
+      const productDetail = orderProductEntity.productDetail as ProductDetail | null
+      if (productDetail && productDetail.id) {
+        await tx
+          .getRepository(ProductDetailStock)
+          .createQueryBuilder()
+          .update(ProductDetailStock)
+          .set({
+            unassignedQty: () => `"unassigned_qty" - ${releaseQty}`,
+            unassignedUomValue: () => `"unassigned_uom_value" - ${releaseUomValue}`
+          })
+          .where({ productDetail: productDetail.id })
+          .execute()
+      }
+    }
+
+    // Delete order product
+    await tx.getRepository(OrderProduct).delete(orderProductId)
+  }
+}
+
+async function updateExistingOrderProduct(
+  tx: EntityManager,
+  existing: OrderProduct,
+  request: any,
+  releaseGood: ReleaseGood,
+  domain: Domain,
+  user: User,
+  context: any,
+  hasOrderInventories: boolean
+) {
+  const newQty = request.releaseQty !== undefined ? request.releaseQty : request.qty
+  if (newQty === undefined) {
+    // No quantity change, just update other fields if provided
+    const updateData: any = { updater: user }
+    if (request.remark !== undefined) updateData.remark = request.remark
+    if (request.unitPrice !== undefined) updateData.unitPrice = request.unitPrice
+
+    await tx.getRepository(OrderProduct).update(existing.id, updateData)
+    return
+  }
+
+  if (newQty <= 0) {
+    throw new ApiError('E01', 'releaseQty must be greater than 0')
+  }
+
+  const qtyDiff = newQty - existing.releaseQty
+  const uomValueDiff = (newQty - existing.releaseQty) * (existing.productDetail?.uomValue || 1)
+
+  // Validate decimal places for non-decimal products
+  if (!existing.product?.isInventoryDecimal && newQty % 1 !== 0) {
+    throw new ApiError('E01', `releaseQty must be an integer for product ${existing.product?.sku}`)
+  }
+
+  // Round to 3 decimal places
+  const roundedNewQty = existing.product?.isInventoryDecimal ? Math.round(newQty * 1000) / 1000 : Math.round(newQty)
+  const roundedNewUomValue = roundedNewQty * (existing.productDetail?.uomValue || 1)
+
+  if (hasOrderInventories) {
+    // Update order inventories
+    await updateOrderInventoriesForQtyChange(
+      tx,
+      existing,
+      qtyDiff,
+      uomValueDiff,
+      roundedNewQty,
+      roundedNewUomValue,
+      user,
+      releaseGood,
+      domain
+    )
+  } else {
+    // Update ProductDetailStock
+    await tx
+      .getRepository(ProductDetailStock)
+      .createQueryBuilder()
+      .update(ProductDetailStock)
+      .set({
+        unassignedQty: () => `"unassigned_qty" + ${qtyDiff}`,
+        unassignedUomValue: () => `"unassigned_uom_value" + ${uomValueDiff}`
+      })
+      .where({ productDetail: existing.productDetail.id })
+      .execute()
+  }
+
+  // Update order product
+  const updateData: any = {
+    releaseQty: roundedNewQty,
+    releaseUomValue: roundedNewUomValue,
+    updater: user
+  }
+  if (request.remark !== undefined) updateData.remark = request.remark
+  if (request.unitPrice !== undefined) updateData.unitPrice = request.unitPrice
+
+  await tx.getRepository(OrderProduct).update(existing.id, updateData)
+}
+
+async function updateOrderInventoriesForQtyChange(
+  tx: EntityManager,
+  orderProduct: OrderProduct,
+  qtyDiff: number,
+  uomValueDiff: number,
+  newQty: number,
+  newUomValue: number,
+  user: User,
+  releaseGood: ReleaseGood,
+  domain: Domain
+) {
+  const existingOrderInventories = (await tx.getRepository(OrderInventory).find({
+    where: { orderProduct },
+    relations: ['inventory']
+  })) as OrderInventory[]
+
+  if (qtyDiff > 0) {
+    // Increase: assign more inventory
+    await assignAdditionalInventory(tx, orderProduct, qtyDiff, uomValueDiff, user, releaseGood, domain)
+  } else if (qtyDiff < 0) {
+    // Decrease: select latest order inventories and deduct from them
+    const reductionQty = Math.abs(qtyDiff)
+    const reductionUomValue = Math.abs(uomValueDiff)
+
+    // Sort order inventories by creation date (latest first)
+    const sortedOrderInventories = [...existingOrderInventories].sort((a, b) => {
+      const dateA = a.createdAt ? new Date(a.createdAt).getTime() : 0
+      const dateB = b.createdAt ? new Date(b.createdAt).getTime() : 0
+      return dateB - dateA // Latest first
+    })
+
+    let remainingReductionQty = reductionQty
+    let remainingReductionUomValue = reductionUomValue
+    const orderInventoriesToDelete: string[] = []
+
+    for (const oi of sortedOrderInventories) {
+      if (remainingReductionQty <= 0 && remainingReductionUomValue <= 0) {
+        break
+      }
+
+      const oiReleaseQty = oi.releaseQty || 0
+      const oiReleaseUomValue = oi.releaseUomValue || 0
+
+      // Calculate how much to deduct from this order inventory
+      const deductQty = Math.min(remainingReductionQty, oiReleaseQty)
+      const deductUomValue = Math.min(remainingReductionUomValue, oiReleaseUomValue)
+
+      const inventory = oi.inventory as Inventory | null
+      if (inventory) {
+        // Release locked quantities from inventory
+        await tx
+          .getRepository(Inventory)
+          .createQueryBuilder()
+          .update(Inventory)
+          .set({
+            lockedQty: () => `COALESCE(locked_qty, 0) - ${deductQty}`,
+            lockedUomValue: () => `COALESCE(locked_uom_value, 0) - ${deductUomValue}`,
+            updater: user
+          })
+          .where('id = :id', { id: inventory.id })
+          .execute()
+      }
+
+      const newOiQty = oiReleaseQty - deductQty
+      const newOiUomValue = oiReleaseUomValue - deductUomValue
+
+      if (newOiQty <= 0 || newOiUomValue <= 0) {
+        // Mark this order inventory for deletion
+        orderInventoriesToDelete.push(oi.id)
+      } else {
+        // Update order inventory with remaining quantity
+        await tx.getRepository(OrderInventory).update(oi.id, {
+          releaseQty: newOiQty,
+          releaseUomValue: newOiUomValue,
+          updater: user
+        })
+      }
+
+      remainingReductionQty -= deductQty
+      remainingReductionUomValue -= deductUomValue
+    }
+
+    // Delete order inventories that are fully consumed
+    if (orderInventoriesToDelete.length > 0) {
+      // Find and delete worksheet details that reference these order inventories
+      const worksheetDetailsToDelete: WorksheetDetail[] = await tx
+        .getRepository(WorksheetDetail)
+        .createQueryBuilder('wsd')
+        .innerJoin('wsd.targetInventory', 'oi')
+        .where('oi.id IN (:...oiIds)', { oiIds: orderInventoriesToDelete })
+        .andWhere('wsd.domain = :domainId', { domainId: domain.id })
+        .getMany()
+
+      if (worksheetDetailsToDelete.length > 0) {
+        const worksheetDetailIds = worksheetDetailsToDelete.map(wsd => wsd.id)
+        await tx.getRepository(WorksheetDetail).delete(worksheetDetailIds)
+      }
+
+      // Now delete the order inventories
+      await tx.getRepository(OrderInventory).delete(orderInventoriesToDelete)
+    }
+  }
+
+  // Update order product totals
+  const remainingOrderInventories = (await tx.getRepository(OrderInventory).find({
+    where: { orderProduct }
+  })) as OrderInventory[]
+
+  const totalReleaseQty = remainingOrderInventories.reduce((sum, oi) => sum + (oi.releaseQty || 0), 0)
+  const totalReleaseUomValue = remainingOrderInventories.reduce((sum, oi) => sum + (oi.releaseUomValue || 0), 0)
+
+  await tx.getRepository(OrderProduct).update(orderProduct.id, {
+    releaseQty: totalReleaseQty,
+    releaseUomValue: totalReleaseUomValue,
+    updater: user
+  })
+}
+
+async function assignAdditionalInventory(
+  tx: EntityManager,
+  orderProduct: OrderProduct,
+  qtyDiff: number,
+  uomValueDiff: number,
+  user: User,
+  releaseGood: ReleaseGood,
+  domain: Domain
+) {
+  // Get customer bizplace from releaseGood (it's already loaded)
+  // If not loaded, fetch it using bizplaceId
+  let customerBizplace = releaseGood.bizplace as Bizplace | undefined
+  if (!customerBizplace && releaseGood.bizplaceId) {
+    customerBizplace = await tx.getRepository(Bizplace).findOne({
+      where: { id: releaseGood.bizplaceId }
+    })
+  }
+  if (!customerBizplace) {
+    throw new ApiError('E04', 'Customer bizplace not found for release order')
+  }
+
+  // Get release shelf life override from contact point (deliverTo)
+  let releaseShelfLifeOverride: number | null = null
+  if (releaseGood.deliverToId) {
+    const deliverToContactPoint: ContactPoint | null = await tx
+      .getRepository(ContactPoint)
+      .findOne({ where: { id: releaseGood.deliverToId } })
+    if (deliverToContactPoint?.releaseShelfLife != null && deliverToContactPoint.releaseShelfLife !== 0) {
+      releaseShelfLifeOverride = deliverToContactPoint.releaseShelfLife
+    }
+  }
+
+  // Get picking product setting
+  const pickingProductSetting: Setting = await tx.getRepository(Setting).findOne({
+    where: { domain, name: 'rule-for-picking-product' }
+  })
+
+  // Determine orderInventory status based on releaseGood status
+  let orderInventoryStatus: string
+  switch (releaseGood.status) {
+    case ORDER_STATUS.PENDING:
+      orderInventoryStatus = ORDER_INVENTORY_STATUS.PENDING
+      break
+    case ORDER_STATUS.PENDING_RECEIVE:
+      orderInventoryStatus = ORDER_INVENTORY_STATUS.PENDING_RECEIVE
+      break
+    case ORDER_STATUS.PENDING_WORKSHEET:
+      orderInventoryStatus = ORDER_INVENTORY_STATUS.PENDING_WORKSHEET
+      break
+    case ORDER_STATUS.READY_TO_PICK:
+      orderInventoryStatus = ORDER_INVENTORY_STATUS.READY_TO_PICK
+      break
+    default:
+      // Default to PENDING_WORKSHEET for other statuses
+      orderInventoryStatus = ORDER_INVENTORY_STATUS.PENDING_WORKSHEET
+  }
+
+  // Ensure product is loaded
+  if (!orderProduct.product) {
+    orderProduct.product = await tx.getRepository(Product).findOne({
+      where: { id: orderProduct.productId }
+    })
+  }
+
+  const product = orderProduct.product
+  if (!product) {
+    throw new ApiError('E04', 'Product not found for order product')
+  }
+
+  // Determine picking strategy sortings
+  let sortings: any = []
+  switch (product.pickingStrategy) {
+    case 'LIFO':
+      sortings.push({ name: 'iv.created_at', desc: true })
+      if (pickingProductSetting?.value) {
+        for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+          sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
+        }
+      } else {
+        sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false })
+      }
+      break
+    case 'FEFO':
+      sortings.push({ name: 'iv.expiration_date', desc: false }, { name: 'iv.created_at', desc: false })
+      if (pickingProductSetting?.value) {
+        for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+          sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
+        }
+      } else {
+        sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false })
+      }
+      break
+    case 'FMFO':
+      sortings.push({ name: 'iv.manufacture_date', desc: false }, { name: 'iv.created_at', desc: false })
+      if (pickingProductSetting?.value) {
+        for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+          sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
+        }
+      } else {
+        sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false })
+      }
+      break
+    case 'LOCATION':
+      if (pickingProductSetting?.value) {
+        for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+          sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
+        }
+      } else {
+        sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false })
+      }
+      break
+    // Every other case includes 'FIFO' will be applicable for this case
+    default:
+      sortings.push({ name: 'iv.created_at', desc: false })
+      if (pickingProductSetting?.value) {
+        for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
+          sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
+        }
+      } else {
+        sortings.push({ name: 'loc.name', desc: false })
+        sortings.push({ name: 'iv.pallet_id', desc: false })
+      }
+      break
+  }
+
+  let queryFilters: any[] = []
+  let queryStrings = queryFilters.reduce(
+    (acc, itm, idx, arr) => {
+      acc.values.push(itm.filters)
+
+      switch (itm?.operator) {
+        case 'notin':
+        case 'in':
+          acc.query.push(
+            `${itm.query} ${itm.operator == 'notin' ? 'NOT IN' : 'IN'} (${itm.filters
+              .map((itm, idx) => {
+                return `$${acc.values.length + 1}`
+              })
+              .join(',')})`
+          )
+          break
+
+        default:
+          acc.query.push(`${itm.query} ${itm?.operator ? itm.operator : '='} $${acc.values.length + 1}`)
+          break
+      }
+      acc.query.push(`${itm.query} ${itm?.operator ? itm.operator : '='} $${acc.values.length + 1}`)
+      return acc
+    },
+    {
+      query: [],
+      values: []
+    }
+  )
+
+  let sortQuery = sortings
+    .map(itm => {
+      return `${itm.name} ${itm.desc ? 'DESC' : 'ASC'}`
+    })
+    .join(`,`)
+
+  // Ensure productDetail is loaded for uom
+  if (!orderProduct.productDetail) {
+    orderProduct.productDetail = await tx.getRepository(ProductDetail).findOne({
+      where: { id: orderProduct.productDetailId }
+    })
+  }
+  const productDetail = orderProduct.productDetail as ProductDetail | null
+  const uom = (productDetail && (productDetail as any).uom) || product.uom || 'UN'
+
+  let params = [
+    user.id,
+    domain.id,
+    customerBizplace.id,
+    orderProduct.packingType,
+    orderProduct.packingSize,
+    product.id,
+    INVENTORY_STATUS.STORED,
+    LOCATION_TYPE.QUARANTINE,
+    LOCATION_TYPE.RESERVE,
+    LOCATION_TYPE.STORAGE
+  ]
+
+  let batchId = orderProduct.batchId && orderProduct.batchId !== '-' ? String(orderProduct.batchId).trim() : null
+  if (batchId) params.push(batchId)
+  params = [...params, ...queryStrings.values]
+
+  // Handle warehouse code filtering
+  const warehouseCode = (orderProduct as any).warehouseCode
+  const warehouseNameFilter = warehouseCode ? `AND w.name = $${params.length + 1}` : ''
+  if (warehouseCode) {
+    params.push(String(warehouseCode).trim())
+  }
+
+  // Add release shelf life override parameter
+  const releaseShelfLifeParamIndex = params.length + 1
+  params.push(releaseShelfLifeOverride)
+
+  // Build the sophisticated SQL query with window functions
+  let query = `
+    update inventories tgt set locked_qty = coalesce(locked_qty,0) + src.reserve_qty, 
+    locked_uom_value = coalesce(locked_uom_value,0) + src.reserve_uom_value,
+    updated_at = NOW(),
+    updater_id = $1
+    from (
+      select "id", "pallet_id","carton_id", "batch_id", "batch_id_ref", "unit", "uom", "packing_type", "packing_size", "manufacture_year",
+      "reserve_qty", (("uom_value"/"qty") * "reserve_qty") as "reserve_uom_value" from (	
+        select "sort_seq", "id", "pallet_id", "batch_id", "batch_id_ref", "unit", "uom", "packing_type", "packing_size", "manufacture_year", "carton_id", "uom_value", "locked_uom_value", "qty", "locked_qty", "created_at", 
+        "release_qty", "release_uom_value", lock_amount, 
+        case when "lock_amount" < 0 then "available_qty" else "available_qty" - "lock_amount" end as "reserve_qty"
+        from (
+          select *,
+          (
+            case when (qty - greatest(locked_qty, 0) - greatest(unassigned_qty, 0)) < 0 then 0
+            else qty - greatest(locked_qty, 0) - greatest(unassigned_qty, 0) end
+          ) as available_qty,
+          sum(qty - locked_qty - release_qty - unassigned_qty) over (order by sort_seq asc rows between unbounded preceding and current row) as lock_amount
+          from (
+            SELECT 0 as sort_seq, null as id, null as pallet_id, null as batch_id, null as batch_id_ref, 
+            null as unit, '${uom}' as uom, '${orderProduct.packingType}' as packing_type, '${
+    orderProduct.packingSize
+  }' as packing_size,
+            null as manufacture_year, null as carton_id, 0 as uom_value, 0 as locked_uom_value, 0 as qty, 0 as locked_qty, 0 as unassigned_uom_value, 0 as unassigned_qty, null as created_at,
+            ${qtyDiff}::numeric as release_qty, ${uomValueDiff}::numeric as release_uom_value
+            UNION
+            (
+              SELECT ROW_NUMBER() OVER(PARTITION BY iv.domain_id ORDER BY wiar.rank ${
+                sortQuery ? ', ' + sortQuery : ''
+              }) as sort_seq, 
+              iv.id, iv.pallet_id, iv.batch_id, iv.batch_id_ref, 
+              iv.unit, iv.uom, iv.packing_type, iv.packing_size, 
+              iv.manufacture_year, iv.carton_id, iv.uom_value, 
+              coalesce(iv.locked_uom_value,0) as locked_uom_value, iv.qty, greatest(coalesce(iv.locked_qty,0),0) as locked_qty, coalesce(pds.unassigned_uom_value,0) as unassigned_uom_value, greatest(coalesce(pds.unassigned_qty,0),0) as unassigned_qty, 
+              iv.created_at, 0 as release_qty, 0 as release_uom_value
+              FROM "inventories" "iv" 
+              LEFT JOIN "product_detail_stocks" "pds" ON "pds"."product_detail_id" = "iv"."product_detail_id"
+              INNER JOIN "locations" "loc" ON "loc"."id"="iv"."location_id" 
+              INNER JOIN "warehouses" "w" ON "w"."id" = "loc"."warehouse_id"
+              INNER JOIN "products" "p" ON "p"."id"="iv"."product_id" 
+              INNER JOIN "warehouse_inventory_assignment_rankings" "wiar" ON "wiar"."location_type"="loc"."type"
+              WHERE case when coalesce("iv"."locked_qty",0) < 0 then 0 else ("iv"."qty" - coalesce("iv"."locked_qty",0)) end > 0 AND 
+               "iv"."domain_id" = $2 AND "iv"."bizplace_id" = $3 AND "iv"."packing_type" = $4 AND "iv"."packing_size" = $5 AND  "iv"."product_id" = $6 AND "iv"."status" = $7 AND "loc"."type" NOT IN ($8, $9, $10)
+               AND ${batchId ? `"iv"."batch_id" = $11` : `1=1`}
+              ${warehouseNameFilter}
+              AND "iv"."obsolete" = false AND (
+                "iv"."expiration_date" IS NULL
+                OR
+                CASE
+                  WHEN $${releaseShelfLifeParamIndex}::integer IS NOT NULL AND $${releaseShelfLifeParamIndex}::integer > 0 THEN
+                    CURRENT_DATE < ("iv"."expiration_date" - $${releaseShelfLifeParamIndex}::integer)
+                  WHEN "p"."min_outbound_shelf_life" IS NOT NULL AND "p"."min_outbound_shelf_life" > 0 THEN
+                    CURRENT_DATE < ("iv"."expiration_date" - "p"."min_outbound_shelf_life")
+                  ELSE
+                    TRUE
+                END
+              )
+              ${queryStrings.query.length > 0 ? `AND ${queryStrings.query.join(' AND ')}` : ''}
+              ORDER BY wiar.rank ${sortQuery ? ', ' + sortQuery : ''}
+            )
+          ) dt1
+        ) dt2 where case when "lock_amount" < 0 then "available_qty" else "available_qty" - "lock_amount" end > 0		
+      ) dt3 where sort_seq > 0
+    ) src where src.id = tgt.id
+    returning 
+      tgt."id", tgt."qty", tgt."pallet_id", tgt."carton_id", tgt."batch_id", tgt."batch_id_ref", tgt."unit", 
+      tgt."uom", tgt."packing_type", tgt."packing_size", tgt."manufacture_year", 
+      tgt."locked_qty", tgt."uom_value", tgt."locked_uom_value", src."reserve_qty", src."reserve_uom_value";`
+
+  let updatedInventories = await tx.getRepository(Inventory).query(query, params)
+
+  let totalAssigned =
+    updatedInventories[0]?.reduce((acc: number, inv: any) => {
+      return acc + inv.reserve_qty
+    }, 0) || 0
+
+  // For non-decimal products, round the values before comparison
+  let roundedQtyDiff = qtyDiff
+  if (!product.isInventoryDecimal) {
+    roundedQtyDiff = Math.round(qtyDiff)
+    totalAssigned = Math.round(totalAssigned)
+  } else {
+    // For decimal products, round to 3 decimal places
+    roundedQtyDiff = Math.round(qtyDiff * 1000) / 1000
+    totalAssigned = Math.round(totalAssigned * 1000) / 1000
+  }
+
+  if (Math.abs(roundedQtyDiff - totalAssigned) > 0.001) {
+    // Using small epsilon for float comparison
+    throw new ApiError('E01', 'INSUFFICIENT_STOCK')
+  }
+
+  // Create order inventory records for each assigned inventory
+  if (updatedInventories[0] && updatedInventories[0].length > 0) {
+    // Ensure releaseGood.id is available (required for TypeORM relation)
+    if (!releaseGood.id) {
+      throw new ApiError('E04', 'Release good ID is required for order inventory')
+    }
+
+    // Ensure orderProduct.id is available (required for TypeORM relation)
+    if (!orderProduct.id) {
+      throw new ApiError('E04', 'Order product ID is required for order inventory')
+    }
+
+    // Get existing order inventories for this order product to check for duplicates
+    const existingOrderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+      where: { orderProduct },
+      relations: ['inventory']
+    })
+
+    // Check if worksheets exist for this release good
+    const existingWorksheets: Worksheet[] = await tx.getRepository(Worksheet).find({
+      where: {
+        releaseGood: { id: releaseGood.id },
+        type: WORKSHEET_TYPE.PICKING,
+        status: In([WORKSHEET_STATUS.DEACTIVATED])
+      },
+      relations: ['bizplace']
+    })
+
+    const newOrderInventories: OrderInventory[] = []
+
+    for (const inv of updatedInventories[0]) {
+      // Check if an order inventory already exists for this inventory ID
+      const existingOI = existingOrderInventories.find(
+        (oi: OrderInventory) => oi.inventory && (oi.inventory as Inventory).id === inv.id
+      )
+
+      let savedOrderInventory: OrderInventory
+
+      if (existingOI) {
+        // Update existing order inventory
+        const updatedReleaseQty = (existingOI.releaseQty || 0) + inv.reserve_qty
+        const updatedReleaseUomValue = (existingOI.releaseUomValue || 0) + inv.reserve_uom_value
+
+        await tx.getRepository(OrderInventory).update(existingOI.id, {
+          releaseQty: updatedReleaseQty,
+          releaseUomValue: updatedReleaseUomValue,
+          updater: user
+        })
+
+        // Reload to get updated entity
+        savedOrderInventory = (await tx.getRepository(OrderInventory).findOne({
+          where: { id: existingOI.id },
+          relations: ['inventory']
+        })) as OrderInventory
+      } else {
+        // Create new order inventory
+        savedOrderInventory = await tx.getRepository(OrderInventory).save(
+          Object.assign(new OrderInventory(), {
+            name: uuidv4(),
+            domain: domain, // Use passed domain parameter
+            bizplace: customerBizplace, // Use customerBizplace from releaseGood
+            releaseGood: releaseGood,
+            releaseGoodId: releaseGood.id, // Explicitly set to ensure foreign key is saved
+            orderProduct: orderProduct,
+            orderProductId: orderProduct.id, // Explicitly set to ensure foreign key is saved
+            product: product,
+            productDetail: productDetail,
+            inventory: { id: inv.id } as Inventory,
+            packingType: inv.packing_type,
+            packingSize: inv.packing_size,
+            batchId: inv.batch_id,
+            releaseQty: inv.reserve_qty,
+            releaseUomValue: inv.reserve_uom_value,
+            uom: inv.uom,
+            type: ORDER_TYPES.RELEASE_OF_GOODS,
+            status: orderInventoryStatus,
+            creator: user,
+            updater: user
+          })
+        )
+        newOrderInventories.push(savedOrderInventory)
+      }
+    }
+
+    // Create worksheet details for newly created order inventories if worksheets exist
+    if (existingWorksheets.length > 0 && newOrderInventories.length > 0) {
+      for (const worksheet of existingWorksheets) {
+        const worksheetDetails = newOrderInventories.map((oi: OrderInventory) => ({
+          domain: domain,
+          bizplace: (worksheet as Worksheet).bizplace || customerBizplace,
+          worksheet: worksheet,
+          name: WorksheetNoGenerator.pickingDetail(),
+          type: WORKSHEET_TYPE.PICKING,
+          status: WORKSHEET_STATUS.DEACTIVATED,
+          targetInventory: oi,
+          creator: user,
+          updater: user
+        }))
+
+        await tx.getRepository(WorksheetDetail).save(worksheetDetails)
+      }
+    }
+  }
+}
+
+async function addNewOrderProduct(
+  tx: EntityManager,
+  orderProductReq: any,
+  releaseGood: ReleaseGood,
+  domain: Domain,
+  user: User,
+  context: any,
+  hasOrderInventories: boolean
+) {
+  const sku = orderProductReq.product?.sku || orderProductReq.sku
+  const refCode = orderProductReq.product?.refCode || orderProductReq.refCode
+  const packingType = orderProductReq.packingType
+  const packingSize = orderProductReq.packingSize
+  const releaseQty = orderProductReq.releaseQty !== undefined ? orderProductReq.releaseQty : orderProductReq.qty
+  const refItemId = orderProductReq.product?.refItemId || orderProductReq.refItemId || null
+
+  if (!sku && !refCode) {
+    throw new ApiError('E01', 'sku or refCode is required for new items')
+  }
+
+  if (!releaseQty || releaseQty <= 0) {
+    throw new ApiError('E01', 'releaseQty must be greater than 0')
+  }
+
+  // Ensure releaseGood has an ID (required for TypeORM relation)
+  if (!releaseGood.id) {
+    throw new ApiError('E04', 'Release good ID is required')
+  }
+
+  // Get company bizplace for product lookup
+  const customerCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, releaseGood.bizplaceId, tx)
+
+  // Find product detail
+  const qb: SelectQueryBuilder<ProductDetail> = tx
+    .getRepository(ProductDetail)
+    .createQueryBuilder('pd')
+    .innerJoinAndSelect('pd.product', 'prod')
+    .where('prod.bizplace_id = :bizplaceId', { bizplaceId: customerCompanyBizplace.id })
+    .andWhere('pd.deleted_at IS NULL')
+
+  if (refCode) {
+    qb.andWhere('pd.ref_code = :refCode', { refCode })
+  }
+
+  if (sku) {
+    qb.andWhere('prod.sku = :sku', { sku })
+  }
+
+  if (packingType) {
+    qb.andWhere('pd.packing_type = :packingType', { packingType })
+  }
+
+  if (packingSize) {
+    qb.andWhere('pd.packing_size = :packingSize', { packingSize })
+  }
+
+  if (!refCode && !packingType && !packingSize) {
+    qb.andWhere('pd.is_default = :isDefault', { isDefault: true })
+  }
+
+  const productDetail: ProductDetail = await qb.getOne()
+
+  if (!productDetail) {
+    throw new ApiError('E04', `Product not found: ${sku || refCode}`)
+  }
+
+  // Validate decimal places
+  if (!productDetail.product.isInventoryDecimal && releaseQty % 1 !== 0) {
+    throw new ApiError('E01', `releaseQty must be an integer for product ${sku || refCode}`)
+  }
+
+  // Round to 3 decimal places
+  const roundedReleaseQty = productDetail.product.isInventoryDecimal
+    ? Math.round(releaseQty * 1000) / 1000
+    : Math.round(releaseQty)
+  const releaseUomValue = roundedReleaseQty * (productDetail.uomValue || 1)
+
+  // Ensure bizplace is loaded - fetch it if not already loaded
+  let bizplace = releaseGood.bizplace
+  if (!bizplace && releaseGood.bizplaceId) {
+    bizplace = await tx.getRepository(Bizplace).findOne({ where: { id: releaseGood.bizplaceId } })
+    if (!bizplace) {
+      throw new ApiError('E04', 'Bizplace not found for release order')
+    }
+  } else if (!bizplace) {
+    throw new ApiError('E04', 'Bizplace is required for order product')
+  }
+
+  const repo = tx.getRepository(OrderProduct)
+
+  const created = repo.create({
+    name: `OP-` + uuidv4(),
+
+    // Use relation stubs (IDs only) to force FK persistence
+    domain: { id: domain.id } as any,
+    bizplace: { id: (bizplace as any).id } as any,
+    releaseGood: { id: releaseGood.id } as any,
+    releaseGoodId: releaseGood.id, // Explicitly set the column value
+    product: { id: (productDetail.product as any).id } as any,
+    productDetail: { id: (productDetail as any).id } as any,
+    packingType: productDetail.packingType,
+    packingSize: packingSize || productDetail.packingSize,
+    batchId: orderProductReq.batchId || '',
+    refItemId: refItemId,
+    releaseQty: roundedReleaseQty,
+    releaseUomValue: releaseUomValue,
+    uom: productDetail.uom,
+    uomValue: productDetail.uomValue,
+    packQty: 0,
+    actualPackQty: 0,
+    palletQty: 0,
+    actualPalletQty: 0,
+    type: ORDER_TYPES.RELEASE_OF_GOODS,
+    status: ORDER_PRODUCT_STATUS.ASSIGNED,
+    unitPrice: orderProductReq.unitPrice || null,
+    remark: orderProductReq.remark || null,
+    creator: user,
+    updater: user
+  })
+
+  const newOrderProduct = await repo.save(created)
+
+  if (hasOrderInventories) {
+    // Assign inventory - pass releaseGood so status can be determined
+    await assignAdditionalInventory(tx, newOrderProduct, roundedReleaseQty, releaseUomValue, user, releaseGood, domain)
+  } else {
+    // Update ProductDetailStock
+    await tx
+      .getRepository(ProductDetailStock)
+      .createQueryBuilder()
+      .update(ProductDetailStock)
+      .set({
+        unassignedQty: () => `"unassigned_qty" + ${roundedReleaseQty}`,
+        unassignedUomValue: () => `"unassigned_uom_value" + ${releaseUomValue}`
+      })
+      .where({ productDetail: productDetail.id })
+      .execute()
+  }
 }