@things-factory/operato-hub 4.3.108 → 4.3.109

package/server/routers/api/restful-apis/v1/warehouse/get-goods-received-note-list.ts

@@ -1,105 +0,0 @@
-import { Between, getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { GoodsReceivalNote } from '@things-factory/sales-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/warehouse/get-goods-received-note-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, fromDate, toDate } = filter
-      filter['bizplace'] = filter['bizplaceId']
-      delete filter['bizplaceId']
-      filter['createdAt'] = Between(fromDate, toDate)
-
-      delete filter['fromDate']
-      delete filter['toDate']
-      delete filter['limit']
-      delete filter['offset']
-      const [goodsReceivedNotes, totalCount]: GoodsReceivalNote[] = await getRepository(GoodsReceivalNote).findAndCount(
-        {
-          where: filter,
-          relations: [
-            'bizplace',
-            'domain',
-            'arrivalNotice',
-            'arrivalNotice.orderProducts',
-            'arrivalNotice.orderProducts.product'
-          ],
-          skip: offset,
-          take: limit,
-          order: { createdAt: 'DESC' }
-        }
-      )
-
-      // create and format data response
-      let data = []
-      for (const goodsReceivedNote of goodsReceivedNotes) {
-        let orderProducts = []
-        for (const orderProduct of goodsReceivedNote.arrivalNotice.orderProducts) {
-          const orderProductsDataPoint = {
-            product: {
-              sku: orderProduct.product.sku,
-              brandSku: orderProduct.product.brandSku,
-              name: orderProduct.product.name,
-              description: orderProduct.product.description
-            },
-            type: orderProduct.type,
-            batchId: orderProduct.batchId,
-            packingType: orderProduct.packingType,
-            packingSize: orderProduct.packingSize,
-            releaseQty: orderProduct.releaseQty,
-            releaseUomValue: orderProduct.releaseUomValue,
-            status: orderProduct.status
-          }
-          orderProducts.push(orderProductsDataPoint)
-        }
-        const datapoint = {
-          id: goodsReceivedNote.id,
-          grnNo: goodsReceivedNote.grnNo,
-          refNo: goodsReceivedNote.refNo,
-          customerStatus: goodsReceivedNote.customerStatus,
-          status: goodsReceivedNote.status,
-          bizplace: {
-            id: goodsReceivedNote.bizplace.id,
-            name: goodsReceivedNote.bizplace.name,
-            description: goodsReceivedNote.bizplace.description
-          },
-          domain: {
-            id: goodsReceivedNote.domain.id,
-            name: goodsReceivedNote.domain.name
-          },
-          arrivalNotice: {
-            id: goodsReceivedNote.arrivalNotice.id,
-            ganNo: goodsReceivedNote.arrivalNotice.ganNo,
-            status: goodsReceivedNote.arrivalNotice.status,
-            refNo: goodsReceivedNote.arrivalNotice.refNo,
-            refNo2: goodsReceivedNote.arrivalNotice.refNo2,
-            refNo3: goodsReceivedNote.arrivalNotice.refNo3,
-            orderProducts
-          }
-        }
-        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/warehouse/get-inbound-order-details.ts

@@ -1,83 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { ArrivalNotice } from '@things-factory/sales-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import _ from 'lodash'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/warehouse/get-inbound-order-details',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      // get contact points for that bizplace
-      // optional query parameter filter
-      let filter = { ...context.query }
-      filter['bizplace'] = filter['bizplaceId']
-      delete filter['bizplaceId']
-      if (_.has(filter, 'ganNo')) {
-        filter['name'] = filter['ganNo']
-        delete filter['ganNo']
-      }
-
-      const arrivalNotice: ArrivalNotice = await getRepository(ArrivalNotice).findOne({
-        where: filter,
-        relations: ['orderProducts', 'orderProducts.product']
-      })
-
-      if (!arrivalNotice) {
-        throw new ApiError('E04', 'arrival notice')
-      }
-      // create and format data response
-      let orderProducts = []
-      for (const orderProduct of arrivalNotice.orderProducts) {
-        const orderProductsDataPoint = {
-          product: {
-            sku: orderProduct.product.sku,
-            uom: orderProduct.product.uom,
-            uomValue: orderProduct.product.uomValue
-          },
-          batchId: orderProduct.batchId,
-          packingType: orderProduct.packingType,
-          packingSize: orderProduct.packingSize,
-          packQty: orderProduct.packQty,
-          palletQty: orderProduct.palletQty
-        }
-        orderProducts.push(orderProductsDataPoint)
-      }
-      const data = {
-        id: arrivalNotice.id,
-        ganNo: arrivalNotice.name,
-        refNo: arrivalNotice.refNo,
-        refNo2: arrivalNotice.refNo2,
-        refNo3: arrivalNotice.refNo3,
-        etaDate: arrivalNotice.etaDate,
-        ownTransport: arrivalNotice.ownTransport,
-        importCargo: arrivalNotice.importCargo,
-        container: arrivalNotice.container,
-        truckNo: arrivalNotice.truckNo,
-        deliveryOrderNo: arrivalNotice.deliveryOrderNo,
-        containerNo: arrivalNotice.containerNo,
-        containerSize: arrivalNotice.containerSize,
-        orderProducts,
-        supplier: {
-          name: arrivalNotice?.supplier?.name || null,
-          companyName: arrivalNotice?.supplier?.companyName || null,
-          email: arrivalNotice?.supplier?.email || null,
-          accountNo: arrivalNotice?.supplier?.accountNo || null
-        }
-      }
-
-      context.body = {
-        data
-      }
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)

package/server/routers/api/restful-apis/v1/warehouse/get-inbound-order-list.ts

@@ -1,96 +0,0 @@
-import { Between, getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { ArrivalNotice } from '@things-factory/sales-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import _ from 'lodash'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/warehouse/get-inbound-order-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      // get contact points for that bizplace
-      // optional query parameter filter
-      let filter = { ...context.query }
-      const { fromDate, toDate, offset, limit } = filter
-      filter['bizplace'] = filter['bizplaceId']
-      delete filter['bizplaceId']
-      if (_.has(filter, 'ganNo')) {
-        filter['name'] = filter['ganNo']
-        delete filter['ganNo']
-      }
-      filter['createdAt'] = Between(fromDate, toDate)
-
-      delete filter['fromDate']
-      delete filter['toDate']
-      delete filter['limit']
-      delete filter['offset']
-      const [arrivalNotices, totalCount]: ArrivalNotice[] = await getRepository(ArrivalNotice).findAndCount({
-        where: filter,
-        relations: ['orderProducts', 'orderProducts.product'],
-        skip: offset,
-        take: limit,
-        order: { createdAt: 'DESC' }
-      })
-
-      // create and format data response
-      let data = []
-      for (const arrivalNotice of arrivalNotices) {
-        let orderProducts = []
-        for (const orderProduct of arrivalNotice.orderProducts) {
-          const orderProductsDataPoint = {
-            product: {
-              sku: orderProduct.product.sku,
-              uom: orderProduct.product.uom,
-              uomValue: orderProduct.product.uomValue
-            },
-            batchId: orderProduct.batchId,
-            packingType: orderProduct.packingType,
-            packingSize: orderProduct.packingSize,
-            packQty: orderProduct.packQty,
-            palletQty: orderProduct.palletQty
-          }
-          orderProducts.push(orderProductsDataPoint)
-        }
-        const datapoint = {
-          id: arrivalNotice.id,
-          ganNo: arrivalNotice.ganNo,
-          refNo: arrivalNotice.refNo,
-          refNo2: arrivalNotice.refNo2,
-          refNo3: arrivalNotice.refNo3,
-          etaDate: arrivalNotice.etaDate,
-          ownTransport: arrivalNotice.ownTransport,
-          importCargo: arrivalNotice.importCargo,
-          container: arrivalNotice.container,
-          truckNo: arrivalNotice.truckNo,
-          deliveryOrderNo: arrivalNotice.deliveryOrderNo,
-          containerNo: arrivalNotice.containerNo,
-          containerSize: arrivalNotice.containerSize,
-          orderProducts,
-          supplier: {
-            name: arrivalNotice?.supplier?.name || null,
-            companyName: arrivalNotice?.supplier?.companyName || null,
-            email: arrivalNotice?.supplier?.email || null,
-            accountNo: arrivalNotice?.supplier?.accountNo || null
-          }
-        }
-        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/warehouse/get-inventory-product-group-list.ts

@@ -1,112 +0,0 @@
-import { EntityManager, getConnection } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
-import { Product, ProductBundle } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
-import { WarehouseBizplaceOnhandInventory } from '@things-factory/worksheet-base'
-
-import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-
-router.get(
-  '/v1/warehouse/get-inventory-product-group-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      // optional query parameter filter
-      let filter = { ...context.query }
-      const { limit, offset } = filter
-
-      delete filter['limit']
-      delete filter['offset']
-
-      await getConnection().transaction(async (tx: EntityManager) => {
-        let customerBizplaceId = filter.bizplaceId
-        const customerCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, customerBizplaceId, tx)
-
-        if (filter.hasOwnProperty('sku')) {
-          let product: Product = await tx.getRepository(Product).findOne({
-            where: { bizplace: customerCompanyBizplace, sku: filter['sku'] }
-          })
-
-          filter.productId = product?.id || null
-
-          if (!product) {
-            let productBundle: ProductBundle = await tx.getRepository(ProductBundle).findOne({
-              where: { bizplace: customerCompanyBizplace, sku: filter['sku'] }
-            })
-
-            filter.productBundleId = productBundle.id
-          }
-        }
-
-        const params: any = { filter, pagination: { page: offset, limit: limit } }
-
-        const { items, total } = await warehouseBizplaceOnhandInventory(customerBizplaceId, params, context, tx)
-
-        let data: any[] = items.map(item => {
-          return {
-            product: {
-              sku: item?.product?.sku || item?.productBundle?.sku,
-              name: item?.product?.name || item?.productBundle?.name,
-              description: item?.product?.description || item?.productBundle?.description,
-              type: item.groupType
-            },
-            batchId: item?.batchId,
-            packingType: item.packingType,
-            packingSize: item.packingSize,
-            qty: item.remainQty,
-            uomValue: item.remainUomValue,
-            uom: item.uom
-          }
-        })
-
-        context.body = {
-          data,
-          totalCount: total,
-          limit,
-          offset
-        }
-      })
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)
-
-async function warehouseBizplaceOnhandInventory(
-  customerBizplaceId: string,
-  params,
-  context: any,
-  trxMgr: EntityManager
-) {
-  let filter = params.filter
-  const { domain }: { domain: Domain } = context.state
-
-  let qb = trxMgr
-    .getRepository(WarehouseBizplaceOnhandInventory)
-    .createQueryBuilder('wboi')
-    .leftJoinAndMapOne('wboi.product', Product, 'prd', 'prd.id = wboi.product_id')
-    .leftJoinAndMapOne('wboi.productBundle', ProductBundle, 'pb', 'pb.id = wboi.product_bundle_id')
-    .where('wboi.bizplace_id=:bizplaceId', { bizplaceId: customerBizplaceId })
-    .andWhere('wboi.domain_id=:domainId', { domainId: domain.id })
-
-  if (filter?.productId) {
-    qb.andWhere('wboi.product_id=:productId', { productId: filter.productId })
-  }
-
-  if (filter?.productBundleId) {
-    qb.andWhere('wboi.product_bundle_id=:productBundleId', { productBundleId: filter.productBundleId })
-  }
-
-  qb.limit(params.pagination.limit).offset(params.pagination.page)
-
-  const items: any[] = await qb.getMany()
-  const { total } = await qb.select('COUNT(*)', 'total').getRawOne()
-
-  return { items, total: parseInt(total) }
-}

package/server/routers/api/restful-apis/v1/warehouse/get-onhand-inventory-list.ts

@@ -1,89 +0,0 @@
-import { Between, getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { Inventory } from '@things-factory/warehouse-base'
-
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import _ from 'lodash'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/warehouse/get-onhand-inventory-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      let filter = { ...context.query }
-      const { limit, offset, fromDate, toDate } = filter
-      filter['bizplace'] = filter['bizplaceId']
-      delete filter['bizplaceId']
-      if (_.has(filter, 'sku')) {
-        filter.product = { sku: filter['sku']}
-        delete filter['sku']
-      }
-      filter['createdAt'] = Between(fromDate, toDate)
-      filter['status'] = 'STORED'
-
-      delete filter['fromDate']
-      delete filter['toDate']
-      delete filter['limit']
-      delete filter['offset']
-
-      const [inventories, totalCount]: Inventory[] = await getRepository(Inventory).findAndCount({
-        where: filter,
-        relations: ['product', 'location'],
-        skip: offset,
-        take: limit,
-        order: { createdAt: 'DESC' }
-      })
-
-      let data = []
-      for (const inventory of inventories) {
-        const datapoint = {
-          id: inventory.id,
-          name: inventory.name,
-          palletId: inventory.palletId,
-          cartonId: inventory.cartonId,
-          batchId: inventory.batchId,
-          packingType: inventory.packingType,
-          packingSize: inventory.packingSize,
-          qty: inventory.qty,
-          expirationDate: inventory.expirationDate,
-          weight: inventory.product.weight ? `${inventory.product.weight * inventory.qty} ${inventory.product.weightUnit}` : null,
-          lastSeq: 0,
-          status: 'STORED',
-          product: {
-            sku: inventory.product.sku,
-            name: inventory.product.name,
-            description: inventory.product.description,
-            type: inventory.product.type,
-            weightUnit: inventory.product.weightUnit,
-            weight: inventory.product.weight,
-            lengthUnit: inventory.product.lengthUnit,
-            width: inventory.product.width,
-            depth: inventory.product.depth,
-            height: inventory.product.height
-          },
-          location: {
-            name: inventory.location.name,
-            type: inventory.location.type,
-            zone: inventory.location.zone
-          }
-        }
-        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/warehouse/get-release-order-details.ts

@@ -1,99 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { ReleaseGood } from '@things-factory/sales-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import _ from 'lodash'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/warehouse/get-release-order-details',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      // get contact points for that bizplace
-      // optional query parameter filter
-      let filter = { ...context.query }
-      filter['bizplace'] = filter['bizplaceId']
-      delete filter['bizplaceId']
-      if (_.has(filter, 'roNo')) {
-        filter['name'] = filter['roNo']
-        delete filter['roNo']
-      }
-
-      const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-        where: filter,
-        relations: ['orderInventories', 'orderInventories.product']
-      })
-
-      if (!releaseGood) throw new ApiError('E04', `release order: ${filter['name']}`)
-
-      // create and format data response
-      let orderInventories = []
-      for (const orderInventory of releaseGood.orderInventories) {
-        const orderInventoriesDataPoint = {
-          product: {
-            sku: orderInventory.product.sku,
-            refCode: orderInventory.product.refCode
-          },
-          batchId: orderInventory.batchId,
-          packingType: orderInventory.packingType,
-          releaseQty: orderInventory.releaseQty,
-          packingSize: orderInventory.packingSize
-        }
-        orderInventories.push(orderInventoriesDataPoint)
-      }
-      const data = {
-        id: releaseGood.id,
-        roNo: releaseGood.roNo,
-        refNo: releaseGood.refNo,
-        refNo2: releaseGood.refNo2,
-        refNo3: releaseGood.refNo3,
-        type: releaseGood.type,
-        releaseDate: releaseGood.releaseDate,
-        collectionOrderNo: releaseGood.collectionOrderNo,
-        ownTransport: releaseGood.ownTransport,
-        exportOption: releaseGood.exportOption,
-        transporter: releaseGood.transporter,
-        trackingNo: releaseGood.trackingNo,
-        marketplaceOrderStatus: releaseGood.marketplaceOrderStatus,
-        airwayBill: releaseGood.airwayBill,
-        invoice: releaseGood.invoice,
-        storeName: releaseGood.storeName,
-        storeId: releaseGood.storeId,
-        routeId: releaseGood.routeId,
-        stopId: releaseGood.stopId,
-        billTo: {
-          billingAddress: releaseGood.billingAddress
-        },
-        deliverTo: {
-          deliveryAddress1: releaseGood.deliveryAddress1,
-          deliveryAddress2: releaseGood.deliveryAddress2,
-          deliveryAddress3: releaseGood.deliveryAddress3,
-          deliveryAddress4: releaseGood.deliveryAddress4,
-          deliveryAddress5: releaseGood.deliveryAddress5,
-          attentionTo: releaseGood.attentionTo,
-          attentionCompany: releaseGood.attentionCompany,
-          city: releaseGood.city,
-          state: releaseGood.state,
-          postalCode: releaseGood.postalCode,
-          country: releaseGood.country,
-          phone1: releaseGood.phone1,
-          phone2: releaseGood.phone2,
-          email: releaseGood.email
-        },
-        orderInventories
-      }
-
-      context.body = {
-        data
-      }
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)

package/server/routers/api/restful-apis/v1/warehouse/get-release-order-list.ts

@@ -1,113 +0,0 @@
-import _ from 'lodash'
-import { Between, getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { ReleaseGood } from '@things-factory/sales-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/warehouse/get-release-order-list',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      // get contact points for that bizplace
-      // optional query parameter filter
-      let filter = { ...context.query }
-      const { fromDate, toDate, offset, limit } = filter
-      filter['bizplace'] = filter['bizplaceId']
-      delete filter['bizplaceId']
-      if (_.has(filter, 'roNo')) {
-        filter['name'] = filter['roNo']
-        delete filter['roNo']
-      }
-      filter['createdAt'] = Between(fromDate, toDate)
-
-      delete filter['fromDate']
-      delete filter['toDate']
-      delete filter['limit']
-      delete filter['offset']
-
-      const [releaseGoods, totalCount]: ReleaseGood[] = await getRepository(ReleaseGood).findAndCount({
-        where: filter,
-        relations: ['orderInventories', 'orderInventories.product'],
-        skip: offset,
-        take: limit,
-        order: { createdAt: 'DESC' }
-      })
-
-      // create and format data response
-      let data = []
-      for (const releaseGood of releaseGoods) {
-        let orderInventories = []
-        for (const orderInventory of releaseGood.orderInventories) {
-          const orderInventoriesDataPoint = {
-            product: {
-              sku: orderInventory.product.sku,
-              refCode: orderInventory.product.refCode
-            },
-            batchId: orderInventory.batchId,
-            packingType: orderInventory.packingType,
-            releaseQty: orderInventory.releaseQty,
-            packingSize: orderInventory.packingSize
-          }
-          orderInventories.push(orderInventoriesDataPoint)
-        }
-        const datapoint = {
-          id: releaseGood.id,
-          roNo: releaseGood.roNo,
-          refNo: releaseGood.refNo,
-          refNo2: releaseGood.refNo2,
-          refNo3: releaseGood.refNo3,
-          type: releaseGood.type,
-          releaseDate: releaseGood.releaseDate,
-          collectionOrderNo: releaseGood.collectionOrderNo,
-          ownTransport: releaseGood.ownTransport,
-          exportOption: releaseGood.exportOption,
-          transporter: releaseGood.transporter,
-          trackingNo: releaseGood.trackingNo,
-          marketplaceOrderStatus: releaseGood.marketplaceOrderStatus,
-          airwayBill: releaseGood.airwayBill,
-          invoice: releaseGood.invoice,
-          storeName: releaseGood.storeName,
-          storeId: releaseGood.storeId,
-          routeId: releaseGood.routeId,
-          stopId: releaseGood.stopId,
-          billTo: {
-            billingAddress: releaseGood.billingAddress
-          },
-          deliverTo: {
-            deliveryAddress1: releaseGood.deliveryAddress1,
-            deliveryAddress2: releaseGood.deliveryAddress2,
-            deliveryAddress3: releaseGood.deliveryAddress3,
-            deliveryAddress4: releaseGood.deliveryAddress4,
-            deliveryAddress5: releaseGood.deliveryAddress5,
-            attentionTo: releaseGood.attentionTo,
-            attentionCompany: releaseGood.attentionCompany,
-            city: releaseGood.city,
-            state: releaseGood.state,
-            postalCode: releaseGood.postalCode,
-            country: releaseGood.country,
-            phone1: releaseGood.phone1,
-            phone2: releaseGood.phone2,
-            email: releaseGood.email
-          },
-          orderInventories
-        }
-        data.push(datapoint)
-      }
-      context.body = {
-        data,
-        totalCount,
-        limit,
-        offset
-      }
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)