@things-factory/operato-hub 4.3.81 → 4.3.82

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

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

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

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