@things-factory/operato-hub 4.3.81 → 4.3.82

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

@@ -0,0 +1,66 @@
+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.business.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

@@ -0,0 +1,55 @@
+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/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.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

@@ -0,0 +1,70 @@
+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'
+
+export async function validationMiddleware(context, next) {
+  let path = context.req._parsedUrl.pathname
+  let endpoint = path.substring(path.lastIndexOf('/') + 1)
+  let q = context?.request?.query
+
+  // 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 = 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)
+  if (required) {
+    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())
+    }
+  }
+}
+
+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 + '.') }
+  }, {})
+}

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
+    }
+  }
+}