@things-factory/operato-pms 6.1.83 → 6.1.85

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

@@ -1,84 +0,0 @@
-import { ListParam } from '@things-factory/shell'
-
-import { Block } from '../../../entities'
-
-export const dailyStaffHarvestReports = {
-  async dailyStaffHarvestReports(_: any, params: ListParam, context: ResolverContext) {
-    try {
-      const { tx } = 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 block = await tx
-        .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 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 = blk.block_id
-                where dh.harvest_date::date between $1 and $2
-              ) as dt
-              group by "harvestDate", "blockName", "staffName"
-              order by "staffName", "harvestDate"
-            )
-          `,
-        [fromDateString, toDateString]
-      )
-
-      const result: any = await tx.query(`
-            select * from temp_daily_staff_harvest_data dt
-      `)
-
-      const total: any = await tx.query(`
-          select count(*) from temp_daily_staff_harvest_data
-      `)
-
-      return { items: result, total: total[0].count }
-    } catch (error) {
-      throw error
-    }
-  }
-}

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

@@ -1,22 +0,0 @@
-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'
-import { dailyFfbDispatchProductionReports } from './daily-ffb-dispatch-production-reports'
-
-export const ReportResolver = {
-  Query: {
-    ...dailyProductionReports,
-    ...monthlyProductionReports,
-    ...monthlyDispatchSummaryReports,
-    ...yearlyProductionReports,
-    ...dailyStaffHarvestReports,
-    ...monthlyBlockDispatchReports,
-    ...monthlyFfbSaleReports,
-    ...dailyFfbDispatchProductionReports
-  },
-  Mutation: {}
-}

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

@@ -1,122 +0,0 @@
-import { ListParam } from '@things-factory/shell'
-
-import { Block } from '../../../entities'
-
-export const monthlyBlockDispatchReports = {
-  async monthlyBlockDispatchReports(_: any, params: ListParam, context: ResolverContext) {
-    try {
-      const { domain, tx } = 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 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 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 AND r.domain_id = '${
-                domain.id
-              }' GROUP BY b.id, b.name$$
-            ) AS ("id" uuid,  ${blocks.map(block => `"${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 ${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
-            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

@@ -1,114 +0,0 @@
-import { IsNull } from 'typeorm'
-
-import { ListParam } from '@things-factory/shell'
-
-import { Organization } from '../../../entities'
-
-export const monthlyDispatchSummaryReports = {
-  async monthlyDispatchSummaryReports(_: any, params: ListParam, context: ResolverContext) {
-    try {
-      const { domain, tx } = 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: { id: 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

@@ -1,111 +0,0 @@
-import { ListParam } from '@things-factory/shell'
-
-export const monthlyFfbSaleReports = {
-  async monthlyFfbSaleReports(_: any, params: ListParam, context: ResolverContext) {
-    try {
-      const { domain, tx } = 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 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",
-            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
-    }
-  }
-}

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

@@ -1,117 +0,0 @@
-import { ListParam } from '@things-factory/shell'
-
-export const monthlyProductionReports = {
-  async monthlyProductionReports(_: any, params: ListParam, context: ResolverContext) {
-    try {
-      const { tx } = 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('-')
-
-      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 GROUP BY block_id, id, name ORDER BY block_id, id, name 
-        );
-      `)
-
-      await tx.query(
-        `
-          create temp table temp_monthly_production_data on commit drop as (
-            select b.id, b.name as "block", 
-            coalesce(harvest.total_harvester, 0) as "totalHarvester", 
-            coalesce(harvest.out_turn,0) as "totalOutTurn", 
-            coalesce(harvest.days_worked,0) as "daysWorked", 
-            round(coalesce((harvest.total_bunch_harvested),0)::DECIMAL, 1)::text as "totalBunchHarvested", 
-            round(coalesce((loading.total_weight_loaded),0)::DECIMAL, 4)::TEXT as "production", 
-            round(case when loading.total_weight_loaded <> 0 then (loading.total_bunch_loaded / loading.total_weight_loaded) else '0' end::DECIMAL, 4)::TEXT as "bunchesPerTon",
-            round(case when loading.total_bunch_loaded <> 0 then (loading.total_weight_loaded / loading.total_bunch_loaded) else '0' end::DECIMAL, 4)::TEXT as "bunchesWt",
-            round(coalesce((harvest.total_bunch_harvested / harvest.total_harvest_coverage),0)::DECIMAL, 4)::TEXT as "bunchesPerHectar",
-            round(coalesce((harvest.total_harvest_coverage / block_details.total_hectarage),0)::DECIMAL, 4)::TEXT as "harvestingRd",
-            round(coalesce((loading.total_weight_loaded / harvest.out_turn),0)::DECIMAL, 4)::TEXT as "productivities",
-            coalesce(block_details.total_hectarage::text, '') as "hectarage",
-            round(coalesce((loading.total_bunch_loaded / block_details.total_hectarage),0)::DECIMAL, 4)::TEXT as "yieldPerHectar",
-            round(coalesce((harvest.total_harvest_coverage / harvest.days_worked),0)::DECIMAL, 4)::TEXT as "coveragePerDay",
-            round(coalesce((harvest.total_bunch_harvested / block_details.total_stand),0)::DECIMAL, 4)::TEXT as "bunchesPerPalm",
-            coalesce(block_details.year_planted::text, '') as "yearPlanted",
-            coalesce(block_details.total_stand::text, '') as "totalStand",
-            '' as "rainfall"
-            from blocks b
-            left join(
-              select blk.block_id,
-              count(distinct dhd.organization_staff_id) as total_harvester,
-              count(dhd.id) as out_turn,
-              count(distinct concat(dh.block_id, dh.harvest_date)) as days_worked,
-              sum(dhd.total_bunch_harvested) as total_bunch_harvested,
-              sum(dh.coverage) as total_harvest_coverage
-              from daily_harvests dh 
-              inner join temp_blocks blk on blk.id = dh.block_id
-              inner join daily_harvest_details dhd on dhd.daily_harvest_id = dh.id
-              where dh.harvest_date::timestamp between $1::timestamp and $2::timestamp
-              group by blk.block_id
-            ) as harvest on harvest.block_id = b.id
-            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 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
-            left join(
-              SELECT DISTINCT ON (blk.block_id) bd.*
-              FROM block_details bd 
-              inner join temp_blocks blk on blk.id = bd.block_id
-              where valid_from::timestamp <= $1::timestamp
-              ORDER BY blk.block_id, valid_from desc
-            ) block_details on block_details.block_id = b.id
-            order by b.name
-          )`,
-        [fromDateString, toDateString]
-      )
-
-      const result: any = await tx.query(`
-        select * 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,
-            avgOutTurn: (parseFloat(itm.totalOutTurn) / parseFloat(itm.daysWorked) || 0).toFixed(4)
-          }
-        }),
-        total: total[0].count
-      }
-    } catch (error) {
-      throw error
-    }
-  }
-}

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

@@ -1,101 +0,0 @@
-import { ListParam } from '@things-factory/shell'
-
-export const yearlyProductionReports = {
-  async yearlyProductionReports(_: any, params: ListParam, context: ResolverContext) {
-    try {
-      const { tx } = context.state
-
-      let year = parseInt(params.filters.filter(x => x.name == 'year')[0].value)
-      let fromDate = new Date(year, 0, 1)
-
-      let pastYearDateString = [String(fromDate.getFullYear() - 1).toString(), '01', '01'].join('-')
-
-      let thisYearDateString = [fromDate.getFullYear().toString(), '01', '01'].join('-')
-
-      let nextYearDateString = [String(fromDate.getFullYear() + 1).toString(), '01', '01'].join('-')
-
-      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 GROUP BY block_id, id, name ORDER BY block_id, id, name 
-        );
-      `)
-
-      await tx.query(
-        `
-          create temp table temp_yearly_production_data on commit drop as (
-            select 
-            b.name as "block",
-            coalesce(bd.year_planted::varchar, '-') as "yearPlanted",
-            '' as "estimatedLastFfb",
-            round(coalesce(last_trans.total_ffb, 0)::DECIMAL, 4)::TEXT as "totalLastFfb",
-            '' as "estimatedFfb",
-            round(coalesce(trans.total_ffb, 0)::DECIMAL, 4)::TEXT as "totalFfb",
-            round((case when last_bd.matured_hectarage is not null AND last_bd.matured_hectarage <> 0 then coalesce(last_trans.total_ffb, 0) / last_bd.matured_hectarage else 0 end)::DECIMAL, 4)::TEXT as "lastYieldPerHectarage",
-            round((case when bd.matured_hectarage is not null AND bd.matured_hectarage <> 0 then coalesce(trans.total_ffb, 0) / bd.matured_hectarage else 0 end)::DECIMAL, 4)::TEXT as "yieldPerHectarage",
-            coalesce(bd.matured_hectarage, 0) as "maturedHectarage",
-            coalesce(harvest.total_coverage, 0) as "totalCoverage",
-            round((case when bd.matured_hectarage is not null AND bd.matured_hectarage <> 0 then coalesce(harvest.total_coverage, 0)/ bd.matured_hectarage else 0 end)::DECIMAL, 4)::TEXT as "totalHarvestingRd",
-            round(((1 - abs(case when last_trans.total_ffb is not null AND last_trans.total_ffb <> 0 then coalesce(trans.total_ffb, 0)/last_trans.total_ffb else 1 end)) * 100)::DECIMAL, 4)::TEXT as "actualAgainstLast"
-            from blocks b 
-            left join (
-              SELECT DISTINCT ON (block_id) *
-              FROM block_details bd 
-              where valid_from < $3::timestamp
-              ORDER  BY block_id, valid_from desc
-            ) bd on bd.block_id = b.id
-            left join (
-              SELECT DISTINCT ON (block_id) *
-              FROM block_details bd 
-              where valid_from < $2::timestamp
-              ORDER  BY block_id, valid_from desc
-            ) last_bd on last_bd.block_id = b.id
-            left join (
-              select blk.block_id, sum(ramp_weight) as total_ffb 
-              from record_transactions t               
-              inner join temp_blocks blk on blk.id = t.block_id
-              where transaction_type = 'LOADING' 
-              and transaction_date::timestamp between $2::timestamp and $3::timestamp
-              group by blk.block_id
-            ) trans on trans.block_id = b.id
-            left join (
-              select blk.block_id, sum(ramp_weight) as total_ffb 
-              from record_transactions t 
-              inner join temp_blocks blk on blk.id = t.block_id
-              where transaction_type = 'LOADING' 
-              and transaction_date::timestamp between $1::timestamp and $2::timestamp
-              group by blk.block_id
-            ) last_trans on last_trans.block_id = b.id
-            left join (
-              select blk.block_id, sum(coverage) as total_coverage 
-              from daily_harvests dh
-              inner join temp_blocks blk on blk.id = dh.block_id
-              where harvest_date::timestamp between $2::timestamp and $3::timestamp
-              group by blk.block_id
-            ) harvest on harvest.block_id = b.id
-            order by b.name 
-          )`,
-        [pastYearDateString, thisYearDateString, nextYearDateString]
-      )
-
-      const result: any = await tx.query(`
-        select * from temp_yearly_production_data dt
-      `)
-
-      const total: any = await tx.query(`
-        select count(*) from temp_yearly_production_data
-      `)
-
-      return { items: result, total: total[0].count }
-    } catch (error) {
-      throw error
-    }
-  }
-}