@things-factory/operato-pms 3.8.0 → 3.8.20

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

@@ -0,0 +1,252 @@
+import { EntityManager } from 'typeorm'
+
+import { ListParam } from '@things-factory/shell'
+
+import { Block } from '../../../entities'
+
+// import { buildQuery, ListParam } from '@things-factory/shell'
+
+export const Query = {
+  /**
+   * @param blockId: id of the block
+   * @param yearAndMonth: the format will be something like 202001; combination of year 2020 and month 01
+   * @returns tonnage data with its sorted date
+   */
+  async monthlyTonnageProductions(_: any, { blockId, yearAndMonth }, context: any) {
+    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 result
+    } catch (ex) {
+    }
+  },
+
+  async monthlyYields(_: any, { blockId, yearAndMonth }, context: any) {
+    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 result
+    } catch (ex) {
+    }
+  },
+
+  async weeklyBunchesCount(_: any, { targetDate }, context: any) {
+    if (!targetDate || targetDate == '') targetDate = new Date()
+
+    let bunchesCount = []
+
+    for (let i = 0; i < 7; i++) {
+      bunchesCount.push({
+        date: new Date(targetDate).toLocaleString('default', { day: '2-digit', month: 'short' }),
+        harvestedCount: 0,
+        collectedCount: 0
+        // harvestedCount: Math.floor(Math.random() * 1000) + 500,
+        // collectedCount: Math.floor(Math.random() * 500) + 50
+      })
+      targetDate.setDate(targetDate.getDate() - 1)
+    }
+
+    return bunchesCount.reverse()
+  },
+
+  async tonnageAndBunchesInventories(_: any, { something }, context: any) {
+    return {
+      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: 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/dashboard/index.ts

@@ -0,0 +1,5 @@
+import { Query } from './dashboard-query'
+
+export const DashboardResolver = {
+  Query
+}

package/server/graphql/resolvers/index.ts

@@ -1,16 +1,20 @@
-export * from './block'
 export * from './block-detail'
+export * from './block'
 export * from './daily-block-detail'
-export * from './daily-dispatch'
 export * from './daily-dispatch-detail'
-export * from './daily-harvest'
+export * from './daily-dispatch'
 export * from './daily-harvest-detail'
-export * from './daily-loading'
+export * from './daily-harvest'
 export * from './daily-loading-detail'
 export * from './daily-loading-ramp'
-export * from './organization'
+export * from './daily-loading'
+export * from './dashboard'
 export * from './organization-staff'
+export * from './organization'
 export * from './plantation-inventory'
+export * from './plantation-setting'
 export * from './ramp'
-export * from './report'
 export * from './record-transaction'
+export * from './report'
+
+export * from './truck'

package/server/graphql/resolvers/organization-staff/organization-staff-query.ts

@@ -1,5 +1,7 @@
-import { buildQuery, ListParam, Domain } from '@things-factory/shell'
-import { IsNull, EntityManager } from 'typeorm'
+import { EntityManager, IsNull } from 'typeorm'
+
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
 import { OrganizationStaff as OrganizationStaffEntity } from '../../../entities'
 
 export const Query = {
@@ -15,7 +17,7 @@ export const Query = {
   async organizationStaffs(_: any, params: ListParam, context: any) {
     const { tx }: { tx: EntityManager } = context.state
 
-    const queryBuilder = tx.getRepository(OrganizationStaffEntity).createQueryBuilder()
+    const queryBuilder = await tx.getRepository(OrganizationStaffEntity).createQueryBuilder()
     buildQuery(queryBuilder, params, context)
 
     queryBuilder
@@ -27,7 +29,14 @@ export const Query = {
     if (params.filters?.length > 0) queryBuilder.andWhere('OrganizationStaff.deletedAt IS NULL')
     else queryBuilder.where('OrganizationStaff.deletedAt IS NULL')
 
-    const [items, total] = await queryBuilder.getManyAndCount()
+    let [items, total] = await queryBuilder.getManyAndCount()
+
+    items = items.map(item => {
+      return {
+        ...item,
+        organizationName: item.organization?.name
+      }
+    })
 
     return { items, total }
   }

package/server/graphql/resolvers/plantation-setting/create-plantation-setting.ts

@@ -0,0 +1,16 @@
+import { getRepository } from 'typeorm'
+import { PlantationSetting } from '../../../entities'
+
+export const createPlantationSetting = {
+  async createPlantationSetting(_: any, { plantationSetting }, context: any) {
+    const { domain, user } = context.state
+
+    return await getRepository(PlantationSetting).save({
+      ...plantationSetting,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+}
+

package/server/graphql/resolvers/plantation-setting/delete-plantation-setting.ts

@@ -0,0 +1,13 @@
+import { getRepository } from 'typeorm'
+import { PlantationSetting } from '../../../entities'
+
+export const deletePlantationSetting = {
+  async deletePlantationSetting(_: any, { name }, context: any) {
+    const { domain, user } = context.state
+
+    await getRepository(PlantationSetting).delete({ domain, name })
+    
+    return true
+  }
+}
+

package/server/graphql/resolvers/plantation-setting/delete-plantation-settings.ts

@@ -0,0 +1,16 @@
+import { getRepository, In } from 'typeorm'
+import { PlantationSetting } from '../../../entities'
+
+export const deletePlantationSettings = {
+  async deletePlantationSettings(_: any, { names }, context: any) {
+    const { domain, user } = context.state
+
+    await getRepository(PlantationSetting).delete({ 
+        domain,
+        name: In(names)
+    })
+    
+    return true
+  }
+}
+

package/server/graphql/resolvers/plantation-setting/index.ts

@@ -0,0 +1,19 @@
+import { Query, PlantationSetting } from './plantation-setting-query'
+
+import { updatePlantationSetting } from './update-plantation-setting'
+import { updateMultiplePlantationSetting } from './update-multiple-plantation-setting'
+import { createPlantationSetting } from './create-plantation-setting'
+import { deletePlantationSetting } from './delete-plantation-setting'
+import { deletePlantationSettings } from './delete-plantation-settings'
+
+export const PlantationSettingResolver = {
+  PlantationSetting,
+  Query,
+  Mutation: {
+    ...updatePlantationSetting,
+    ...updateMultiplePlantationSetting,
+    ...createPlantationSetting,
+    ...deletePlantationSetting,
+    ...deletePlantationSettings
+  }
+}

package/server/graphql/resolvers/plantation-setting/plantation-setting-query.ts

@@ -0,0 +1,38 @@
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { PlantationSetting as PlantationSettingEntity } from '../../../entities'
+
+export const Query = {
+  async plantationSetting(_: any, { name }, context: any) {
+    const { domain, user } = context.state
+    const repository = getRepository(PlantationSettingEntity)
+
+    return await repository.findOne({
+      where: { domain, name }
+    })
+  },
+
+  async plantationSettings(_: any, params: ListParam, context: any) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(PlantationSettingEntity).findAndCount({
+      ...convertedParams
+    })
+    
+    return { items, total }
+  }
+}
+
+export const PlantationSetting = {
+  async domain(plantationSetting) {
+    return await getRepository(Domain).findOne(plantationSetting.domainId)
+  },
+
+  async creator(plantationSetting) {
+    return await getRepository(User).findOne(plantationSetting.creatorId)
+  },
+
+  async updater(plantationSetting) {
+    return await getRepository(User).findOne(plantationSetting.updaterId)
+  }
+}

package/server/graphql/resolvers/plantation-setting/update-multiple-plantation-setting.ts

@@ -0,0 +1,46 @@
+import { getRepository } from 'typeorm'
+import { PlantationSetting } from '../../../entities'
+
+export const updateMultiplePlantationSetting = {
+  async updateMultiplePlantationSetting(_: any, { patches }, context: any) {
+    const { domain, user } = context.state
+    
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const plantationSettingRepo = getRepository(PlantationSetting)
+
+    if (_createRecords.length > 0) {
+        for (let i = 0; i < _createRecords.length; i++) {
+          const newRecord = _createRecords[i]
+          
+          const result = await plantationSettingRepo.save({
+            ...newRecord,
+            domain: domain,
+            creator: user,
+            updater: user,
+          })
+          
+          results.push({ ...result, cuFlag: '+' })
+        }
+    }
+
+    if (_updateRecords.length > 0) {
+        for (let i = 0; i < _updateRecords.length; i++) {
+          const newRecord = _updateRecords[i]
+          const plantationSetting = await plantationSettingRepo.findOne({ domain, id: newRecord.id})
+  
+          const result = await plantationSettingRepo.save({
+            ...plantationSetting,
+            ...newRecord,
+            updater: user
+          })
+  
+          results.push({ ...result, cuFlag: 'M' })
+        }
+    }
+  
+    return results
+  }
+}
+

package/server/graphql/resolvers/plantation-setting/update-plantation-setting.ts

@@ -0,0 +1,19 @@
+import { getRepository } from 'typeorm'
+import { PlantationSetting } from '../../../entities'
+
+export const updatePlantationSetting = {
+  async updatePlantationSetting(_: any, { name, patch }, context: any) {
+    const { domain, user } = context.state
+
+    const repository = getRepository(PlantationSetting)
+    const plantationSetting = await repository.findOne({ 
+      where: { domain, name }
+    })
+
+    return await repository.save({
+      ...plantationSetting,
+      ...patch,
+      updater: user
+    })
+  }
+}

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