@things-factory/operato-pms 4.3.595 → 4.3.601

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

@@ -6,7 +6,7 @@ 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
+      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])
@@ -36,14 +36,16 @@ export const dailyFfbDispatchProductionReports = {
         where: { domain: domain.id, deletedAt: IsNull() }
       })
 
-      let blocks = await tx.getRepository(Block).query(`
+      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])
-
+      `,
+        [domain.id]
+      )
 
       // --  WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
       // [fromDateString, toDateString]
@@ -52,44 +54,67 @@ export const dailyFfbDispatchProductionReports = {
       await tx.query(
         `
           CREATE TEMP TABLE raw_block_dispatch ON COMMIT DROP AS (
-            SELECT "name", "dispatch_at", sum(weight) AS weight	FROM(
+            SELECT 
+              "name", 
+              "dispatch_at", 
+              SUM(weight::numeric) 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
-                AND b.deleted_at is null
+                SELECT 
+                  rbh.id, 
+                  COALESCE(b.name, 'unknown') AS name, 
+                  1 AS "rank", 
+                  rbh.transaction_date::date AS dispatch_at,
+                  CASE
+                    WHEN rbh.transaction_type = 'DISPATCH' AND rbh.weight < 0 THEN ABS(rbh.weight)
+                    WHEN rbh.transaction_type IN ('REVERSE_DISPATCH', 'TONNAGE_VARIANCE') THEN ABS(rbh.weight)
+                    ELSE 0
+                  END AS weight
+                FROM ramp_block_histories rbh
+                INNER JOIN blocks b ON b.id = rbh.block_id 
+                WHERE rbh.transaction_type IN ('DISPATCH', 'REVERSE_DISPATCH', 'TONNAGE_VARIANCE')
+                  AND rbh.transaction_date::date BETWEEN $1 AND $2
+                  AND b.deleted_at IS NULL
                 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	
+                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
+                WHERE dd.dispatch_at::date BETWEEN $1 AND $2
+                  AND dd.deleted_at IS NULL
               ) foo 
               ORDER BY "rank", "name", "dispatch_at"
             ) foo
             GROUP BY "name", "dispatch_at"
             ORDER BY name, "dispatch_at"
-          )          
+          );        
         `,
         [fromDateString, toDateString]
       )
 
-      await tx.query(`
+      await tx.query(
+        `
         create temp table cross_column ON COMMIT DROP as (
-          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 = $1
+          SELECT b.name FROM blocks b
+          WHERE 1=1  
+          AND b.domain_id = $1
           AND b.deleted_at is null
           GROUP BY b.id, b.name
           UNION
           SELECT c.name FROM organizations c
           where c.deleted_at is null
         )
-      `, [domain.id])
+      `,
+        [domain.id]
+      )
 
       let definedCrossColumn = await tx.query(`
         select string_agg(concat('"', name, '"'),',') as columns from cross_column
@@ -108,7 +133,12 @@ export const dailyFfbDispatchProductionReports = {
               $$
                 SELECT name from cross_column
               $$
-            ) AS (dispatch_at date, ${definedCrossColumn[0].columns.split(',').map(itm => { return itm + ' varchar' }).join(',')} )
+            ) AS (dispatch_at date, ${definedCrossColumn[0].columns
+              .split(',')
+              .map(itm => {
+                return itm + ' varchar'
+              })
+              .join(',')} )
           );
         `
       )
@@ -117,7 +147,12 @@ export const dailyFfbDispatchProductionReports = {
         `
           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 ${definedCrossColumn[0].columns.split(',').map(itm => { return 'pbd.' + itm }).join(',')}) d))::varchar as "blockData"
+            , row_to_json((SELECT d FROM (SELECT ${definedCrossColumn[0].columns
+              .split(',')
+              .map(itm => {
+                return 'pbd.' + itm
+              })
+              .join(',')}) 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
@@ -138,13 +173,13 @@ export const dailyFfbDispatchProductionReports = {
         `
       )
 
-
       return {
         items: result.map(itm => {
           return {
             ...itm
           }
-        }), total: total[0].count
+        }),
+        total: total[0].count
       }
     } catch (error) {
       throw error

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

@@ -32,7 +32,8 @@ export const dailyProductionReports = {
         .getRepository(Block)
         .findOneOrFail({ where: { id: params.filters.filter(x => x.name == 'block')[0].value } })
 
-      await tx.query(`
+      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 
@@ -45,23 +46,36 @@ export const dailyProductionReports = {
           )
           SELECT * FROM b
         );
-      `, [block.id]
+      `,
+        [block.id]
       )
 
-      await tx.query(`
+      await tx.query(
+        `
         CREATE TEMP TABLE temp_records on commit drop AS (	
           SELECT *
           FROM (
-            select blk.block_id, coalesce(sum(field_bunches),0) AS today_field_bunches, 
+            select 
+            blk.block_id, 
+            COALESCE(
+              SUM(
+                CASE
+                  WHEN transaction_type = 'HARVEST' THEN field_bunches
+                  WHEN transaction_type IN ('LOADING', 'LOADING_ADJUSTMENT') THEN -field_bunches
+                  ELSE 0
+                END
+              ), 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,
+            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' and transaction_type = 'LOADING_ADJUSTMENT' 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
             inner join temp_blocks blk on blk.id = t2.block_id
             where transaction_date <= $1
+            and t2.deleted_at is null
             group by blk.block_id, transaction_date
           ) src
         )
@@ -71,69 +85,87 @@ export const dailyProductionReports = {
 
       await tx.query(
         `
-          create temp table temp_daily_production_data on commit drop as (
-            select *,
-            coalesce(sum(today_bunch_harvest) over (order by date_day asc rows between unbounded preceding and current row), 0) as to_date_bunch_harvest,
-            coalesce(sum(today_bunch_collected) over (order by date_day asc rows between unbounded preceding and current row), 0) as to_date_bunch_collected,
-            coalesce(sum(today_ramp_weight_collected) over (order by date_day asc rows between unbounded preceding and current row), 0) as to_date_ramp_weight_collected,
-            coalesce(sum(today_weight_dispatch) over (order by date_day asc rows between unbounded preceding and current row), 0) as to_date_weight_dispatch,
-            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
+          CREATE TEMP TABLE temp_daily_production_data ON COMMIT DROP AS (
+            SELECT 
+              *,
+              COALESCE(SUM(today_bunch_harvest) OVER (ORDER BY date_day ASC ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 0) AS to_date_bunch_harvest,
+              COALESCE(SUM(today_bunch_collected) OVER (ORDER BY date_day ASC ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 0) AS to_date_bunch_collected,
+              COALESCE(SUM(today_ramp_weight_collected) OVER (ORDER BY date_day ASC ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 0) AS to_date_ramp_weight_collected,
+              COALESCE(SUM(today_weight_dispatch) OVER (ORDER BY date_day ASC ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 0) AS to_date_weight_dispatch,
+              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 extract(day from md.dateDay) as date_day,
-              coalesce(
-              (
-                select sum(today_field_bunches) from temp_records t2 
-                where transaction_date::timestamp < md.dateDay
-                and transaction_date between $1 and $2 
-              )
-              , 0) as prev_bunch_bal_in_field,
-              coalesce(
-              (
-                select sum(today_ramp_weight) from temp_records t2 
-                where transaction_date::timestamp < md.dateDay
-                and transaction_date between $1 and $2 
-              )
-              , 0) as prev_weight_bal_in_ramp,
-              coalesce(today_bunch_harvest, 0) as today_bunch_harvest,
-              coalesce(today_bunch_collected, 0) as today_bunch_collected,
-              coalesce(today_ramp_weight_collected, 0) as today_ramp_weight_collected, 
-              COALESCE(-(
-                SELECT sum(weight) FROM ramp_block_histories rbh 
-                inner join temp_blocks blk on blk.id = rbh.block_id
-                where rbh.transaction_date::timestamp = md.dateDay
-                AND rbh.transaction_type='DISPATCH'
-              ),0) AS today_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,
-              (select name from blocks b2 where id = $3) 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
+              SELECT 
+                EXTRACT(DAY FROM md.dateDay) AS date_day,
+                COALESCE(
+                  (SELECT SUM(today_field_bunches) 
+                  FROM temp_records t2 
+                  WHERE transaction_date::timestamp < md.dateDay
+                    AND transaction_date BETWEEN $1 AND $2
+                  ), 0
+                ) AS prev_bunch_bal_in_field,
+                COALESCE(
+                  (SELECT SUM(today_ramp_weight) 
+                  FROM temp_records t2 
+                  WHERE transaction_date::timestamp < md.dateDay
+                    AND transaction_date BETWEEN $1 AND $2
+                  ), 0
+                ) AS prev_weight_bal_in_ramp,
+                COALESCE(today_bunch_harvest, 0) AS today_bunch_harvest,
+                COALESCE(today_bunch_collected, 0) AS today_bunch_collected,
+                COALESCE(today_ramp_weight_collected, 0) AS today_ramp_weight_collected,
+                COALESCE(
+                  (SELECT SUM(
+                    CASE
+                      WHEN rbh.transaction_type = 'DISPATCH' AND rbh.weight < 0 THEN ABS(rbh.weight)
+                      WHEN rbh.transaction_type IN ('REVERSE_DISPATCH', 'TONNAGE_VARIANCE') THEN ABS(rbh.weight)
+                      ELSE 0
+                    END
+                  )
+                  FROM ramp_block_histories rbh
+                  INNER JOIN temp_blocks blk ON blk.id = rbh.block_id
+                  WHERE rbh.transaction_date::timestamp = md.dateDay
+                    AND rbh.transaction_type IN ('DISPATCH', 'REVERSE_DISPATCH', 'TONNAGE_VARIANCE')
+                  ), 0
+                ) AS today_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,
+                (SELECT name FROM blocks b2 WHERE id = $3) 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
+                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 dh.deleted_at IS NULL
+                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
+                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 dhd.deleted_at IS NULL
                 GROUP BY blk.block_id, dh.harvest_date
-              ) as tot ON tot.harvest_date::date = md.dateDay
+              ) AS tot ON tot.harvest_date::date = md.dateDay
             ) dt
-          )`,
+          );`,
         [fromDateString, toDateString, block.id]
       )
 
@@ -174,7 +206,6 @@ export const dailyProductionReports = {
   }
 }
 
-
 // async function updateAllData() {
 //   await getManager().transaction(async txMgr => {
 //     let data = await txMgr.query(`
@@ -182,8 +213,8 @@ export const dailyProductionReports = {
 //         SELECT uuid_generate_v4() AS id, DATE(dd.dispatch_at)::varchar AS transaction_date, 'DISPATCH' AS transaction_type, dd.dispatch_at AS created_at, dd.dispatch_at AS updated_at,
 //         ddd.collected_ramp_weight AS dispatch_weight, '980f20a0-747c-4d04-a870-97a09f6ba807' AS domain_id, ddd.ramp_id, '0933baea-e099-494b-9791-3dfe805731f0' AS creator_id, '0933baea-e099-494b-9791-3dfe805731f0' AS updater_id,
 //         dd.id as daily_dispatch_id
-//         FROM daily_dispatch_details ddd 
-//         INNER JOIN daily_dispatches dd ON dd.id = ddd.daily_dispatch_id 
+//         FROM daily_dispatch_details ddd
+//         INNER JOIN daily_dispatches dd ON dd.id = ddd.daily_dispatch_id
 //         WHERE dd.dispatch_at >='2023-07-01 00:00:00.000'
 //         AND dd.deleted_at IS null
 //       ) src ORDER BY src.ramp_id, src.transaction_date
@@ -195,7 +226,7 @@ export const dailyProductionReports = {
 
 //       let rampBlockHistory = await txMgr.query(`
 //         SELECT * FROM (
-//           SELECT *, ROW_NUMBER () OVER (PARTITION BY ramp_id, block_id ORDER BY transaction_date desc, transaction_type) AS rn FROM ramp_block_histories 
+//           SELECT *, ROW_NUMBER () OVER (PARTITION BY ramp_id, block_id ORDER BY transaction_date desc, transaction_type) AS rn FROM ramp_block_histories
 //           WHERE ramp_id =$1 AND transaction_date <= $2
 //         ) foo WHERE rn = 1
 //       `, [dt.ramp_id, dt.transaction_date])
@@ -215,7 +246,7 @@ export const dailyProductionReports = {
 //         // insert into ramp_block_histories (id,transaction_type, creator_id, updater_id, transaction_date, created_at, updated_at, weight, domain_id, block_id, ramp_id)
 //         let processedData = await txMgr.query(`
 //           insert into ramp_block_histories (id, transaction_type, creator_id, updater_id, transaction_date, created_at, updated_at, domain_id, ramp_id, weight, previous_weight, current_weight, block_id, daily_dispatch_id)
-//           SELECT uuid_generate_v4() AS id, 'DISPATCH' AS transaction_type, 
+//           SELECT uuid_generate_v4() AS id, 'DISPATCH' AS transaction_type,
 //           '0933baea-e099-494b-9791-3dfe805731f0' AS creator_id, '0933baea-e099-494b-9791-3dfe805731f0' AS updater_id,
 //           $1 AS transaction_date, $2 AS created_at, $3 AS updated_at,
 //           $4 AS domain_id, $5 AS ramp_id,
@@ -228,7 +259,7 @@ export const dailyProductionReports = {
 
 //         // await txMgr.query(`
 //         //   SELECT * FROM (
-//         //     SELECT *, ROW_NUMBER () OVER (PARTITION BY ramp_id, block_id ORDER BY transaction_date desc) AS rn FROM ramp_block_histories 
+//         //     SELECT *, ROW_NUMBER () OVER (PARTITION BY ramp_id, block_id ORDER BY transaction_date desc) AS rn FROM ramp_block_histories
 //         //     WHERE ramp_id =$1 AND transaction_date <= $2
 //         //   ) foo WHERE rn = 1
 //         // `, [dt.ramp_id, dt.transaction_date]
@@ -240,4 +271,4 @@ export const dailyProductionReports = {
 //     };
 
 //   })
-// }
+// }

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

@@ -32,7 +32,8 @@ export const dailyStaffHarvestReports = {
         .getRepository(Block)
         .findOneOrFail({ where: { id: params.filters.filter(x => x.name == 'block')[0].value } })
 
-      await tx.query(`
+      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 
@@ -45,7 +46,8 @@ export const dailyStaffHarvestReports = {
           )
           SELECT * FROM b
         );
-      `, [block.id]
+      `,
+        [block.id]
       )
 
       await tx.query(
@@ -60,6 +62,7 @@ export const dailyStaffHarvestReports = {
                 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
+                and dhd.deleted_at is null
               ) as dt
               group by "harvestDate", "blockName", "staffName"
               order by "staffName", "harvestDate"

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

@@ -6,7 +6,7 @@ import { Block, Ramp } from '../../../entities'
 export const monthlyBlockDispatchReports = {
   async monthlyBlockDispatchReports(_: any, params: ListParam, context: any) {
     try {
-      const { domain, tx }: { domain: Domain, tx: EntityManager } = context.state
+      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])
@@ -27,13 +27,16 @@ export const monthlyBlockDispatchReports = {
         String(toDate.getDate()).padStart(2, '0')
       ].join('-')
 
-      let blocks = await tx.getRepository(Block).query(`
+      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])
+      `,
+        [domain.id]
+      )
 
       // --  WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
       // [fromDateString, toDateString]
@@ -49,8 +52,11 @@ export const monthlyBlockDispatchReports = {
           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
+          AND dd.deleted_at is null
+          AND ddd.deleted_at is null
         )
-        `, [fromDateString, toDateString]
+        `,
+        [fromDateString, toDateString]
       )
 
       await tx.query(
@@ -58,10 +64,13 @@ 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 AND r.domain_id = '${domain.id}' GROUP BY b.id, b.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$$
             ) AS ("id" uuid,  ${blocks.map(block => `"${block.name}" varchar`).join(',')})
           );
-        `)
+        `
+      )
 
       await tx.query(
         `
@@ -75,7 +84,9 @@ 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 ${blocks.map(block => `pbd."${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
@@ -99,13 +110,13 @@ export const monthlyBlockDispatchReports = {
         `
       )
 
-
       return {
         items: result.map(itm => {
           return {
             ...itm
           }
-        }), total: total[0].count
+        }),
+        total: total[0].count
       }
     } catch (error) {
       throw error

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

@@ -6,7 +6,7 @@ import { Organization } from '../../../entities'
 export const monthlyDispatchSummaryReports = {
   async monthlyDispatchSummaryReports(_: any, params: ListParam, context: any) {
     try {
-      const { domain, tx }: { domain: Domain, tx: EntityManager } = context.state
+      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])
@@ -27,22 +27,26 @@ export const monthlyDispatchSummaryReports = {
         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 } })
-
+      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
+            COALESCE((SELECT SUM(COALESCE(ddd.adjusted_weight, ddd.collected_ramp_weight, 0)) FROM daily_dispatch_details ddd WHERE ddd.daily_dispatch_id = dd.id AND ddd.deleted_at is null),0) AS tonnage
             FROM daily_dispatches dd 
             WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
             AND dd.dispatch_to_id = $3
+            AND dd.deleted_at is null
           );
-        `, [fromDateString, toDateString, org.id]
+        `,
+        [fromDateString, toDateString, org.id]
       )
 
       await tx.query(
@@ -80,8 +84,8 @@ export const monthlyDispatchSummaryReports = {
               ORDER BY rbd.dispatch_to_id, rbd.dispatch_at
             ) src
           );
-        `)
-
+        `
+      )
 
       const result: any = await tx.query(
         `
@@ -95,13 +99,13 @@ export const monthlyDispatchSummaryReports = {
         `
       )
 
-
       return {
         items: result.map(itm => {
           return {
             ...itm
           }
-        }), total: total[0].count
+        }),
+        total: total[0].count
       }
     } catch (error) {
       throw error