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

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

@@ -1,56 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { Bizplace } from '@things-factory/biz-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-bizplace-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
-
-      // get bizplaces for that company
-      const companyId = context.state.business.id
-      const [bizplaces, totalCount]: Bizplace[] = await getRepository(Bizplace).findAndCount({
-        where: { company: companyId },
-        relations: ['domain'],
-        skip: offset,
-        take: limit,
-        order: { createdAt: 'DESC' }
-      })
-
-      // create and format data response
-      let data = []
-      for (const bizplace of bizplaces) {
-        const datapoint = {
-          bizplace: {
-            id: bizplace.id,
-            name: bizplace.name,
-            description: bizplace.description,
-            address: bizplace.address,
-            postalCode: bizplace.postalCode
-          },
-          extType: bizplace.domain.extType
-        }
-        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-contact-point-list.ts

@@ -1,69 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { ContactPoint } from '@things-factory/biz-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-contact-point-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
-
-      // get contact points for that bizplace
-      // 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 [contactPoints, totalCount]: ContactPoint[] = await getRepository(ContactPoint).findAndCount({
-        where: filter,
-        relations: ['bizplace'],
-        skip: offset,
-        take: limit,
-        order: { createdAt: 'DESC' }
-      })
-
-      // create and format data response
-      let data = []
-      for (const contactPoint of contactPoints) {
-        const datapoint = {
-          bizplace: {
-            id: contactPoint.bizplace.id,
-            name: contactPoint.bizplace.name
-          },
-          name: contactPoint.name,
-          companyName: contactPoint.companyName,
-          email: contactPoint.email,
-          fax: contactPoint.fax,
-          phone: contactPoint.phone,
-          accountNo: contactPoint.accountNo,
-          address: contactPoint.address,
-          address2: contactPoint.address2,
-          city: contactPoint.city,
-          postCode: contactPoint.postCode,
-          type: contactPoint.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-marketplace-order-shipping-list.ts

@@ -1,118 +0,0 @@
-import { getRepository, Between } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { MarketplaceOrderShipping } from '@things-factory/marketplace-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { validateFromToDate, validateLimitOffset } from '../utils/validate-util'
-import _ from 'lodash'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/company/get-marketplace-order-shipping-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
-      const { fromDate, toDate } = validateFromToDate(context.query.fromDate, context.query.toDate)
-
-      let filter = { ...context.query }
-      const domainId = context.state.domain.id
-      filter.marketplaceStore = {}
-      filter.marketplaceStore.name = filter.storeId
-      filter.domain = domainId
-
-      // map optional fields to db columns
-      if (_.has(filter, 'shippingNo')) {
-        filter['name'] = filter['shippingNo']
-        delete filter['shippingNo']
-      }
-      if (_.has(filter, 'orderNo')) {
-        filter['orderNoRef'] = filter['orderNo']
-        delete filter['orderNo']
-      }
-
-      filter['createdAt'] = Between(fromDate, toDate)
-
-      delete filter['storeId']
-      delete filter['fromDate']
-      delete filter['toDate']
-      delete filter['limit']
-      delete filter['offset']
-      // get marketplace order shippings for that domain
-      const [marketplaceOrderShippings, totalCount]: MarketplaceOrderShipping[] = await getRepository(
-        MarketplaceOrderShipping
-      ).findAndCount({
-        where: filter,
-        relations: [
-          'marketplaceStore',
-          'marketplaceOrderShippingItems',
-          'marketplaceOrderShippingItems.marketplaceOrderItem',
-          'marketplaceOrderShippingItems.marketplaceOrderItem.marketplaceProductVariation'
-        ],
-        skip: offset,
-        take: limit,
-        order: { createdAt: 'DESC' }
-      })
-
-      // create and format data response
-      let data = []
-      for (const marketplaceOrderShipping of marketplaceOrderShippings) {
-        const datapoint = {
-          attentionTo: marketplaceOrderShipping.attentionTo,
-          address1: marketplaceOrderShipping.address1,
-          address2: marketplaceOrderShipping.address2,
-          address3: marketplaceOrderShipping.address3,
-          address4: marketplaceOrderShipping.address4,
-          address5: marketplaceOrderShipping.address5,
-          state: marketplaceOrderShipping.state,
-          city: marketplaceOrderShipping.city,
-          postCode: marketplaceOrderShipping.postCode,
-          country: marketplaceOrderShipping.country,
-          phone1: marketplaceOrderShipping.phone1,
-          phone2: marketplaceOrderShipping.phone2,
-          email: marketplaceOrderShipping.email,
-          freightType: marketplaceOrderShipping.freightType,
-          parcelType: marketplaceOrderShipping.parcelType,
-          deliveryMethod: marketplaceOrderShipping.deliveryMethod,
-          totalWeight: marketplaceOrderShipping.totalWeight,
-          totalVolume: marketplaceOrderShipping.totalVolume,
-          transporter: marketplaceOrderShipping.transporter,
-          marketplaceStore: {
-            name: marketplaceOrderShipping.marketplaceStore.name,
-            storeId: marketplaceOrderShipping.marketplaceStore.id
-          },
-          marketplaceOrderItems: marketplaceOrderShipping.marketplaceOrderShippingItems.map(mposi => {
-            return {
-              marketplaceProductVariation: {
-                variationId: mposi.marketplaceOrderItem.marketplaceProductVariation.variationId,
-                sku: mposi.marketplaceOrderItem.marketplaceProductVariation.sku,
-                variationSku: mposi.marketplaceOrderItem.marketplaceProductVariation.variationSku,
-                variationName: mposi.marketplaceOrderItem.marketplaceProductVariation.name
-              },
-              orderItemId: mposi.marketplaceOrderItem.id,
-              qty: mposi.marketplaceOrderItem.qty,
-              cancelBy: mposi.marketplaceOrderItem.cancelBy,
-              returnStatus: mposi.marketplaceOrderItem.returnStatus,
-              packageId: mposi.marketplaceOrderItem.packageId,
-              status: mposi.marketplaceOrderItem.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-marketplace-store-list.ts

@@ -1,58 +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 { 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

@@ -1,97 +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 {
-      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

@@ -1,105 +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 { 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

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

@@ -1,70 +0,0 @@
-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/middlewares/business-middleware.ts

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

@@ -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)
-}