@things-factory/operato-pms 3.7.7 → 3.8.19

package/server/graphql/resolvers/daily-loading/update-daily-loading.ts

@@ -1,17 +1,11 @@
+import { EntityManager, getRepository, Repository } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { INVENTORY_TYPE, INVENTORY_STATUS, TRANSACTION_TYPE } from '../../../constants'
-import {
-  Block,
-  DailyLoading,
-  DailyLoadingDetail,
-  DailyLoadingRamp,
-  Ramp,
-  OrganizationStaff,
-  PlantationInventory
-} from '../../../entities'
-import { NoGenerator, generateTransactionHistory } from '../../../utils'
+
+import { INVENTORY_TYPE, TRANSACTION_TYPE } from '../../../constants'
+import { Block, DailyLoading, DailyLoadingDetail, PlantationInventory, Ramp, Truck } from '../../../entities'
+import { generateTransactionHistory, NoGenerator } from '../../../utils'
 
 export const updateDailyLoading = {
   async updateDailyLoading(_: any, { name, dailyLoadingPatch }, context: any) {
@@ -21,23 +15,13 @@ export const updateDailyLoading = {
     let dailyLoading: DailyLoading = await dailyLoadingRepo.findOne({
       where: { name },
       relations: [
-        'block',
         'dailyLoadingDetails',
-        'dailyLoadingDetails.organizationStaff',
-        'dailyLoadingRamps',
-        'dailyLoadingRamps.ramp'
+        'dailyLoadingDetails.truck',
+        'dailyLoadingDetails.ramp',
+        'dailyLoadingDetails.block'
       ]
     })
 
-    const block: Block = await tx.getRepository(Block).findOne({
-      where: { name: dailyLoadingPatch.block }
-    })
-
-    const {
-      totalBunch: prevLoadedBunch,
-      totalWeight: prevLoadedTonnage
-    }: { totalBunch: number; totalWeight: number } = dailyLoading
-
     // get sum of bunch loaded from all trip
     var totalBunch: number = dailyLoadingPatch.dailyLoadingDetails.reduce(function (prev, cur) {
       return prev + cur.totalBunchLoaded
@@ -47,7 +31,6 @@ export const updateDailyLoading = {
       return prev + cur.totalBunchWeight
     }, 0)
 
-    dailyLoading.block = block
     dailyLoading.totalBunch = totalBunch
     dailyLoading.totalWeight = totalWeight
     dailyLoading.loadingDate = dailyLoadingPatch.loadingDate
@@ -56,8 +39,6 @@ export const updateDailyLoading = {
 
     // 2. Create daily loading detail
     await updateDailyLoadingDetail(domain, dailyLoading, dailyLoadingPatch.dailyLoadingDetails, user, tx)
-    await updateDailyLoadingRamp(domain, dailyLoading, dailyLoadingPatch.dailyLoadingRamps, user, tx)
-    await updatePlantationInventory(domain, dailyLoading, prevLoadedBunch, prevLoadedTonnage, block, user, tx)
 
     return dailyLoading
   }
@@ -70,8 +51,9 @@ export async function updateDailyLoadingDetail(
   user: User,
   tx?: EntityManager
 ): Promise<void> {
-  const organizationStaffRepo: Repository<OrganizationStaff> =
-    tx?.getRepository(OrganizationStaff) || getRepository(OrganizationStaff)
+  const truckRepo: Repository<Truck> = tx?.getRepository(Truck) || getRepository(Truck)
+  const blockRepo: Repository<Block> = tx?.getRepository(Block) || getRepository(Block)
+  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
   const dailyLoadingDetailRepo: Repository<DailyLoadingDetail> =
     tx?.getRepository(DailyLoadingDetail) || getRepository(DailyLoadingDetail)
 
@@ -87,25 +69,29 @@ export async function updateDailyLoadingDetail(
 
   if (existingDailyLoadingDetails?.length > 0) {
     updatedDailyLoadingDetails = await Promise.all(
-      dailyLoadingDetails.map(async (record: DailyLoadingDetail) => {
-        const foundDailyLoadingDetailPatch = dailyLoadingDetailPatches.find(detail => detail.name === record.name)
+      dailyLoadingDetails.map(async (existingRecord: DailyLoadingDetail) => {
+        const foundDailyLoadingDetailPatch = dailyLoadingDetailPatches.find(
+          detail => detail.name === existingRecord.name
+        )
 
-        const foundStaff: OrganizationStaff = await organizationStaffRepo.findOne({
-          where: { id: foundDailyLoadingDetailPatch.organizationStaff.id }
-        })
+        if (foundDailyLoadingDetailPatch.totalBunchWeight !== existingRecord.totalBunchWeight) {
+          await updatePlantationInventory(domain, dailyLoading, foundDailyLoadingDetailPatch, existingRecord, user, tx)
+        }
 
         return {
-          ...record,
+          ...existingRecord,
           dailyLoading,
-          organizationStaff: foundStaff,
-          totalBunchLoaded: foundDailyLoadingDetailPatch.totalBunchLoaded,
-          totalBunchWeight: foundDailyLoadingDetailPatch.totalBunchWeight,
-          remark: foundDailyLoadingDetailPatch.remark,
+          truck: await truckRepo.findOne({ id: existingRecord.truck.id }),
+          block: await blockRepo.findOne({ id: existingRecord.block.id }),
+          ramp: await rampRepo.findOne({ id: existingRecord.ramp.id }),
+          totalBunchLoaded: foundDailyLoadingDetailPatch?.totalBunchLoaded || 0,
+          totalBunchWeight: foundDailyLoadingDetailPatch?.totalBunchWeight || 0,
+          remark: foundDailyLoadingDetailPatch?.remark || null,
           updater: user
         }
       })
     )
-    await dailyLoadingDetailRepo.save(updatedDailyLoadingDetails)
+    updatedDailyLoadingDetails = await dailyLoadingDetailRepo.save(updatedDailyLoadingDetails)
   }
 
   if (newDailyLoadingDetail?.length > 0) {
@@ -114,14 +100,13 @@ export async function updateDailyLoadingDetail(
         let newDailyLoadingDetail: DailyLoadingDetail = new DailyLoadingDetail()
         newDailyLoadingDetail.domain = domain
         newDailyLoadingDetail.name = NoGenerator.dailyLoadingDetail()
-        newDailyLoadingDetail.organizationStaff = await organizationStaffRepo.findOne({
-          id: dailyLoadingDetail.organizationStaff.id
-        })
-        newDailyLoadingDetail.totalBunchLoaded = dailyLoadingDetail.totalBunchLoaded
-        newDailyLoadingDetail.totalBunchWeight = dailyLoadingDetail.totalBunchWeight
-        newDailyLoadingDetail.remark = dailyLoadingDetail.remark
+        newDailyLoadingDetail.truck = await truckRepo.findOne({ id: dailyLoadingDetail.truck.id })
+        newDailyLoadingDetail.block = await blockRepo.findOne({ id: dailyLoadingDetail.block.id })
+        newDailyLoadingDetail.ramp = await rampRepo.findOne({ id: dailyLoadingDetail.ramp.id })
+        newDailyLoadingDetail.totalBunchLoaded = dailyLoadingDetail?.totalBunchLoaded || 0
+        newDailyLoadingDetail.totalBunchWeight = dailyLoadingDetail?.totalBunchWeight || 0
+        newDailyLoadingDetail.remark = dailyLoadingDetail?.remark || null
         newDailyLoadingDetail.creator = user
-        newDailyLoadingDetail.updater = user
         newDailyLoadingDetail.dailyLoading = dailyLoading
 
         await dailyLoadingDetailRepo.save(newDailyLoadingDetail)
@@ -130,181 +115,38 @@ export async function updateDailyLoadingDetail(
   }
 }
 
-export async function updateDailyLoadingRamp(
-  domain: Domain,
-  dailyLoading: DailyLoading,
-  dailyLoadingRampPatches: DailyLoadingRamp[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-  const dailyLoadingRampRepo: Repository<DailyLoadingRamp> =
-    tx?.getRepository(DailyLoadingRamp) || getRepository(DailyLoadingRamp)
-
-  let updatedDailyLoadingRamps: any[] = []
-  const dailyLoadingRamps: DailyLoadingRamp[] = dailyLoading.dailyLoadingRamps
-  const existingDailyLoadingRamps: DailyLoadingRamp[] = dailyLoadingRampPatches.filter(detail => detail.name !== null)
-
-  // new row added in client side
-  const newDailyLoadingRamps: DailyLoadingRamp[] = dailyLoadingRampPatches.filter(detail => detail.name === null)
-
-  if (existingDailyLoadingRamps?.length > 0) {
-    // TODO: delete function for removing data
-    updatedDailyLoadingRamps = await Promise.all(
-      dailyLoadingRamps.map(async (dailyLoadingRamp: DailyLoadingRamp) => {
-        const foundDailyLoadingRampPatch = dailyLoadingRampPatches.find(detail => detail.name === dailyLoadingRamp.name)
-
-        const foundRamp: Ramp = await rampRepo.findOne({
-          where: { id: foundDailyLoadingRampPatch.ramp.id }
-        })
-
-        return {
-          ...dailyLoadingRamp,
-          dailyLoading,
-          ramp: foundRamp,
-          totalBunchWeight: foundDailyLoadingRampPatch.totalBunchWeight,
-          updater: user
-        }
-      })
-    )
-    await dailyLoadingRampRepo.save(updatedDailyLoadingRamps)
-  }
-
-  if (newDailyLoadingRamps?.length > 0) {
-    await Promise.all(
-      newDailyLoadingRamps.map(async (dailyLoadingRamp: DailyLoadingRamp) => {
-        let newDailyLoadingRamp: DailyLoadingRamp = new DailyLoadingRamp()
-        newDailyLoadingRamp.domain = domain
-        newDailyLoadingRamp.name = NoGenerator.dailyLoadingDetail()
-        newDailyLoadingRamp.ramp = await rampRepo.findOne({ id: dailyLoadingRamp.ramp.id })
-        newDailyLoadingRamp.totalBunchWeight = dailyLoadingRamp.totalBunchWeight
-        newDailyLoadingRamp.creator = user
-        newDailyLoadingRamp.updater = user
-        newDailyLoadingRamp.dailyLoading = dailyLoading
-
-        await dailyLoadingRampRepo.save(newDailyLoadingRamp)
-      })
-    )
-  }
-}
-
 export async function updatePlantationInventory(
   domain: Domain,
   dailyLoading: DailyLoading,
-  prevLoadedBunch: number,
-  prevLoadedTonnage: number,
-  block: Block,
+  foundDailyLoadingDetailPatch: any,
+  existingRecord: DailyLoadingDetail,
   user: User,
   tx?: EntityManager
 ): Promise<void> {
   const plantationInvRepo: Repository<PlantationInventory> =
     tx?.getRepository(PlantationInventory) || getRepository(PlantationInventory)
 
-  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-
-  let existingBunchesInventory: PlantationInventory = await plantationInvRepo.findOne({
-    where: { domain, block, type: INVENTORY_TYPE.FIELD_BUNCHES },
-    relations: ['domain', 'block']
+  let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
+    where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: existingRecord.ramp },
+    relations: ['domain', 'block', 'ramp']
   })
 
-  const originBunchesInventory: number = existingBunchesInventory.totalBunches + prevLoadedBunch
-  const loadedFieldBunches: number = dailyLoading.totalBunch
-
-  if (!existingBunchesInventory) throw new Error('Unable to find plantation bunches inventory')
-  existingBunchesInventory.totalBunches = originBunchesInventory - loadedFieldBunches
-  existingBunchesInventory.updater = user
-  existingBunchesInventory = await plantationInvRepo.save(existingBunchesInventory)
-
-  await generateTransactionHistory(
-    existingBunchesInventory,
-    dailyLoading.id,
-    dailyLoading.name,
-    TRANSACTION_TYPE.BUNCHES_ADJUSTMENT,
-    dailyLoading.loadingDate,
-    prevLoadedBunch,
-    0,
-    user,
-    tx
-  )
-
-  await generateTransactionHistory(
-    existingBunchesInventory,
-    dailyLoading.id,
-    dailyLoading.name,
-    TRANSACTION_TYPE.BUNCHES_ADJUSTMENT,
-    dailyLoading.loadingDate,
-    -loadedFieldBunches,
-    0,
-    user,
-    tx
-  )
-
-  await Promise.all(
-    dailyLoading.dailyLoadingRamps.map(async (record: any) => {
-      const ramp: Ramp = await rampRepo.findOne({
-        where: { domain, id: record.ramp.id }
-      })
-
-      let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
-        where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp },
-        relations: ['domain', 'block', 'ramp']
-      })
-
-      const originRampTonnage: number = existingRampTonnage.totalTonnage - prevLoadedTonnage
-      const loadedRampTonnage: number = dailyLoading.totalWeight
-
-      if (existingRampTonnage) {
-        existingRampTonnage.totalTonnage = originRampTonnage - loadedRampTonnage
-        existingRampTonnage.updater = user
-        await plantationInvRepo.save(existingRampTonnage)
-
-        await generateTransactionHistory(
-          existingRampTonnage,
-          dailyLoading.id,
-          dailyLoading.name,
-          TRANSACTION_TYPE.TONNAGE_ADJUSTMENT,
-          dailyLoading.loadingDate,
-          0,
-          -prevLoadedTonnage,
-          user,
-          tx
-        )
-
-        await generateTransactionHistory(
-          existingRampTonnage,
-          dailyLoading.id,
-          dailyLoading.name,
-          TRANSACTION_TYPE.TONNAGE_ADJUSTMENT,
-          dailyLoading.loadingDate,
-          0,
-          loadedRampTonnage,
-          user,
-          tx
-        )
-      } else {
-        let plantationInventory: PlantationInventory = new PlantationInventory()
-        plantationInventory.domain = domain
-        plantationInventory.name = NoGenerator.rampTonnageName()
-        plantationInventory.block = block
-        plantationInventory.type = INVENTORY_TYPE.RAMP_TONNAGE
-        plantationInventory.totalTonnage = record.totalBunchWeight
-        plantationInventory.status = INVENTORY_STATUS.STORED
-        plantationInventory.ramp = ramp
-        plantationInventory.creator = user
-        plantationInventory = await plantationInvRepo.save(plantationInventory)
-
-        await generateTransactionHistory(
-          plantationInventory,
-          dailyLoading.id,
-          dailyLoading.name,
-          TRANSACTION_TYPE.LOADING,
-          dailyLoading.loadingDate,
-          0,
-          record.totalBunchWeight,
-          user,
-          tx
-        )
-      }
-    })
-  )
+  if (existingRampTonnage) {
+    const tonnageChanges: number = foundDailyLoadingDetailPatch.totalBunchWeight - existingRecord.totalBunchWeight
+    existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + tonnageChanges
+    existingRampTonnage.updater = user
+    await plantationInvRepo.save(existingRampTonnage)
+
+    await generateTransactionHistory(
+      existingRampTonnage,
+      dailyLoading.id,
+      dailyLoading.name,
+      TRANSACTION_TYPE.LOADING_ADJUSTMENT,
+      dailyLoading.loadingDate,
+      0,
+      tonnageChanges,
+      user,
+      tx
+    )
+  }
 }

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