@things-factory/worksheet-base 4.3.824 → 4.3.827

package/server/graphql/resolvers/worksheet/recommend-putaway-location.ts

@@ -3,12 +3,15 @@ import { getRepository, In } from 'typeorm'
 import { ArrivalNotice, ReturnOrder } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, Location, LOCATION_STATUS, LOCATION_TYPE, Warehouse } from '@things-factory/warehouse-base'
+import { Inventory, Location, LOCATION_STATUS, LOCATION_TYPE, Warehouse, calcVolumeInM3, buildProductDetailLabel } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { isInventoryExpiring } from '../../../utils/inventory-util'
 
+// 10% headroom required when storing — accounts for practical height gaps in shelving
+const HEIGHT_GAP_FACTOR = 0.9 // ONLY FOR RECOMMENDATION LEVEL 4
+
 export const recommendPutawayLocationResolver = {
   async recommendPutawayLocation(
     _: void,
@@ -26,7 +29,8 @@ export const recommendPutawayLocationResolver = {
           'worksheet.returnOrder',
           'targetInventory',
           'targetInventory.inventory',
-          'targetInventory.inventory.product'
+          'targetInventory.inventory.product',
+          'targetInventory.inventory.productDetail'
         ]
       }
     )
@@ -87,6 +91,10 @@ export const recommendPutawayLocationResolver = {
         recommendedLocations = await recommendLocationLevel3(domain, targetWarehouse, optCnt, inventory)
         break
 
+      case 'level 4':
+        recommendedLocations = await recommendLocationLevel4(domain, targetWarehouse, optCnt, inventory)
+        break
+
       default:
         recommendedLocations = await recommendLocationLevel1(domain, targetWarehouse, optCnt)
         break
@@ -404,7 +412,7 @@ export async function recommendLocationLevel3(
 
     // ---------------- EMPTY fallback (same type, ordered by rule) ----------------
     if (recommended.length < optCnt) {
-      const emptyLocations = await getRepository(Location).find({
+      const emptyLocationsAll = await getRepository(Location).find({
         where: {
           domain,
           warehouse,
@@ -415,9 +423,107 @@ export async function recommendLocationLevel3(
         take: optCnt - recommended.length
       })
 
-      recommended.push(...emptyLocations)
+      recommended.push(...emptyLocationsAll)
     }
   }
 
   return recommended.slice(0, optCnt)
 }
+
+export async function recommendLocationLevel4(
+  domain: Domain,
+  warehouse: Warehouse,
+  optCnt: number,
+  inventory: Inventory
+): Promise<Location[]> {
+  const allowedTypesInOrder: LOCATION_TYPE[] = [LOCATION_TYPE.STORAGE, LOCATION_TYPE.SHELF, LOCATION_TYPE.FLOOR]
+
+  // --- Step 1: Check all EMPTY locations have volume ---
+  const emptyLocations: Location[] = await getRepository(Location).find({
+    where: {
+      domain,
+      warehouse,
+      status: LOCATION_STATUS.EMPTY,
+      type: In(allowedTypesInOrder)
+    }
+  })
+
+  const missingVolume = emptyLocations.some((loc: Location) => !loc.volume)
+  if (missingVolume) {
+    throw new Error('Please update the Location Master to include volume calculation')
+  }
+
+  // --- Step 2: Check product dimensions and length unit ---
+  const pd = inventory.productDetail
+  if (!pd?.lengthUnit || (pd?.volume == null && (!pd?.width || !pd?.depth || !pd?.height))) {
+    throw new Error(
+      'Missing product dimensions or length unit. Please provide width, depth, height, and length unit for correct volume calculation'
+    )
+  }
+
+  const incomingDetail = buildProductDetailLabel(pd)
+  const incomingLabel = `SKU: ${inventory.product?.sku} ${incomingDetail}`.trim()
+  const incomingVolume: number = calcVolumeInM3(pd, incomingLabel) * (inventory.qty ?? 1)
+
+  // --- Step 3: rule-for-storing-product ---
+  const orderSetting: Setting | undefined = await getRepository(Setting).findOne({
+    where: { domain, name: 'rule-for-storing-product' }
+  })
+
+  let sortLocation: Record<string, 'ASC' | 'DESC'> = {}
+  if (orderSetting?.value) {
+    try {
+      sortLocation = JSON.parse(orderSetting.value)
+    } catch {
+      // ignore malformed setting
+    }
+  }
+
+  // --- Step 4: Check if all empty locations having same volume ---
+  const allSameVolume =
+    emptyLocations.length > 0 && emptyLocations.every((loc: Location) => loc.volume === emptyLocations[0].volume)
+
+  if (allSameVolume) {
+    const usableVolume = emptyLocations[0].volume * HEIGHT_GAP_FACTOR
+    if (incomingVolume > usableVolume) return [] // return early to not recommend any
+  }
+
+  const recommended: Location[] = []
+
+  for (const type of allowedTypesInOrder) {
+    if (recommended.length >= optCnt) break
+
+    const candidates: Location[] = emptyLocations.filter((loc: Location) => loc.type === type)
+    if (candidates.length === 0) continue
+
+    if (allSameVolume) {
+      const sortKeys = Object.keys(sortLocation)
+      const sorted = candidates.sort((a: Location, b: Location) => {
+        for (const key of sortKeys) {
+          const dir = sortLocation[key] === 'DESC' ? -1 : 1
+          if (a[key] < b[key]) return -1 * dir
+          if (a[key] > b[key]) return 1 * dir
+        }
+        return 0
+      })
+      recommended.push(...sorted.slice(0, optCnt - recommended.length))
+      if (recommended.length >= optCnt) break
+    } else {
+      // Sort by least remaining space ASC (usable = volume * 0.9, 10% height gap)
+      const sorted = candidates
+        .map((loc: Location) => {
+          const usableVolume = loc.volume * HEIGHT_GAP_FACTOR
+          const remaining = usableVolume - incomingVolume
+          return { loc, remaining }
+        })
+        .filter(({ remaining }) => remaining >= 0)
+        .sort((a, b) => a.remaining - b.remaining)
+        .map(({ loc }) => loc)
+
+      recommended.push(...sorted.slice(0, optCnt - recommended.length))
+    }
+  }
+
+  return recommended.slice(0, optCnt)
+}
+