@things-factory/operato-hub 4.3.697 → 4.3.698

package/server/routers/api/restful-apis/v1/warehouse/add-inventory-adjustment.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash'
 import { EntityManager, SelectQueryBuilder, getConnection } from 'typeorm'
 
 import { restfulApiRouter as router } from '@things-factory/api'
@@ -9,8 +8,9 @@ import {
   InventoryChange,
   submitInventoryChangesService
 } from '@things-factory/warehouse-base'
-import { ProductDetail } from '@things-factory/product-base'
-import { getCompanyBizplace } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
+import { Setting } from '@things-factory/setting-base'
 
 import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
 import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
@@ -37,10 +37,40 @@ type TargetSelector = {
 }
 
 type AdjustmentInput = {
-  target: TargetSelector
-  changes: Record<string, any>
+  target?: TargetSelector
+  changes?: Record<string, any>
+}
+
+type CreateInput = {
+  bizplaceId?: string
+  locationId?: string
+  locationName?: string
+  sku?: string
+  refCode?: string
+  productName?: string
+  packingType?: string
+  packingSize?: number
+  uom?: string
+  uomValue?: number
+  qty?: number
+  unitCost?: number
+  batchId?: string
+  batchIdRef?: string
+  cartonId?: string
+  expirationDate?: string
+  manufactureDate?: string
+  serialNumbers?: string | string[]
+  remark?: string
+  adjustmentCode?: string
+  adjustmentNote?: string
+  adjustment_code?: string
+  adjustment_note?: string
 }
 
+type NormalizedEntry =
+  | { kind: 'create'; payload: CreateInput; source: string; index: number }
+  | { kind: 'adjust'; payload: AdjustmentInput; source: string; index: number }
+
 router.post(
   '/v1/warehouse/add-inventory-adjustment',
   businessMiddleware,
@@ -51,95 +81,230 @@ router.post(
       const { domain, user } = context.state
       const payload = context.request.body?.data
 
-      if (!payload) throw new ApiError('E01', 'data')
-
-      // Accept either { adjustments: [...] } or a single adjustment object for convenience
-      const adjustments: AdjustmentInput[] = Array.isArray(payload?.adjustments)
-        ? payload.adjustments
-        : Array.isArray(payload)
-        ? payload
-        : payload?.target && payload?.changes
-        ? [payload as AdjustmentInput]
-        : []
+      if (!payload) throw new ApiError('E01', 'Request body must contain data')
 
-      if (!adjustments.length) {
-        throw new ApiError('E01', 'adjustments')
-      }
+      const entries: NormalizedEntry[] = normalizeAdjustmentEntries(payload)
+      if (!entries.length)
+        throw new ApiError(
+          'E01',
+          'No valid adjustment entries found. Provide create or adjustments array with valid items'
+        )
 
       // Build patches with deterministic targeting (resolve inventory by pallet/carton/batch/location)
       await getConnection().transaction(async (tx: EntityManager) => {
         const patches: InventoryPatch[] = []
         const correlationIds: string[] = []
 
-        for (const [index, adj] of adjustments.entries()) {
-          const target: TargetSelector = adj?.target || {}
-          const rawChanges: any = adj?.changes || {}
+        let strictProduct: boolean = false
+
+        const strictProductSelectionSetting: Setting = await tx.getRepository(Setting).findOne({
+          where: { domain, category: 'id-rule', name: 'strict-product-selection' }
+        })
+
+        if (strictProductSelectionSetting) strictProduct = strictProductSelectionSetting.value
+
+        for (const entry of entries) {
+          const indexLabel = `${entry.source}[${entry.index}]`
+          const correlationId = `rest-adjustment:${uuidv4()}`
+
+          let rawPatch: any
+          let patch: InventoryPatch
+          let inventory: Inventory | null = null
+          let target: TargetSelector | null = null
+
+          let rawSerialNumbers: string | string[] | undefined
+          let resolvedProductDetail: ProductDetail | null = null
+
+          if (entry.kind === 'create') {
+            rawPatch = entry.payload || {}
+            rawSerialNumbers = rawPatch?.serialNumbers
+            patch = massageChanges({ ...rawPatch })
+
+            const sku = rawPatch?.sku
+            const refCode: string | undefined = rawPatch?.refCode
+            const packingType: string | undefined = rawPatch?.packingType
+            const packingSize: number | undefined = rawPatch?.packingSize
+
+            if (!refCode) {
+              throw new ApiError('E01', `refCode is required at ${indexLabel}`)
+            }
+
+            const bizplaceId =
+              rawPatch?.bizplaceId ||
+              rawPatch?.bizplace?.id ||
+              (patch?.bizplace as any)?.id ||
+              entry.payload?.bizplaceId
+
+            if (!bizplaceId) {
+              throw new ApiError('E01', `bizplaceId is required at ${indexLabel}`)
+            }
+
+            const companyBizplace: Bizplace = await getCompanyBizplace(domain, null, bizplaceId, tx)
+            const companyDomainId = (companyBizplace?.domain as any)?.id
+
+            const productDetail: ProductDetail | undefined = await tx
+              .getRepository(ProductDetail)
+              .createQueryBuilder('pd')
+              .innerJoinAndSelect('pd.product', 'product')
+              .where('pd.domain = :domain', { domain: companyDomainId })
+              .andWhere('pd.deleted_at ISNULL')
+              .andWhere('pd.ref_code = :refCode', { refCode })
+              .getOne()
+
+            if (!productDetail) {
+              throw new ApiError('E04', 'productDetail not found (invalid sku, refCode, packingType, or packingSize)')
+            }
+
+            // Strict product validation: ensure provided packingType and packingSize match productDetail
+            if (strictProduct) {
+              if (packingType && packingType !== productDetail.packingType) {
+                throw new ApiError(
+                  'E04',
+                  `packingType mismatch: provided '${packingType}' but productDetail has '${productDetail.packingType}' at ${indexLabel}`
+                )
+              }
+              if (packingSize && packingSize !== productDetail.packingSize) {
+                throw new ApiError(
+                  'E04',
+                  `packingSize mismatch: provided '${packingSize}' but productDetail has '${productDetail.packingSize}' at ${indexLabel}`
+                )
+              }
+            }
+
+            patch.productDetailId = productDetail.id
+            resolvedProductDetail = productDetail
+            if (!patch.sku && productDetail?.product?.sku) {
+              patch.sku = productDetail.product.sku
+            }
+
+            // Assign packingType and packingSize from productDetail if not provided
+            if (!packingType && productDetail.packingType) {
+              patch.packingType = productDetail.packingType
+            }
+            if (!packingSize && productDetail.packingSize) {
+              patch.packingSize = productDetail.packingSize
+            }
+          } else if (entry.kind === 'adjust') {
+            target = entry.payload?.target || {}
+            rawPatch = entry?.payload.changes && typeof entry.payload.changes === 'object' ? entry.payload.changes : {}
+            rawSerialNumbers = rawPatch?.serialNumbers
+
+            // Resolve inventory by target selector. Require at least one selector.
+            if (!target?.palletId && !target?.cartonId && !target?.batchId && !target?.locationName) {
+              throw new ApiError('E01', `target (need palletId/cartonId/batchId/locationName) at ${indexLabel}`)
+            }
+
+            inventory = await findSingleInventoryByTarget(tx, domain.id, target)
+
+            // Map human-friendly keys to InventoryPatch structure
+            patch = massageChanges(rawPatch)
+
+            // Attach the resolved inventory identifiers so the mutation updates existing record
+            patch.id = inventory.id
+            patch.palletId = inventory.palletId
+          } else {
+            continue
+          }
 
           // Validate required fields
-          const adjustmentCode: string | undefined = rawChanges?.adjustmentCode || rawChanges?.adjustment_code
-          const adjustmentNote: string | undefined = rawChanges?.adjustmentNote || rawChanges?.adjustment_note
+          const adjustmentCode: string | undefined = rawPatch?.adjustmentCode || rawPatch?.adjustment_code
+          const adjustmentNote: string | undefined = rawPatch?.adjustmentNote || rawPatch?.adjustment_note
 
           if (!adjustmentCode) {
-            throw new ApiError('E01', `adjustmentCode (adjustmentCode is required) at index ${index}`)
+            throw new ApiError('E01', `adjustmentCode (required) at ${indexLabel}`)
           }
           if (!adjustmentNote) {
-            throw new ApiError('E01', `adjustmentNote (adjustmentNote is required) at index ${index}`)
+            throw new ApiError('E01', `adjustmentNote (required) at ${indexLabel}`)
           }
           if (!ALLOWED_ADJUSTMENT_CODES.includes(adjustmentCode)) {
-            throw new ApiError('E01', `Invalid adjustmentCode '${adjustmentCode}' at index ${index}`)
+            throw new ApiError('E01', `Invalid adjustmentCode '${adjustmentCode}' at ${indexLabel}`)
           }
 
-          // Resolve inventory by target selector. Require at least one selector.
-          if (!target?.palletId && !target?.cartonId && !target?.batchId && !target?.locationName) {
-            throw new ApiError('E01', `target (need palletId/cartonId/batchId/locationName) at index ${index}`)
-          }
-
-          const inventory: Inventory = await findSingleInventoryByTarget(tx, domain.id, target)
-
-          // Map human-friendly keys to InventoryPatch structure
-          const changes: InventoryPatch = massageChanges(rawChanges)
-
-          // Attach the resolved inventory identifiers so the mutation updates existing record
-          changes.id = inventory.id
-          changes.palletId = inventory.palletId
-
           // Enforce required note/code
-          changes.adjustmentCode = adjustmentCode
-          changes.adjustmentNote = adjustmentNote
+          patch.adjustmentCode = adjustmentCode
+          patch.adjustmentNote = adjustmentNote
 
           // Correlate each generated InventoryChange using details field
-          const correlationId = `rest-adjustment:${uuidv4()}`
-          ;(changes as any).details = correlationId
+          ;(patch as any).details = correlationId
           correlationIds.push(correlationId)
 
-          // If sku is changed, require refCode and resolve productDetailId to ensure exact match
-          if (changes?.sku && changes.sku !== inventory?.product?.sku) {
-            const refCode: string | undefined = rawChanges?.refCode
-            if (!refCode) {
-              throw new ApiError('E01', 'changes.refCode (required when changing sku)')
+          let serialProduct: Product | null = null
+
+          if (inventory && target) {
+            // If sku is changed, resolve productDetailId using sku, refCode, packingType, and packingSize
+            if (patch?.sku && patch.sku !== inventory?.product?.sku) {
+              const refCode: string | undefined = rawPatch?.refCode
+              const packingType: string | undefined = rawPatch?.packingType
+              const packingSize: number | undefined = rawPatch?.packingSize
+
+              if (!refCode) {
+                throw new ApiError('E01', 'adjustment.changes.refCode (required when changing sku)')
+              }
+
+              const companyBizplace: any = await getCompanyBizplace(
+                domain,
+                null,
+                target.bizplaceId || inventory?.bizplace?.id,
+                tx
+              )
+
+              const companyDomainId = (companyBizplace?.domain as any)?.id
+
+              const pd: ProductDetail | undefined = await tx
+                .getRepository(ProductDetail)
+                .createQueryBuilder('pd')
+                .innerJoinAndSelect('pd.product', 'prod')
+                .where('pd.domain = :domain', { domain: companyDomainId })
+                .andWhere('prod.sku = :sku', { sku: patch.sku })
+                .andWhere('pd.deleted_at ISNULL')
+                .andWhere('pd.ref_code = :refCode', { refCode })
+                .getOne()
+
+              if (!pd) {
+                throw new ApiError('E04', 'productDetail not found (by sku, refCode, packingType, and packingSize)')
+              }
+
+              // Strict product validation for adjustments: ensure provided packingType and packingSize match productDetail
+              if (strictProduct) {
+                if (packingType && packingType !== pd.packingType) {
+                  throw new ApiError(
+                    'E04',
+                    `packingType mismatch in adjustment: provided '${packingType}' but productDetail has '${pd.packingType}' at ${indexLabel}`
+                  )
+                }
+                if (packingSize && packingSize !== pd.packingSize) {
+                  throw new ApiError(
+                    'E04',
+                    `packingSize mismatch in adjustment: provided '${packingSize}' but productDetail has '${pd.packingSize}' at ${indexLabel}`
+                  )
+                }
+              }
+
+              if (strictProduct) {
+                patch.packingType = pd.packingType
+                patch.packingSize = pd.packingSize
+              }
+
+              ;(patch as any).productDetailId = (pd as any).id
+              resolvedProductDetail = pd as ProductDetail
             }
-            const companyBizplace: any = await getCompanyBizplace(
-              domain,
-              null,
-              target.bizplaceId || inventory?.bizplace?.id,
-              tx
-            )
-            const domainId = (companyBizplace?.domain as any)?.id
-            const pd = await tx
-              .getRepository(ProductDetail)
-              .createQueryBuilder('pd')
-              .innerJoinAndSelect('pd.product', 'prod')
-              .where('pd.domain = :domain', { domain: domainId })
-              .andWhere('prod.sku = :sku', { sku: changes.sku })
-              .andWhere('pd.refCode = :refCode', { refCode })
-              .getOne()
-            if (!pd) {
-              throw new ApiError('E04', 'productDetail (by sku and refCode)')
-            }
-            ;(changes as any).productDetailId = (pd as any).id
+
+            serialProduct = (resolvedProductDetail || inventory.product) as Product
+          }
+
+          if (!serialProduct && resolvedProductDetail) {
+            serialProduct = resolvedProductDetail?.product || serialProduct
           }
 
-          patches.push(changes)
+          const needsSerialNumbers = productRequiresSerialTracking(serialProduct)
+          if (needsSerialNumbers && !defined(rawSerialNumbers)) {
+            throw new ApiError('E01', `serialNumbers (required for serial-tracked product) at ${indexLabel}`)
+          }
+          if (defined(rawSerialNumbers)) {
+            patch.serialNumbers = normalizeSerialNumbersValue(rawSerialNumbers)
+          }
+
+          patches.push(patch)
         }
 
         // Submit via shared service to preserve core business logic
@@ -185,6 +350,30 @@ router.post(
   }
 )
 
+function normalizeAdjustmentEntries(payload: any): NormalizedEntry[] {
+  const entries: NormalizedEntry[] = []
+
+  if (payload?.create && !Array.isArray(payload.create)) {
+    throw new ApiError('E01', 'create must be an array')
+  }
+  if (payload?.adjustments && !Array.isArray(payload.adjustments)) {
+    throw new ApiError('E01', 'adjustments must be an array')
+  }
+
+  const sources = [
+    { data: payload?.create || [], kind: 'create', source: 'create' },
+    { data: payload?.adjustments || [], kind: 'adjust', source: 'adjustments' }
+  ]
+
+  entries.push(
+    ...sources.flatMap(({ data, kind, source }) =>
+      data.map((item, idx) => item && { kind, payload: item, source, index: idx }).filter(Boolean)
+    )
+  )
+
+  return entries
+}
+
 async function findSingleInventoryByTarget(
   tx: EntityManager,
   domainId: string,
@@ -227,33 +416,19 @@ async function findSingleInventoryByTarget(
 }
 
 function massageChanges(input: any): InventoryPatch {
-  // Normalize incoming keys (support snake_case & alternate names)
   const changes = { ...input }
 
-  // Field aliases from requirement list
-  if (changes.batchNo && !changes.batchId) changes.batchId = changes.batchNo
-  if (changes.batchNoRef && !changes.batchIdRef) changes.batchIdRef = changes.batchNoRef
-  if (changes.company && !changes.bizplaceId) changes.bizplaceId = changes.company
-  if (changes.totalUomValue && !changes.uomValue) changes.uomValue = Number(changes.totalUomValue)
-  if (changes.expDate && !changes.expirationDate) changes.expirationDate = changes.expDate
-  if (changes.location && typeof changes.location === 'string') {
-    changes.locationName = changes.location
-    delete changes.location
-  }
-
   // Build InventoryPatch with supported fields only
   const patch: InventoryPatch = {}
 
   assignIfDefined(patch, 'bizplace', changes.bizplace)
   if (changes.bizplaceId) patch.bizplace = { id: String(changes.bizplaceId) } as any
 
-  // Identify product by productDetailId or sku
-  if (changes.productDetailId) assignIfDefined(patch, 'productDetailId', String(changes.productDetailId))
+  // Identify product by sku
   if (changes.sku) assignIfDefined(patch, 'sku', String(changes.sku))
   if (changes.productName) assignIfDefined(patch, 'productName', String(changes.productName))
 
   // Location can be id or name
-  if (changes.locationId) patch.location = { id: String(changes.locationId) } as any
   if (changes.locationName) patch.location = { name: String(changes.locationName) } as any
 
   assignIfDefined(patch, 'batchId', changes.batchId)
@@ -264,7 +439,6 @@ function massageChanges(input: any): InventoryPatch {
   if (defined(changes.qty)) patch.qty = Number(changes.qty)
   if (defined(changes.uomValue)) patch.uomValue = Number(changes.uomValue)
   if (defined(changes.uom)) patch.uom = String(changes.uom).trim()
-  assignIfDefined(patch, 'serialNumbers', changes.serialNumbers)
   assignIfDefined(patch, 'remark', changes.remark)
   assignIfDefined(patch, 'expirationDate', changes.expirationDate)
   assignIfDefined(patch, 'manufactureDate', changes.manufactureDate)
@@ -275,6 +449,25 @@ function massageChanges(input: any): InventoryPatch {
   return patch
 }
 
+function productRequiresSerialTracking(product?: Product | null): boolean {
+  return !!(product?.isRequireSerialNumberScanning || product?.isRequireSerialNumberScanningInbound)
+}
+
+function normalizeSerialNumbersValue(serialNumbers: string | string[]): string {
+  if (Array.isArray(serialNumbers)) {
+    return serialNumbers
+      .map(sn => String(sn || '').trim())
+      .filter(Boolean)
+      .join(',')
+  }
+
+  return String(serialNumbers || '')
+    .split(',')
+    .map(sn => sn.trim())
+    .filter(Boolean)
+    .join(',')
+}
+
 function assignIfDefined<T extends object, K extends keyof any>(obj: T, key: K, value: any) {
   if (defined(value)) (obj as any)[key] = value
 }