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

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

@@ -0,0 +1,242 @@
+import { getConnection, EntityManager, IsNull, SelectQueryBuilder } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+
+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 { v4 as uuidv4 } from 'uuid'
+
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Product, ProductBundle, ProductBundleSetting } from '@things-factory/product-base'
+
+import {
+  MarketplaceOrder as MarketplaceOrderEntity,
+  MarketplaceOrderItem as MarketplaceOrderItemEntity,
+  MarketplaceOrderShipping as MarketplaceOrderShippingEntity,
+  MarketplaceOrderShippingItem as MarketplaceOrderShippingItemEntity,
+  MarketplaceProductVariation as MarketplaceProductVariationEntity,
+  NoGenerator
+} from '@things-factory/marketplace-base'
+import { loggingMiddleware } from '../middlewares/logging-middleware'
+
+router.post('/v1/company/add-marketplace-order', businessMiddleware, loggingMiddleware, async (context, next) => {
+  try {
+    validateReqParams(context.request.body, reqParams.addMplaceOrder)
+    validateFilter(context.request.body, expectedParams.addMplaceOrder)
+    validateReqParams(context.request.body.data, reqParams.addMplaceData)
+    validateFilter(context.request.body.data, expectedParams.addMplaceData)
+    for (const mplaceOrderItem of context.request.body.data.marketplaceOrderItems) {
+      validateReqParams(mplaceOrderItem, reqParams.addMplaceOrderDataMplaceOrderItems)
+      validateFilter(mplaceOrderItem, expectedParams.addMplaceDataMplaceOrderItems)
+      validateReqParams(mplaceOrderItem.marketplaceProductVariation, reqParams.addMplaceDataMplaceProductVar)
+      validateFilter(mplaceOrderItem.marketplaceProductVariation, expectedParams.addMplaceDataMplaceProductVar)
+      validateReqParams(mplaceOrderItem.marketplaceOrderShipping, reqParams.addMplaceDataMplaceOrderShipping)
+      validateFilter(mplaceOrderItem.marketplaceOrderShipping, expectedParams.addMplaceDataMplaceOrderShipping)
+    }
+
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const { user, domain } = context.state
+      const marketplaceOrder = context.request.body.data
+
+      const marketplaceStore: MarketplaceStore = await tx.getRepository(MarketplaceStore).findOne({
+        where: { name: context.request.body.storeId, domain }
+      })
+      if (!marketplaceStore) throw new ApiError('E01', 'storeId')
+
+      let marketplaceOrderItems: MarketplaceOrderItemEntity[] = []
+
+      let newMarketplaceOrder: MarketplaceOrderEntity = Object.assign({}, marketplaceOrder)
+      const itemCount: number = marketplaceOrder.marketplaceOrderItems?.length
+
+      const currentDate = new Date()
+      newMarketplaceOrder.name = `MO-${currentDate.getFullYear()}${
+        currentDate.getMonth() + 1
+      }${currentDate.getDate()}${currentDate.getHours()}${currentDate.getMinutes()}${currentDate.getSeconds()}${currentDate.getMilliseconds()}`
+      newMarketplaceOrder.itemCount = itemCount
+      newMarketplaceOrder.marketplaceStore = marketplaceStore
+      newMarketplaceOrder.domain = domain
+      newMarketplaceOrder.creator = user
+      newMarketplaceOrder = await tx.getRepository(MarketplaceOrderEntity).save(newMarketplaceOrder)
+
+      let newMarketplaceOrderShipping: MarketplaceOrderShippingEntity
+      if (marketplaceOrder?.marketplaceOrderShipping) {
+        const marketplaceOrderShipping: any = marketplaceOrder.marketplaceOrderShipping
+        newMarketplaceOrderShipping = Object.assign({}, marketplaceOrderShipping)
+        newMarketplaceOrderShipping.name = marketplaceOrderShipping?.shippingId
+          ? marketplaceOrderShipping.shippingId
+          : NoGenerator.orderShipping()
+        newMarketplaceOrderShipping.transporter =
+          marketplaceOrderShipping?.transporter === '' ? null : marketplaceOrderShipping.transporter
+        newMarketplaceOrderShipping.ownTransporter =
+          marketplaceOrderShipping?.transporter === '' ? null : marketplaceOrderShipping.transporter
+        newMarketplaceOrderShipping.marketplaceStore = marketplaceStore
+        newMarketplaceOrderShipping.orderNoRef = newMarketplaceOrder.orderNo
+        newMarketplaceOrderShipping.subOrderNoRef = newMarketplaceOrder.orderNo
+        newMarketplaceOrderShipping.domain = domain
+        newMarketplaceOrderShipping.creator = user
+        newMarketplaceOrderShipping = await tx
+          .getRepository(MarketplaceOrderShippingEntity)
+          .save(newMarketplaceOrderShipping)
+      }
+
+      marketplaceOrderItems = await Promise.all(
+        marketplaceOrder?.marketplaceOrderItems.map(async orderItem => {
+          let marketplaceOrderItem: MarketplaceOrderItemEntity = Object.assign({}, orderItem)
+
+          const marketplaceProductVariation = orderItem.marketplaceProductVariation
+          const qb: SelectQueryBuilder<MarketplaceProductVariationEntity> = await tx
+            .getRepository(MarketplaceProductVariationEntity)
+            .createQueryBuilder('mpv')
+            .leftJoin('mpv.marketplaceProduct', 'mp')
+            .leftJoin('mp.marketplaceStore', 'ms')
+            .where('mpv.domain_id = :domainId')
+            .andWhere('mpv.variation_id = :variationId')
+            .andWhere('ms.id = :marketplaceStoreId')
+            .setParameters({
+              domainId: domain.id,
+              variationId: marketplaceProductVariation.variationId,
+              marketplaceStoreId: marketplaceStore.id
+            })
+
+          let foundVariation: MarketplaceProductVariationEntity = await qb.getOne()
+
+          if (!foundVariation) {
+            let newVariation: MarketplaceProductVariationEntity = Object.assign({}, marketplaceProductVariation)
+            newVariation.status = 'ACTIVE'
+            newVariation.domain = domain
+
+            await tx.getRepository(MarketplaceProductVariationEntity).save(newVariation)
+            foundVariation = newVariation
+          }
+
+          marketplaceOrderItem.marketplaceProductVariation = foundVariation
+          marketplaceOrderItem.name = orderItem.orderItemId
+          marketplaceOrderItem.marketplaceOrder = newMarketplaceOrder
+          marketplaceOrderItem.domain = domain
+          marketplaceOrderItem.creator = user
+
+          return marketplaceOrderItem
+        })
+      )
+
+      marketplaceOrderItems = await tx.getRepository(MarketplaceOrderItemEntity).save(marketplaceOrderItems)
+
+      await Promise.all(
+        marketplaceOrderItems.map(async marketplaceOrderItem => {
+          const marketplaceProductVariation = marketplaceOrderItem.marketplaceProductVariation
+
+          let product: Product = await tx.getRepository(Product).findOne({
+            where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku, deletedAt: IsNull() },
+            relations: ['productDetails']
+          })
+
+          let productBundle: ProductBundle
+          if (!product) {
+            productBundle = await tx.getRepository(ProductBundle).findOne({
+              where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku },
+              relations: ['productBundleSettings', 'productBundleSettings.product']
+            })
+          }
+
+          let existingMarketplaceOrderShippingItems: MarketplaceOrderShippingItemEntity[] = await tx
+            .getRepository(MarketplaceOrderShippingItemEntity)
+            .find({
+              where: { domain: marketplaceStore.domain, marketplaceOrderItem }
+            })
+
+          if (existingMarketplaceOrderShippingItems && existingMarketplaceOrderShippingItems?.length) {
+          } else {
+            if (productBundle) {
+              const productBundleSettings: ProductBundleSetting[] = productBundle.productBundleSettings
+              let marketplaceOrderShippingItems: MarketplaceOrderShippingItemEntity[] = []
+              productBundleSettings.map(productBundleSetting => {
+                let marketplaceOrderShippingItem: MarketplaceOrderShippingItemEntity =
+                  new MarketplaceOrderShippingItemEntity()
+                marketplaceOrderShippingItem.name = uuidv4()
+                marketplaceOrderShippingItem.qty = marketplaceOrderItem.qty * productBundleSetting.bundleQty
+                marketplaceOrderShippingItem.domain = marketplaceStore.domain
+                marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem
+                marketplaceOrderShippingItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+                marketplaceOrderShippingItem.product = productBundleSetting.product
+
+                marketplaceOrderShippingItems.push(marketplaceOrderShippingItem)
+              })
+
+              await tx.getRepository(MarketplaceOrderShippingItemEntity).save(marketplaceOrderShippingItems)
+            } else {
+              let marketplaceOrderShippingItem: MarketplaceOrderShippingItemEntity =
+                new MarketplaceOrderShippingItemEntity()
+              marketplaceOrderShippingItem.name = uuidv4()
+              marketplaceOrderShippingItem.qty = marketplaceOrderItem.qty
+              marketplaceOrderShippingItem.domain = marketplaceStore.domain
+              marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem
+              marketplaceOrderShippingItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+              marketplaceOrderShippingItem.product = product ? product : null
+
+              await tx.getRepository(MarketplaceOrderShippingItemEntity).save(marketplaceOrderShippingItem)
+            }
+          }
+        })
+      )
+
+      let marketplaceOrderItemsData = []
+      for (const item of marketplaceOrderItems) {
+        const datapoint = {
+          marketplaceOrderVariation: {
+            variationId: item.marketplaceProductVariation.variationId,
+            sku: item.marketplaceProductVariation.sku,
+            variationSku: item.marketplaceProductVariation.variationSku,
+            variationName: item.marketplaceProductVariation.variationName
+          },
+          marketplaceOrderShipping: {
+            attentionTo: item.marketplaceOrderShipping.attentionTo,
+            address1: item.marketplaceOrderShipping.address1,
+            address2: item.marketplaceOrderShipping.address2,
+            address3: item.marketplaceOrderShipping.address3,
+            address4: item.marketplaceOrderShipping.address4,
+            address5: item.marketplaceOrderShipping.address5,
+            state: item.marketplaceOrderShipping.state,
+            city: item.marketplaceOrderShipping.city,
+            postCode: item.marketplaceOrderShipping.postCode,
+            country: item.marketplaceOrderShipping.country,
+            phone1: item.marketplaceOrderShipping.phone1,
+            phone2: item.marketplaceOrderShipping.phone2,
+            email: item.marketplaceOrderShipping.email,
+            freightType: item.marketplaceOrderShipping.freightType,
+            parcelType: item.marketplaceOrderShipping.parcelType,
+            deliveryMethod: item.marketplaceOrderShipping.deliveryMethod,
+            totalWeight: item.marketplaceOrderShipping.totalWeight,
+            totalVolume: item.marketplaceOrderShipping.totalVolume,
+            transporter: item.marketplaceOrderShipping.transporter
+          }
+        }
+        marketplaceOrderItemsData.push(datapoint)
+      }
+      const data = {
+        orderNo: newMarketplaceOrder.orderNo,
+        itemCount,
+        paymentMethod: newMarketplaceOrder.paymentMethod,
+        remark: newMarketplaceOrder.remark,
+        giftOption: newMarketplaceOrder.giftOption,
+        orderCreatedAt: newMarketplaceOrder.orderCreatedAt,
+        orderUpdatedAt: newMarketplaceOrder.orderUpdatedAt,
+        marketplaceOrderItems: marketplaceOrderItemsData,
+        orderItemId: newMarketplaceOrder.orderItemId,
+        qty: newMarketplaceOrder.qty,
+        cancelBy: newMarketplaceOrder.cancelBy,
+        returnStatus: newMarketplaceOrder.returnStatus,
+        packageId: newMarketplaceOrder.packageId,
+        status: newMarketplaceOrder.status
+      }
+
+      context.body = {
+        data
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})

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

@@ -0,0 +1,78 @@
+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 { 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 _ from 'lodash'
+import { loggingMiddleware } from '../middlewares/logging-middleware'
+
+router.post('/v1/company/add-products', businessMiddleware, loggingMiddleware, async (context, next) => {
+  try {
+    if (!_.has(context.request.body, 'data')) throw new ApiError('E03', 'data')
+    if (!Array.isArray(context.request.body.data)) throw new ApiError('E01', 'data field is not an array')
+    for (const datapoint of context.request.data) {
+      validateReqParams(datapoint, reqParams.addProductsData)
+      validateFilter(datapoint, expectedParams.addProductsData)
+      validateReqParams(datapoint.productDetails, reqParams.addProductsDataProductDetails)
+      validateFilter(datapoint.productDetails, expectedParams.addProductsDataProductDetails)
+    }
+
+    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,102 @@
+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 { 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 { User } from '@things-factory/auth-base'
+import { Bizplace, getCustomerBizplaces } from '@things-factory/biz-base'
+import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
+import { loggingMiddleware } from '../middlewares/logging-middleware'
+
+router.post('/v1/company/cancel-marketplace-order', 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)
+
+    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('E01', 'storeId does not exist')
+
+      let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { domain, orderNo, marketplaceStore },
+        relations: ['fulfillmentCenter', 'marketplaceStore', 'marketplaceOrderItems']
+      })
+      if (!marketplaceOrder) throw new ApiError('E01', 'orderNo is invalid')
+
+      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,56 @@
+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

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

@@ -0,0 +1,118 @@
+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)
+    }
+  }
+)