@things-factory/operato-hub 4.3.108 → 4.3.110

package/server/routers/api/restful-apis/v1/company/get-marketplace-store-list.ts

@@ -1,57 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { MarketplaceStore } from '@things-factory/integration-marketplace'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/company/get-marketplace-store-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      const { limit, offset } = context.query
-
-      // get marketplace stores for that domain
-      const domainId = context.state.domain.id
-      const [marketplaceStores, totalCount]: MarketplaceStore[] = await getRepository(MarketplaceStore).findAndCount({
-        where: { domain: domainId },
-        skip: offset,
-        take: limit,
-        order: { createdAt: 'DESC' }
-      })
-
-      // create and format data response
-      let data = []
-      for (const marketplaceStore of marketplaceStores) {
-        const datapoint = {
-          id: marketplaceStore.id,
-          name: marketplaceStore.name,
-          platform: marketplaceStore.platform,
-          eTrax: marketplaceStore.eTrax,
-          storeName: marketplaceStore.storeName,
-          storeUrl: marketplaceStore.storeUrl,
-          isAutoUpdateStockQty: marketplaceStore.isAutoUpdateStockQty,
-          isAutoUpdateShipment: marketplaceStore.isAutoUpdateShipment,
-          storeId: marketplaceStore.storeId,
-          countryCode: marketplaceStore.countryCode,
-          status: marketplaceStore.status
-        }
-        data.push(datapoint)
-      }
-
-      context.body = {
-        data,
-        totalCount,
-        limit,
-        offset
-      }
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)

package/server/routers/api/restful-apis/v1/company/get-partner-list.ts

@@ -1,95 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { Bizplace } from '@things-factory/biz-base'
-import { Partner } from '@things-factory/auth-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { validateLimitOffset } from '../utils/validate-util'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/company/get-partner-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      //validate bizplace belongs to company
-      const { limit, offset } = context.query
-      const companyId = context.state.business.id
-      const { bizplaceId } = context.query
-      const bizplace: Bizplace = await getRepository(Bizplace).findOne({
-        where: { company: companyId, id: bizplaceId },
-        relations: ['domain']
-      })
-      if (!bizplace) throw new ApiError('E01', 'bizplaceId')
-
-      const partners: Partner[] = await getRepository(Partner)
-        .createQueryBuilder('p')
-        .innerJoinAndSelect('bizplaces', 'bpp', 'bpp.domain_id = p.partner_domain_id')
-        .innerJoinAndSelect('bizplaces', 'bpo', 'bpo.domain_id = p.domain_id')
-        .innerJoinAndSelect('domains', 'dp', 'bpp.domain_id = dp.id')
-        .innerJoinAndSelect('domains', 'do', 'bpo.domain_id = do.id')
-        .where('p.partner_domain_id = :domainId', { domainId: bizplace.domain.id })
-        .orWhere('p.domain_id = :domainId', { domainId: bizplace.domain.id })
-        .limit(limit)
-        .offset(offset)
-        .getRawMany()
-
-      const count = await getRepository(Partner)
-        .createQueryBuilder('p')
-        .select('COUNT(p.id)')
-        .innerJoin('bizplaces', 'bpp', 'bpp.domain_id = p.partner_domain_id')
-        .innerJoin('bizplaces', 'bpo', 'bpo.domain_id = p.domain_id')
-        .innerJoin('domains', 'dp', 'bpp.domain_id = dp.id')
-        .innerJoin('domains', 'do', 'bpo.domain_id = do.id')
-        .where('p.partner_domain_id = :domainId', { domainId: bizplace.domain.id })
-        .orWhere('p.domain_id = :domainId', { domainId: bizplace.domain.id })
-        .getRawOne()
-
-      const totalCount = parseInt(count.count)
-
-      let data = []
-      for (const partner of partners) {
-        let datapoint = {}
-        if (partner.bpo_id === bizplaceId) {
-          datapoint = {
-            bizplace: {
-              id: partner.bpp_id,
-              name: partner.bpp_name,
-              description: partner.bpp_description,
-              address: partner.bpp_address,
-              postalCode: partner.bpp_postal_code
-            },
-            partnershipOwner: false,
-            extType: partner.dp_ext_type
-          }
-        } else {
-          datapoint = {
-            bizplace: {
-              id: partner.bpo_id,
-              name: partner.bpo_name,
-              description: partner.bpo_description,
-              address: partner.bpo_address,
-              postalCode: partner.bpo_postal_code
-            },
-            partnershipOwner: true,
-            extType: partner.do_ext_type
-          }
-        }
-        data.push(datapoint)
-      }
-
-      context.body = {
-        data,
-        totalCount,
-        limit,
-        offset
-      }
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)

package/server/routers/api/restful-apis/v1/company/get-product-list.ts

@@ -1,103 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { Product } from '@things-factory/product-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/company/get-product-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      // get productDetails for that bizplace/domain
-      // optional query parameter filter
-      let filter = { ...context.query }
-      const { limit, offset } = filter
-      // map query field to database column
-      filter['bizplace'] = filter['bizplaceId']
-      delete filter['bizplaceId']
-      delete filter['limit']
-      delete filter['offset']
-      const [products, totalCount]: Product[] = await getRepository(Product).findAndCount({
-        where: filter,
-        relations: ['productDetails'],
-        skip: offset,
-        take: limit,
-        order: { createdAt: 'DESC' }
-      })
-
-      // create and format data response
-      let data = []
-      for (const product of products) {
-        let productDetails = []
-        for (const productDetail of product.productDetails) {
-          const productDetailDataPoint = {
-            isDefault: productDetail.isDefault,
-            gtin: productDetail.gtin,
-            refCode: productDetail.refCode,
-            packingType: productDetail.packingType,
-            packingSize: productDetail.packingSize,
-            uom: productDetail.uom,
-            uomValue: productDetail.uomValue,
-            costPrice: productDetail.costPrice,
-            minQty: productDetail.minQty,
-            maxQty: productDetail.maxQty,
-            bufferQty: productDetail.bufferQty,
-            movement: productDetail.movement,
-            weightUnit: productDetail.weightUnit,
-            nettWeight: productDetail.nettWeight,
-            grossWeight: productDetail.grossWeight,
-            lengthUnit: productDetail.lengthUnit,
-            width: productDetail.width,
-            depth: productDetail.depth,
-            height: productDetail.height,
-            volume: productDetail.volume,
-            auxUnit1: productDetail.auxUnit1,
-            auxValue1: productDetail.auxValue1,
-            auxUnit2: productDetail.auxUnit2,
-            auxValue2: productDetail.auxValue2,
-            auxUnit3: productDetail.auxUnit3,
-            auxValue3: productDetail.auxValue3,
-            auxUnit4: productDetail.auxUnit4,
-            auxValue4: productDetail.auxValue4,
-            auxUnit5: productDetail.auxUnit5,
-            auxValue5: productDetail.auxValue5,
-            childProductDetail: productDetail.childProductDetail
-          }
-          productDetails.push(productDetailDataPoint)
-        }
-        const datapoint = {
-          sku: product.sku,
-          brandSku: product.brandSku,
-          name: product.name,
-          description: product.description,
-          type: product.type,
-          brand: product.brand,
-          subBrand: product.subBrand,
-          isRequiredCheckExpiry: product.isRequiredCheckExpiry,
-          isRequireSerialNumberScanning: product.isRequireSerialNumberScanning,
-          isRequireSerialNumberScanningInbound: product.isRequireSerialNumberScanningInbound,
-          isRequireSerialNumberScanningOutbound: product.isRequireSerialNumberScanningOutbound,
-          pickingStrategy: product.pickingStrategy,
-          expirationPeriod: product.expirationPeriod,
-          productDetails
-        }
-        data.push(datapoint)
-      }
-
-      context.body = {
-        data,
-        totalCount,
-        limit,
-        offset
-      }
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)

package/server/routers/api/restful-apis/v1/company/index.ts

@@ -1,12 +0,0 @@
-import './add-contact-points'
-import './add-marketplace-order'
-import './add-products'
-import './cancel-marketplace-order'
-import './get-bizplace-list'
-import './get-contact-point-list'
-import './get-marketplace-order-shipping-list'
-import './get-marketplace-store-list'
-import './get-partner-list'
-import './get-product-list'
-import './update-marketplace-order-delivered'
-import './update-marketplace-shipping-order'

package/server/routers/api/restful-apis/v1/company/update-marketplace-order-delivered.ts

@@ -1,66 +0,0 @@
-import { getConnection, EntityManager } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { MarketplaceOrder } from '@things-factory/marketplace-base'
-import { MarketplaceStore } from '@things-factory/integration-marketplace'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.post(
-  '/v1/company/update-marketplace-order-delivered',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      await getConnection().transaction(async (tx: EntityManager) => {
-        // check if name exists under the domain of the requester
-        const marketplaceStore: MarketplaceStore = await tx.getRepository(MarketplaceStore).findOne({
-          where: { name: context.request.body.data.storeId, domain: context.state.domain }
-        })
-        if (!marketplaceStore) throw new ApiError('E04', 'storeId')
-
-        // update values to DB
-        // restricted to marketplaceStores in the domain of the requester
-        const datapoint = context.request.body.data
-        const result = await tx
-          .getRepository(MarketplaceOrder)
-          .createQueryBuilder()
-          .update(MarketplaceOrder)
-          .set({ status: 'delivered' })
-          .where({ orderNo: datapoint.orderNo, marketplaceStore })
-          .execute()
-        if (result.affected !== 1) throw new ApiError('E01', 'orderNo is invalid')
-
-        const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-          where: { orderNo: datapoint.orderNo, marketplaceStore },
-          relations: ['domain', 'marketplaceStore', 'updater']
-        })
-
-        // create and format response
-        const data = {
-          orderNo: marketplaceOrder.orderNo,
-          status: marketplaceOrder.status,
-          updatedAt: marketplaceOrder.updatedAt,
-          domain: {
-            name: marketplaceOrder.domain.name
-          },
-          marketplaceStore: {
-            name: marketplaceOrder.marketplaceStore.storeName
-          },
-          updater: {
-            name: marketplaceOrder?.updater?.name
-          }
-        }
-
-        context.body = {
-          data
-        }
-      })
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)

package/server/routers/api/restful-apis/v1/company/update-marketplace-shipping-order.ts

@@ -1,55 +0,0 @@
-import { getConnection, EntityManager } from 'typeorm'
-import { restfulApiRouter as router } from '@things-factory/api'
-import { MarketplaceOrderShipping as MarketplaceOrderShippingEntity } from '@things-factory/marketplace-base'
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { businessMiddleware, validationMiddleware, loggingMiddleware, storeMiddleware } from '../middlewares'
-import { User } from '@things-factory/auth-base'
-
-router.post(
-  '/v1/company/update-marketplace-shipping-order',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  storeMiddleware,
-  async (context, next) => {
-    await getConnection().transaction(async (tx: EntityManager) => {
-      try {
-        const { user }: { user: User } = context.state
-        const { marketplaceStore } = context.state
-        const data = context.request.body.data
-        let marketplaceOrderShipping: MarketplaceOrderShippingEntity = await tx
-          .getRepository(MarketplaceOrderShippingEntity)
-          .findOne({
-            where: { marketplaceStore, subOrderNoRef: data.orderNo },
-            relations: ['marketplaceStore']
-          })
-
-        if (!marketplaceOrderShipping) throw new ApiError('E04', 'Order Shipping')
-
-        marketplaceOrderShipping.ownTrackingNo = data.trackingNo
-
-        if (marketplaceOrderShipping.marketplaceStore.platform == 'lazada') {
-          if (data.trackingNo) {
-            data.trackingNo = marketplaceOrderShipping.trackingNo
-          }
-        }
-
-        marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShippingEntity).save({
-          ...marketplaceOrderShipping,
-          ...data,
-          updater: user
-        })
-
-        context.body = {
-          orderNoRef: marketplaceOrderShipping.orderNoRef,
-          transporter: marketplaceOrderShipping.transporter,
-          airwayBill: marketplaceOrderShipping.airwayBill,
-          trackingNo: marketplaceOrderShipping.trackingNo
-        }
-      } catch (e) {
-        if (e instanceof ApiError) ApiErrorHandler(context, e)
-        else throwInternalServerError(context, e)
-      }
-    })
-  }
-)

package/server/routers/api/restful-apis/v1/middlewares/business-middleware.ts

@@ -1,68 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { Application } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { MarketplaceStore } from '@things-factory/integration-marketplace'
-import { Domain, getDomainFromURL } from '@things-factory/shell'
-import { Partner } from '@things-factory/auth-base'
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { isValidUUID } from '../utils/validate-util'
-
-const debug = require('debug')('things-factory:operato-hub:business-middleware')
-
-export async function businessMiddleware(context, next) {
-  const { user } = context.state
-
-  debug('user', user?.email)
-
-  try {
-    if (user) {
-      const domain: Domain = await getDomainFromURL(context)
-      const application: Application = await getRepository(Application).findOne({ where: { id: user.reference } })
-
-      if (
-        context?.query?.bizplaceId ||
-        context?.request?.body?.bizplaceId ||
-        context?.request?.body?.data?.bizplaceId
-      ) {
-        let bizplaceId =
-          context?.query?.bizplaceId || context?.request?.body?.bizplaceId || context?.request?.body?.data?.bizplaceId
-        if (!isValidUUID(bizplaceId)) throw new ApiError('E01', 'bizplaceId')
-
-        const bizplace: Bizplace = await getRepository(Bizplace).findOne({
-          where: { id: bizplaceId },
-          relations: ['domain', 'company', 'company.domain']
-        })
-        if (!bizplace || (bizplace.company.domain.id !== domain.id && domain.extType == 'company')) {
-          throw new ApiError('E01', 'bizplace')
-        }
-        if (domain.extType == 'warehouse') {
-          const partner: Partner = await getRepository(Partner).findOne({
-            where: { partnerDomain: bizplace.domain, domain }
-          })
-          if (!partner) {
-            throw new ApiError('E01', 'bizplace')
-          }
-        }
-        context.state.business = bizplace.company
-      }
-      // storeId validation
-      else if (context?.query?.storeId || context?.request?.body?.storeId || context?.request?.body?.data?.storeId) {
-        let storeId =
-          context?.query?.storeId || context?.request?.body?.storeId || context?.request?.body?.data?.storeId
-        const store: MarketplaceStore = await getRepository(MarketplaceStore).findOne({
-          where: { name: storeId, domain }
-        })
-
-        if (!store) {
-          throw new ApiError('E01', 'storeId')
-        }
-      }
-      context.state.application = application
-    }
-    await next()
-  } catch (e) {
-    if (e instanceof ApiError) ApiErrorHandler(context, e)
-    else throwInternalServerError(context, e)
-  }
-}

package/server/routers/api/restful-apis/v1/middlewares/index.ts

@@ -1,26 +0,0 @@
-import { businessMiddleware } from './business-middleware'
-
-const debug = require('debug')('things-factory:operato-hub:index')
-
-export function initMiddlewares(app) {
-  /*
-   * post:graphql 에 대해서는 businessMiddleware를 적용한다.
-   * graphql app을 router에 적용하지 못하기 때문임.
-   */
-  app.use(async (context, next) => {
-    const { method, path } = context
-
-    if (method == 'POST' && path.startsWith('/graphql')) {
-      debug(method, path)
-      return await businessMiddleware(context, next)
-    }
-
-    await next()
-  })
-}
-
-export * from './business-middleware'
-export * from './logging-middleware'
-export * from './store-middleware'
-export * from './warehouse-middleware'
-export * from './validation-middleware'

package/server/routers/api/restful-apis/v1/middlewares/logging-middleware.ts

@@ -1,24 +0,0 @@
-import { createPayloadLog, PayloadType } from '@things-factory/integration-base'
-
-// inserts payload log after successful endpoint request
-export async function loggingMiddleware(context, next) {
-  // wait for endpoint logic to complete
-  await next()
-
-  // name of requester's domain
-  const name = context.state.domain.name
-
-  // endpoint that was queried
-  const endpoint = context.req._parsedUrl.pathname
-
-  // request body and query
-  const request = {
-    query: context.query,
-    requestBody: context.request.body
-  }
-
-  // response
-  const response = context.body
-
-  await createPayloadLog(name, endpoint, request, response, context, PayloadType.INGESTION)
-}

package/server/routers/api/restful-apis/v1/middlewares/store-middleware.ts

@@ -1,34 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { ApiError } from '../utils/error-util'
-
-import { MarketplaceStore as MarketplaceStoreEntity } from '@things-factory/integration-marketplace'
-
-const debug = require('debug')('things-factory:operato-hub:store-middleware')
-
-export async function storeMiddleware(context, next) {
-  const { storeId } = context.method == 'GET' ? context.query : context.request.body.data
-  const { business } = context.state
-
-  let marketplaceStore: MarketplaceStoreEntity
-
-  debug('company and store', business, storeId)
-
-  if (!business) throw new ApiError('E04', 'Company')
-
-  if (storeId) {
-    marketplaceStore = await getRepository(MarketplaceStoreEntity).findOne({
-      where: { domain: business.domain, name: storeId, status: 'ACTIVE' },
-      relations: ['domain']
-    })
-    debug('marketplace-store', storeId, marketplaceStore?.domain?.subdomain)
-
-    if (!marketplaceStore) throw new ApiError('E04', 'Operato Marketplace Store')
-  } else {
-    throw new ApiError('E04', 'storeId')
-  }
-
-  context.state.marketplaceStore = marketplaceStore
-
-  await next()
-}

package/server/routers/api/restful-apis/v1/middlewares/validation-middleware.ts

@@ -1,116 +0,0 @@
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-
-const debug = require('debug')('things-factory:operato-hub:validation-middleware')
-
-import { params, reqParams, requireLimitOffsetValidation, requireFromToDateValidation } from '../utils/params'
-import { validateFromToDate, validateLimitOffset } from '../utils/validate-util'
-
-let req
-
-export async function validationMiddleware(context, next) {
-  let path = context.req._parsedUrl.pathname
-  let endpoint = path.substring(path.lastIndexOf('/') + 1)
-  let q = context?.request?.query
-  req = reqParams[endpoint]
-
-  // validate data key
-  try {
-    if (context.method == 'POST' && !context?.request?.body?.data) {
-      throw new ApiError('E03', 'data')
-    }
-
-    validateExpected(endpoint, context)
-    validateRequired(endpoint, context)
-
-    if (requireLimitOffsetValidation.includes(endpoint)) {
-      let { limit, offset } = validateLimitOffset(q?.limit, q?.offset)
-      context.request.query.limit = limit
-      context.request.query.offset = offset
-    }
-    if (requireFromToDateValidation.includes(endpoint)) {
-      let { fromDate, toDate } = validateFromToDate(q?.fromDate, q?.toDate)
-      context.request.query.fromDate = fromDate
-      context.request.query.toDate = toDate
-    }
-
-    await next()
-  } catch (e) {
-    if (e instanceof ApiError) ApiErrorHandler(context, e)
-    else throwInternalServerError(context, e)
-  }
-}
-
-function validateExpected(endpoint, context) {
-  let data = context.method == 'POST' ? context.request.body.data : context.request.query
-  let expected = params[endpoint]
-  let result = context.method == 'POST' ? Object.keys(flatten(data)) : Object.keys(data)
-  for (let r of result) {
-    if (!expected.includes(r)) throw new ApiError('E02', r.toString())
-  }
-}
-
-function validateRequired(endpoint, context) {
-  let data
-  if (context.method == 'GET') {
-    data = context.request.query
-    let required = reqParams[endpoint]
-    let result = Object.keys(data)
-    if (required) {
-      for (let r of required) {
-        if (!result.includes(r)) throw new ApiError('E03', r.toString())
-      }
-      for (let r of result) {
-        if (data[r] == null || data[r] === "") throw new ApiError('E01', r.toString())
-      }
-    }
-  } else {
-    data = context.request.body.data
-    if (data instanceof Array) {
-      for (let d of data) {
-        validateReq(d)
-      }
-    } else {
-      validateReq(data)
-    }
-  }
-}
-
-function flatten(obj, path = '') {
-  if (!(obj instanceof Object)) return { [path.replace(/\.$/g, '')]: obj }
-
-  return Object.keys(obj).reduce((output, key) => {
-    return obj instanceof Array
-      ? { ...output, ...flatten(obj[key], path) }
-      : { ...output, ...flatten(obj[key], path + key + '.') }
-  }, {})
-}
-
-function validateReq(obj, path = []) {
-  let keys = Object.keys(obj)
-  let reqTemp = req
-  let pathTemp = path.slice()
-  while (pathTemp.length > 0) {
-    reqTemp = reqTemp.find(e => e.name == pathTemp[0]).data
-    pathTemp.shift()
-  }
-  for (let rule of reqTemp) {
-    if (rule.type == 'field') {
-      if (rule.required && !keys.includes(rule.name)) {
-        throw new ApiError('E03', rule.name)
-      }
-    } else {
-      if (!obj.hasOwnProperty(rule.name) && rule.required) {
-        throw new ApiError('E03', rule.name)
-      }
-      if (obj[rule.name]) {
-        let arr = rule.type == 'array' ? obj[rule.name] : [obj[rule.name]]
-        for (let arrObj of arr) {
-          validateReq(arrObj, [...path, rule.name])
-        }
-      }
-    }
-    if (rule.required && (obj[rule.name] == null || obj[rule.name] == undefined || obj[rule.name] === "")) {
-      throw new ApiError('E01', `${rule.name}: null`)
-    }
-  }
-}