@things-factory/operato-pms 3.8.13 → 3.8.14

package/server/graphql/resolvers/dashboard/dashboard-query.ts

@@ -1,4 +1,8 @@
-// import { EntityManager } from 'typeorm'
+import { EntityManager } from 'typeorm'
+
+import { ListParam } from '@things-factory/shell'
+
+import { Block } from '../../../entities'
 
 // import { buildQuery, ListParam } from '@things-factory/shell'
 
@@ -9,57 +13,55 @@ export const Query = {
    * @returns tonnage data with its sorted date
    */
   async monthlyTonnageProductions(_: any, { blockId, yearAndMonth }, context: any) {
-    if (blockId == 'ALL_BLOCKS') {
-      // should remove block filter
-      // 'ALL_BLOCKS' was hardcoded from dashboard
-    }
-
-    const year: string = yearAndMonth.substring(0, 4)
-    const month: string = yearAndMonth.substring(4)
-
-    let data = []
-
-    for (let i = 1, l = new Date(Number(year), Number(month), 0).getDate(); i <= l; i++) {
-      let theDate = new Date(`${year}-${month}-${i}`)
-      theDate.setHours(8, 0, 0, 0)
-
-      data.push({
-        blockId,
-        tonnage: Math.floor(Math.random() * 1000) + 200, // generate random value within 200-1000
-        year,
-        month,
-        date: theDate.toLocaleString('default', { day: '2-digit', month: 'short' })
+    try {
+      const { tx }: { tx: EntityManager } = context.state
+
+      const year = parseInt(yearAndMonth.substring(0, 4))
+      const month = parseInt(yearAndMonth.substring(4))
+
+      let data: any[] = await getDailyProductionData(blockId, year, month, tx);
+      let result = []
+
+      result = data.map(itm => {
+        return {
+          ...itm,
+          blockId,
+          tonnage: itm.todayWeightCollected,
+          year: itm.dateDay.getFullYear(),
+          month: itm.dateDay.getMonth(),
+          date: itm.dateDay.toLocaleString('default', { day: '2-digit', month: 'short' })
+        }
       })
-    }
 
-    return data.sort((a, b) => (a.date > b.date ? 1 : -1))
+      return result
+    } catch (ex) {
+    }
   },
 
   async monthlyYields(_: any, { blockId, yearAndMonth }, context: any) {
-    if (blockId == 'ALL_BLOCKS') {
-      // should remove block filter
-      // 'ALL_BLOCKS' was hardcoded from dashboard
-    }
-
-    const year: string = yearAndMonth.substring(0, 4)
-    const month: string = yearAndMonth.substring(4)
-
-    let data = []
-
-    for (let i = 1, l = new Date(Number(year), Number(month), 0).getDate(); i <= l; i++) {
-      let theDate = new Date(`${year}-${month}-${i}`)
-      theDate.setHours(8, 0, 0, 0)
-
-      data.push({
-        blockId,
-        yield: Math.floor(Math.random() * 1000) + 200, // generate random value within 200-1000
-        year,
-        month,
-        date: theDate.toLocaleString('default', { day: '2-digit', month: 'short' })
+    try {
+      const { tx }: { tx: EntityManager } = context.state
+
+      const year = parseInt(yearAndMonth.substring(0, 4))
+      const month = parseInt(yearAndMonth.substring(4))
+
+      let data: any[] = await getDailyProductionData(blockId, year, month, tx);
+      let result = []
+
+      result = data.map(itm => {
+        return {
+          ...itm,
+          blockId,
+          yield: (itm.todayHectareCover != 0 ? itm.todayWeightCollected / itm.todayHectareCover : 0).toFixed(4),
+          year: itm.dateDay.getFullYear(),
+          month: itm.dateDay.getMonth(),
+          date: itm.dateDay.toLocaleString('default', { day: '2-digit', month: 'short' })
+        }
       })
-    }
 
-    return data.sort((a, b) => (a.date > b.date ? 1 : -1))
+      return result
+    } catch (ex) {
+    }
   },
 
   async weeklyBunchesCount(_: any, { targetDate }, context: any) {
@@ -70,8 +72,10 @@ export const Query = {
     for (let i = 0; i < 7; i++) {
       bunchesCount.push({
         date: new Date(targetDate).toLocaleString('default', { day: '2-digit', month: 'short' }),
-        harvestedCount: Math.floor(Math.random() * 1000) + 500,
-        collectedCount: Math.floor(Math.random() * 500) + 50
+        harvestedCount: 0,
+        collectedCount: 0
+        // harvestedCount: Math.floor(Math.random() * 1000) + 500,
+        // collectedCount: Math.floor(Math.random() * 500) + 50
       })
       targetDate.setDate(targetDate.getDate() - 1)
     }
@@ -81,16 +85,168 @@ export const Query = {
 
   async tonnageAndBunchesInventories(_: any, { something }, context: any) {
     return {
-      bunches: Math.floor(Math.random() * 10000) + 500,
-      tonnage: Math.floor(Math.random() * 10000) + 500
+      bunches: 0,
+      tonnage: 0
+      // bunches: Math.floor(Math.random() * 10000) + 500,
+      // tonnage: Math.floor(Math.random() * 10000) + 500
     }
   },
 
   async productionsOverview(_: any, { something }, context: any) {
     return {
-      averageBunchWeight: Math.floor(Math.random() * 150) + 70,
-      bunchesCount: Math.floor(Math.random() * 10000) + 500,
-      tonnageWeighed: Math.floor(Math.random() * 10000) + 500
+      averageBunchWeight: 0,
+      bunchesCount: 0,
+      tonnageWeighed: 0,
+      // averageBunchWeight: Math.floor(Math.random() * 150) + 70,
+      // bunchesCount: Math.floor(Math.random() * 10000) + 500,
+      // tonnageWeighed: Math.floor(Math.random() * 10000) + 500
     }
   }
 }
+
+
+export async function getDailyProductionData(
+  blockId: String,
+  year: number,
+  month: number,
+  tx: EntityManager
+): Promise<any> {
+  await tx.query(`
+    CREATE TEMP TABLE temp_blocks on commit drop AS (
+      WITH RECURSIVE b AS (   
+        SELECT b.id AS block_id, * FROM blocks b 
+        WHERE b.deleted_at IS null
+        UNION ALL
+        SELECT b.id AS block_id, cb.* FROM blocks cb
+        INNER JOIN b ON b.id = cb.parent_block_id
+        WHERE cb.deleted_at IS null
+      )
+      SELECT block_id, id, name FROM b 
+      ${blockId != 'all-blocks' && blockId != '' ? `WHERE block_id = '${blockId}' or id = '${blockId}'` : ``}
+      GROUP BY block_id, id, name 
+      ORDER BY block_id, id, name 
+    );
+  `)
+
+  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 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' OR transaction_type = 'BUNCHES_ADJUSTMENT' then field_bunches else 0 end) as today_bunch_harvest,
+      sum(case when transaction_type = 'LOADING' OR transaction_type = 'LOADING_ADJUSTMENT' then -field_bunches else 0 end) as today_bunch_collected,
+      round(sum(case when transaction_type = 'LOADING' OR transaction_type = 'LOADING_ADJUSTMENT' then ramp_weight else 0 end)::numeric,4) as today_ramp_weight_collected,
+      round(sum(case when transaction_type = 'DISPATCHMENT' OR transaction_type = 'DISPATCHMENT_ADJUSTMENT' then -ramp_weight else 0 end)::numeric,4) as today_weight_dispatch,	  
+      transaction_date
+      from record_transactions t2
+      inner join temp_blocks blk on blk.id = t2.block_id
+      where transaction_date <= $1
+      group by blk.block_id, transaction_date
+    )
+  `,
+    [toDateString]
+  )
+
+  await tx.query(
+    `
+    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,
+      prev_weight_bal_in_ramp + today_ramp_weight_collected - today_weight_dispatch as today_weight_bal_in_ramp FROM (
+        select md.dateDay as date_day,
+        coalesce(
+        (
+          select sum(today_field_bunches) from temp_records t2 
+          where transaction_date::timestamp < md.dateDay
+        )
+        , 0) as prev_bunch_bal_in_field,
+        coalesce(
+        (
+          select sum(today_ramp_weight) from temp_records t2 
+          where transaction_date::timestamp < md.dateDay
+        )
+        , 0) as prev_weight_bal_in_ramp,
+        coalesce(today_bunch_harvest, 0) as today_bunch_harvest,
+        coalesce(sum(today_bunch_harvest) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_bunch_harvest,
+        coalesce(today_bunch_collected, 0) as today_bunch_collected, 
+        coalesce(sum(today_bunch_collected) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_bunch_collected,
+        coalesce(today_ramp_weight_collected, 0) as today_ramp_weight_collected, 
+        coalesce(sum(today_ramp_weight_collected) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_ramp_weight_collected,
+        coalesce(today_weight_dispatch, 0) as today_weight_dispatch, 
+        coalesce(sum(today_weight_dispatch) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_weight_dispatch,
+        coalesce(tot.today_out_turn, 0) as today_out_turn,
+        coalesce(sum(tot.today_out_turn) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_out_turn,
+        ${blockId != 'all-blocks' && blockId != '' ? `(select name from blocks b2 WHERE id = '${blockId}')` : `''`} as block,
+        coalesce(thr.today_harvesting_round, 0) as today_harvesting_round,
+        coalesce(thr.today_hectare_cover, 0) as today_hectare_cover
+        from 
+        (select generate_series((date '${fromDateString}')::timestamp, (date '${toDateString}')::timestamp, interval '1 day')::date as dateDay) as md 
+        left join (
+          select * from temp_records trx
+          where transaction_date between $1 and $2 
+          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 
+          inner join temp_blocks blk on blk.id = dh.block_id
+          where harvest_date between $1 and $2
+          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 
+          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
+          GROUP BY blk.block_id, dh.harvest_date
+        ) as tot ON tot.harvest_date::date = md.dateDay
+      ) dt
+    )`,
+    [fromDateString, toDateString]
+  )
+
+  const result: any = await tx.query(`
+    select * from temp_daily_production_data dt
+  `)
+
+  return result.map(itm => {
+    return {
+      block: itm.block,
+      dateDay: itm.date_day,
+      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: 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: parseFloat(itm.today_hectare_cover).toFixed(4),
+      todayOutTurn: itm.today_out_turn,
+      todayWeightCollected: parseFloat(itm.today_ramp_weight_collected).toFixed(4),
+      todayWeightBalInRamp: parseFloat(itm.today_weight_bal_in_ramp).toFixed(4),
+      todayWeightDispatch: parseFloat(itm.today_weight_dispatch).toFixed(4),
+    }
+  })
+
+}

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

@@ -0,0 +1,138 @@
+import { EntityManager, getRepository, Not, IsNull } from 'typeorm'
+
+import { ListParam, Domain } from '@things-factory/shell'
+import { Block, Organization, Ramp } from '../../../entities'
+
+export const dailyFfbDispatchProductionReports = {
+  async dailyFfbDispatchProductionReports(_: 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']
+      })
+
+      let organizations = await getRepository(Organization).find({
+        where: { domain: domain.id, deletedAt: IsNull() }
+      })
+
+      let blocks = await tx.getRepository(Block).query(`
+        SELECT b.id, b.name FROM ramps r
+        INNER JOIN blocks b ON b.id = r.block_id 
+        WHERE b.deleted_at IS NULL
+        AND r.domain_id = $1
+        GROUP BY b.id, b.name         
+      `, [domain.id])
+
+
+      // --  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 "name", "dispatch_at", sum(weight) AS weight	FROM(
+              SELECT * FROM (
+                SELECT dd.id,COALESCE(b.name, 'unknown') AS name, 1 AS "rank", dd.dispatch_at::date AS dispatch_at,
+                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::date between $1 and $2
+                UNION
+                SELECT dd.id, COALESCE(c.name, 'unknown') AS name, CASE WHEN c.name IS NULL THEN 3 ELSE 2 END AS "rank", dd.dispatch_at::date AS dispatch_at,
+                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 weight	
+                FROM daily_dispatches dd 
+                LEFT JOIN organizations c ON c.id = dd.dispatch_to_id
+                WHERE dd.dispatch_at::date between $1 and $2
+              ) foo 
+              ORDER BY "rank", "name", "dispatch_at"
+            ) foo
+            GROUP BY "name", "dispatch_at"
+            ORDER BY name, "dispatch_at"
+          )          
+        `,
+        [fromDateString, toDateString]
+      )
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE pivot_block_dispatch ON COMMIT DROP AS (
+            SELECT * FROM crosstab(
+              $$
+                SELECT rbd."dispatch_at",  rbd."name",
+                CONCAT('today: ', round(rbd.weight,2)::varchar, ' | todate: ', round(coalesce(sum(rbd.weight) over (PARTITION BY "name" ORDER BY name, dispatch_at asc rows between unbounded preceding and current row), 0),2)::varchar) AS weight
+                FROM raw_block_dispatch rbd
+                ORDER BY rbd."dispatch_at",  rbd."name"
+              $$,
+              $$
+                SELECT b.name FROM ramps r INNER JOIN blocks b ON b.id = r.block_id WHERE r.deleted_at IS NULL AND r.domain_id = '${domain.id}' 
+                GROUP BY b.id, b.name
+                UNION
+                SELECT c.name FROM organizations c
+              $$
+            ) AS (dispatch_at date, ${[...blocks.map(block => `"${block.name}" varchar`), ...organizations.map(organization => `"${organization.name}" varchar`)].join(',')},"unknown" varchar)
+          );
+        `
+      )
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE temp_monthly_production_data ON COMMIT DROP AS (
+            SELECT TO_CHAR(md.dateDay:: DATE, 'dd/mm/yyyy') as "date"
+            , row_to_json((SELECT d FROM (SELECT ${[...blocks.map(block => `pbd."${block.name}"`), ...organizations.map(organization => `pbd."${organization.name}"`)].join(',')}, pbd."unknown") d))::varchar as "blockData"
+            , (SELECT sum(weight) FROM raw_block_dispatch rbd WHERE rbd.dispatch_at = pbd.dispatch_at) AS "today"
+            FROM (select generate_series((date '${fromDateString}')::timestamp, (date '${toDateString}')::timestamp, interval '1 day')::date as dateDay) as md 
+            LEFT JOIN pivot_block_dispatch pbd on pbd.dispatch_at::date = md.dateDay
+          );
+        `
+      )
+
+      const result: any = await tx.query(
+        `
+          select "date", "blockData", "today"
+          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/daily-production-reports.ts

@@ -52,10 +52,10 @@ export const dailyProductionReports = {
         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,
-          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,	  
+          sum(case when transaction_type = 'HARVEST' OR transaction_type = 'BUNCHES_ADJUSTMENT' then field_bunches else 0 end) as today_bunch_harvest,
+          sum(case when transaction_type = 'LOADING' OR transaction_type = 'LOADING_ADJUSTMENT' then -field_bunches else 0 end) as today_bunch_collected,
+          round(sum(case when transaction_type = 'LOADING' OR transaction_type = 'LOADING_ADJUSTMENT' then ramp_weight else 0 end)::numeric,4) as today_ramp_weight_collected,
+          round(sum(case when transaction_type = 'DISPATCHMENT' OR transaction_type = 'DISPATCHMENT_ADJUSTMENT' then -ramp_weight else 0 end)::numeric,4) as today_weight_dispatch,	  
           transaction_date
           from record_transactions t2
           inner join temp_blocks blk on blk.id = t2.block_id
@@ -127,11 +127,11 @@ export const dailyProductionReports = {
       )
 
       const result: any = await tx.query(`
-            select * from temp_daily_production_data dt
+        select * from temp_daily_production_data dt
       `)
 
       const total: any = await tx.query(`
-          select count(*) from temp_daily_production_data
+        select count(*) from temp_daily_production_data
       `)
 
       let items = result.map(itm => {

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

@@ -5,6 +5,7 @@ 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'
+import { dailyFfbDispatchProductionReports } from './daily-ffb-dispatch-production-reports'
 
 export const ReportResolver = {
   Query: {
@@ -14,7 +15,8 @@ export const ReportResolver = {
     ...yearlyProductionReports,
     ...dailyStaffHarvestReports,
     ...monthlyBlockDispatchReports,
-    ...monthlyFfbSaleReports
+    ...monthlyFfbSaleReports,
+    ...dailyFfbDispatchProductionReports
   },
   Mutation: {}
 }

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

@@ -1,7 +1,7 @@
 import { EntityManager, getRepository, Not, IsNull } from 'typeorm'
 
 import { ListParam, Domain } from '@things-factory/shell'
-import { Ramp } from '../../../entities'
+import { Block, Ramp } from '../../../entities'
 
 export const monthlyBlockDispatchReports = {
   async monthlyBlockDispatchReports(_: any, params: ListParam, context: any) {
@@ -27,11 +27,13 @@ export const monthlyBlockDispatchReports = {
         String(toDate.getDate()).padStart(2, '0')
       ].join('-')
 
-      let ramps = await getRepository(Ramp).find({
-        where: { domain: domain.id, deletedAt: IsNull() },
-        relations: ['block']
-      })
-
+      let blocks = await tx.getRepository(Block).query(`
+        SELECT b.id, b.name FROM ramps r
+        INNER JOIN blocks b ON b.id = r.block_id 
+        WHERE b.deleted_at IS NULL
+        AND r.domain_id = $1
+        GROUP BY b.id, b.name
+      `, [domain.id])
 
       // --  WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
       // [fromDateString, toDateString]
@@ -56,8 +58,8 @@ export const monthlyBlockDispatchReports = {
           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(',')})
+              $$SELECT b.name FROM ramps r INNER JOIN blocks b ON b.id = r.block_id WHERE r.deleted_at IS NULL AND r.domain_id = '${domain.id}' GROUP BY b.id, b.name$$
+            ) AS ("id" uuid,  ${blocks.map(block => `"${block.name}" varchar`).join(',')})
           );
         `)
 
@@ -73,7 +75,7 @@ export const monthlyBlockDispatchReports = {
             , 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"
+            , row_to_json((SELECT d FROM (SELECT ${blocks.map(block => `pbd."${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

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

@@ -46,7 +46,7 @@ export const monthlyFfbSaleReports = {
             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 forward_rn = 1 THEN TO_CHAR(dispatch_at:: DATE, 'dd/mm/yyyy') 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",

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

@@ -78,8 +78,8 @@ export const monthlyProductionReports = {
             left join(
               select blk.block_id, sum(total_weight) as total_weight_loaded, sum(total_bunch) as total_bunch_loaded
               from daily_loadings dl 
-              inner join temp_blocks blk on blk.id = dl.block_id
               inner join daily_loading_details dld on dld.daily_loading_id = dl.id
+              inner join temp_blocks blk on blk.id = dld.block_id
               where dl.loading_date::timestamp between $1::timestamp and $2::timestamp
               group by blk.block_id
             ) as loading on loading.block_id = b.id

package/server/graphql/types/report/daily-ffb-dispatch-production-report-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const DailyFfbDispatchProductionReportList = gql`
+  type DailyFfbDispatchProductionReportList {
+    items: [DailyFfbDispatchProductionReport]
+    total: Int
+  }
+`

package/server/graphql/types/report/daily-ffb-dispatch-production-report.ts

@@ -0,0 +1,9 @@
+import gql from 'graphql-tag'
+
+export const DailyFfbDispatchProductionReport = gql`
+  type DailyFfbDispatchProductionReport {
+    date: String
+    blockData: String 
+    today: String 
+  }
+`

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

@@ -12,16 +12,20 @@ export * from './monthly-production-report-list'
 export * from './monthly-production-report'
 export * from './yearly-production-report-list'
 export * from './yearly-production-report'
+export * from './daily-ffb-dispatch-production-report'
+export * from './daily-ffb-dispatch-production-report-list'
 
 export const ReportResolver = gql`
   extend type Query {
     dailyProductionReports(filters: [Filter], pagination: Pagination, sortings: [Sorting]): DailyProductionReportList
       @transaction
+      
     monthlyProductionReports(
       filters: [Filter]
       pagination: Pagination
       sortings: [Sorting]
     ): MonthlyProductionReportList @transaction
+
     yearlyProductionReports(filters: [Filter], pagination: Pagination, sortings: [Sorting]): YearlyProductionReportList
       @transaction
     dailyStaffHarvestReports(
@@ -29,21 +33,30 @@ export const ReportResolver = gql`
       pagination: Pagination
       sortings: [Sorting]
     ): DailyStaffHarvestReportList @transaction
+
     monthlyDispatchSummaryReports(
       filters: [Filter], 
       pagination: Pagination, 
       sortings: [Sorting]
     ): MonthlyDispatchSummaryReportList @transaction
+
     monthlyBlockDispatchReports(
       filters: [Filter], 
       pagination: Pagination, 
       sortings: [Sorting]
     ): MonthlyBlockDispatchReportList @transaction
+
     monthlyFfbSaleReports(
       filters: [Filter], 
       pagination: Pagination, 
       sortings: [Sorting]
     ): MonthlyDispatchSummaryReportList @transaction
+
+    dailyFfbDispatchProductionReports(
+      filters: [Filter], 
+      pagination: Pagination, 
+      sortings: [Sorting]
+    ): DailyFfbDispatchProductionReportList @transaction
   }
   
 `

package/server/utils/core-values.ts

@@ -43,8 +43,8 @@ export async function getDailyBlockCalculatedValues(
           select block_id, transaction_date, 
           (select opening_field_bunches from transactions dt where dt.block_id = trx.block_id and dt.seq = min(trx.seq)) as prev_bunch_bal_in_field,
           0 as prev_weight_bal_in_ramp,
-          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 = 'HARVEST' OR transaction_type = 'BUNCHES_ADJUSTMENT' then field_bunches else 0 end) as today_bunch_harvest,
+          sum(case when transaction_type = 'LOADING' OR transaction_type = 'LOADING_ADJUSTMENT' then -field_bunches else 0 end) as today_bunch_collected,
           0 as today_weight_dispatch, 
           0 as today_weight_bal_in_ramp, 
           (

package/server/utils/transaction-util.ts

@@ -47,7 +47,8 @@ export async function generateTransactionHistory(
   if (
     transactionType === TRANSACTION_TYPE.LOADING ||
     transactionType === TRANSACTION_TYPE.DISPATCHMENT ||
-    transactionType === TRANSACTION_TYPE.TONNAGE_ADJUSTMENT
+    transactionType === TRANSACTION_TYPE.LOADING_ADJUSTMENT ||
+    transactionType === TRANSACTION_TYPE.DISPATCHMENT_ADJUSTMENT
   ) {
     await switchRampStatus(domain, ramp, user, trxMgr)
   }