@things-factory/operato-hub 4.3.82 → 4.3.83

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

@@ -1,261 +0,0 @@
-import { EntityManager, getConnection } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { ArrivalNotice, ReleaseGood } from '@things-factory/sales-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import _ from 'lodash'
-
-// import for cancelling Inbound Order Purpose
-import { ORDER_STATUS } from '@things-factory/sales-base'
-import { User, ApplicationType } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import {
-  OrderProduct,
-  OrderVas,
-  CollectionOrder,
-  ORDER_PRODUCT_STATUS,
-  ORDER_VAS_STATUS,
-  ORDER_INVENTORY_STATUS,
-  ShippingOrder,
-  SellercraftController,
-  OrderInventory
-} from '@things-factory/sales-base'
-import { getDomainUsers } from '@things-factory/biz-base'
-import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
-import { Inventory } from '@things-factory/warehouse-base'
-
-import { loggingMiddleware, validationMiddleware, businessMiddleware } from '../middlewares'
-
-router.post(
-  '/v1/warehouse/cancel-inbound-order',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      await getConnection().transaction(async (tx: EntityManager) => {
-        let bodyReq = context.request.body.data
-        const validateArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-          where: { name: bodyReq.ganNo }
-        })
-        if (!validateArrivalNotice) throw new ApiError('E04', 'ganNo')
-
-        const arrivalNotice: ArrivalNotice = await rejectArrivalNotice(
-          tx,
-          validateArrivalNotice.name,
-          bodyReq.remark,
-          context
-        )
-
-        if (arrivalNotice.crossDocking) {
-          const { releaseGood }: ReleaseGood = await tx.getRepository(arrivalNotice).findOne(arrivalNotice.id, {
-            relations: ['releaseGood']
-          })
-
-          if (releaseGood.status !== ORDER_STATUS.REJECTED) {
-            await rejectReleaseGood(tx, context, releaseGood.name, bodyReq.remark)
-          }
-        }
-
-        context.body = {
-          data: {
-            ganNo: arrivalNotice.name
-          }
-        }
-      })
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)
-
-async function rejectArrivalNotice(
-  tx: EntityManager,
-  name: string,
-  remark: string,
-  context: any
-): Promise<ArrivalNotice> {
-  const { user, domain }: { user: User; domain: Domain } = context.state
-
-  const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { name, status: ORDER_STATUS.PENDING_RECEIVE }, // try remove domain
-    relations: ['bizplace', 'orderProducts', 'orderVass', 'collectionOrders']
-  })
-
-  if (!foundArrivalNotice) throw new ApiError('E04', 'arrival notice')
-  if (!remark) throw new ApiError('E03', 'remark')
-
-  let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-  let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-  let foundCOs: CollectionOrder[] = foundArrivalNotice.collectionOrders
-
-  // 1. Update status of order products (PENDING_RECEIVE => REJECTED)
-  foundOPs = foundOPs.map((op: OrderProduct) => {
-    op.status = ORDER_PRODUCT_STATUS.REJECTED
-    op.updater = user
-    return op
-  })
-  await tx.getRepository(OrderProduct).save(foundOPs)
-
-  // 2. Update status of order vass if it exists (PENDING_RECEIVE => REJECTED)
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((ov: OrderVas) => {
-      ov.status = ORDER_VAS_STATUS.REJECTED
-      ov.updater = user
-      return ov
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // 3. If there's collection order, update status of collection order (PENDING_RECEIVE => REJECTED)
-  if (foundCOs) {
-    foundCOs = foundCOs.map((co: CollectionOrder) => {
-      co.status = ORDER_STATUS.REJECTED
-      co.updater = user
-      return co
-    })
-    await tx.getRepository(CollectionOrder).save(foundCOs)
-  }
-
-  foundArrivalNotice.remark = remark
-  foundArrivalNotice.status = ORDER_STATUS.REJECTED
-  foundArrivalNotice.updater = user
-  await tx.getRepository(ArrivalNotice).save(foundArrivalNotice)
-
-  // notification logics
-  const users: any[] = await getDomainUsers(foundArrivalNotice?.bizplace, tx)
-
-  // send notification to Customer Users
-  if (users?.length && context.header?.referer) {
-    const receivers: any[] = users.map(user => user.id)
-    const msg = {
-      title: `Latest status for ${foundArrivalNotice.name}`,
-      body: `Your GAN has been rejected.`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    }
-  }
-  return foundArrivalNotice
-}
-
-async function rejectReleaseGood(tx: EntityManager, context: any, name: string, remark: string): Promise<ReleaseGood> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-
-  const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: [
-      'bizplace',
-      'bizplace.domain',
-      'orderProducts',
-      'orderProducts.product',
-      'orderProducts.product.productDetails',
-      'orderInventories',
-      'orderInventories.inventory',
-      'orderVass',
-      'shippingOrder'
-    ]
-  })
-
-  if (!releaseGood) throw new ApiError('E04', `release good`)
-  if (!remark) throw new ApiError('E03', 'remark')
-
-  let foundOIs: OrderInventory[] = releaseGood.orderInventories
-  let foundOVs: OrderVas[] = releaseGood.orderVass
-  let foundOPs: OrderProduct[] = releaseGood.orderProducts
-
-  // 1. Update status of order products (PENDING_RECEIVE => REJECTED)
-  if (foundOIs && foundOIs.length) {
-    await tx.getRepository(OrderInventory).save(
-      await Promise.all(
-        foundOIs.map(async (oi: OrderInventory) => {
-          if (oi?.inventory?.id) {
-            oi.inventory = await tx.getRepository(Inventory).findOne(oi.inventory.id)
-
-            await tx.getRepository(Inventory).save({
-              ...oi.inventory,
-              lockedQty: oi.inventory.lockedQty - oi.releaseQty,
-              lockedUomValue: oi.inventory.lockedUomValue - oi.releaseUomValue,
-              updater: user
-            })
-          }
-
-          oi.status = ORDER_INVENTORY_STATUS.REJECTED
-          oi.updater = user
-          return oi
-        })
-      )
-    )
-  }
-
-  if (foundOPs && foundOPs.length) {
-    const orderSource: string = releaseGood.source
-    switch (orderSource) {
-      case ApplicationType.SELLERCRAFT:
-        const sellercraft: Sellercraft = await tx
-          .getRepository(Sellercraft)
-          .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
-
-        if (sellercraft) {
-          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-          await sellercraftCtrl.updateSellercraftStock(sellercraft, foundOPs, 'REJECT_ORDER')
-        }
-        break
-
-      default:
-        break
-    }
-
-    await tx.getRepository(OrderProduct).save(
-      await Promise.all(
-        foundOPs.map(async (op: OrderProduct) => {
-          op.status = ORDER_PRODUCT_STATUS.REJECTED
-          op.updater = user
-          return op
-        })
-      )
-    )
-  }
-
-  // 2. Update status of order vass if it exists (PENDING_RECEIVE => REJECTED)
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((ov: OrderVas) => {
-      ov.status = ORDER_VAS_STATUS.REJECTED
-      ov.updater = user
-      return ov
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  if (releaseGood.shippingOrder) {
-    // 2. 1) if it's yes update status of collection order
-    const shippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).findOne({
-      where: { domain, name: releaseGood.shippingOrder.name }
-    })
-
-    shippingOrder.status = ORDER_STATUS.REJECTED
-    shippingOrder.updater = user
-    await tx.getRepository(ShippingOrder).save(shippingOrder)
-  }
-
-  releaseGood.remark = remark
-  releaseGood.status = ORDER_STATUS.REJECTED
-  releaseGood.updater = user
-  await tx.getRepository(ReleaseGood).save(releaseGood)
-
-  // notification logics
-  const users: any[] = await getDomainUsers(releaseGood?.bizplace, tx)
-
-  if (users?.length && context.header?.referer) {
-    const receivers: any[] = users.map(user => user.id)
-    const msg = {
-      title: `Latest status for ${releaseGood.name}`,
-      body: `Your RO has been rejected.`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    }
-  }
-
-  return releaseGood
-}

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

@@ -1,252 +0,0 @@
-import { EntityManager, getConnection, In } from 'typeorm'
-import { restfulApiRouter as router } from '@things-factory/api'
-import { Bizplace } from '@things-factory/biz-base'
-import { ReleaseGood, DraftReleaseGood, OrderInventory, DeliveryOrder, OrderVas, ORDER_STATUS, ORDER_INVENTORY_STATUS, ORDER_VAS_STATUS } from '@things-factory/sales-base'
-import { Worksheet, WorksheetDetail } from '@things-factory/worksheet-base'
-import { User } from '@things-factory/auth-base'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-
-const debug = require('debug')('things-factory:operato-hub:restful-api:unstable:cancel-release-order')
-
-router.post(
-  '/v1/warehouse/cancel-release-order',
-  businessMiddleware,
-  validationMiddleware,
-  loggingMiddleware,
-  async (context, next) => {
-    try {
-      const { domain } = context.state
-      const { bizplaceId: warehouseId } = context.request.body.data
-      const { user }: { user: User } = context.state
-      const bodyReq = context.request.body.data
-
-      await getConnection().transaction(async (tx: EntityManager) => {
-        const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
-          where: { id: warehouseId }
-        })
-
-        const releaseOrder: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-          where: [{ id: bodyReq.releaseOrderId }, { refNo: bodyReq.orderNo }]
-        })
-
-        if (!releaseOrder) {
-          const draftReleaseOrder: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).findOne({
-            where: [{ refNo: bodyReq.orderNo }]
-          })
-          if (draftReleaseOrder) {
-            context.body = await cancelDraftReleaseOrder(tx, domain, draftReleaseOrder.name, user)
-            return
-          } else {
-            throw new ApiError('E04', 'release order')
-          }
-        }
-
-        debug('post:/cancel-release-order body request', bodyReq)
-
-        context.body = await pendingCancellationReleaseOrder(tx, domain, releaseOrder.name, user)
-      })
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)
-
-async function cancelDraftReleaseOrder(tx, domain, name, user) {
-  const foundDRO: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).findOne({
-    where: { domain, name }
-  })
-
-  if (foundDRO) {
-    await tx.getRepository(DraftReleaseGood).save({
-      ...foundDRO,
-      status: ORDER_STATUS.CANCELLED,
-      updater: user
-    })
-    return {
-      data: {
-        draftRoNo: foundDRO.name
-      }
-    }
-  }
-}
-
-async function pendingCancellationReleaseOrder(tx, domain, name, user) {
-  const foundRO: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name },
-    relations: ['bizplace', 'orderInventories', 'orderVass']
-  })
-
-  if (foundRO.status === "DONE") throw new ApiError('E01', 'Release good has been completed!')
-  if (!foundRO) throw new ApiError('E04', `Release good order doesn't exist`)
-  let targetOIs: OrderInventory[] = foundRO.orderInventories
-  let foundOVs: OrderVas[] = foundRO.orderVass
-  let pickedOIs: OrderInventory[]
-  let pickingOIs: OrderInventory[]
-
-  // 1. Check RO status
-  if (
-    foundRO.status === ORDER_STATUS.LOADING ||
-    foundRO.status === ORDER_STATUS.PACKING ||
-    foundRO.status === ORDER_STATUS.SORTING
-  ) {
-    // 1a. Case 1: RO is done or loading, pending cancel order, worksheet, worksheet detail, order inventory
-    // update status of order inventory to PENDING_CANCEL
-    pickedOIs = targetOIs.map((orderInv: OrderInventory) => {
-      return {
-        ...orderInv,
-        status: ORDER_INVENTORY_STATUS.PENDING_REVERSE,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderInventory).save(pickedOIs)
-  } else if (
-    foundRO.status === ORDER_STATUS.PICKING ||
-    foundRO.status === ORDER_STATUS.READY_TO_PICK ||
-    foundRO.status === ORDER_STATUS.PENDING_WORKSHEET
-  ) {
-    pickingOIs = targetOIs
-      .filter(
-        (oi: OrderInventory) =>
-          oi.status === ORDER_INVENTORY_STATUS.ASSIGNED ||
-          oi.status === ORDER_INVENTORY_STATUS.PICKING ||
-          oi.status === ORDER_INVENTORY_STATUS.READY_TO_PICK ||
-          oi.status === ORDER_INVENTORY_STATUS.PENDING_SPLIT ||
-          oi.status === ORDER_INVENTORY_STATUS.PENDING_WORKSHEET
-      )
-      .map((targetOI: OrderInventory) => {
-        return {
-          ...targetOI,
-          status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
-          updater: user
-        }
-      })
-    await tx.getRepository(OrderInventory).save(pickingOIs)
-
-    pickedOIs = targetOIs
-      .filter((pickedOI: OrderInventory) => pickedOI.status === ORDER_INVENTORY_STATUS.PICKED)
-      .map((targetOI: OrderInventory) => {
-        return {
-          ...targetOI,
-          status: ORDER_INVENTORY_STATUS.PENDING_REVERSE,
-          updater: user
-        }
-      })
-    await tx.getRepository(OrderInventory).save(pickedOIs)
-  }
-
-  // update status of order vass to PENDING_CANCEL
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((orderVas: OrderVas) => {
-      return {
-        ...orderVas,
-        status: ORDER_VAS_STATUS.PENDING_CANCEL,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // find worksheet and update status to PENDING_CANCEL
-  let foundWS: Worksheet = await tx.getRepository(Worksheet).findOne({
-    where: {
-      domain,
-      releaseGood: foundRO
-    },
-    order: { 'createdAt': 'DESC' }
-  })
-
-  if (foundWS) {
-    await tx.getRepository(Worksheet).update({ id: foundWS.id }, {
-      status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
-      updater: user
-    })
-
-    if (pickedOIs && pickedOIs.length) {
-      let pickedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-        where: {
-          domain,
-          targetInventory: In(pickedOIs.map(oi => oi.id)),
-          status: ORDER_INVENTORY_STATUS.DONE,
-          worksheet: foundWS
-        }
-      })
-
-      pickedWSD = pickedWSD.map((wsd: WorksheetDetail) => {
-        return {
-          ...wsd,
-          status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
-          updater: user
-        }
-      })
-      await tx.getRepository(WorksheetDetail).save(pickedWSD)
-
-      let replacedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-        where: {
-          domain,
-          targetInventory: In(pickedOIs.map(oi => oi.id)),
-          status: ORDER_INVENTORY_STATUS.REPLACED,
-          worksheet: foundWS
-        },
-        relations: ['targetInventory']
-      })
-
-      if (replacedWSD && replacedWSD.length) {
-        let replacedOI: OrderInventory[] = replacedWSD.map((wsd: WorksheetDetail) => wsd.targetInventory)
-        replacedOI = replacedOI.map((oi: OrderInventory) => {
-          return {
-            ...oi,
-            status: ORDER_INVENTORY_STATUS.REPLACED,
-            updater: user
-          }
-        })
-        await tx.getRepository(OrderInventory).save(replacedOI)
-      }
-    }
-
-    if (pickingOIs && pickingOIs.length) {
-      let pickingWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-        where: {
-          domain, targetInventory: In(pickingOIs.map(oi => oi.id)),
-          worksheet: foundWS
-        }
-      })
-
-      pickingWSD = pickingWSD.map((wsd: WorksheetDetail) => {
-        return {
-          ...wsd,
-          status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
-          updater: user
-        }
-      })
-      await tx.getRepository(WorksheetDetail).save(pickingWSD)
-    }
-  }
-
-  // find DO and change status to pending cancel
-  let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
-    where: { domain, releaseGood: foundRO }
-  })
-
-  foundDO = foundDO.map((deliveryOrder: DeliveryOrder) => {
-    return {
-      ...deliveryOrder,
-      status: ORDER_STATUS.PENDING_CANCEL,
-      updater: user
-    }
-  })
-  await tx.getRepository(DeliveryOrder).save(foundDO)
-
-  await tx.getRepository(ReleaseGood).save({
-    ...foundRO,
-    status: ORDER_STATUS.PENDING_CANCEL,
-    updater: user
-  })
-
-  return {
-    data: {
-      roNo: foundRO.name
-    }
-  }
-}

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

@@ -1,141 +0,0 @@
-import _ from 'lodash'
-import { Between, getRepository } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { DeliveryOrder } from '@things-factory/sales-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-router.get(
-  '/v1/warehouse/get-delivery-order-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']
-      if (_.has(filter, 'doNo')) {
-        filter['name'] = filter['doNo']
-        delete filter['doNo']
-      }
-      filter['createdAt'] = Between(fromDate, toDate)
-
-      delete filter['fromDate']
-      delete filter['toDate']
-      delete filter['limit']
-      delete filter['offset']
-      const [deliveryOrders, totalCount]: DeliveryOrder[] = await getRepository(DeliveryOrder).findAndCount({
-        where: filter,
-        relations: ['releaseGood', 'releaseGood.orderInventories', 'bizplace', 'domain'],
-        skip: offset,
-        take: limit,
-        order: { createdAt: 'DESC' }
-      })
-
-      // create and format data response
-      let data = []
-      for (const deliveryOrder of deliveryOrders) {
-        let orderInventories = []
-        for (const orderInventory of deliveryOrder.releaseGood.orderInventories) {
-          orderInventories.push(orderInventory)
-        }
-        const datapoint = {
-          id: deliveryOrder.id,
-          doNo: deliveryOrder.name,
-          from: deliveryOrder.from,
-          to: deliveryOrder.to,
-          contactPointRefId: deliveryOrder.contactPointRefId,
-          truckNo: deliveryOrder.truckNo,
-          deliveryDate: deliveryOrder.deliveryDate,
-          status: deliveryOrder.status,
-          ownCollection: deliveryOrder.ownCollection,
-          looseItem: deliveryOrder.looseItem,
-          deliveryDateTime: deliveryOrder.deliveryDateTime,
-          loadWeight: deliveryOrder.loadWeight,
-          cargoType: deliveryOrder.cargoType,
-          urgency: deliveryOrder.urgency,
-          telNo: deliveryOrder.telNo,
-          refNo: deliveryOrder.refNo,
-          otherDriver: deliveryOrder.otherDriver,
-          palletQty: deliveryOrder.palletQty,
-          remark: deliveryOrder.remark,
-          description: deliveryOrder.description,
-          reusablePallet: deliveryOrder.reusablePallet,
-          bizplace: {
-            id: deliveryOrder.bizplace.id,
-            name: deliveryOrder.bizplace.name,
-            description: deliveryOrder.bizplace.description
-          },
-          domain: {
-            id: deliveryOrder.domain.id,
-            name: deliveryOrder.domain.name
-          },
-          releaseGood: {
-            id: deliveryOrder.releaseGood.id,
-            roNo: deliveryOrder.releaseGood.name,
-            description: deliveryOrder.releaseGood.description,
-            status: deliveryOrder.releaseGood.status,
-            refNo: deliveryOrder.releaseGood.refNo,
-            refNo2: deliveryOrder.releaseGood.refNo2,
-            refNo3: deliveryOrder.releaseGood.refNo3,
-            truckNo: deliveryOrder.releaseGood.truckNo,
-            exportOption: deliveryOrder.releaseGood.exportOption,
-            ownTransport: deliveryOrder.releaseGood.ownTransport,
-            crossDocking: deliveryOrder.releaseGood.crossDocking,
-            releaseDateTime: deliveryOrder.releaseGood.releaseDateTime,
-            releaseDate: deliveryOrder.releaseGood.releaseDate,
-            remark: deliveryOrder.releaseGood.remark,
-            courierOption: deliveryOrder.releaseGood.courierOption,
-            packingOption: deliveryOrder.releaseGood.packingOption,
-            type: deliveryOrder.releaseGood.type,
-            acceptedAt: deliveryOrder.releaseGood.acceptedAt,
-            marketplaceOrderStatus: deliveryOrder.releaseGood.marketplaceOrderStatus,
-            billingAddress: deliveryOrder.releaseGood.billingAddress,
-            deliveryAddress1: deliveryOrder.releaseGood.deliveryAddress1,
-            deliveryAddress2: deliveryOrder.releaseGood.deliveryAddress2,
-            deliveryAddress3: deliveryOrder.releaseGood.deliveryAddress3,
-            deliveryAddress4: deliveryOrder.releaseGood.deliveryAddress4,
-            deliveryAddress5: deliveryOrder.releaseGood.deliveryAddress5,
-            attentionTo: deliveryOrder.releaseGood.attentionTo,
-            attentionCompany: deliveryOrder.releaseGood.attentionCompany,
-            city: deliveryOrder.releaseGood.city,
-            state: deliveryOrder.releaseGood.state,
-            postalCode: deliveryOrder.releaseGood.postalCode,
-            country: deliveryOrder.releaseGood.country,
-            phone1: deliveryOrder.releaseGood.phone1,
-            phone2: deliveryOrder.releaseGood.phone2,
-            email: deliveryOrder.releaseGood.email,
-            transporter: deliveryOrder.releaseGood.transporter,
-            trackingNo: deliveryOrder.releaseGood.trackingNo,
-            airwayBill: deliveryOrder.releaseGood.airwayBill,
-            invoice: deliveryOrder.releaseGood.invoice,
-            pickupAddress: deliveryOrder.releaseGood.pickupAddress,
-            pickupTime: deliveryOrder.releaseGood.pickupTime,
-            handoverType: deliveryOrder.releaseGood.handoverType,
-            dropoffAddress: deliveryOrder.releaseGood.dropoffAddress,
-            noOfItems: deliveryOrder.releaseGood.noOfItems,
-            orderProducts: []
-          },
-          orderInventories
-        }
-        data.push(datapoint)
-      }
-
-      context.body = {
-        data,
-        totalCount,
-        limit,
-        offset
-      }
-    } catch (e) {
-      if (e instanceof ApiError) ApiErrorHandler(context, e)
-      else throwInternalServerError(context, e)
-    }
-  }
-)