@things-factory/operato-hub 4.3.108 → 4.3.110

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

@@ -1,234 +0,0 @@
-import { getConnection, EntityManager, IsNull, SelectQueryBuilder } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-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 { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.post(
-  '/v1/company/add-marketplace-order',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      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: marketplaceOrder.storeId, domain }
-        })
-        if (!marketplaceStore) throw new ApiError('E04', 'storeId')
-
-        let invalidQty = marketplaceOrder.marketplaceOrderItems.find(itm => itm.qty <= 0)
-        if (invalidQty) {
-          throw new ApiError('E01', 'qty')
-        }
-
-        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-products.ts

@@ -1,96 +0,0 @@
-import { getRepository, In, getConnection, EntityManager } 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 {
-      await getConnection().transaction(async (tx: EntityManager) => {
-        if (!Array.isArray(context.request.body.data)) throw new ApiError('E01', 'data field is not an array')
-
-        const products = context.request.body.data
-        const skus = products.map(p => p.sku)
-        const { user, domain } = context.state
-
-        // find bizplace
-        const bizplace = await getRepository(Bizplace).findOne({
-          where: {
-            domain
-          }
-        })
-
-        //check duplicate sku from request
-        let duplicateSku = skus.filter((item, index) => skus.indexOf(item) != index)
-
-        if (duplicateSku?.length > 0) {
-          throw new ApiError('E05', `duplicated products found: ${[...new Set(duplicateSku)]}`)
-        }
-
-        //check if sku existed in db
-        let existedProducts: Product = await getRepository(Product).find({
-          where: {
-            sku: In(skus),
-            bizplace
-          }
-        })
-
-        if (existedProducts?.length > 0) {
-          throw new ApiError('E05', `existing products found: ${existedProducts.map(ep => ep.sku)}`)
-        }
-
-        // 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 tx.getRepository(Product).save(products)
-
-            const newProduct = result[0]
-
-            // save product details
-            await Promise.all(
-              productDetails.map(async pd => {
-                if (pd.packingSize < 0) throw new ApiError('E01', `${pd.gtin}: packing size cannot be negative`)
-                const productDetails = pd
-                await tx.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

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

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

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

@@ -1,115 +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 _ 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)
-    }
-  }
-)