@things-factory/operato-hub 4.3.701 → 4.3.708

package/server/routers/api/restful-apis/v1/company/add-contact-points.ts

@@ -26,11 +26,15 @@ router.post(
         // check if phone or email already belongs in bizplace
         const phones = []
         const emails = []
+        const ids = []
         let values = []
         for (const datapoint of context.request.body.data) {
           phones.push(datapoint.phone)
           emails.push(datapoint.email)
-          const value = {
+          if (datapoint.id) {
+            ids.push(datapoint.id)
+          }
+          const value: any = {
             name: datapoint.name,
             description: datapoint.description,
             companyName: datapoint.companyName,
@@ -43,6 +47,8 @@ router.post(
             address2: datapoint.address2,
             city: datapoint.city,
             state: datapoint.state,
+            country: datapoint.country,
+            releaseShelfLife: datapoint.releaseShelfLife,
             postCode: datapoint.postCode,
             type: datapoint.type,
             domain: context.state.domain,
@@ -50,9 +56,28 @@ router.post(
             creator: context.state.user,
             updater: context.state.user
           }
+          // Add id if provided by external system
+          if (datapoint.id) {
+            value.id = datapoint.id
+          }
           values.push(value)
         }
 
+        // Check for duplicate IDs if provided
+        if (ids.length > 0) {
+          const checkDuplicateIds: ContactPoint[] = await tx
+            .getRepository(ContactPoint)
+            .createQueryBuilder('cp')
+            .where('cp.id IN (:...ids)', { ids })
+            .getMany()
+          if (checkDuplicateIds.length > 0) {
+            throw new ApiError(
+              'E05',
+              `Contact point ID(s) already exist: ${checkDuplicateIds.map(cp => cp.id).join(', ')}`
+            )
+          }
+        }
+
         const checkDuplicateEmailPhone: ContactPoint = await tx
           .getRepository(ContactPoint)
           .createQueryBuilder('cp')
@@ -80,6 +105,7 @@ router.post(
         let data = []
         for (const contactPoint of result.generatedMaps) {
           const datapoint = {
+            id: contactPoint.id,
             name: contactPoint.name,
             description: contactPoint.description,
             companyName: contactPoint.companyName,
@@ -92,6 +118,8 @@ router.post(
             address2: contactPoint.address2,
             city: contactPoint.city,
             state: contactPoint.state,
+            country: contactPoint.country,
+            releaseShelfLife: contactPoint.releaseShelfLife,
             postCode: contactPoint.postCode,
             type: contactPoint.type,
             createdAt: contactPoint.createdAt

package/server/routers/api/restful-apis/v1/utils/params.ts

@@ -83,6 +83,7 @@ export const params = {
   'get-webhook-details': ['warehouseBizplaceId', 'webhookId'],
   'add-contact-points': [
     'bizplaceId',
+    'id',
     'name',
     'companyName',
     'description',
@@ -95,6 +96,8 @@ export const params = {
     'address2',
     'city',
     'state',
+    'country',
+    'releaseShelfLife',
     'postCode',
     'type'
   ],
@@ -358,6 +361,7 @@ export const params = {
     'refNo2',
     'refNo3',
     'refOrderId',
+    'contactPointId',
     'type',
     'transporter',
     'trackingNo',
@@ -1112,6 +1116,11 @@ export const reqParams = {
       required: true,
       type: 'field'
     },
+    {
+      name: 'contactPointId',
+      required: false,
+      type: 'field'
+    },
     {
       name: 'shippingOrder',
       required: false,
@@ -1201,7 +1210,7 @@ export const reqParams = {
       name: 'releaseGood',
       required: true,
       type: 'object',
-      data: [{ name: 'roId', required: true, type: 'field' }]
+      data: []
     },
     {
       name: 'shippingOrder',

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

@@ -13,7 +13,7 @@ import { v4 as uuidv4 } from 'uuid'
 import { webhookHandler, WebhookEventsEnum } from '@things-factory/integration-base'
 import { restfulApiRouter as router } from '@things-factory/api'
 import { User } from '@things-factory/auth-base'
-import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
+import { Bizplace, ContactPoint, getCompanyBizplace } from '@things-factory/biz-base'
 import { GeoCountry } from '@things-factory/geography'
 import { generateId } from '@things-factory/id-rule-base'
 import { LastMileDelivery } from '@things-factory/integration-lmd'
@@ -87,6 +87,23 @@ router.post(
           relations: ['domain']
         })
 
+        // optional override: release shelf life from ContactPoint
+        const contactPointId: string | undefined = bodyReq?.contactPointId
+        let releaseShelfLifeOverride: number | null = null
+        let deliverToContactPoint: ContactPoint | null = null
+        if (contactPointId) {
+          const contactPoint: ContactPoint | undefined = await tx
+            .getRepository(ContactPoint)
+            .findOne({ where: { id: contactPointId } })
+          if (!contactPoint) {
+            throw new ApiError('E04', 'contactPoint not found')
+          }
+          if (contactPoint?.releaseShelfLife != null && contactPoint.releaseShelfLife !== 0) {
+            releaseShelfLifeOverride = contactPoint.releaseShelfLife
+          }
+          deliverToContactPoint = contactPoint
+        }
+
         const worksheetPickingAssignment: Setting = await tx.getRepository(Setting).findOne({
           where: { domain, category: 'id-rule', name: 'enable-worksheet-picking-activation-assignment' }
         })
@@ -105,7 +122,12 @@ router.post(
           })
         }
 
-        let newPhone1 = bodyReq?.deliverTo?.phone1 ? bodyReq.deliverTo.phone1.replace(/\D/g, '') : null
+        // derive phone values: prefer contact point when provided, else use body
+        let newPhone1 = deliverToContactPoint?.phone
+          ? String(deliverToContactPoint.phone).replace(/\D/g, '')
+          : bodyReq?.deliverTo?.phone1
+          ? bodyReq.deliverTo.phone1.replace(/\D/g, '')
+          : null
         let newPhone2 = bodyReq?.deliverTo?.phone2 ? bodyReq.deliverTo.phone2.replace(/\D/g, '') : null
 
         releaseGood = {
@@ -126,23 +148,36 @@ router.post(
           type: bodyReq.type,
           marketplaceOrderStatus: bodyReq?.marketplaceOrderStatus,
           remark: bodyReq?.remark || null,
-          billingAddress: bodyReq?.billTo?.billingAddress || null,
-          deliveryAddress1: bodyReq?.deliverTo?.deliveryAddress1 || null,
-          deliveryAddress2: bodyReq?.deliverTo?.deliveryAddress2 || null,
+          // when contactPoint exists, override target fields from contactPoint, else use request body
+          billingAddress: deliverToContactPoint
+            ? deliverToContactPoint.billingAddress || null
+            : bodyReq?.billTo?.billingAddress || null,
+          deliveryAddress1: deliverToContactPoint
+            ? deliverToContactPoint.address || null
+            : bodyReq?.deliverTo?.deliveryAddress1 || null,
+          deliveryAddress2: deliverToContactPoint
+            ? deliverToContactPoint.address2 || null
+            : bodyReq?.deliverTo?.deliveryAddress2 || null,
           deliveryAddress3: bodyReq?.deliverTo?.deliveryAddress3 || null,
           deliveryAddress4: bodyReq?.deliverTo?.deliveryAddress4 || null,
           deliveryAddress5: bodyReq?.deliverTo?.deliveryAddress5 || null,
-          attentionTo: bodyReq?.deliverTo?.attentionTo || null,
-          attentionCompany: bodyReq?.deliverTo?.attentionCompany || null,
-          city: bodyReq?.deliverTo?.city || null,
+          attentionTo: deliverToContactPoint
+            ? deliverToContactPoint.name || null
+            : bodyReq?.deliverTo?.attentionTo || null,
+          attentionCompany: deliverToContactPoint
+            ? deliverToContactPoint.companyName || null
+            : bodyReq?.deliverTo?.attentionCompany || null,
+          city: deliverToContactPoint ? deliverToContactPoint.city || null : bodyReq?.deliverTo?.city || null,
           ward: bodyReq?.deliverTo?.ward,
-          district: bodyReq?.deliverTo?.district,
-          state: bodyReq?.deliverTo?.state || null,
-          postalCode: bodyReq?.deliverTo?.postalCode || null,
-          country: bodyReq?.deliverTo?.country || null,
+          district: deliverToContactPoint ? null : bodyReq?.deliverTo?.district,
+          state: deliverToContactPoint ? deliverToContactPoint.state || null : bodyReq?.deliverTo?.state || null,
+          postalCode: deliverToContactPoint
+            ? deliverToContactPoint.postCode || null
+            : bodyReq?.deliverTo?.postalCode || null,
+          country: deliverToContactPoint ? null : bodyReq?.deliverTo?.country || null,
           phone1: newPhone1,
           phone2: newPhone2,
-          email: bodyReq?.deliverTo?.email || null,
+          email: deliverToContactPoint ? deliverToContactPoint.email || null : bodyReq?.deliverTo?.email || null,
           transporter: bodyReq?.transporter,
           trackingNo: bodyReq?.trackingNo,
           airwayBill: bodyReq?.airwayBill,
@@ -162,6 +197,7 @@ router.post(
           shippingFee: bodyReq?.shippingFee,
           lmdOption: bodyReq?.lmdOption,
           priorityDelivery: bodyReq?.priorityDelivery,
+          deliverTo: deliverToContactPoint || null,
           shippingOrder: bodyReq?.shippingOrder
             ? {
                 shipName: bodyReq?.shippingOrder.shipName,
@@ -235,150 +271,155 @@ router.post(
 
         const invWithoutBatchId = batchIdStates.withoutBatchId
 
+        // Helper function to build inventory availability query
+        const buildInventoryAvailabilityQuery = (
+          item: any,
+          domain: Domain,
+          customerBizplace: Bizplace,
+          options: {
+            batchId?: string | null
+            warehouseName?: string | null
+            releaseShelfLifeOverride: number | null
+            requireWarehouseJoin?: boolean
+            includeLockInventoryCheck?: boolean
+          }
+        ) => {
+          const { batchId, warehouseName, releaseShelfLifeOverride, requireWarehouseJoin, includeLockInventoryCheck } =
+            options
+
+          const hasWarehouse = warehouseName != null
+          const hasBatch = batchId != null
+
+          // Determine warehouse join strategy
+          const warehouseJoin =
+            requireWarehouseJoin || hasWarehouse ? 'inner join warehouses w on w.id = loc.warehouse_id' : ''
+
+          // Build warehouse filter
+          let warehouseFilter = ''
+          if (requireWarehouseJoin) {
+            // For batch queries: always join warehouses, filter optionally
+            warehouseFilter = 'and ($8::text is null or w.name = $8::text)'
+          } else if (hasWarehouse) {
+            // For non-batch queries: only filter if warehouse is specified
+            warehouseFilter = 'and w.name = $7'
+          }
+
+          // Build batch filter
+          const batchFilter = hasBatch ? 'and iv.batch_id = $7' : ''
+
+          // Calculate parameter indices
+          const shelfLifeParamIndex = hasBatch ? '$9' : hasWarehouse ? '$8' : '$7'
+
+          // Build lock inventory check
+          const lockInventoryCheck = includeLockInventoryCheck
+            ? `and not exists (
+                select 1 from inventories i
+                where i.domain_id = $1 and i.bizplace_id = $2 and i.product_id = $3 and i.packing_type = $4 and i.packing_size = $5 and i.uom = $6 and i.status = 'STORED' and i.lock_inventory is true
+              )`
+            : ''
+
+          const query = `
+            select
+              coalesce(sum(
+                case when (iv.qty - greatest(coalesce(iv.locked_qty,0),0) - greatest(coalesce(pds.unassigned_qty,0),0)) < 0
+                     then 0
+                     else (iv.qty - greatest(coalesce(iv.locked_qty,0),0) - greatest(coalesce(pds.unassigned_qty,0),0))
+                end
+              ), 0) as total_available_qty,
+              coalesce(sum(
+                case when (iv.uom_value - greatest(coalesce(iv.locked_uom_value,0),0) - greatest(coalesce(pds.unassigned_uom_value,0),0)) < 0
+                     then 0
+                     else (iv.uom_value - greatest(coalesce(iv.locked_uom_value,0),0) - greatest(coalesce(pds.unassigned_uom_value,0),0))
+                end
+              ), 0) as total_available_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
+            ${warehouseJoin}
+            inner join products p on p.id = iv.product_id
+            where iv.domain_id = $1
+              and iv.bizplace_id = $2
+              and iv.product_id = $3
+              and iv.packing_type = $4
+              and iv.packing_size = $5
+              and iv.uom = $6
+              and iv.status = 'STORED'
+              and loc.type not in ('QUARANTINE','RESERVE','DAMAGE','STORAGE')
+              and iv.obsolete = false
+              and (
+                iv.expiration_date is null
+                or
+                case
+                  when ${shelfLifeParamIndex}::integer is not null and ${shelfLifeParamIndex}::integer > 0 then
+                    CURRENT_DATE < iv.expiration_date - ${shelfLifeParamIndex}::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
+              )
+              ${batchFilter}
+              ${warehouseFilter}
+              ${lockInventoryCheck}
+          `
+
+          // Build parameters array
+          const params: any[] = [
+            domain.id,
+            customerBizplace.id,
+            item.product.id,
+            item.packingType,
+            item.packingSize,
+            item.uom
+          ]
+
+          if (hasBatch) {
+            params.push(batchId)
+          }
+          if (requireWarehouseJoin || hasWarehouse) {
+            params.push(warehouseName)
+          }
+          params.push(releaseShelfLifeOverride)
+
+          return { query, params }
+        }
+
+        // Helper function to validate inventory availability
+        const validateInventoryAvailability = async (item: any, query: string, params: any[], tx: EntityManager) => {
+          const rows = await tx.query(query, params)
+
+          const totalQty = parseFloat(rows?.[0]?.total_available_qty || '0')
+          const totalUomVal = parseFloat(rows?.[0]?.total_available_uom_value || '0')
+
+          let reqQty = item.releaseQty
+          let reqUomVal = item.releaseUomValue
+
+          if (!item.product.isInventoryDecimal) {
+            reqQty = Math.round(reqQty)
+          } else {
+            reqQty = Math.round(reqQty * 1000) / 1000
+          }
+
+          if (totalQty + 1e-6 < reqQty || totalUomVal + 1e-6 < reqUomVal) {
+            throw new ApiError('E01', 'INSUFFICIENT_STOCK')
+          }
+        }
+
         //inv without batchId will check stock in wboi
         if (invWithoutBatchId) {
           // validation
           await Promise.all(
             massagedData.combinedItems.map(async item => {
-              const hasWarehouse = !!item.warehouseCode
-              if (hasWarehouse) {
-                // Validate availability within the specific warehouse across pickable locations (exclude Q/R/D/STORAGE)
-                const rows = await tx.query(
-                  `
-                  select
-                    coalesce(sum(
-                      case when (iv.qty - greatest(coalesce(iv.locked_qty,0),0) - greatest(coalesce(pds.unassigned_qty,0),0)) < 0
-                           then 0
-                           else (iv.qty - greatest(coalesce(iv.locked_qty,0),0) - greatest(coalesce(pds.unassigned_qty,0),0))
-                      end
-                    ), 0) as total_available_qty,
-                    coalesce(sum(
-                      case when (iv.uom_value - greatest(coalesce(iv.locked_uom_value,0),0) - greatest(coalesce(pds.unassigned_uom_value,0),0)) < 0
-                           then 0
-                           else (iv.uom_value - greatest(coalesce(iv.locked_uom_value,0),0) - greatest(coalesce(pds.unassigned_uom_value,0),0))
-                      end
-                    ), 0) as total_available_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
-                  where iv.domain_id = $1
-                    and iv.bizplace_id = $2
-                    and iv.product_id = $3
-                    and iv.packing_type = $4
-                    and iv.packing_size = $5
-                    and iv.uom = $6
-                    and iv.status = 'STORED'
-                    and loc.type not in ('QUARANTINE','RESERVE','DAMAGE','STORAGE')
-                    and iv.obsolete = false
-                    and (case when iv.expiration_date is not null and p.min_outbound_shelf_life is not null then CURRENT_DATE < iv.expiration_date - p.min_outbound_shelf_life else true end)
-                    and w.name = $7
-                    and not exists (
-                      select 1 from inventories i
-                      where i.domain_id = $1 and i.bizplace_id = $2 and i.product_id = $3 and i.packing_type = $4 and i.packing_size = $5 and i.uom = $6 and i.status = 'STORED' and i.lock_inventory is true
-                    )
-                  `,
-                  [
-                    domain.id,
-                    customerBizplace.id,
-                    item.product.id,
-                    item.packingType,
-                    item.packingSize,
-                    item.uom,
-                    String(item.warehouseCode).trim()
-                  ]
-                )
+              const warehouseName = item.warehouseCode ? String(item.warehouseCode).trim() : null
 
-                const totalQty = parseFloat(rows?.[0]?.total_available_qty || '0')
-                const totalUomVal = parseFloat(rows?.[0]?.total_available_uom_value || '0')
-
-                let reqQty = item.releaseQty
-                let reqUomVal = item.releaseUomValue
-
-                if (!item.product.isInventoryDecimal) {
-                  reqQty = Math.round(reqQty)
-                } else {
-                  reqQty = Math.round(reqQty * 1000) / 1000
-                }
-
-                if (totalQty + 1e-6 < reqQty || totalUomVal + 1e-6 < reqUomVal) {
-                  throw new ApiError('E01', 'INSUFFICIENT_STOCK')
-                }
-              } else {
-                // Fallback to existing global view-based validation when no warehouseCode provided
-                let itemList = await tx.query(
-                  `
-                  select wboi.* 
-                  from warehouse_bizplace_onhand_inventories wboi 
-                  left join (
-                    select i2.product_id, i2.domain_id, i2.bizplace_id, i2.packing_type, i2.packing_size, i2.uom, 
-                          sum(i2.qty) as storage_qty, 
-                          sum(i2.uom_value) as storage_uom_value 
-                    from inventories i2 
-                    inner join locations l2 on l2.id = i2.location_id 
-                    inner join warehouses w on w.id = l2.warehouse_id
-                    where i2.domain_id = $1 
-                      and i2.bizplace_id = $2
-                      and i2.product_id = $3 
-                      and i2.packing_type = $4 
-                      and i2.packing_size = $5 
-                      and i2.uom = $6 
-                      and i2.status = 'STORED'
-                      and l2.type = 'STORAGE' 
-                    group by i2.product_id, i2.domain_id, i2.bizplace_id, i2.packing_type, i2.packing_size, i2.uom
-                  ) storageInv 
-                    on storageInv.product_id = wboi.product_id 
-                  and storageInv.domain_id = wboi.domain_id 
-                  and storageInv.bizplace_id = wboi.bizplace_id 
-                  and storageInv.packing_type = wboi.packing_type 
-                  and storageInv.packing_size = wboi.packing_size 
-                  and storageInv.uom = wboi.uom
-                  left join (
-                    select i.product_id, i.domain_id, i.bizplace_id, i.packing_type, i.packing_size, i.uom, i.lock_inventory 
-                    from inventories i 
-                    where i.domain_id = $1  
-                      and i.bizplace_id = $2
-                      and i.product_id = $3 
-                      and i.packing_type = $4 
-                      and i.packing_size = $5 
-                      and i.uom = $6 
-                      and i.status = 'STORED'
-                    group by i.product_id, i.domain_id, i.bizplace_id, i.packing_type, i.packing_size, i.uom, i.lock_inventory
-                  ) lockInv 
-                    on lockInv.product_id = wboi.product_id 
-                  and lockInv.domain_id = wboi.domain_id 
-                  and lockInv.bizplace_id = wboi.bizplace_id 
-                  and lockInv.packing_type = wboi.packing_type 
-                  and lockInv.packing_size = wboi.packing_size 
-                  and lockInv.uom = wboi.uom 
-                  where wboi.domain_id = $1 
-                    and wboi.bizplace_id = $2 
-                    and wboi.group_type = 'SINGLE' 
-                    and wboi.product_id = $3 
-                    and wboi.packing_type = $4 
-                    and wboi.packing_size = $5 
-                    and wboi.uom = $6 
-                    and lockInv.lock_inventory is not true 
-                    and (wboi.remain_qty - wboi.transfer_qty - coalesce(storageInv.storage_qty, 0)) >= $7 
-                    and (wboi.remain_uom_value - wboi.transfer_uom_value - coalesce(storageInv.storage_uom_value, 0)) >= $8
-                `,
-                  [
-                    domain.id,
-                    customerBizplace.id,
-                    item.product.id,
-                    item.packingType,
-                    item.packingSize,
-                    item.uom,
-                    item.releaseQty,
-                    item.releaseUomValue
-                  ]
-                )
-                if (itemList.length <= 0) {
-                  throw new ApiError('E01', 'INSUFFICIENT_STOCK')
-                }
-                console.log()
-              }
+              const { query, params } = buildInventoryAvailabilityQuery(item, domain, customerBizplace, {
+                warehouseName,
+                releaseShelfLifeOverride,
+                requireWarehouseJoin: false,
+                includeLockInventoryCheck: true
+              })
+
+              await validateInventoryAvailability(item, query, params, tx)
             })
           )
         }
@@ -392,59 +433,15 @@ router.post(
 
               const warehouseName = item?.warehouseCode ? String(item.warehouseCode).trim() : null
 
-              const rows = await tx.query(
-                `
-                select
-                  coalesce(sum(
-                    case when (iv.qty - greatest(coalesce(iv.locked_qty,0),0) - greatest(coalesce(pds.unassigned_qty,0),0)) < 0
-                         then 0
-                         else (iv.qty - greatest(coalesce(iv.locked_qty,0),0) - greatest(coalesce(pds.unassigned_qty,0),0))
-                    end
-                  ), 0) as total_available_qty
-                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
-                where iv.domain_id = $1
-                  and iv.bizplace_id = $2
-                  and iv.product_id = $3
-                  and iv.packing_type = $4
-                  and iv.packing_size = $5
-                  and iv.uom = $6
-                  and iv.status = 'STORED'
-                  and loc.type not in ('QUARANTINE','RESERVE','DAMAGE','STORAGE')
-                  and iv.obsolete = false
-                  and (case when iv.expiration_date is not null and p.min_outbound_shelf_life is not null then CURRENT_DATE < iv.expiration_date - p.min_outbound_shelf_life else true end)
-                  and iv.batch_id = $7
-                  and ( $8::text is null or w.name = $8::text )
-              `,
-                [
-                  domain.id,
-                  customerBizplace.id,
-                  item.product.id,
-                  item.packingType,
-                  item.packingSize,
-                  item.uom,
-                  batchId,
-                  warehouseName
-                ]
-              )
-
-              const totalQty = parseFloat(rows?.[0]?.total_available_qty || '0')
+              const { query, params } = buildInventoryAvailabilityQuery(item, domain, customerBizplace, {
+                batchId,
+                warehouseName,
+                releaseShelfLifeOverride,
+                requireWarehouseJoin: true,
+                includeLockInventoryCheck: false
+              })
 
-              let reqQty = item.releaseQty
-
-              // normalize comparison for decimal vs non-decimal products
-              if (!item.product.isInventoryDecimal) {
-                reqQty = Math.round(reqQty)
-              } else {
-                reqQty = Math.round(reqQty * 1000) / 1000
-              }
-
-              if (totalQty + 1e-6 < reqQty) {
-                throw new ApiError('E01', 'INSUFFICIENT_STOCK')
-              }
+              await validateInventoryAvailability(item, query, params, tx)
             })
           )
         }
@@ -456,7 +453,8 @@ router.post(
           customerBizplace,
           context,
           tx,
-          worksheetPickingAssignment
+          worksheetPickingAssignment,
+          releaseShelfLifeOverride
         )
         // console.timeEnd('assign')
 
@@ -765,6 +763,7 @@ async function createReleaseGood(
       : OrderNoGenerator.releaseGood(),
     domain: domain,
     bizplace: bizplace,
+    deliverTo: releaseGood?.deliverTo || null,
     collectionOrderNo: releaseGood.collectionOrderNo,
     courierOption: courierOption,
     codOption: releaseGood?.codOption,
@@ -1247,7 +1246,8 @@ async function assignToInventory(
   customerBizplace,
   context,
   tx,
-  worksheetPickingAssignment
+  worksheetPickingAssignment,
+  releaseShelfLifeOverride: number | null
 ) {
   const { domain, user } = context.state
 
@@ -1381,6 +1381,9 @@ async function assignToInventory(
         if (orderInventory[oiIdx]?.warehouseCode) {
           params.push(String(orderInventory[oiIdx].warehouseCode).trim())
         }
+        // add release shelf life override parameter
+        const releaseShelfLifeParamIndex = params.length + 1
+        params.push(releaseShelfLifeOverride)
 
         let query = `
           update inventories tgt set locked_qty = coalesce(locked_qty,0) + src.reserve_qty, 
@@ -1429,7 +1432,18 @@ async function assignToInventory(
                      "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 case when "iv"."expiration_date" is not null and "p"."min_outbound_shelf_life" is not null then CURRENT_DATE < "iv"."expiration_date" - "p"."min_outbound_shelf_life" else true end
+                    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.join(' AND ')}` : ''}
                     ORDER BY wiar.rank ${sortQuery ? ', ' + sortQuery : ''}
                   )

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

@@ -43,16 +43,30 @@ router.post(
 async function updateReleaseGoodDetails(tx, domain, patch, user) {
   let { releaseGood, shippingOrder } = patch
   let status = [ORDER_STATUS.DONE, ORDER_STATUS.CANCELLED, ORDER_STATUS.REJECTED]
+  
+  // Build where clause: prioritize refOrderId over roId
+  let whereClause: any = { domain }
+  const refOrderId = releaseGood?.refOrderId
+  const hasRefOrderId = refOrderId != null && refOrderId !== ''
+  
+  if (hasRefOrderId) {
+    whereClause.refOrderId = refOrderId
+  } else if (releaseGood?.roId) {
+    whereClause.id = releaseGood.roId
+  } else {
+    throw new ApiError('E04', 'release order: roId or refOrderId is required')
+  }
+  
   let foundReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: {
-      id: releaseGood.roId,
-      domain
-    },
+    where: whereClause,
     relations: ['shippingOrder']
   })
 
   if (!foundReleaseGood) {
-    throw new ApiError('E04', `release order: ${releaseGood.roId}`)
+    const searchId = hasRefOrderId 
+      ? `refOrderId: ${refOrderId}` 
+      : `roId: ${releaseGood?.roId}`
+    throw new ApiError('E04', `release order: ${searchId}`)
   }
 
   if (status.indexOf(foundReleaseGood.status) !== -1) {