@things-factory/operato-hub 4.3.744 → 4.3.745

package/server/routers/api/restful-apis/v1/warehouse/update-arrival-notice.ts

@@ -0,0 +1,429 @@
+import { EntityManager, getConnection, SelectQueryBuilder, In } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Bizplace, ContactPoint, getCompanyBizplace } from '@things-factory/biz-base'
+import { ProductDetail } from '@things-factory/product-base'
+import {
+  ArrivalNotice,
+  ORDER_PRODUCT_STATUS,
+  ORDER_STATUS,
+  ORDER_TYPES,
+  OrderProduct
+} from '@things-factory/sales-base'
+import { WorksheetDetail } from '@things-factory/worksheet-base'
+import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+
+// Allowed statuses for update
+const ALLOWED_STATUSES = [
+  ORDER_STATUS.PENDING,
+  ORDER_STATUS.PENDING_RECEIVE,
+  ORDER_STATUS.INTRANSIT,
+  ORDER_STATUS.ARRIVED,
+  ORDER_STATUS.READY_TO_UNLOAD
+]
+
+router.post(
+  '/v1/warehouse/update-arrival-notice',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      const { domain } = context.state
+      const bodyReq = context.request.body.data
+
+      await getConnection().transaction(async (tx: EntityManager) => {
+        // Validate arrival notice exists and get it
+        if (!bodyReq.arrivalNoticeId && !bodyReq.ganNo) {
+          throw new ApiError('E01', 'arrivalNoticeId or ganNo is required')
+        }
+
+        // Build where clause: arrivalNoticeId maps to id, ganNo maps to name
+        const whereClause: any = { domain }
+        if (bodyReq.arrivalNoticeId) {
+          whereClause.id = bodyReq.arrivalNoticeId
+        }
+        if (bodyReq.ganNo) {
+          whereClause.name = bodyReq.ganNo
+        }
+
+        const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+          where: whereClause,
+          relations: ['bizplace', 'orderProducts', 'orderProducts.product', 'orderProducts.productDetail']
+        })
+
+        if (!foundArrivalNotice) {
+          const searchCriteria = []
+          if (bodyReq.arrivalNoticeId) searchCriteria.push(`id: ${bodyReq.arrivalNoticeId}`)
+          if (bodyReq.ganNo) searchCriteria.push(`ganNo: ${bodyReq.ganNo}`)
+          throw new ApiError('E04', `Arrival notice not found: ${searchCriteria.join(', ')}`)
+        }
+
+        // Validate status
+        if (!ALLOWED_STATUSES.includes(foundArrivalNotice.status)) {
+          throw new ApiError(
+            'E04',
+            `Arrival notice status "${
+              foundArrivalNotice.status
+            }" does not allow updates. Allowed statuses: ${ALLOWED_STATUSES.join(', ')}`
+          )
+        }
+
+        // Update arrival notice fields if provided
+        const updateData: any = {
+          updater: context.state.user
+        }
+
+        if (bodyReq.hasOwnProperty('refNo')) updateData.refNo = bodyReq.refNo
+        if (bodyReq.hasOwnProperty('refNo2')) updateData.refNo2 = bodyReq.refNo2
+        if (bodyReq.hasOwnProperty('refNo3')) updateData.refNo3 = bodyReq.refNo3
+        if (bodyReq.hasOwnProperty('etaDate')) updateData.etaDate = bodyReq.etaDate
+        if (bodyReq.hasOwnProperty('ownTransport')) updateData.ownTransport = bodyReq.ownTransport
+        if (bodyReq.hasOwnProperty('importCargo')) updateData.importCargo = bodyReq.importCargo
+        if (bodyReq.hasOwnProperty('container')) updateData.container = bodyReq.container
+        if (bodyReq.hasOwnProperty('containerNo')) updateData.containerNo = bodyReq.containerNo
+        if (bodyReq.hasOwnProperty('containerSize')) updateData.containerSize = bodyReq.containerSize
+        if (bodyReq.hasOwnProperty('truckNo')) updateData.truckNo = bodyReq.truckNo
+        if (bodyReq.hasOwnProperty('deliveryOrderNo')) updateData.deliveryOrderNo = bodyReq.deliveryOrderNo
+        if (bodyReq.hasOwnProperty('remark')) updateData.remark = bodyReq.remark
+        if (bodyReq.hasOwnProperty('description')) updateData.description = bodyReq.description
+
+        // Update supplier if provided
+        if (bodyReq.hasOwnProperty('supplierId')) {
+          if (bodyReq.supplierId) {
+            const foundSupplier: ContactPoint = await tx.getRepository(ContactPoint).findOne({
+              where: { id: bodyReq.supplierId }
+            })
+            if (!foundSupplier) {
+              throw new ApiError('E04', `Supplier not found: ${bodyReq.supplierId}`)
+            }
+            updateData.supplier = foundSupplier
+          } else {
+            updateData.supplier = null
+          }
+        }
+
+        // Handle order products: add, update, remove
+        if (bodyReq.orderProducts && Array.isArray(bodyReq.orderProducts)) {
+          const existingOrderProducts = foundArrivalNotice.orderProducts || []
+          const orderProductsToAdd = []
+          const orderProductsToUpdate = []
+          const orderProductIdsToRemove = []
+
+          // Helper function to find matching order product by id, sku, refCode, batchId, packingType, or refItemId
+          const findMatchingOrderProduct = (orderProductReq: any): OrderProduct | null => {
+            // Match 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
+            )
+          }
+
+          // Process each order product in the request
+          for (const orderProductReq of bodyReq.orderProducts) {
+            // Handle removal request
+            if (orderProductReq._action === 'remove') {
+              const matchingOP = findMatchingOrderProduct(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(orderProductReq)
+
+            if (matchingOP) {
+              // Update existing order product
+              // Validate and prepare update data
+              const opUpdateData: any = {
+                updater: context.state.user
+              }
+
+              // Update quantity if provided (accepts 'qty' or 'packQty')
+              if (orderProductReq.hasOwnProperty('qty') || orderProductReq.hasOwnProperty('packQty')) {
+                const qty = orderProductReq.qty !== undefined ? orderProductReq.qty : orderProductReq.packQty
+                if (qty <= 0) {
+                  throw new ApiError('E01', 'Quantity must be greater than 0')
+                }
+
+                // Round quantity based on product's decimal support
+                if (!matchingOP.product.isInventoryDecimal) {
+                  opUpdateData.packQty = Math.round(qty)
+                } else {
+                  opUpdateData.packQty = parseFloat(qty.toFixed(3))
+                }
+
+                // Recalculate total UOM value
+                if (matchingOP.productDetail) {
+                  opUpdateData.totalUomValue = `${(
+                    opUpdateData.packQty * (matchingOP.productDetail.uomValue || 1)
+                  ).toFixed(2)} ${matchingOP.productDetail.uom}`
+                }
+              }
+
+              // Update other fields if provided
+              if (orderProductReq.hasOwnProperty('batchId')) opUpdateData.batchId = orderProductReq.batchId
+              if (orderProductReq.hasOwnProperty('unitPrice'))
+                opUpdateData.unitPrice = orderProductReq.unitPrice ? parseFloat(orderProductReq.unitPrice) : null
+              if (orderProductReq.hasOwnProperty('manufactureDate'))
+                opUpdateData.manufactureDate = orderProductReq.manufactureDate || null
+              if (orderProductReq.hasOwnProperty('remark')) opUpdateData.remark = orderProductReq.remark || null
+              if (orderProductReq.hasOwnProperty('refItemId')) opUpdateData.refItemId = orderProductReq.refItemId
+
+              orderProductsToUpdate.push({
+                id: matchingOP.id,
+                ...opUpdateData
+              })
+            } else {
+              // No matching order product found - add as new
+              orderProductsToAdd.push(orderProductReq)
+            }
+          }
+
+          // Remove order products
+          // First, delete any worksheet details that reference these order products
+          if (orderProductIdsToRemove.length > 0) {
+            // Find and delete worksheet details that reference the order products to be deleted
+            const worksheetDetailsToDelete: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+              where: {
+                targetProduct: In(orderProductIdsToRemove),
+                domain
+              }
+            })
+
+            if (worksheetDetailsToDelete.length > 0) {
+              const worksheetDetailIds = worksheetDetailsToDelete.map(wsd => wsd.id)
+              await tx.getRepository(WorksheetDetail).delete({
+                id: In(worksheetDetailIds)
+              })
+            }
+
+            // Now delete the order products
+            await tx.getRepository(OrderProduct).delete({
+              id: In(orderProductIdsToRemove),
+              arrivalNotice: foundArrivalNotice
+            })
+          }
+
+          // Update existing order products
+          for (const opUpdate of orderProductsToUpdate) {
+            await tx.getRepository(OrderProduct).update(opUpdate.id, opUpdate)
+          }
+
+          // Add new order products
+          if (orderProductsToAdd.length > 0) {
+            const massagedData = await massageOrderItems(foundArrivalNotice, orderProductsToAdd, context, tx)
+            for (const newOrderProduct of massagedData.orderProducts) {
+              const orderProduct = Object.assign(new OrderProduct(), {
+                ...newOrderProduct,
+                name: uuidv4(),
+                domain: domain,
+                bizplace: foundArrivalNotice.bizplace,
+                arrivalNotice: foundArrivalNotice,
+                type: ORDER_TYPES.ARRIVAL_NOTICE,
+                status:
+                  existingOrderProducts.length > 0
+                    ? existingOrderProducts[0].status
+                    : ORDER_PRODUCT_STATUS.PENDING_RECEIVE,
+                creator: context.state.user,
+                updater: context.state.user
+              })
+              await tx.getRepository(OrderProduct).save(orderProduct)
+            }
+          }
+        }
+
+        // Save arrival notice updates
+        await tx.getRepository(ArrivalNotice).update(foundArrivalNotice.id, updateData)
+
+        // Fetch updated arrival notice with relations
+        const updatedArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+          where: { id: foundArrivalNotice.id },
+          relations: ['bizplace', 'orderProducts', 'orderProducts.product', 'orderProducts.productDetail', 'supplier']
+        })
+
+        // Format response
+        const resultOrderProducts = (updatedArrivalNotice.orderProducts || []).map(op => ({
+          id: op.id,
+          product: { name: op.product.name, sku: op.product.sku },
+          batchId: op.batchId,
+          packingType: op.packingType,
+          packingSize: op.packingSize,
+          qty: op.packQty,
+          palletQty: op.palletQty,
+          uom: op.uom,
+          uomValue: op.uomValue,
+          refItemId: op?.refItemId,
+          unitPrice: op.unitPrice,
+          manufactureDate: op.manufactureDate,
+          remark: op.remark
+        }))
+
+        const data = {
+          id: updatedArrivalNotice.id,
+          ganNo: updatedArrivalNotice.name,
+          refNo: updatedArrivalNotice.refNo,
+          refNo2: updatedArrivalNotice.refNo2,
+          refNo3: updatedArrivalNotice.refNo3,
+          etaDate: updatedArrivalNotice.etaDate,
+          ownTransport: updatedArrivalNotice.ownTransport,
+          importCargo: updatedArrivalNotice.importCargo,
+          container: updatedArrivalNotice.container,
+          containerNo: updatedArrivalNotice.containerNo,
+          containerSize: updatedArrivalNotice.containerSize,
+          truckNo: updatedArrivalNotice.truckNo,
+          deliveryOrderNo: updatedArrivalNotice.deliveryOrderNo,
+          remark: updatedArrivalNotice.remark,
+          description: updatedArrivalNotice.description,
+          status: updatedArrivalNotice.status,
+          orderProducts: resultOrderProducts,
+          supplier: updatedArrivalNotice?.supplier
+            ? {
+                id: updatedArrivalNotice.supplier.id,
+                name: updatedArrivalNotice.supplier.name,
+                email: updatedArrivalNotice.supplier.email,
+                phone: updatedArrivalNotice.supplier.phone
+              }
+            : null
+        }
+
+        context.body = {
+          responseCode: '200',
+          message: 'success',
+          data
+        }
+      })
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)
+
+async function massageOrderItems(
+  arrivalNotice: ArrivalNotice,
+  inputOrderProducts: any[],
+  context: any,
+  tx: EntityManager
+): Promise<{ orderProducts: OrderProduct[] }> {
+  let orderProducts: OrderProduct[] = []
+
+  // Get company bizplace for product lookup
+  const customerCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, arrivalNotice.bizplaceId, tx)
+
+  await Promise.all(
+    inputOrderProducts.map(async inputOrderItem => {
+      const sku: string = inputOrderItem.product?.sku || inputOrderItem.sku
+      const refCode: string = inputOrderItem.product?.refCode || inputOrderItem.refCode
+      const packingType: string = inputOrderItem.packingType
+      const packingSize: string = inputOrderItem.packingSize
+      const packQty = inputOrderItem.qty !== undefined ? inputOrderItem.qty : inputOrderItem.packQty
+
+      if (!sku && !refCode) {
+        throw new ApiError('E01', 'sku or refCode is required')
+      }
+
+      if (!packQty || packQty <= 0) {
+        throw new ApiError('E01', 'Quantity must be greater than 0')
+      }
+
+      const qb: SelectQueryBuilder<ProductDetail> = tx
+        .getRepository(ProductDetail)
+        .createQueryBuilder('pd')
+        .innerJoinAndSelect('pd.product', 'prod')
+        .where('prod.bizplace_id = :bizplaceId', { bizplaceId: customerCompanyBizplace.id })
+
+      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) {
+        // Validate packQty based on product's isInventoryDecimal
+        let validatedPackQty: number
+        if (!productDetail.product.isInventoryDecimal) {
+          validatedPackQty = Math.round(packQty)
+        } else {
+          validatedPackQty = parseFloat(packQty.toFixed(3))
+        }
+
+        let newOrderProduct: OrderProduct = {
+          product: productDetail.product,
+          productDetail: productDetail,
+          packingType: productDetail.packingType,
+          packingSize: productDetail.packingSize,
+          uom: productDetail.uom,
+          uomValue: productDetail.uomValue,
+          packQty: validatedPackQty,
+          totalUomValue: `${(validatedPackQty * (productDetail.uomValue || 1)).toFixed(2)} ${productDetail.uom}`,
+          batchId: inputOrderItem.batchId || null,
+          status: ORDER_PRODUCT_STATUS.PENDING_RECEIVE,
+          unitPrice: inputOrderItem?.unitPrice ? parseFloat(inputOrderItem.unitPrice) : null,
+          manufactureDate: inputOrderItem?.manufactureDate || null,
+          remark: inputOrderItem?.remark || null,
+          refItemId: inputOrderItem?.refItemId || null
+        }
+
+        orderProducts.push(newOrderProduct)
+      } else {
+        // Product not found - provide clear error message
+        const identifier = sku ? `sku: ${sku}` : `refCode: ${refCode}`
+        const packingInfo = packingType ? `, packingType: ${packingType}` : ''
+        const packingSizeInfo = packingSize ? `, packingSize: ${packingSize}` : ''
+        throw new ApiError('E04', `Product not found: ${identifier}${packingInfo}${packingSizeInfo}`)
+      }
+    })
+  )
+
+  return { orderProducts }
+}