@things-factory/operato-hub 4.3.108 → 4.3.110

package/server/routers/api/restful-apis/v1/utils/validate-util.ts

@@ -1,53 +0,0 @@
-import _ from 'lodash'
-
-import { ApiError } from './error-util'
-
-// validates limit and offset are passed in as integers within accepted range
-// values are floored
-export function validateLimitOffset(limit, offset) {
-  if (!limit) limit = 100
-  limit = parseInt(limit)
-  if (isNaN(limit)) throw new ApiError('E01', 'limit')
-  if (limit > 100 || limit < 1) throw new ApiError('E01', 'limit')
-
-  if (!offset) offset = 0
-  offset = parseInt(offset)
-  if (isNaN(offset)) throw new ApiError('E01', 'offset')
-  if (offset < 0) throw new ApiError('E01', 'offset')
-
-  return { limit, offset }
-}
-
-// assigns default values if undefined
-// validates passed in dates are ISO format
-// toDate cannot be before fromDate
-// difference in days cannot exceed 31
-// converts ISO format dates to UTC format dates for database query
-export function validateFromToDate(fromDate, toDate) {
-  const now = new Date()
-  const then = new Date(new Date().setDate(new Date().getDate() - 7))
-
-  // validate date format
-  if (fromDate && !(new Date(fromDate) instanceof Date)) throw new ApiError('E01', 'fromDate')
-  if (toDate && !(new Date(toDate) instanceof Date)) throw new ApiError('E01', 'toDate')
-
-  // assign default dates
-  if (!fromDate) fromDate = then.toISOString()
-  if (!toDate) toDate = now.toISOString()
-
-  // validate conjuction
-  if (toDate < fromDate) throw new ApiError('E01', 'from and to dates are not in conjuction')
-
-  // validate date range
-  const diffTime = Math.abs(new Date(toDate).getTime() - new Date(fromDate).getTime())
-  const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24))
-  if (diffDays > 31) throw new ApiError('E01', 'date range is more than 31 days')
-
-  return { fromDate, toDate }
-}
-
-// Regular expression to check if string is a valid UUID
-export function isValidUUID(str) {
-  const regexExp = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/gi
-  return regexExp.test(str)
-}

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

@@ -1,324 +0,0 @@
-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, packQty } = itm
-
-    if (packQty <= 0) {
-      throw new ApiError('E01', 'packQty 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,
-      packQty: orderProduct.packQty,
-      palletQty: orderProduct.palletQty,
-      uom: orderProduct.uom,
-      uomValue: orderProduct.uomValue
-    })
-  }
-  newArrivalNotice.orderProducts = resultOrderProducts
-
-  return newArrivalNotice
-}