@things-factory/operato-hub 4.3.79-alpha.1 → 4.3.79

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

@@ -1,74 +0,0 @@
-import _ from 'lodash'
-import { getRepository } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-
-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 }
-}
-
-// loops through query parameters to ensure only expected parameters are passed to logic
-export function validateFilter(queryObj: Object, expectedParams: string[]) {
-  for (const key in queryObj) {
-    if (!expectedParams.includes(key)) throw new ApiError('E02', key)
-  }
-}
-
-// checks if object has required parameter property
-export function validateReqParams(queryObj: Object, reqParams: string[]) {
-  let noparams = []
-  for (const reqParam of reqParams) {
-    if (!_.has(queryObj, reqParam)) noparams.push(reqParam)
-  }
-  if (noparams.length > 0) throw new ApiError('E03', noparams.join(', '))
-}
-
-// assigns default values if undefined
-// validates passed in dates are ISO format
-// converts ISO format dates to UTC format dates for database query
-export function validateFromToDate(fromDate, toDate) {
-  const now = new Date()
-  const ago = new Date(now.getTime())
-  const sevenDaysAgo = ago.setDate(ago.getDate() - 7)
-  const nowUtc = now.toUTCString()
-  const sevenDaysAgoUtc = new Date(sevenDaysAgo).toUTCString()
-
-  if (!fromDate) fromDate = sevenDaysAgoUtc
-  else fromDate = new Date(fromDate).toUTCString()
-  if (!toDate) toDate = nowUtc
-  else toDate = new Date(toDate).toUTCString()
-
-  if (isNaN(Date.parse(fromDate))) throw new ApiError('E01', 'fromDate')
-  if (isNaN(Date.parse(toDate))) throw new ApiError('E01', 'toDate')
-
-  return { fromDate, toDate }
-}
-
-// validates if bizplace belongs to company
-export async function validateBizplaceOfCompany(companyId, bizplaceId) {
-  if (!isValidUUID(bizplaceId)) throw new ApiError('E01', 'bizplaceId')
-  const bizplace: Bizplace = await getRepository(Bizplace).findOne({
-    where: { id: bizplaceId }
-  })
-  if (!bizplace) throw new ApiError('E01', 'bizplaceId')
-}
-
-// Regular expression to check if string is a valid UUID
-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,361 +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.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)
-  }
-}