@things-factory/operato-hub 4.3.81 → 4.3.82

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

@@ -0,0 +1,361 @@
+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.domain
+      const bodyReq = context.request.body
+      let inboundOrder
+      let massagedData = { orderProducts: [] }
+
+      const customerBizplaceId = bodyReq.data.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?.supplier) {
+          const supplierInfo = bodyReq.supplier
+          const foundSupplier: ContactPoint = await tx.getRepository(ContactPoint).findOne({
+            where: {
+              domain,
+              bizplace: customerBizplaceId,
+              name: supplierInfo.name,
+              companyName: supplierInfo.companyName,
+              email: supplierInfo.email,
+              accountNo: supplierInfo.accountNo,
+              type: 'SUPPLIER'
+            }
+          })
+
+          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
+            ? {
+                name: result.supplier.name,
+                companyName: result.supplier.companyName,
+                email: result.supplier.email,
+                accountNo: result.supplier.accountNo
+              }
+            : {}
+        }
+
+        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[] }> {
+  try {
+    let orderProducts: OrderProduct[] = []
+    let errorList = []
+    inputOrderProducts = inputOrderProducts.reduce((acc, itm, idx) => {
+      let { sku, refCode } = itm.product
+      let { packingType, packingSize, batchId, packQty } = itm
+
+      if (packQty <= 0) {
+        errorList.push(
+          JSON.stringify({
+            code: 'INVALID_DATA',
+            message: 'negative stock request',
+            sku: sku,
+            refCode: refCode,
+            packingType: packingType?.trim(),
+            packingSize: packingSize,
+            qty: packQty
+          })
+        )
+      }
+
+      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,
+          releaseQty: 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 }
+  } catch (error) {
+    if (error instanceof ApiError) ApiErrorHandler(context, error)
+    else throwInternalServerError(context, error)
+  }
+}
+
+async function createInboundOrder(
+  inboundOrder: any,
+  orderProducts: OrderProduct[],
+  bizplace: Bizplace,
+  context: any,
+  tx?: EntityManager
+): Promise<ArrivalNotice> {
+  try {
+    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?.type || 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,
+        packQty: orderProduct.packQty,
+        palletQty: orderProduct.palletQty,
+        uom: orderProduct.uom,
+        uomValue: orderProduct.uomValue
+      })
+    }
+    newArrivalNotice.orderProducts = resultOrderProducts
+
+    return newArrivalNotice
+  } catch (error) {
+    if (error instanceof ApiError) ApiErrorHandler(context, error)
+    else throwInternalServerError(context, error)
+  }
+}