@things-factory/operato-hub 4.3.76 → 4.3.79-alpha.0

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

@@ -0,0 +1,58 @@
+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 { validateLimitOffset } from '../utils/validate-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 } = validateLimitOffset(context.query.limit, context.query.offset)
+
+      // 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

@@ -0,0 +1,97 @@
+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 {
+      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
+
+      //validate bizplace belongs to company
+      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)
+        .orderBy('p.created_at', 'DESC')
+        .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

@@ -0,0 +1,105 @@
+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 { validateLimitOffset } from '../utils/validate-util'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/company/get-product-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
+
+      // get productDetails for that bizplace/domain
+      // optional query parameter filter
+      let filter = { ...context.query }
+      // 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

@@ -0,0 +1,11 @@
+import './add-contact-points'
+import './add-marketplace-order'
+import './add-product'
+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'

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

@@ -0,0 +1,70 @@
+import { getRepository } 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 { businessMiddleware } from '../middlewares/business-middleware'
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { expectedParams, reqParams } from '../utils/expected-parameters'
+import { validateFilter, validateReqParams } from '../utils/validate-util'
+import { loggingMiddleware } from '../middlewares/logging-middleware'
+
+router.post(
+  '/v1/company/update-marketplace-order-delivered',
+  businessMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      validateReqParams(context.request.body, reqParams.requireDataKey)
+      validateFilter(context.request.body, expectedParams.requireDataKey)
+      validateReqParams(context.request.body.data, reqParams.cancelMarketplaceOrder)
+      validateFilter(context.request.body.data, expectedParams.cancelMarketplaceOrder)
+
+      // check if name exists under the domain of the requester
+      const marketplaceStore: MarketplaceStore = await getRepository(MarketplaceStore).findOne({
+        where: { name: context.request.body.data.storeId, domain: context.state.business.domain }
+      })
+      if (!marketplaceStore) throw new ApiError('E01', 'storeId does not exist')
+
+      // update values to DB
+      // restricted to marketplaceStores in the domain of the requester
+      const datapoint = context.request.body.data
+      const result = await 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 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/index.ts

@@ -1,31 +1,2 @@
-import './add-contact-point'
-import './add-inbound-order'
-import './add-marketplace-order'
-import './add-products'
-import './add-draft-release-order'
-import './add-release-order'
-import './bizplace'
-import './reject-inbound-order'
-import './get-contact-point-list'
-import './get-delivery-order-detail'
-import './get-delivery-order-list'
-import './get-inbound-order-detail'
-import './get-inbound-order-list'
-import './get-inventory-product-group'
-import './get-inventory-overall-product-group'
-import './get-onhand-inventories'
-import './get-products'
-import './get-release-order-detail'
-import './get-marketplace-store-list'
-import './get-marketplace-order-shipping-list'
-import './get-release-order-list'
-import './get-warehouses'
-import './cancel-marketplace-order'
-import './cancel-release-order'
-import './set-marketplace-order-delivered'
-import './set-marketplace-order-failed-delivery'
-import './update-marketplace-shipping-order'
-import './update-marketplace-order'
-import './update-release-order-details'
-import './get-goods-received-notes'
-import './get-delivery-orders'
+import './company'
+import './warehouse'

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

@@ -0,0 +1,31 @@
+import { getRepository } from 'typeorm'
+
+import { Bizplace, Company } from '@things-factory/biz-base'
+import { Domain, getDomainFromURL } from '@things-factory/shell'
+
+const debug = require('debug')('things-factory:operato-hub:business-middleware')
+
+export async function businessMiddleware(context, next) {
+  const { user } = context.state
+
+  debug('user', user?.email)
+
+  if (user) {
+    const domain: Domain = await getDomainFromURL(context)
+
+    let company: Company
+    if (domain.extType === 'company') {
+      company = await getRepository(Company).findOne({ where: { domain }, relations: ['domain'] })
+    } else {
+      const bizplace: Bizplace = await getRepository(Bizplace).findOne({
+        where: { domain },
+        relations: ['company', 'domain']
+      })
+      company = bizplace.company
+    }
+
+    context.state.business = company
+  }
+
+  await next()
+}

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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,34 @@
+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.query
+  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

@@ -0,0 +1,50 @@
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+
+const debug = require('debug')('things-factory:operato-hub:validation-middleware')
+
+import { params, reqParams } from '../utils/params'
+
+export async function validationMiddleware(context, next) {
+  let path = context.req._parsedUrl.pathname
+  let endpoint = path.substring(path.lastIndexOf('/') + 1)
+
+  // validate data key
+  try {
+    validateExpected(endpoint, context)
+    validateRequired(endpoint, context)
+    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 = context.method == 'POST' ? context.request.body.data : context.request.query
+  let required = reqParams[endpoint]
+  let result = context.method == 'POST' ? Object.keys(flatten(data)) : Object.keys(data)
+  for (let r of required) {
+    let v = r.split('.').slice(0, -1).join('.')
+    if (!required.includes(v) && !result.includes(v)) continue
+    if (!result.includes(r)) throw new ApiError('E03', r.toString())
+  }
+}
+
+const 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 + '.') }
+  }, {})
+}

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

@@ -0,0 +1,31 @@
+import { getRepository } from 'typeorm'
+import { Bizplace } from '@things-factory/biz-base'
+import { ApiError } from '../utils/error-util'
+
+const debug = require('debug')('things-factory:operato-hub:warehouse-middleware')
+
+export async function warehouseMiddleware(context, next) {
+  const { warehouseId } = context.query
+  const { business } = context.state
+
+  let warehouse: Bizplace
+
+  debug('company and warehouse', business, warehouseId)
+
+  if (!business) throw new ApiError('E04', 'Company')
+
+  if (warehouseId) {
+    warehouse = await getRepository(Bizplace).findOne(warehouseId, {
+      relations: ['company', 'domain']
+    })
+    debug('warehouse', warehouseId, warehouse?.domain?.subdomain)
+
+    if (!warehouse) throw new ApiError('E04', 'Warehouse')
+  } else {
+    throw new ApiError('E04', 'Warehouse')
+  }
+
+  context.state.warehouse = warehouse
+
+  await next()
+}

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

@@ -0,0 +1,70 @@
+// custom error class used when throwing errors for API V1
+export class ApiError extends Error {
+  responseCode: string
+  status: number
+  message: string
+  details: string
+  constructor(responseCode: string, message: string, ...params) {
+    super(...params)
+    this.responseCode = responseCode
+    this.name = 'ApiError'
+    switch (responseCode) {
+      case 'E01':
+        this.status = 400
+        this.message = 'Invalid parameter values'
+        this.details = message
+        break
+      case 'E02':
+        this.status = 400
+        this.message = 'Unexpected parameters'
+        this.details = message
+        break
+      case 'E03':
+        this.status = 400
+        this.message = 'Missing parameters'
+        this.details = message
+        break
+      case 'E04':
+        this.status = 404
+        this.message = 'Resource not found'
+        this.details = message
+        break
+      case 'E05':
+        this.status = 409
+        this.message = 'Duplicate entry'
+        this.details = message
+        break
+      case 'E06':
+        this.status = 500
+        this.message = 'Internal server error'
+        this.details = message
+        break
+    }
+  }
+}
+
+// used in catch block to give an error response
+export function ApiErrorHandler(context, e) {
+  context.type = 'application/json'
+  context.status = e.status
+  context.body = {
+    error: {
+      responseCode: e.responseCode,
+      message: e.message,
+      details: e.details
+    }
+  }
+}
+
+// used in catch block for all errors that are not ApiError
+export function throwInternalServerError(context, e) {
+  context.type = 'application/json'
+  context.status = 500
+  context.body = {
+    error: {
+      responseCode: 'E06',
+      message: 'Internal Server Error',
+      details: e.message
+    }
+  }
+}