@things-factory/sales-base 4.3.695 → 4.3.700

package/server/service/release-good/release-good-mutation.ts

@@ -22,6 +22,7 @@ import {
   getOutletBizplace,
   getPermittedBizplaces
 } from '@things-factory/biz-base'
+import { ContactPoint } from '@things-factory/biz-base'
 import { GeoCountry } from '@things-factory/geography'
 import { generateId } from '@things-factory/id-rule-base'
 import { WebhookEventsEnum, webhookHandler } from '@things-factory/integration-base'
@@ -30,7 +31,7 @@ import { MarketplaceStore } from '@things-factory/integration-marketplace'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { MarketplaceOrder } from '@things-factory/marketplace-base'
 // import { sendNotification } from '@things-factory/notification'
-import { ProductBundleSetting, ProductDetail } from '@things-factory/product-base'
+import { Product, ProductBundleSetting, ProductDetail } from '@things-factory/product-base'
 import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, ProductDetailStock } from '@things-factory/warehouse-base'
@@ -620,6 +621,162 @@ export async function generateReleaseGoodFunction(
     await InventoryUtil.validateWarehousePartnersProductsQuantity(domain, bizplace, orderInventories, context, tx)
     /** End Validate Release Order Product Quantity Section */
 
+    /**
+     * Enforce outbound shelf-life at submission time using deliverTo.releaseShelfLife (if present).
+     * This guards scenarios where user selected inventories first and then set Contact Point,
+     * ensuring final validation rejects items that don't meet the shelf-life requirement.
+     */
+    let outboundShelfLifeOverride: number | null = null
+    let contactPoint: ContactPoint = null
+    const deliverToId: string | null =
+      typeof releaseGood?.deliverTo === 'string' && releaseGood?.deliverTo ? String(releaseGood.deliverTo) : null
+    if (deliverToId) {
+      contactPoint = await tx.getRepository(ContactPoint).findOne({ where: { id: deliverToId } })
+      if (contactPoint?.releaseShelfLife != null && contactPoint.releaseShelfLife !== 0) {
+        outboundShelfLifeOverride = Number(contactPoint.releaseShelfLife)
+      }
+    }
+
+    if (orderInventories?.length) {
+      // Helper function to build inventory availability query with optional warehouse and batch filters
+      const buildInventoryAvailabilityQuery = (
+        productId: string,
+        packingType: string,
+        packingSize: number,
+        uom: string,
+        warehouseName: string | null,
+        batchId: string | null,
+        outboundShelfLifeOverride: number | null
+      ) => {
+        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,
+            max(p.sku) as product_sku
+          from inventories iv
+          left join product_detail_stocks pds on pds.product_detail_id = iv.product_detail_id
+          inner join products p on p.id = iv.product_id
+          inner join locations loc on loc.id = iv.location_id
+          inner join warehouses w on w.id = loc.warehouse_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
+                  then CURRENT_DATE < iv.expiration_date - (
+                    case
+                      when $9::integer is not null and $9::integer > 0
+                        then $9::integer
+                      when p.min_outbound_shelf_life is not null
+                        then p.min_outbound_shelf_life
+                      else 0
+                    end
+                  )
+                else true
+              end
+            )
+            and ($7::text is null or w.name = $7::text)
+            and ($8::text is null or iv.batch_id = $8::text)
+        `
+
+        const params = [
+          domain.id,
+          bizplace.id,
+          productId,
+          packingType,
+          packingSize,
+          uom,
+          warehouseName,
+          batchId,
+          outboundShelfLifeOverride
+        ]
+
+        return { query, params }
+      }
+
+      const insufficientItems: any[] = []
+      for (const item of orderInventories) {
+        // Only validate standard (non-bundle) rows that have product/productDetail context
+        if (!item?.productDetail?.id || !item?.uom) continue
+
+        const productDetailId = item.productDetail.id
+        const productId = item?.product?.id || item?.productDetail?.product?.id
+        const packingType = item.packingType
+        const packingSize = item.packingSize
+        const uom = item.uom
+        const warehouseName = (item as any)?.warehouseCode ? String((item as any).warehouseCode).trim() : null
+        const batchId = item?.batchId && item.batchId !== '-' ? String(item.batchId).trim() : null
+
+        // Validate availability with shelf-life predicate applied
+        const { query, params } = buildInventoryAvailabilityQuery(
+          productId,
+          packingType,
+          packingSize,
+          uom,
+          warehouseName,
+          batchId,
+          outboundShelfLifeOverride
+        )
+
+        const rows = await tx.query(query, params)
+
+        const totalQty = parseFloat(rows?.[0]?.total_available_qty || '0')
+        // Normalize release quantity for non-decimal products
+        let reqQty = item.releaseQty
+        if ((item as any)?.product?.isInventoryDecimal === false) {
+          reqQty = Math.round(reqQty)
+        } else {
+          reqQty = Math.round(reqQty * 1000) / 1000
+        }
+
+        let productSku: string = rows?.[0]?.product_sku || null
+        if (!productSku && productId) {
+          const prod: Product = await tx
+            .getRepository(Product)
+            .findOne({ where: { id: productId }, select: ['id', 'sku'] })
+          if (prod?.sku) {
+            productSku = prod.sku
+          }
+        }
+        if (totalQty + 1e-6 < reqQty) {
+          insufficientItems.push({
+            productId,
+            productDetailId,
+            productSku: productSku,
+            packingType,
+            packingSize,
+            uom,
+            batchId,
+            requiredQty: reqQty,
+            availableQty: totalQty
+          })
+        }
+      }
+      if (insufficientItems.length > 0) {
+        throw new ValidationError({
+          ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
+          detail: { data: JSON.stringify(insufficientItems) }
+        })
+      }
+    }
+
     const orderSource: string = releaseGood.source
     switch (orderSource) {
       case ApplicationType.SELLERCRAFT:
@@ -801,6 +958,7 @@ export async function generateReleaseGoodFunction(
       lastMileDelivery: lmd || null,
       codOption: releaseGood?.codOption || null,
       paidAmount: releaseGood?.paidAmount || null,
+      deliverTo: contactPoint || null,
       creator: user,
       updater: user
     }
@@ -948,7 +1106,13 @@ export async function generateReleaseGoodFunction(
             bizplace,
             warehouseDomain,
             tx,
-            newOrderInv.batchId
+            newOrderInv.batchId,
+            undefined,
+            undefined,
+            undefined,
+            undefined,
+            undefined,
+            outboundShelfLifeOverride
           )
 
           assignedOrderInventories = assignedOrderInventories.map(aoi => {
@@ -1681,6 +1845,21 @@ export async function bulkGenerateReleaseGood(
       newReleaseGood.shippingOrder = createdSO
     }
 
+    /**
+     * Enforce outbound shelf-life at submission time using deliverTo.releaseShelfLife (if present).
+     * This guards scenarios where user selected inventories first and then set Contact Point,
+     * ensuring final validation rejects items that don't meet the shelf-life requirement.
+     */
+    let outboundShelfLifeOverride: number | null = null
+    const deliverToId: string | null =
+      typeof releaseGood?.deliverTo === 'string' && releaseGood?.deliverTo ? String(releaseGood.deliverTo) : null
+    if (deliverToId) {
+      const contactPoint: ContactPoint = await tx.getRepository(ContactPoint).findOne({ where: { id: deliverToId } })
+      if (contactPoint?.releaseShelfLife != null && contactPoint.releaseShelfLife !== 0) {
+        outboundShelfLifeOverride = Number(contactPoint.releaseShelfLife)
+      }
+    }
+
     let finalOrderInventories: Partial<OrderInventory>[] = []
 
     // pre assign inventory to orderInventories
@@ -1717,7 +1896,9 @@ export async function bulkGenerateReleaseGood(
           '',
           null,
           oi.cartonId,
-          oi.expirationDate
+          oi.expirationDate,
+          undefined,
+          outboundShelfLifeOverride
         )
 
         finalOrderInventories.push(
@@ -1976,7 +2157,7 @@ function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
           packingSize: item.packingSize,
           uom: item.uom,
           releaseQty: Math.round(parseFloat(item.releaseQty) * 1000) / 1000,
-          releaseUomValue: Math.round(parseFloat(item.releaseUomValue) * 1000) / 1000,
+          releaseUomValue: Math.round(parseFloat(item.releaseUomValue) * 1000) / 1000
         })
       }
     } else {

package/server/service/release-good/release-good-query.ts

@@ -952,6 +952,13 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
   const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
 
   if (!rawReleaseGoods) return
+  // derive optional release shelf life override (use the first non-null value if provided)
+  const releaseShelfLifeOverride: number | null = (() => {
+    const found = (rawReleaseGoods || []).find(
+      (r: any) => r?.releaseShelfLifeOverride !== undefined && r?.releaseShelfLifeOverride !== null
+    )
+    return found ? Number(found.releaseShelfLifeOverride) : null
+  })()
   // derive optional filters
   const uniqueWarehouseCodes: string[] = Array.from(
     new Set(
@@ -1067,6 +1074,13 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
         AND i.transfer_uom_value <= 0
         AND ( $5::text IS NULL OR w.name = $5 )
         ${`AND ( $6::text IS NULL OR i.batch_id = $6 )`}
+        AND (
+          CASE 
+            WHEN i.expiration_date IS NOT NULL AND COALESCE($7::integer, p.min_outbound_shelf_life) IS NOT NULL 
+              THEN CURRENT_DATE < i.expiration_date - COALESCE($7::integer, p.min_outbound_shelf_life)
+            ELSE TRUE 
+          END
+        )
         GROUP BY i.product_id, foo.product_detail_id, foo.sku, foo.product_info, i.packing_type, i.packing_size, i.uom, p.is_inventory_decimal${
           groupByWarehouse ? ', w.name' : ''
         }
@@ -1080,7 +1094,8 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
       LOCATION_TYPE.QUARANTINE,
       LOCATION_TYPE.RESERVE,
       uniqueWarehouseCodes.length === 1 ? uniqueWarehouseCodes[0] : null,
-      uniqueBatchIds.length === 1 ? uniqueBatchIds[0] : null
+      uniqueBatchIds.length === 1 ? uniqueBatchIds[0] : null,
+      releaseShelfLifeOverride
     ]
   )
 

package/server/utils/inventory-util.ts

@@ -78,6 +78,8 @@ export const InventoryUtil = {
         }
       }
 
+      // optional override for outbound shelf life (from ContactPoint deliverTo)
+      const releaseShelfLifeOverrideFilter = filters.find(f => f.name === 'releaseShelfLifeOverride')
       let queryStrings = `
         CREATE TEMP TABLE temp_inventory_product_group ON COMMIT DROP AS (
           SELECT * FROM (
@@ -163,7 +165,19 @@ export const InventoryUtil = {
             ) bp on i.product_id = bp.product_id
             WHERE i.bizplace_id IN (${bizplaceIds})
             AND i.lock_inventory is not true
-            AND case when i.expiration_date is not null and p.min_outbound_shelf_life is not null then CURRENT_DATE < i.expiration_date - p.min_outbound_shelf_life else true end
+            AND case 
+              when i.expiration_date is not null 
+                then CURRENT_DATE < i.expiration_date - (
+                  case
+                    when $2::integer is not null and $2::integer > 0
+                      then $2::integer
+                    when p.min_outbound_shelf_life is not null
+                      then p.min_outbound_shelf_life
+                    else 0
+                  end
+                )
+              else true 
+            end
               ${productDetailWhereClause}
               ${
                 productFilter
@@ -252,7 +266,10 @@ export const InventoryUtil = {
         )
       `
 
-      await trxMgr.query(queryStrings, [domain.id])
+      await trxMgr.query(queryStrings, [
+        domain.id,
+        releaseShelfLifeOverrideFilter ? releaseShelfLifeOverrideFilter.value : null
+      ])
 
       const [{ total }]: any = await trxMgr.query(`select count(*) as total from temp_inventory_product_group`)
       let items: any[] = []
@@ -295,6 +312,7 @@ export const InventoryUtil = {
       let cycleCountFilter = filters.find(filter => filter.name == 'cycleCount')?.value
 
       const _groupType = filters.find(res => res.name == 'groupType')
+      const releaseShelfLifeOverrideFilter = filters.find(filter => filter.name === 'releaseShelfLifeOverride')
       let queryStrings = `
         CREATE TEMP TABLE temp_inventory_product_group AS (
           SELECT * FROM (
@@ -335,7 +353,7 @@ export const InventoryUtil = {
               AND i.transfer_qty <= 0
               AND i.transfer_uom_value <= 0
               AND i.lock_inventory is not true
-              AND CASE WHEN i.expiration_date IS NOT NULL AND p.min_outbound_shelf_life IS NOT NULL THEN CURRENT_DATE < i.expiration_date - p.min_outbound_shelf_life ELSE true END
+              AND CASE WHEN i.expiration_date IS NOT NULL AND COALESCE($2::integer, p.min_outbound_shelf_life) IS NOT NULL THEN CURRENT_DATE < i.expiration_date - COALESCE($2::integer, p.min_outbound_shelf_life) ELSE true END
                ${
                  cycleCountFilter
                    ? `AND i.id NOT IN (
@@ -425,7 +443,10 @@ export const InventoryUtil = {
         })
       }
 
-      await trxMgr.query(queryStrings, [domain.id])
+      await trxMgr.query(queryStrings, [
+        domain.id,
+        releaseShelfLifeOverrideFilter ? releaseShelfLifeOverrideFilter.value : null
+      ])
 
       const [{ total }]: any = await trxMgr.query(
         `select count(*) as total from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''}`
@@ -873,7 +894,8 @@ export const InventoryUtil = {
     recall: boolean = null,
     cartonId?: string,
     expirationDate?: Date,
-    warehouseName?: string
+    warehouseName?: string,
+    outboundShelfLifeOverride?: number
   ): Promise<OrderInventory[]> {
     let strictProduct = 'false'
 
@@ -918,14 +940,15 @@ export const InventoryUtil = {
       .andWhere('"iv"."transfer_uom_value" <= 0')
       .andWhere('"iv"."product_id" = :productId')
       .andWhere(
-        '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'
+        'case when "iv"."expiration_date" is not null then CURRENT_DATE < "iv"."expiration_date" - (case when :outboundShelfLifeOverride::integer is not null and :outboundShelfLifeOverride::integer > 0 then :outboundShelfLifeOverride::integer when "p"."min_outbound_shelf_life" is not null then "p"."min_outbound_shelf_life" else 0 end) else true end'
       )
       .setParameters({
         domainId: domain.id,
         bizplaceId: customerBizplace.id,
         productId: product.id,
         status: INVENTORY_STATUS.STORED,
-        locationTypes
+        locationTypes,
+        outboundShelfLifeOverride: outboundShelfLifeOverride ?? null
       })
 
     if (batchId) {