@things-factory/operato-hub 4.3.79 → 4.3.80-alpha.2

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

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

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

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

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

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