@things-factory/operato-hub 4.3.122 → 4.3.123

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

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

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

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

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

@@ -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.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,51 @@
+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
+
+
+        marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShippingEntity).save({
+          ...marketplaceOrderShipping,
+          ...data,
+          updater: user
+        })
+
+        context.body = {
+          orderNoRef: marketplaceOrderShipping.orderNoRef,
+          transporter: marketplaceOrderShipping.transporter,
+          airwayBill: marketplaceOrderShipping.airwayBill,
+          trackingNo: marketplaceOrderShipping.trackingNo,
+          ownTrackingNo: marketplaceOrderShipping.ownTrackingNo
+        }
+      } 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,72 @@
+import { getRepository } from 'typeorm'
+
+import { Application } from '@things-factory/auth-base'
+import { Bizplace, Company } 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
+      }
+      else if ((domain.extType === 'company')) {
+        let company = await getRepository(Company).findOne({ where: { domain }, relations: ['domain'] })
+        context.state.business = 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

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