@things-factory/operato-pms 3.8.0 → 3.8.13

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

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

@@ -8,7 +8,12 @@ export * from './new-daily-dispatch'
 export const DailyDispatchResolver = gql`
   extend type Mutation {
     generateDailyDispatch(dailyDispatch: NewDailyDispatch!): DailyDispatch @transaction
-    updateDailyDispatch(name: String!, dailyDispatchDetails: [DailyDispatchDetailPatch]): DailyDispatch @transaction
+    updateDailyDispatch(
+      name: String!
+      chitNo: String
+      percentage: Float
+      dailyDispatchDetails: [DailyDispatchDetailPatch]
+    ): DailyDispatch @transaction
     deleteDailyDispatch(name: String!): Boolean @transaction
   }
 

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

@@ -4,10 +4,13 @@ export const NewDailyDispatch = gql`
   input NewDailyDispatch {
     name: String
     description: String
+    transport: ObjectRef
     transportNo: String
     driverIdentification: String
     totalTonnageRelease: Float
-    dispatchTo: String!
+    dispatchTo: ObjectRef!
+    chitNo: String
+    percentage: Float
     dispatchAt: String!
     driver: ObjectRef
     externalDriver: String

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

@@ -3,9 +3,12 @@ import gql from 'graphql-tag'
 export const DailyHarvestPatch = gql`
   input DailyHarvestPatch {
     name: String
-    harvestDate: String!
-    harvestingRound: Int!
+    harvestDate: String
+    harvestingRound: Int
     totalBunchHarvested: Float
+    yesterdayBalanceBunchInField: Float
+    balanceBunchInField: Float
+    collectedBunch: Float
     block: String!
     coverage: Float
     rainfall: String

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

@@ -9,6 +9,9 @@ export const DailyHarvest = gql`
     dailyHarvestDetails: [DailyHarvestDetail]
     harvestDate: String
     totalBunchHarvested: Float
+    yesterdayBalanceBunchInField: Float
+    balanceBunchInField: Float
+    collectedBunch: Float
     harvestingRound: Int
     coverage: Float
     rainfall: String

package/server/graphql/types/daily-harvest/new-daily-harvest.ts

@@ -3,8 +3,11 @@ import gql from 'graphql-tag'
 export const NewDailyHarvest = gql`
   input NewDailyHarvest {
     harvestDate: String!
-    harvestingRound: Int!
+    harvestingRound: Int
     block: String!
+    balanceBunchInField: Float
+    yesterdayBalanceBunchInField: Float
+    collectedBunch: Float
     coverage: Float
     rainfall: String
     dailyHarvestDetails: [NewDailyHarvestDetail]

package/server/graphql/types/daily-harvest-detail/daily-harvest-detail-patch.ts

@@ -4,6 +4,7 @@ export const DailyHarvestDetailPatch = gql`
   input DailyHarvestDetailPatch {
     name: String
     totalBunchHarvested: Float!
+    totalTonnageHarvested: Float
     organizationStaff: ObjectRef!
     remark: String
   }

package/server/graphql/types/daily-harvest-detail/daily-harvest-detail.ts

@@ -8,6 +8,7 @@ export const DailyHarvestDetail = gql`
     dailyHarvest: DailyHarvest
     organizationStaff: OrganizationStaff
     totalBunchHarvested: Int
+    totalTonnageHarvested: Float
     remark: String
     deletedAt: String
     description: String

package/server/graphql/types/daily-harvest-detail/new-daily-harvest-detail.ts

@@ -3,6 +3,7 @@ import gql from 'graphql-tag'
 export const NewDailyHarvestDetail = gql`
   input NewDailyHarvestDetail {
     totalBunchHarvested: Float!
+    totalTonnageHarvested: Float
     organizationStaff: ObjectRef!
     remark: String
   }

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

@@ -3,8 +3,6 @@ import gql from 'graphql-tag'
 export const DailyLoadingPatch = gql`
   input DailyLoadingPatch {
     loadingDate: String!
-    block: String!
     dailyLoadingDetails: [DailyLoadingDetailPatch]
-    dailyLoadingRamps: [DailyLoadingRampPatch]
   }
 `

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

@@ -5,9 +5,7 @@ export const DailyLoading = gql`
     id: String
     name: String
     domain: Domain
-    block: Block
     dailyLoadingDetails: [DailyLoadingDetail]
-    dailyLoadingRamps: [DailyLoadingRamp]
     loadingDate: String
     totalWeight: Float
     totalBunch: Int

package/server/graphql/types/daily-loading/new-daily-loading.ts

@@ -3,8 +3,6 @@ import gql from 'graphql-tag'
 export const NewDailyLoading = gql`
   input NewDailyLoading {
     loadingDate: String
-    block: String!
     dailyLoadingDetails: [NewDailyLoadingDetail]
-    dailyLoadingRamps: [NewDailyLoadingRamp]
   }
 `

package/server/graphql/types/daily-loading-detail/daily-loading-detail-patch.ts

@@ -3,9 +3,12 @@ import gql from 'graphql-tag'
 export const DailyLoadingDetailPatch = gql`
   input DailyLoadingDetailPatch {
     name: String
-    organizationStaff: ObjectRef!
-    totalBunchLoaded: Int!
-    totalBunchWeight: Float!
+    organizationStaff: ObjectRef
+    truck: ObjectRef
+    block: ObjectRef
+    ramp: ObjectRef
+    totalBunchLoaded: Int
+    totalBunchWeight: Float
     remark: String
   }
 `

package/server/graphql/types/daily-loading-detail/daily-loading-detail.ts

@@ -7,6 +7,9 @@ export const DailyLoadingDetail = gql`
     domain: Domain
     organizationStaff: OrganizationStaff
     dailyLoading: DailyLoading
+    truck: Truck
+    block: Block
+    ramp: Ramp
     remark: String
     totalBunchLoaded: Int
     totalBunchWeight: Float

package/server/graphql/types/daily-loading-detail/new-daily-loading-detail.ts

@@ -2,9 +2,12 @@ import gql from 'graphql-tag'
 
 export const NewDailyLoadingDetail = gql`
   input NewDailyLoadingDetail {
-    organizationStaff: ObjectRef!
-    totalBunchLoaded: Int!
-    totalBunchWeight: Float!
+    organizationStaff: ObjectRef
+    totalBunchLoaded: Int
+    totalBunchWeight: Float
+    truck: ObjectRef
+    block: ObjectRef
+    ramp: ObjectRef
     remark: String
   }
 `

package/server/graphql/types/dashboard/bunches-count.ts

@@ -0,0 +1,9 @@
+import gql from 'graphql-tag'
+
+export const BunchesCount = gql`
+  type BunchesCount {
+    date: String
+    harvestedCount: Int
+    collectedCount: Int
+  }
+`

package/server/graphql/types/dashboard/index.ts

@@ -0,0 +1,17 @@
+import gql from 'graphql-tag'
+
+export * from './tonnage-production'
+export * from './yield-production'
+export * from './tonnage-bunches-inventories'
+export * from './bunches-count'
+export * from './productions-overview'
+
+export const DashboardResolver = gql`
+  extend type Query {
+    monthlyTonnageProductions(blockId: String, yearAndMonth: String!): [TonnageProduction] @transaction
+    monthlyYields(blockId: String, yearAndMonth: String!): [YieldProduction] @transaction
+    tonnageAndBunchesInventories(something: String): TonnageBunchesInventories @transaction
+    weeklyBunchesCount(targetDate: String): [BunchesCount] @transaction
+    productionsOverview(something: String): ProductionsOverview @transaction
+  }
+`