@things-factory/operato-pms 3.7.5 → 3.8.13

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
+    }
+  }
+}

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

@@ -1,6 +1,7 @@
-import { ListParam } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
 
+import { ListParam } from '@things-factory/shell'
+
 export const monthlyProductionReports = {
   async monthlyProductionReports(_: any, params: ListParam, context: any) {
     try {
@@ -25,79 +26,92 @@ export const monthlyProductionReports = {
         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 as (
+          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.out_turn / harvest.days_worked),0)::DECIMAL, 2)::TEXT as "avgOutTurn",
-            round(coalesce((harvest.total_bunch_harvested),0)::DECIMAL, 2)::text as "totalBunchHarvested", 
-            round(coalesce((loading.total_weight_loaded),0)::DECIMAL, 2)::TEXT as "production", 
-            round(case when loading.total_weight_loaded <> 0 then (loading.total_bunch_loaded / loading.total_weight_loaded * 1000) else '0' end::DECIMAL, 2)::TEXT as "bunchesPerTon",
-            round(case when loading.total_bunch_loaded <> 0 then (loading.total_weight_loaded / loading.total_bunch_loaded * 1000) else '0' end::DECIMAL, 2)::TEXT as "bunchesWt",
-            round(coalesce((harvest.total_bunch_harvested / harvest.total_harvest_coverage),0)::DECIMAL, 2)::TEXT as "bunchesPerHectar",
-            round(coalesce((harvest.total_harvest_coverage / block_details.total_hectarage),0)::DECIMAL, 2)::TEXT as "harvestingRd",
-            round(coalesce((loading.total_weight_loaded / harvest.out_turn),0)::DECIMAL, 2)::TEXT as "productivities",
-            coalesce(block_details.total_hectarage::text, '-') as "hectarage",
-            round(coalesce((loading.total_bunch_loaded / block_details.total_hectarage),0)::DECIMAL, 2)::TEXT as "yieldPerHectar",
-            round(coalesce((harvest.total_harvest_coverage / harvest.days_worked),0)::DECIMAL, 2)::TEXT as "coveragePerDay",
-            '-' as "rainfall",
-            round(coalesce((harvest.total_bunch_harvested / block_details.total_stand),0)::DECIMAL, 2)::TEXT as "bunchesPerPalm",
-            coalesce(block_details.year_planted::text, '-') as "yearPlanted",
-            coalesce(block_details.total_stand::text, '-') as "totalStand"
+            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 dh.block_id,
+              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 dh.block_id
+              group by blk.block_id
             ) as harvest on harvest.block_id = b.id
             left join(
-              select dl.block_id, sum(total_weight) as total_weight_loaded, sum(total_bunch) as total_bunch_loaded
+              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
               where dl.loading_date::timestamp between $1::timestamp and $2::timestamp
-              group by dl.block_id
+              group by blk.block_id
             ) as loading on loading.block_id = b.id
             left join(
-              SELECT DISTINCT ON (block_id)
-                *
+              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 block_id, valid_from desc
+              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 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
-          `
-      )
+      const total: any = await tx.query(`
+        select count(*) from temp_monthly_production_data
+      `)
 
-      await tx.query(
-        `
-            drop table temp_monthly_production_data
-          `
-      )
 
-      return { items: result, total: total[0].count }
+      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,6 +1,7 @@
-import { ListParam } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
 
+import { ListParam } from '@things-factory/shell'
+
 export const yearlyProductionReports = {
   async yearlyProductionReports(_: any, params: ListParam, context: any) {
     try {
@@ -15,80 +16,84 @@ export const yearlyProductionReports = {
 
       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 as (
+          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",
-            coalesce(last_trans.total_ffb, 0) as "totalLastFfb",
-            '-' as "estimatedFfb",
-            coalesce(trans.total_ffb, 0) as "totalFfb",
-            case when last_bd.matured_hectarage is not null then coalesce(last_trans.total_ffb, 0) / last_bd.matured_hectarage else 0 end as "lastYieldPerHectarage",
-            case when bd.matured_hectarage is not null then coalesce(trans.total_ffb, 0) / bd.matured_hectarage else 0 end as "yieldPerHectarage",
+            '' 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",
-            case when bd.matured_hectarage is not null then coalesce(harvest.total_coverage, 0)/ bd.matured_hectarage else 0 end as "totalHarvestingRd",
-            (1 - abs(case when last_trans.total_ffb is not null then coalesce(trans.total_ffb, 0)/last_trans.total_ffb else 1 end)) * 100 as "actualAgainstLast"
+            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)
-              *
+              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)
-              *
+              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 t.block_id, sum(ramp_weight) as total_ffb 
-              from record_transactions t 
+              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 block_id
+              group by blk.block_id
             ) trans on trans.block_id = b.id
             left join (
-              select t.block_id, sum(ramp_weight) as total_ffb 
+              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 block_id
+              group by blk.block_id
             ) last_trans on last_trans.block_id = b.id
             left join (
-              select dh.block_id, sum(coverage) as total_coverage 
+              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 block_id
+              group by blk.block_id
             ) harvest on harvest.block_id = b.id
-            where b.has_children = false 
             order by b.name 
           )`,
         [pastYearDateString, thisYearDateString, nextYearDateString]
       )
 
-      const result: any = await tx.query(
-        `
-            select * from temp_yearly_production_data dt
-          `
-      )
+      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
-          `
-      )
-
-      await tx.query(
-        `
-            drop table temp_yearly_production_data
-          `
-      )
+      const total: any = await tx.query(`
+        select count(*) from temp_yearly_production_data
+      `)
 
       return { items: result, total: total[0].count }
     } catch (error) {

package/server/graphql/resolvers/truck/delete-trucks.ts

@@ -0,0 +1,21 @@
+import { In } from 'typeorm'
+
+import { Truck } from '../../../entities'
+
+export const deleteTrucks = {
+  async deleteTrucks(_: any, { ids }, context: any) {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Truck).update(
+      {
+        domain,
+        id: In(ids)
+      },
+      {
+        deletedAt: new Date()
+      }
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,12 @@
+import { deleteTrucks } from './delete-trucks'
+import { Query, Truck } from './truck-query'
+import { updateMultipleTruck } from './update-multiple-truck'
+
+export const TruckResolver = {
+  Truck,
+  Query,
+  Mutation: {
+    ...updateMultipleTruck,
+    ...deleteTrucks
+  }
+}

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

@@ -0,0 +1,52 @@
+import { EntityManager, getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
+import { Truck as TruckEntity } from '../../../entities'
+
+export const Query = {
+  async truck(_: any, { name }, context: any) {
+    const { domain, tx } = context.state
+    const repository = await tx.getRepository(TruckEntity)
+
+    return await repository.findOne({
+      where: { domain, name },
+      relations: ['domain', 'organization', 'creator', 'updater']
+    })
+  },
+
+  async trucks(_: any, params: ListParam, context: any) {
+    const { tx }: { tx: EntityManager } = context.state
+
+    const queryBuilder = await tx.getRepository(TruckEntity).createQueryBuilder()
+    buildQuery(queryBuilder, params, context)
+
+    queryBuilder
+      .leftJoinAndSelect('Truck.domain', 'Domain')
+      .leftJoinAndSelect('Truck.organization', 'Organization')
+      .leftJoinAndSelect('Truck.creator', 'Creator')
+      .leftJoinAndSelect('Truck.updater', 'Updater')
+
+    if (params.filters?.length > 0) queryBuilder.andWhere('Truck.deletedAt IS NULL')
+    else queryBuilder.where('Truck.deletedAt IS NULL')
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+}
+
+export const Truck = {
+  async domain(truck) {
+    return await getRepository(Domain).findOne(truck.domainId)
+  },
+
+  async creator(truck) {
+    return await getRepository(User).findOne(truck.creatorId)
+  },
+
+  async updater(truck) {
+    return await getRepository(User).findOne(truck.updaterId)
+  }
+}

package/server/graphql/resolvers/truck/update-multiple-truck.ts

@@ -0,0 +1,55 @@
+import { Organization, Truck } from '../../../entities'
+
+export const updateMultipleTruck = {
+  async updateMultipleTruck(_: any, { patches }, context: any) {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const truckRepo = tx.getRepository(Truck)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const organization = await tx.getRepository(Organization).findOneOrFail({
+          where: { id: newRecord?.organization?.id }
+        })
+
+        const result = await truckRepo.save({
+          ...newRecord,
+          domain: domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        let newRecord = _updateRecords[i]
+        const truck = await truckRepo.findOne({ domain, id: newRecord.id })
+
+        if (newRecord?.organization?.id) {
+          const organization = await tx.getRepository(Organization).findOneOrFail({
+            where: { id: newRecord?.organization?.id }
+          })
+          newRecord = { ...newRecord, organization }
+        }
+
+        const result = await truckRepo.save({
+          ...truck,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/types/daily-dispatch/daily-dispatch-patch.ts

@@ -5,10 +5,13 @@ export const DailyDispatchPatch = gql`
     id: String
     name: String
     description: String
+    transport: ObjectRef
     transportNo: String
+    chitNo: String
+    percentage: Float
     driverIdentification: String
     totalTonnageRelease: Float
-    dispatchTo: String
+    dispatchTo: ObjectRef
     dispatchAt: String
     externalDriver: String
     driver: ObjectRef

package/server/graphql/types/daily-dispatch/daily-dispatch.ts

@@ -6,8 +6,11 @@ export const DailyDispatch = gql`
     name: String
     domain: Domain
     dispatchAt: String
-    dispatchTo: String
+    dispatchTo: Organization
     driverIdentification: String
+    chitNo: String
+    percentage: Float
+    transport: Truck
     transportNo: String
     driver: OrganizationStaff
     externalDriver: String