@things-factory/operato-pms 3.8.0 → 3.8.13

package/server/graphql/resolvers/report/daily-production-reports.ts

@@ -1,5 +1,7 @@
-import { ListParam } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
+
+import { ListParam } from '@things-factory/shell'
+
 import { Block } from '../../../entities'
 
 export const dailyProductionReports = {
@@ -31,25 +33,42 @@ export const dailyProductionReports = {
         .findOneOrFail({ where: { id: params.filters.filter(x => x.name == 'block')[0].value } })
 
       await tx.query(`
-        CREATE TEMP TABLE temp_records AS (	
-          select block_id, coalesce(sum(field_bunches),0) AS today_field_bunches, 
-          coalesce(sum(ramp_weight),0) AS today_ramp_weight,
+        CREATE TEMP TABLE temp_blocks on commit drop AS (
+          WITH RECURSIVE b AS (   
+            SELECT $1::uuid as block_id, * FROM blocks b 
+            WHERE id = $1::uuid
+            AND b.deleted_at IS null
+            UNION ALL
+            SELECT $1::uuid as block_id, cb.* FROM blocks cb
+            INNER JOIN b ON b.id = cb.parent_block_id
+            WHERE cb.deleted_at IS null
+          )
+          SELECT * FROM b
+        );
+      `, [block.id]
+      )
+
+      await tx.query(`
+        CREATE TEMP TABLE temp_records on commit drop AS (	
+          select blk.block_id, coalesce(sum(field_bunches),0) AS today_field_bunches, 
+          round(coalesce(sum(ramp_weight),0)::numeric,4) AS today_ramp_weight,
           sum(case when transaction_type = 'HARVEST' then field_bunches else 0 end) as today_bunch_harvest,
           sum(case when transaction_type = 'LOADING' then -field_bunches else 0 end) as today_bunch_collected,
-          sum(case when transaction_type = 'LOADING' then ramp_weight else 0 end) as today_ramp_weight_collected,
-          sum(case when transaction_type = 'DISPATCHMENT' then -ramp_weight else 0 end) as today_weight_dispatch,	  
+          round(sum(case when transaction_type = 'LOADING' then ramp_weight else 0 end)::numeric,4) as today_ramp_weight_collected,
+          round(sum(case when transaction_type = 'DISPATCHMENT' then -ramp_weight else 0 end)::numeric,4) as today_weight_dispatch,	  
           transaction_date
-          from record_transactions t2 
+          from record_transactions t2
+          inner join temp_blocks blk on blk.id = t2.block_id
           where transaction_date <= $1
-          and block_id = $2
-          group by block_id, transaction_date
+          group by blk.block_id, transaction_date
         )
-      `, 
-      [toDateString, block.id])
+      `,
+        [toDateString]
+      )
 
       await tx.query(
         `
-          create temp table temp_daily_production_data as (
+          create temp table temp_daily_production_data on commit drop as (
             select *,
             prev_bunch_bal_in_field + today_bunch_harvest as today_bunch_in_field,
             prev_bunch_bal_in_field + today_bunch_harvest - today_bunch_collected as today_bunch_bal_in_field,
@@ -88,60 +107,52 @@ export const dailyProductionReports = {
                 order by transaction_date
               ) as dt on dt.transaction_date::date = md.dateDay
               LEFT JOIN (
-                select sum(harvesting_round) AS today_harvesting_round, sum(coverage) AS today_hectare_cover, harvest_date from daily_harvests dh 
+                select sum(harvesting_round) AS today_harvesting_round, sum(coverage) AS today_hectare_cover, harvest_date 
+                from daily_harvests dh 
+                inner join temp_blocks blk on blk.id = dh.block_id
                 where harvest_date between $1 and $2
-                and block_id = $3
-                group by block_id, harvest_date
+                group by blk.block_id, harvest_date
               ) as thr ON thr.harvest_date::date = md.dateDay
               LEFT JOIN (
-                select count(*) AS today_out_turn, dh.harvest_date from daily_harvest_details dhd 
+                select count(*) AS today_out_turn, dh.harvest_date 
+                from daily_harvest_details dhd 
                 inner join daily_harvests dh on dh.id = dhd.daily_harvest_id
+                inner join temp_blocks blk on blk.id = dh.block_id
                 where dh.harvest_date between $1 and $2
-                and block_id = $3
-                GROUP BY dh.block_id, dh.harvest_date
+                GROUP BY blk.block_id, dh.harvest_date
               ) as tot ON tot.harvest_date::date = md.dateDay
             ) dt
           )`,
         [fromDateString, toDateString, block.id]
       )
 
-      const result: any = await tx.query(
-        `
+      const result: any = await tx.query(`
             select * from temp_daily_production_data dt
-          `
-      )
+      `)
 
-      const total: any = await tx.query(
-        `
+      const total: any = await tx.query(`
           select count(*) from temp_daily_production_data
-          `
-      )
-
-      await tx.query(
-        `
-            drop table temp_daily_production_data, temp_records
-          `
-      )
+      `)
 
       let items = result.map(itm => {
         return {
           block: itm.block,
           dateDay: itm.date_day,
-          diffInBunches: itm.diff_in_bunches,
-          prevBunchBalInField: itm.prev_bunch_bal_in_field,
-          prevWeightBalInRamp: itm.prev_weight_bal_in_ramp,
-          toDateBunchHarvest: itm.to_date_bunch_harvest,
+          diffInBunches: parseFloat(itm.diff_in_bunches).toFixed(1),
+          prevBunchBalInField: parseFloat(itm.prev_bunch_bal_in_field).toFixed(1),
+          prevWeightBalInRamp: parseFloat(itm.prev_weight_bal_in_ramp).toFixed(4),
+          toDateBunchHarvest: parseFloat(itm.to_date_bunch_harvest).toFixed(1),
           toDateOutTurn: itm.to_date_out_turn,
-          toDateWeightDispatch: itm.to_date_weight_dispatch,
-          todayBunchBalInField: itm.today_bunch_bal_in_field,
-          todayBunchCollected: itm.today_bunch_collected,
-          todayBunchHarvest: itm.today_bunch_harvest,
-          todayBunchInField: itm.today_bunch_in_field,
+          toDateWeightDispatch: parseFloat(itm.to_date_weight_dispatch).toFixed(4),
+          todayBunchBalInField: parseFloat(itm.today_bunch_bal_in_field).toFixed(1),
+          todayBunchCollected: parseFloat(itm.today_bunch_collected).toFixed(1),
+          todayBunchHarvest: parseFloat(itm.today_bunch_harvest).toFixed(1),
+          todayBunchInField: parseFloat(itm.today_bunch_in_field).toFixed(1),
           todayHarvestingRound: itm.today_harvesting_round,
-          todayHectareCover: itm.today_hectare_cover,
+          todayHectareCover: parseFloat(itm.today_hectare_cover).toFixed(4),
           todayOutTurn: itm.today_out_turn,
-          todayWeightBalInRamp: itm.today_weight_bal_in_ramp,
-          todayWeightDispatch: itm.today_weight_dispatch
+          todayWeightBalInRamp: parseFloat(itm.today_weight_bal_in_ramp).toFixed(4),
+          todayWeightDispatch: parseFloat(itm.today_weight_dispatch).toFixed(4)
         }
       })
 

package/server/graphql/resolvers/report/daily-staff-harvest-reports.ts

@@ -1,5 +1,7 @@
-import { ListParam } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
+
+import { ListParam } from '@things-factory/shell'
+
 import { Block } from '../../../entities'
 
 export const dailyStaffHarvestReports = {
@@ -30,43 +32,49 @@ export const dailyStaffHarvestReports = {
         .getRepository(Block)
         .findOneOrFail({ where: { id: params.filters.filter(x => x.name == 'block')[0].value } })
 
+      await tx.query(`
+        CREATE TEMP TABLE temp_blocks on commit drop AS (
+          WITH RECURSIVE b AS (   
+            SELECT $1::uuid as block_id, * FROM blocks b 
+            WHERE id = $1::uuid 
+            AND b.deleted_at IS null
+            UNION ALL
+            SELECT $1::uuid as block_id, cb.* FROM blocks cb
+            INNER JOIN b ON b.id = cb.parent_block_id
+            WHERE cb.deleted_at IS null
+          )
+          SELECT * FROM b
+        );
+      `, [block.id]
+      )
+
       await tx.query(
         `
-            create temp table temp_daily_staff_harvest_data as (
+            create temp table temp_daily_staff_harvest_data on commit drop as (
               select "harvestDate"::varchar as "harvestDate", "blockName"::varchar, "staffName"::varchar, sum("totalBunchHarvested")::varchar as "totalBunchHarvested" from (
                 select dh.harvest_date::date as "harvestDate", b2."name" as "blockName", os."name" as "staffName",
                 dhd.total_bunch_harvested as "totalBunchHarvested"
                 from daily_harvest_details dhd 
                 inner join daily_harvests dh on dh.id = dhd.daily_harvest_id
+                inner join temp_blocks blk on blk.id = dh.block_id
                 inner join organization_staffs os on os.id = dhd.organization_staff_id 
-                inner join blocks b2 on b2.id = dh.block_id
-                where dh.block_id = $1
-                and dh.harvest_date::date between $2 and $3
+                inner join blocks b2 on b2.id = blk.block_id
+                where dh.harvest_date::date between $1 and $2
               ) as dt
               group by "harvestDate", "blockName", "staffName"
               order by "staffName", "harvestDate"
             )
           `,
-        [block.id, fromDateString, toDateString]
+        [fromDateString, toDateString]
       )
 
-      const result: any = await tx.query(
-        `
+      const result: any = await tx.query(`
             select * from temp_daily_staff_harvest_data dt
-          `
-      )
+      `)
 
-      const total: any = await tx.query(
-        `
+      const total: any = await tx.query(`
           select count(*) from temp_daily_staff_harvest_data
-          `
-      )
-
-      await tx.query(
-        `
-            drop table temp_daily_staff_harvest_data
-          `
-      )
+      `)
 
       return { items: result, total: total[0].count }
     } catch (error) {

package/server/graphql/resolvers/report/index.ts

@@ -1,14 +1,20 @@
 import { dailyProductionReports } from './daily-production-reports'
 import { monthlyProductionReports } from './monthly-production-reports'
+import { monthlyDispatchSummaryReports } from './monthly-dispatch-summary-reports'
 import { yearlyProductionReports } from './yearly-production-reports'
 import { dailyStaffHarvestReports } from './daily-staff-harvest-reports'
+import { monthlyBlockDispatchReports } from './monthly-block-dispatch-reports'
+import { monthlyFfbSaleReports } from './monthly-ffb-sale-reports'
 
 export const ReportResolver = {
   Query: {
     ...dailyProductionReports,
     ...monthlyProductionReports,
+    ...monthlyDispatchSummaryReports,
     ...yearlyProductionReports,
-    ...dailyStaffHarvestReports
+    ...dailyStaffHarvestReports,
+    ...monthlyBlockDispatchReports,
+    ...monthlyFfbSaleReports
   },
   Mutation: {}
 }

package/server/graphql/resolvers/report/monthly-block-dispatch-reports.ts

@@ -0,0 +1,112 @@
+import { EntityManager, getRepository, Not, IsNull } from 'typeorm'
+
+import { ListParam, Domain } from '@things-factory/shell'
+import { Ramp } from '../../../entities'
+
+export const monthlyBlockDispatchReports = {
+  async monthlyBlockDispatchReports(_: any, params: ListParam, context: any) {
+    try {
+      const { domain, tx }: { domain: Domain, tx: EntityManager } = context.state
+
+      let year = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[0])
+      let month = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[1])
+
+      let fromDate = new Date(year, month - 1, 1)
+      let toDate = new Date(year, month, 1)
+      toDate.setDate(toDate.getDate() - 1)
+
+      let fromDateString = [
+        fromDate.getFullYear().toString(),
+        String(fromDate.getMonth() + 1).padStart(2, '0'),
+        '01'
+      ].join('-')
+
+      let toDateString = [
+        toDate.getFullYear().toString(),
+        String(toDate.getMonth() + 1).padStart(2, '0'),
+        String(toDate.getDate()).padStart(2, '0')
+      ].join('-')
+
+      let ramps = await getRepository(Ramp).find({
+        where: { domain: domain.id, deletedAt: IsNull() },
+        relations: ['block']
+      })
+
+
+      // --  WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
+      // [fromDateString, toDateString]
+      await tx.query(`create extension if not exists tablefunc`)
+
+      await tx.query(
+        `
+        CREATE TEMP TABLE raw_block_dispatch ON COMMIT DROP AS (
+          SELECT dd.id, b.name AS block_name,
+          COALESCE(ddd.adjusted_weight, ddd.collected_ramp_weight, 0) AS weight
+          FROM daily_dispatches dd 
+          INNER JOIN daily_dispatch_details ddd ON ddd.daily_dispatch_id = dd.id
+          INNER JOIN ramps r ON r.id = ddd.ramp_id 
+          INNER JOIN blocks b ON b.id = r.block_id
+          WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
+        )
+        `, [fromDateString, toDateString]
+      )
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE pivot_block_dispatch ON COMMIT DROP AS (
+            SELECT * FROM crosstab(
+              $$SELECT rbd.id, rbd.block_name, round(rbd.weight, 2 )::varchar FROM raw_block_dispatch rbd$$,
+              $$SELECT b.name FROM ramps r INNER JOIN blocks b ON b.id = r.block_id WHERE r.deleted_at IS NULL$$
+            ) AS ("id" uuid,  ${ramps.map(ramp => `"${ramp.block.name}" varchar`).join(',')})
+          );
+        `)
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE temp_monthly_production_data ON COMMIT DROP AS (
+            SELECT 
+            ROW_NUMBER() OVER(
+              PARTITION BY dd.dispatch_at::date
+              ORDER BY dd.dispatch_at
+            ) as rn
+            , dd.id, COALESCE(c.name, 'UNKNOWN') AS "dispatchTo"
+            , dd.transport_no as "lorryNo"
+            , dd.driver_identification as "driverIdentification"
+            , TO_CHAR(dd.dispatch_at:: DATE, 'dd/mm/yyyy') as "date"
+            , row_to_json((SELECT d FROM (SELECT ${ramps.map(ramp => `pbd."${ramp.block.name}"`).join(',')}) d))::varchar as "blockData"
+            , (SELECT sum(weight) FROM raw_block_dispatch rbd WHERE rbd.id = dd.id) AS "today"
+            FROM daily_dispatches dd 
+            INNER JOIN pivot_block_dispatch pbd ON pbd.id = dd.id
+            LEFT JOIN organizations c ON c.id = dd.dispatch_to_id 
+          );
+        `
+      )
+
+      const result: any = await tx.query(
+        `
+          select "id", "dispatchTo", "lorryNo", "driverIdentification", 
+          CASE WHEN "rn" = 1 THEN "date" ELSE '' END AS "date", "blockData", "today",
+          coalesce(sum(today) over (order by date asc rows between unbounded preceding and current row), 0) as "todate"
+          from temp_monthly_production_data dt
+        `
+      )
+
+      const total: any = await tx.query(
+        `
+          select count(*) from temp_monthly_production_data
+        `
+      )
+
+
+      return {
+        items: result.map(itm => {
+          return {
+            ...itm
+          }
+        }), total: total[0].count
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+}

package/server/graphql/resolvers/report/monthly-dispatch-summary-reports.ts

@@ -0,0 +1,110 @@
+import { EntityManager, getRepository, Not, IsNull } from 'typeorm'
+
+import { ListParam, Domain } from '@things-factory/shell'
+import { Organization } from '../../../entities'
+
+export const monthlyDispatchSummaryReports = {
+  async monthlyDispatchSummaryReports(_: any, params: ListParam, context: any) {
+    try {
+      const { domain, tx }: { domain: Domain, tx: EntityManager } = context.state
+
+      let year = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[0])
+      let month = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[1])
+
+      let fromDate = new Date(year, month - 1, 1)
+      let toDate = new Date(year, month, 1)
+      toDate.setDate(toDate.getDate() - 1)
+
+      let fromDateString = [
+        fromDate.getFullYear().toString(),
+        String(fromDate.getMonth() + 1).padStart(2, '0'),
+        '01'
+      ].join('-')
+
+      let toDateString = [
+        toDate.getFullYear().toString(),
+        String(toDate.getMonth() + 1).padStart(2, '0'),
+        String(toDate.getDate()).padStart(2, '0')
+      ].join('-')
+
+
+      const org = await tx
+        .getRepository(Organization)
+        .findOneOrFail({ where: { domain: domain.id, deletedAt: IsNull(), id: params.filters.filter(x => x.name == 'organization')[0].value } })
+
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE raw_dispatch ON COMMIT DROP AS (
+            SELECT dd.*,
+            COALESCE((SELECT SUM(COALESCE(ddd.adjusted_weight, ddd.collected_ramp_weight, 0)) FROM daily_dispatch_details ddd WHERE ddd.daily_dispatch_id = dd.id),0) AS tonnage
+            FROM daily_dispatches dd 
+            WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
+            AND dd.dispatch_to_id = $3
+          );
+        `, [fromDateString, toDateString, org.id]
+      )
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE temp_monthly_dispatch_to_mill_data ON COMMIT DROP AS (
+            SELECT "id", dispatch_at AS "dispatchAt", transport_no AS "lorryNo", 
+            driver_identification AS "driverIdentification", chit_no AS "chitNo",	round(COALESCE(percentage,0)::numeric, 2)::varchar AS "percentage",
+            COALESCE(diapatch_to_name, 'UNKNOWN') AS "dispatchTo", "tonnage",
+            CASE WHEN reverse_rn = 1 THEN round((coalesce(sum(percentage) over (PARTITION BY dispatch_to_id, dispatch_at::date ORDER BY dispatch_at asc rows between unbounded preceding and current row), 0)/forward_rn)::numeric,2)::varchar ELSE '' END AS "todayAvg",
+            CASE WHEN reverse_rn = 1 THEN round((coalesce(sum(percentage) over (PARTITION BY dispatch_to_id ORDER BY dispatch_at asc rows between unbounded preceding and current row), 0)/forward_rn)::numeric,2)::varchar ELSE '' END AS "todateAvg",
+            CASE WHEN reverse_rn = 1 THEN round(coalesce(sum(tonnage) over (PARTITION BY dispatch_to_id, dispatch_at::date ORDER BY dispatch_at asc rows between unbounded preceding and current row), 0),2)::varchar ELSE '' END AS "today",
+            CASE WHEN reverse_rn = 1 THEN round(coalesce(sum(tonnage) over (PARTITION BY dispatch_to_id ORDER BY dispatch_at asc rows between unbounded preceding and current row), 0),2)::varchar ELSE '' END AS "todate"
+            FROM (
+              SELECT 
+              ROW_NUMBER() OVER(
+                PARTITION BY rbd.dispatch_to_id, rbd.dispatch_at::date
+                ORDER BY rbd.dispatch_at ASC
+              ) as forward_rn
+              , ROW_NUMBER() OVER(
+                PARTITION BY rbd.dispatch_to_id, rbd.dispatch_at::date
+                ORDER BY rbd.dispatch_at DESC
+              ) as reverse_rn
+              , rbd.id
+              , rbd.dispatch_at
+              , rbd.transport_no
+              , rbd.driver_identification
+              , rbd.external_driver
+              , rbd.chit_no
+              , rbd.percentage
+              , rbd.dispatch_to_id
+              , c.name AS diapatch_to_name
+              , rbd.tonnage 
+              FROM raw_dispatch rbd
+              LEFT JOIN organizations c ON c.id = rbd.dispatch_to_id
+              ORDER BY rbd.dispatch_to_id, rbd.dispatch_at
+            ) src
+          );
+        `)
+
+
+      const result: any = await tx.query(
+        `
+          select * from temp_monthly_dispatch_to_mill_data dt
+        `
+      )
+
+      const total: any = await tx.query(
+        `
+          select count(*) from temp_monthly_dispatch_to_mill_data
+        `
+      )
+
+
+      return {
+        items: result.map(itm => {
+          return {
+            ...itm
+          }
+        }), total: total[0].count
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+}

package/server/graphql/resolvers/report/monthly-ffb-sale-reports.ts

@@ -0,0 +1,107 @@
+import { EntityManager, getRepository, Not, IsNull } from 'typeorm'
+
+import { ListParam, Domain } from '@things-factory/shell'
+import { Ramp } from '../../../entities'
+
+export const monthlyFfbSaleReports = {
+  async monthlyFfbSaleReports(_: any, params: ListParam, context: any) {
+    try {
+      const { domain, tx }: { domain: Domain, tx: EntityManager } = context.state
+
+      let year = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[0])
+      let month = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[1])
+      let organization = params.filters.find(x => x.name == 'organization')
+
+      let fromDate = new Date(year, month - 1, 1)
+      let toDate = new Date(year, month, 1)
+      toDate.setDate(toDate.getDate() - 1)
+
+      let fromDateString = [
+        fromDate.getFullYear().toString(),
+        String(fromDate.getMonth() + 1).padStart(2, '0'),
+        '01'
+      ].join('-')
+
+      let toDateString = [
+        toDate.getFullYear().toString(),
+        String(toDate.getMonth() + 1).padStart(2, '0'),
+        String(toDate.getDate()).padStart(2, '0')
+      ].join('-')
+
+      await tx.query(
+        `
+        CREATE TEMP TABLE raw_block_dispatch ON COMMIT DROP AS (
+          SELECT dd.*,
+          COALESCE((SELECT SUM(COALESCE(ddd.adjusted_weight, ddd.collected_ramp_weight, 0)) FROM daily_dispatch_details ddd WHERE ddd.daily_dispatch_id = dd.id),0) AS tonnage
+          FROM daily_dispatches dd 
+          WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
+          ${organization ? organization.value == 'null' ? `AND dd.dispatch_to_id IS NULL` : `AND dd.dispatch_to_id = '${organization.value}'` : ''}
+        );
+        `, [fromDateString, toDateString]
+      )
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE temp_monthly_dispatch_to_mill_data ON COMMIT DROP AS (
+            SELECT "id", dispatch_at, transport_no AS "lorryNo", 
+            driver_identification AS "driverIdentification", chit_no AS "chitNo",	round(COALESCE(percentage,0)::numeric, 2)::varchar AS "percentage", 
+            COALESCE(diapatch_to_name, 'UNKNOWN') AS "dispatchTo", round(COALESCE(tonnage,0), 2)::varchar AS "tonnage",
+            CASE WHEN forward_rn = 1 THEN dispatch_at::date::varchar ELSE '' END AS "dispatchAt", 
+            CASE WHEN reverse_rn = 1 THEN round((coalesce(sum(percentage) over (PARTITION BY dispatch_to_id, dispatch_at::date ORDER BY dispatch_at asc rows between unbounded preceding and current row), 0)/forward_rn)::numeric,2)::varchar ELSE '' END AS "todayAvg",
+            CASE WHEN reverse_rn = 1 THEN round((coalesce(sum(percentage) over (PARTITION BY dispatch_to_id ORDER BY dispatch_at asc rows between unbounded preceding and current row), 0)/forward_rn)::numeric,2)::varchar ELSE '' END AS "todateAvg",
+            CASE WHEN reverse_rn = 1 THEN round(coalesce(sum(tonnage) over (PARTITION BY dispatch_to_id, dispatch_at::date ORDER BY dispatch_at asc rows between unbounded preceding and current row), 0),2)::varchar ELSE '' END AS "today",
+            CASE WHEN reverse_rn = 1 THEN round(coalesce(sum(tonnage) over (PARTITION BY dispatch_to_id ORDER BY dispatch_at asc rows between unbounded preceding and current row), 0),2)::varchar ELSE '' END AS "todate"
+            FROM (
+              SELECT 
+              ROW_NUMBER() OVER(
+                PARTITION BY rbd.dispatch_at::date
+                ORDER BY rbd.dispatch_at ASC
+              ) as forward_rn
+              , ROW_NUMBER() OVER(
+                PARTITION BY rbd.dispatch_at::date
+                ORDER BY rbd.dispatch_at DESC
+              ) as reverse_rn
+              , rbd.id
+              , rbd.dispatch_at
+              , rbd.transport_no
+              , rbd.driver_identification
+              , rbd.external_driver
+              , rbd.chit_no
+              , rbd.percentage
+              , rbd.dispatch_to_id
+              , c.name AS diapatch_to_name
+              , rbd.tonnage 
+              FROM raw_block_dispatch rbd
+              LEFT JOIN organizations c ON c.id = rbd.dispatch_to_id
+              ORDER BY rbd.dispatch_to_id, rbd.dispatch_at
+            ) src
+          );
+        `
+      )
+
+      const result: any = await tx.query(
+        `
+          SELECT * FROM temp_monthly_dispatch_to_mill_data
+          ORDER BY "dispatch_at";
+        `
+      )
+
+      const total: any = await tx.query(
+        `
+          select count(*) from temp_monthly_dispatch_to_mill_data;
+        `
+      )
+
+
+      return {
+        items: result.map(itm => {
+          return {
+            ...itm
+          }
+        }), total: total[0].count
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+}