@things-factory/operato-hub 4.3.120 → 4.3.123

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

@@ -0,0 +1,324 @@
+import { EntityManager, getConnection, SelectQueryBuilder } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint, getCompanyBizplace } from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-base'
+import { ProductDetail } from '@things-factory/product-base'
+import {
+  ArrivalNotice,
+  ORDER_NUMBER_RULE_TYPE,
+  ORDER_NUMBER_SETTING_KEY,
+  ORDER_PRODUCT_STATUS,
+  ORDER_STATUS,
+  ORDER_TYPES,
+  OrderNoGenerator,
+  OrderProduct
+} from '@things-factory/sales-base'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+
+import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+
+router.post(
+  '/v1/warehouse/add-inbound-order',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      const { domain, application } = context.state
+      const bodyReq = context.request.body.data
+      let inboundOrder
+      let massagedData = { orderProducts: [] }
+
+      const customerBizplaceId = bodyReq.bizplaceId
+
+      await getConnection().transaction(async (tx: EntityManager) => {
+        // get customer company's bizplace
+        const customerCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, customerBizplaceId, tx)
+        const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+          where: { id: customerBizplaceId },
+          relations: ['company', 'company.domain']
+        })
+
+        inboundOrder = {
+          domain,
+          bizplace: customerBizplace,
+          companyBizplace: customerCompanyBizplace,
+          refNo: bodyReq?.refNo || null,
+          refNo2: bodyReq?.refNo2 || null,
+          refNo3: bodyReq?.refNo3 || null,
+          etaDate: bodyReq.etaDate,
+          ownTransport: bodyReq.ownTransport,
+          importCargo: bodyReq?.importCargo || false,
+          container: bodyReq?.container || false,
+          containerNo: bodyReq?.containerNo || null,
+          containerSize: bodyReq?.containerSize || null,
+          truckNo: bodyReq?.truckNo || null,
+          deliveryOrderNo: bodyReq?.deliveryOrderNo || null,
+          source: application?.type
+        }
+
+        if (bodyReq?.supplierId) {
+          const foundSupplier: ContactPoint = await tx.getRepository(ContactPoint).findOne({
+            where: { id: bodyReq.supplierId }
+          })
+
+          if (foundSupplier) {
+            inboundOrder.supplier = foundSupplier
+          } else {
+            throw new ApiError('E04', 'supplier')
+          }
+        }
+
+        //massage data
+        massagedData = await massageOrderItems(inboundOrder, bodyReq.orderProducts, context, tx)
+
+        let result = await createInboundOrder(inboundOrder, massagedData.orderProducts, customerBizplace, context, tx)
+
+        const data = {
+          id: result.id,
+          ganNo: result.name,
+          refNo: result.refNo,
+          refNo2: result.refNo2,
+          refNo3: result.refNo3,
+          etaDate: result.etaDate,
+          ownTransport: result.ownTransport,
+          importCargo: result.importCargo,
+          container: result.container,
+          containerNo: result.containerNo,
+          containerSize: result.containerSize,
+          truckNo: result.truckNo,
+          deliveryOrderNo: result.deliveryOrderNo,
+          orderProducts: result.orderProducts,
+          supplier: result?.supplier
+        }
+
+        context.body = {
+          responseCode: '200',
+          message: 'success',
+          data
+        }
+      })
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)
+
+async function massageOrderItems(
+  inboundOrder,
+  inputOrderProducts,
+  context,
+  tx
+): Promise<{ orderProducts: OrderProduct[] }> {
+  let orderProducts: OrderProduct[] = []
+  inputOrderProducts = inputOrderProducts.reduce((acc, itm, idx) => {
+    let { sku, refCode } = itm.product
+    let { packingType, packingSize, batchId, qty: packQty } = itm
+
+    if (packQty <= 0) {
+      throw new ApiError('E01', 'qty negative value')
+    }
+
+    let existingIndex = acc.findIndex(
+      itm =>
+        itm?.sku == sku?.trim() &&
+        itm?.refCode == refCode?.trim() &&
+        itm?.batchId == batchId?.trim() &&
+        itm?.packingType == packingType?.trim() &&
+        itm?.packingSize == packingSize
+    )
+
+    if (existingIndex >= 0 && packQty > 0) {
+      acc[existingIndex].packQty = acc[existingIndex].packQty + packQty
+    } else {
+      acc.push({
+        sku: sku?.trim(),
+        refCode: refCode?.trim(),
+        batchId: batchId?.trim(),
+        packingType: packingType?.trim(),
+        packingSize: packingSize,
+        packQty
+      })
+    }
+
+    return acc
+  }, [])
+
+  await Promise.all(
+    inputOrderProducts.map(async inputOrderItem => {
+      const sku: string = inputOrderItem.sku
+      const refCode: string = inputOrderItem.refCode
+      const packingType: string = inputOrderItem.packingType
+      const packingSize: string = inputOrderItem.packingSize
+
+      const qb: SelectQueryBuilder<ProductDetail> = tx
+        .getRepository(ProductDetail)
+        .createQueryBuilder('pd')
+        .innerJoinAndSelect('pd.product', 'prod')
+        .where('prod.bizplace_id = :bizplaceId', { bizplaceId: inboundOrder.companyBizplace.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 ((!packingType && !refCode) || !packingSize) {
+        qb.andWhere('pd.is_default = :isDefault', { isDefault: true })
+      }
+
+      const productDetail: ProductDetail = await qb.getOne()
+
+      if (productDetail) {
+        let newOrderProduct: OrderProduct = Object.assign({}, inputOrderItem)
+        newOrderProduct = {
+          ...newOrderProduct,
+          product: productDetail.product,
+          productDetail: productDetail,
+          packingType: productDetail.packingType,
+          packingSize: productDetail.packingSize,
+          uom: productDetail.uom,
+          uomValue: productDetail.uomValue,
+          packQty: inputOrderItem.packQty,
+          totalUomValue: `${inputOrderItem.packQty * (productDetail.uomValue || 1)} ${productDetail.uomValue}`,
+          batchId: inputOrderItem.batchId,
+          status: ORDER_PRODUCT_STATUS.PENDING_RECEIVE,
+          unitPrice: inputOrderItem?.unitPrice ? parseFloat(inputOrderItem.unitPrice) : null,
+          manufactureDate: inputOrderItem?.manufactureDate || null,
+          remark: inputOrderItem?.remark || null
+        }
+
+        orderProducts.push(newOrderProduct)
+      } else {
+        if (sku && refCode) {
+          throw new ApiError('E04', `sku ${sku} and refCode ${refCode}`)
+        }
+
+        if (sku) {
+          throw new ApiError('E04', `sku ${sku}`)
+        }
+
+        if (refCode) {
+          throw new ApiError('E04', `refCode ${refCode}`)
+        }
+      }
+    })
+  )
+
+  return { orderProducts }
+}
+
+async function createInboundOrder(
+  inboundOrder: any,
+  orderProducts: OrderProduct[],
+  bizplace: Bizplace,
+  context: any,
+  tx?: EntityManager
+): Promise<ArrivalNotice> {
+  const { domain, user }: { domain: Domain; user: User } = context.state
+
+  let newArrivalNotice: ArrivalNotice = new ArrivalNotice()
+  const ganNoSetting: Setting = await tx.getRepository(Setting).findOne({
+    where: {
+      domain,
+      name: ORDER_NUMBER_SETTING_KEY.GAN_NUMBER_RULE
+    }
+  })
+
+  let anStatus = ORDER_STATUS.PENDING_RECEIVE
+  let opStatus = ORDER_PRODUCT_STATUS.PENDING_RECEIVE
+  let acceptedByUser = null
+  let acceptedTime = null
+
+  const ganProcessingSetting: Setting = await tx.getRepository(Setting).findOne({
+    where: { domain, category: 'id-rule', name: 'gan-order-processing' }
+  })
+
+  const partnerGanProcessingSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+    where: { setting: ganProcessingSetting, domain, partnerDomain: bizplace?.domain }
+  })
+
+  // If status of GAN is PENDING_RECEIVE then directly to assign warehouse
+  if (ganProcessingSetting) {
+    let setting = !isNaN(partnerGanProcessingSetting?.value)
+      ? partnerGanProcessingSetting?.value
+      : ganProcessingSetting.value
+
+    // CONFIRM to assign if setting value is 1
+    if (setting == 1) {
+      opStatus = ORDER_PRODUCT_STATUS.ARRIVED
+      anStatus = ORDER_STATUS.ARRIVED
+      acceptedByUser = user
+      acceptedTime = new Date()
+    }
+  }
+
+  newArrivalNotice = {
+    name: ganNoSetting
+      ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.GAN_NUMBER, seed: {} })
+      : OrderNoGenerator.arrivalNotice(),
+    domain: domain,
+    bizplace: bizplace,
+    refNo: inboundOrder?.refNo || null,
+    refNo2: inboundOrder?.refNo2 || null,
+    refNo3: inboundOrder?.refNo3 || null,
+    etaDate: inboundOrder.etaDate,
+    ownTransport: inboundOrder.ownTransport,
+    looseItem: false,
+    importCargo: inboundOrder?.importCargo || false,
+    container: inboundOrder?.container || false,
+    containerNo: inboundOrder?.containerNo || null,
+    containerSize: inboundOrder?.containerSize || null,
+    truckNo: inboundOrder?.truckNo || null,
+    deliveryOrderNo: inboundOrder?.deliveryOrderNo || null,
+    source: inboundOrder?.source || null,
+    status: anStatus,
+    supplier: inboundOrder?.supplier || null,
+    creator: user,
+    updater: user,
+    acceptedByUser,
+    acceptedTime
+  }
+
+  let resultArrivalNotice = await tx.getRepository(ArrivalNotice).save(newArrivalNotice)
+
+  let resultOrderProducts: OrderProduct[] = []
+  for (let i = 0; i < orderProducts.length; i++) {
+    let orderProduct = Object.assign(new OrderProduct(), {
+      ...orderProducts[i],
+      name: uuidv4(),
+      domain: domain,
+      bizplace: bizplace,
+      arrivalNotice: resultArrivalNotice,
+      type: ORDER_TYPES.ARRIVAL_NOTICE,
+      status: opStatus
+    })
+    await tx.getRepository(OrderProduct).save(orderProduct)
+
+    resultOrderProducts.push({
+      product: { name: orderProduct.product.name, sku: orderProduct.product.sku },
+      batchId: orderProduct.batchId,
+      packingType: orderProduct.packingType,
+      packingSize: orderProduct.packingSize,
+      qty: orderProduct.packQty,
+      palletQty: orderProduct.palletQty,
+      uom: orderProduct.uom,
+      uomValue: orderProduct.uomValue
+    })
+  }
+  newArrivalNotice.orderProducts = resultOrderProducts
+
+  return newArrivalNotice
+}