@things-factory/operato-hub 4.3.82 → 4.3.83

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

@@ -1,106 +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' }
-        }
-      )
-      const limitedGoodsReceivedNotes: GoodsReceivalNote[] = goodsReceivedNotes.slice(offset, offset + limit)
-
-      // create and format data response
-      let data = []
-      for (const goodsReceivedNote of limitedGoodsReceivedNotes) {
-        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,74 +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']
-    })
-
-    // 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,293 +0,0 @@
-import { EntityManager, getConnection } from 'typeorm'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { LOCATION_TYPE } from '@things-factory/warehouse-base'
-
-import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
-import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
-
-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']
-
-      let filters = []
-      if (filter.hasOwnProperty('sku')) {
-        filters.push({ name: 'productSKU', operator: 'eq', value: filter['sku'] })
-      }
-      if (filter.hasOwnProperty('batchId')) {
-        filters.push({ name: 'batchId', operator: 'eq', value: filter['batchId'] })
-      }
-
-      await getConnection().transaction(async (tx: EntityManager) => {
-        let customerBizplaceId = filter.bizplaceId
-        const customerCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, customerBizplaceId, tx)
-        const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
-          where: { id: customerBizplaceId },
-          relations: ['company', 'company.domain']
-        })
-
-        const bizplaces: Bizplace[] = [customerBizplace, customerCompanyBizplace]
-        const params: any = { filters, pagination: { page: offset, limit: limit } }
-
-        const { items, total } = await bizplaceInventoryProductGroup(bizplaces, params, context, tx)
-
-        let data = items.map(item => {
-          return {
-            product: {
-              sku: item.productSKU,
-              name: item.productName,
-              description: item.productDescription,
-              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 bizplaceInventoryProductGroup(bizplaces: Bizplace[], params, context: any, trxMgr: EntityManager) {
-  try {
-    let filters = params.filters
-    const { domain }: { domain: Domain } = context.state
-
-    const { bizplaceIds, productWhereClause, bundleWhereClause, whereClause, batchBundle } = await getConditions(
-      bizplaces,
-      filters
-    )
-
-    const _groupType = filters.find(res => res.name == 'groupType')
-
-    let queryStrings = `
-        CREATE TEMP TABLE temp_inventory_product_group AS (
-          SELECT * FROM (
-            WITH oi as (
-              SELECT
-                SUM(oi.release_qty) AS release_qty,
-                SUM(oi.release_uom_value) AS release_uom_value,
-                oi.batch_id,
-                oi.batch_id_ref,
-                oi.product_id,
-                p.name AS product_name,
-                oi.packing_type,
-                oi.packing_size,
-                oi.uom
-              FROM
-                order_inventories oi
-              LEFT JOIN
-                products p
-              ON
-                oi.product_id = p.id
-              WHERE
-                (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
-                AND oi.batch_id NOTNULL
-                AND oi.product_id NOTNULL
-                AND oi.packing_type NOTNULL
-                AND oi.packing_size NOTNULL
-                AND oi.inventory_id IS NULL
-              GROUP BY
-                oi.batch_id,
-                oi.batch_id_ref,
-                oi.product_id,
-                oi.packing_type,
-                oi.packing_size,
-                oi.uom,
-                p.name
-            )
-            SELECT
-              i.batch_id AS "batchId",
-              i.batch_id_ref AS "batchIdRef",
-              i.packing_type AS "packingType",
-              i.packing_size AS "packingSize",
-              i.uom AS "uom",
-              coalesce(p.sku, '') AS "productSKU",
-              coalesce(p.name, '') AS "productName",
-              coalesce(p.description, '') AS "productDescription",
-              p.id AS "productId",
-              SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) AS "remainQty",
-              SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) AS "remainUomValue",
-              concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', i.uom) AS "remainUomValueWithUom",
-              'SINGLE' AS "groupType"
-            FROM
-              inventories i
-              LEFT JOIN products p ON i.product_id = p.id
-              LEFT JOIN oi ON i.batch_id = oi.batch_id AND p.name = oi.product_name AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
-              LEFT JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
-              LEFT JOIN (
-                SELECT pbs.product_id, SUM(pbs.bundle_qty * src.release_qty) AS bundle_product_release_qty, SUM(pbs.bundle_qty * src.release_uom_value) AS bundle_product_release_uom_value 
-                FROM product_bundle_settings pbs
-                INNER JOIN json_populate_recordset(NULL::order_inventories,'${batchBundle}') src ON src.product_id = pbs.product_bundle_id
-                GROUP BY pbs.product_id
-              ) bp on i.product_id = bp.product_id
-            WHERE i.domain_id = $1
-            AND l2.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
-            ${productWhereClause}
-            GROUP BY
-            i.batch_id,
-            i.batch_id_ref,
-            p.id,
-            i.packing_type,
-            i.packing_size,
-            i.uom
-            UNION 
-            SELECT 'BUNDLE' AS "batchId", null as "batchIdRef", packing_type, packing_size,'UNIT' AS "uom", sku AS "productSKU", name AS "productName", description AS "productDescription", id AS "productId",
-            MIN(FLOOR(pbs."availableQty")) AS "remainQty", 
-            MIN(FLOOR(pbs."availableUomValue")) AS "remainUomValue", 
-            CONCAT(MIN(FLOOR(pbs."availableUomValue")),' UNIT') AS "remainUomValueWithUom", 
-            'BUNDLE' AS "groupType"
-            FROM product_bundles pb
-            INNER JOIN (
-              SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
-              (SUM(COALESCE(i2.qty, 0)) - SUM(COALESCE(i2.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
-              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue"
-              FROM product_bundle_settings pbs 
-              LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id AND i2.domain_id = $1
-              AND i2.bizplace_id IN (${bizplaceIds})
-              AND i2.status = 'STORED'
-              LEFT JOIN oi ON oi.product_id = i2.product_id
-              GROUP BY pbs.product_id, pbs.product_bundle_id
-            ) pbs ON pbs.product_bundle_id = pb.id
-            ${bundleWhereClause}
-            GROUP BY pb.packing_type, pb.packing_size, pb.name, pb.sku, pb.id
-          )
-          AS inv_prod_grp
-          ${whereClause}
-        )
-      `
-
-    let filterGroupTypeQuery
-
-    if (_groupType) {
-      if (_groupType.value === 'SINGLE') {
-        filterGroupTypeQuery = `where "groupType"= 'SINGLE' `
-      } else {
-        filterGroupTypeQuery = `where "groupType"= 'BUNDLE' `
-      }
-    }
-
-    await trxMgr.query(queryStrings, [domain.id])
-
-    const [{ total }]: any = await trxMgr.query(
-      `select count(*) as total from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''}`
-    )
-    let items: any[] = []
-
-    if (params?.pagination) {
-      items = await trxMgr.query(
-        `select * from temp_inventory_product_group  ${
-          filterGroupTypeQuery ? filterGroupTypeQuery : ''
-        } OFFSET $1 LIMIT $2`,
-        [(params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]
-      )
-    } else {
-      items = await trxMgr.query(
-        `select * from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''}
-        }`
-      )
-    }
-
-    await trxMgr.query(`drop table temp_inventory_product_group`)
-
-    return { items, total }
-  } catch (error) {
-    throw error
-  }
-}
-
-async function getConditions(
-  bizplaces: Bizplace[],
-  filters: [{ name: string; operator: string; value: any }],
-  hasRemainingQty: Boolean = true
-) {
-  let bizplaceIds = bizplaces.map((bizplace: Bizplace) => `'${bizplace.id}'`).join()
-
-  let productWhereClause = `
-    AND i.status = 'STORED'
-    AND i.bizplace_id IN (${bizplaceIds})
-  `
-
-  let bundleWhereClause = `
-    WHERE pb.status = 'ACTIVATED'
-  `
-
-  let whereClause = hasRemainingQty ? ` WHERE "remainQty" > 0` : ` WHERE 1 = 1`
-
-  let productDetailWhereClause = ``
-
-  let batchBundle: string
-  if (filters?.length) {
-    await Promise.all(
-      filters.map(async (filter: { name: string; operator: string; value: any }) => {
-        const name = filter.name
-        const operator = filter.operator.toLowerCase()
-        let value = filter.value
-
-        switch (name) {
-          case 'batchId':
-            whereClause += `AND LOWER("batchId") LIKE '${value.toLowerCase()}'`
-            break
-
-          case 'productSKU':
-            whereClause += `AND LOWER("productSKU") LIKE '${value.toLowerCase()}'`
-
-          case 'batch_bundle':
-            bundleWhereClause += `
-              ${bundleWhereClause == '' ? 'WHERE' : 'AND'} pb.id ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
-              .map((v: { productId: string }) => `('${v.productId}')`)
-              .join()})
-            `
-            break
-        }
-      })
-    )
-
-    batchBundle = JSON.stringify(
-      filters
-        .find(filter => filter.name === 'batch_bundle')
-        ?.value.map(itm => {
-          return {
-            product_id: itm.productId,
-            release_qty: itm?.releaseQty || 0,
-            release_uom_value: itm?.releaseUomValue || 0
-          }
-        }) || []
-    )
-  }
-
-  return {
-    bizplaceIds,
-    productWhereClause,
-    bundleWhereClause,
-    whereClause,
-    batchBundle,
-    productDetailWhereClause
-  }
-}

package/server/routers/api/restful-apis/v1/warehouse/get-onhand-inventory-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-onhand-inventory-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, '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)
-    }
-  }
-)