@things-factory/operato-hub 4.3.79 → 4.3.80-alpha.2

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

@@ -0,0 +1,68 @@
+import { getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Bizplace } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import _ from 'lodash'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.post('/v1/company/add-products', businessMiddleware, validationMiddleware, loggingMiddleware, async (context, next) => {
+  try {
+    if (!Array.isArray(context.request.body.data)) throw new ApiError('E01', 'data field is not an array')
+
+    const products = context.request.body.data
+    const { user, domain } = context.state
+
+    // find bizplace
+    const bizplace = await getRepository(Bizplace).findOne({
+      where: {
+        domain: context.state.domain
+      },
+      relations: ['domain']
+    })
+
+    // save product
+    await Promise.all(
+      products.map(async p => {
+        const product = p
+        const productDetails = p.productDetails
+
+        product.domain = domain
+        product.bizplace = bizplace
+        product.creator = user
+        product.updater = user
+        delete product.productDetails
+
+        const result = await getRepository(Product).save(products)
+
+        const newProduct = result[0]
+
+        // save product details
+        await Promise.all(
+          productDetails.map(async pd => {
+            const productDetails = pd
+            await getRepository(ProductDetail).save({
+              ...productDetails,
+              name: productDetails.gtin,
+              product: newProduct,
+              childProductDetail: null,
+              childQty: 0,
+              domain: domain,
+              creator: user,
+              updater: user
+            })
+          })
+        )
+      })
+    )
+
+    context.body = {
+      data: context.request.body
+    }
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})

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

@@ -0,0 +1,94 @@
+import { getConnection, EntityManager } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Domain } from '@things-factory/shell'
+import { MarketplaceOrder, MarketplaceOrderItem } from '@things-factory/marketplace-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getCustomerBizplaces } from '@things-factory/biz-base'
+import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.post('/v1/company/cancel-marketplace-order', businessMiddleware, validationMiddleware, loggingMiddleware, async (context, next) => {
+  try {
+    const { orderNo, remark, cancelBy } = context.request.body.data
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    await getConnection().transaction(async (tx: EntityManager) => {
+      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')
+
+      let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { domain, orderNo, marketplaceStore },
+        relations: ['fulfillmentCenter', 'marketplaceStore', 'marketplaceOrderItems']
+      })
+      if (!marketplaceOrder) throw new ApiError('E04', 'orderNo')
+
+      let marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems.map(orderItem => {
+        let marketplaceOrderItem: MarketplaceOrderItem = Object.assign({}, orderItem)
+        marketplaceOrderItem.reason = remark
+        marketplaceOrderItem.status = 'cancelled'
+        marketplaceOrderItem.updater = user
+        marketplaceOrderItem.cancelBy = cancelBy
+
+        return marketplaceOrderItem
+      })
+      await tx.getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
+
+      marketplaceOrder.status = 'cancelled'
+      marketplaceOrder.remark = remark
+      marketplaceOrder.updater = user
+      marketplaceOrder = await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
+
+      const cancelStatuses: string[] = ['cancelled', 'canceled']
+      if (cancelStatuses.includes(marketplaceOrder.status) && marketplaceOrder?.releaseOrderId) {
+        if (marketplaceOrder.isSplitted) {
+          const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+          const centerId: string = fulfillmentCenter.centerId
+          const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
+          const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+          const customerBizplaceId: string = customerBizplaces[0].id
+
+          const { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
+            customerBizplaceId,
+            refNo: marketplaceOrder.orderNo
+          })
+          if (releaseOrders?.length) {
+            for (var a = 0; a < releaseOrders.length; a++) {
+              const releaseOrderId: string = releaseOrders[a].id
+              await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
+            }
+          }
+        } else {
+          const releaseOrderId: string = marketplaceOrder.releaseOrderId
+          const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+          const centerId: string = fulfillmentCenter.centerId
+
+          const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
+          const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+          const customerBizplaceId: string = customerBizplaces[0].id
+          await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
+        }
+      }
+      const data = {
+        orderNo: marketplaceOrder.orderNo,
+        status: marketplaceOrder.status,
+        remark: marketplaceOrder.remark,
+        cancelBy: cancelBy || null,
+        createdAt: marketplaceOrder.createdAt,
+        updatedAt: marketplaceOrder.updatedAt
+      }
+
+      context.body = {
+        data
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})

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

@@ -0,0 +1,55 @@
+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 { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/company/get-bizplace-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      const { limit, offset } = context.query
+
+      // 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

@@ -0,0 +1,67 @@
+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 { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/company/get-contact-point-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      // get contact points for that bizplace
+      // 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 [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

@@ -0,0 +1,115 @@
+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 _ from 'lodash'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/company/get-marketplace-order-shipping-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      let filter = { ...context.query }
+      const { limit, offset, fromDate, toDate } = filter
+      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

@@ -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,96 @@
+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)
+        .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,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,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'