@things-factory/operato-pms 3.7.5 → 3.8.13

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

@@ -1,16 +1,10 @@
+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_STATUS, INVENTORY_TYPE, RECORD_STATUS, TRANSACTION_TYPE } from '../../../constants'
-import {
-  Block,
-  DailyLoading,
-  DailyLoadingDetail,
-  DailyLoadingRamp,
-  OrganizationStaff,
-  PlantationInventory,
-  Ramp
-} from '../../../entities'
+import { Block, DailyLoading, DailyLoadingDetail, PlantationInventory, Ramp, Truck } from '../../../entities'
 import { generateTransactionHistory, NoGenerator } from '../../../utils'
 
 export const generateDailyLoading = {
@@ -18,26 +12,19 @@ export const generateDailyLoading = {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
     let dailyLoadingDetails: DailyLoadingDetail[] = dailyLoading.dailyLoadingDetails
-    let dailyLoadingRamps: DailyLoadingRamp[] = dailyLoading.dailyLoadingRamps
 
-    const block: Block = await tx.getRepository(Block).findOne({
-      where: { name: dailyLoading.block }
-    })
+    const totalWeight: number = dailyLoadingDetails.reduce(function (prev, cur) {
+      return prev + cur.totalBunchWeight
+    }, 0)
 
-    // get sum of bunch loaded from all trip
     const totalBunch: number = dailyLoadingDetails.reduce(function (prev, cur) {
       return prev + cur.totalBunchLoaded
     }, 0)
 
-    const totalWeight: number = dailyLoadingDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchWeight
-    }, 0)
-
     // 1. Create daily loading
     let newDailyLoading: DailyLoading = new DailyLoading()
     newDailyLoading.name = NoGenerator.dailyLoading()
     newDailyLoading.domain = domain
-    newDailyLoading.block = block
     newDailyLoading.loadingDate = dailyLoading.loadingDate
     newDailyLoading.totalBunch = totalBunch
     newDailyLoading.totalWeight = totalWeight
@@ -57,20 +44,6 @@ export const generateDailyLoading = {
       tx
     )
 
-    // 2. Create daily loading ramp
-    dailyLoadingRamps = await addDailyLoadingRamps(
-      domain,
-      newDailyLoading,
-      dailyLoadingRamps.map((record: DailyLoadingRamp) => {
-        return { ...record }
-      }),
-      user,
-      tx
-    )
-
-    // 3. Deduct bunches inventory in field and add ramp tonnage
-    await updatePlantationInventory(domain, newDailyLoading, dailyLoadingRamps, block, user, tx)
-
     return newDailyLoading
   }
 }
@@ -82,8 +55,10 @@ export async function addDailyLoadingDetail(
   user: User,
   tx?: EntityManager
 ): Promise<DailyLoadingDetail[]> {
-  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)
 
@@ -93,97 +68,40 @@ export async function addDailyLoadingDetail(
         ...record,
         domain,
         name: NoGenerator.dailyLoadingDetail(),
-        organizationStaff: await organizationStaffRepo.findOne({ id: record.organizationStaff.id }),
-        dailyLoading: newDailyLoading,
-        creator: user,
-        updater: user
-      }
-    })
-  )
-
-  return await dailyLoadingDetailRepo.save(dailyLoadingDetails)
-}
-
-export async function addDailyLoadingRamps(
-  domain: Domain,
-  newDailyLoading: DailyLoading,
-  dailyLoadingRamps: DailyLoadingRamp[],
-  user: User,
-  tx?: EntityManager
-): Promise<DailyLoadingRamp[]> {
-  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-  const dailyLoadingRampRepo: Repository<DailyLoadingRamp> =
-    tx?.getRepository(DailyLoadingRamp) || getRepository(DailyLoadingRamp)
-
-  dailyLoadingRamps = await Promise.all(
-    dailyLoadingRamps.map(async (record: DailyLoadingRamp) => {
-      return {
-        ...record,
-        domain,
-        name: NoGenerator.dailyLoadingRamp(),
+        truck: await truckRepo.findOne({ id: record.truck.id }),
+        block: await blockRepo.findOne({ id: record.block.id }),
         ramp: await rampRepo.findOne({ id: record.ramp.id }),
         dailyLoading: newDailyLoading,
-        creator: user,
-        updater: user
+        creator: user
       }
     })
   )
 
-  return await dailyLoadingRampRepo.save(dailyLoadingRamps)
+  dailyLoadingDetails = await dailyLoadingDetailRepo.save(dailyLoadingDetails)
+  await updatePlantationInventory(domain, newDailyLoading, dailyLoadingDetails, user, tx)
+
+  return dailyLoadingDetails
 }
 
 export async function updatePlantationInventory(
   domain: Domain,
   newDailyLoading: DailyLoading,
-  dailyLoadingRamps: DailyLoadingRamp[],
-  block: Block,
+  dailyLoadingDetails: 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']
-  })
-
-  const currentFieldBunches: number = existingBunchesInventory.totalBunches
-  const loadedFieldBunches: number = newDailyLoading.totalBunch
-
-  // deduct field bunches
-  if (loadedFieldBunches > currentFieldBunches) throw new Error('Insufficient Bunches in Field to be Loaded')
-  existingBunchesInventory.totalBunches = currentFieldBunches - loadedFieldBunches
-  existingBunchesInventory.updater = user
-  existingBunchesInventory = await plantationInvRepo.save(existingBunchesInventory)
-
-  await generateTransactionHistory(
-    existingBunchesInventory,
-    newDailyLoading.id,
-    newDailyLoading.name,
-    TRANSACTION_TYPE.BUNCHES_ADJUSTMENT,
-    newDailyLoading.loadingDate,
-    -loadedFieldBunches,
-    0,
-    user,
-    tx
-  )
-
   await Promise.all(
-    dailyLoadingRamps.map(async (record: any) => {
-      let ramp: Ramp = await rampRepo.findOne({
-        where: { domain, id: record.ramp.id }
-      })
-
+    dailyLoadingDetails.map(async (dailyLoadingDetail: any) => {
       let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
-        where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp },
+        where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: dailyLoadingDetail.ramp },
         relations: ['domain', 'block', 'ramp']
       })
 
       if (existingRampTonnage) {
-        existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + record.totalBunchWeight
+        existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + dailyLoadingDetail.totalBunchWeight
         existingRampTonnage.updater = user
         await plantationInvRepo.save(existingRampTonnage)
 
@@ -194,7 +112,7 @@ export async function updatePlantationInventory(
           TRANSACTION_TYPE.LOADING,
           newDailyLoading.loadingDate,
           0,
-          record.totalBunchWeight,
+          dailyLoadingDetail.totalBunchWeight,
           user,
           tx
         )
@@ -202,11 +120,11 @@ export async function updatePlantationInventory(
         let plantationInventory: PlantationInventory = new PlantationInventory()
         plantationInventory.domain = domain
         plantationInventory.name = NoGenerator.rampTonnageName()
-        plantationInventory.block = block
+        plantationInventory.block = dailyLoadingDetail.block
         plantationInventory.type = INVENTORY_TYPE.RAMP_TONNAGE
-        plantationInventory.totalTonnage = record.totalBunchWeight
+        plantationInventory.totalTonnage = dailyLoadingDetail.totalBunchWeight
         plantationInventory.status = INVENTORY_STATUS.STORED
-        plantationInventory.ramp = ramp
+        plantationInventory.ramp = dailyLoadingDetail.ramp
         plantationInventory.creator = user
         plantationInventory = await plantationInvRepo.save(plantationInventory)
 
@@ -217,7 +135,7 @@ export async function updatePlantationInventory(
           TRANSACTION_TYPE.LOADING,
           newDailyLoading.loadingDate,
           0,
-          record.totalBunchWeight,
+          dailyLoadingDetail.totalBunchWeight,
           user,
           tx
         )

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

@@ -1,17 +1,10 @@
+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 { Block, DailyLoading, DailyLoadingDetail, PlantationInventory, Ramp, Truck } from '../../../entities'
+import { NoGenerator } from '../../../utils'
 
 export const updateDailyLoading = {
   async updateDailyLoading(_: any, { name, dailyLoadingPatch }, context: any) {
@@ -21,23 +14,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 +30,6 @@ export const updateDailyLoading = {
       return prev + cur.totalBunchWeight
     }, 0)
 
-    dailyLoading.block = block
     dailyLoading.totalBunch = totalBunch
     dailyLoading.totalWeight = totalWeight
     dailyLoading.loadingDate = dailyLoadingPatch.loadingDate
@@ -56,8 +38,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 +50,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)
 
@@ -90,22 +71,22 @@ export async function updateDailyLoadingDetail(
       dailyLoadingDetails.map(async (record: DailyLoadingDetail) => {
         const foundDailyLoadingDetailPatch = dailyLoadingDetailPatches.find(detail => detail.name === record.name)
 
-        const foundStaff: OrganizationStaff = await organizationStaffRepo.findOne({
-          where: { id: foundDailyLoadingDetailPatch.organizationStaff.id }
-        })
-
         return {
           ...record,
           dailyLoading,
-          organizationStaff: foundStaff,
-          totalBunchLoaded: foundDailyLoadingDetailPatch.totalBunchLoaded,
-          totalBunchWeight: foundDailyLoadingDetailPatch.totalBunchWeight,
-          remark: foundDailyLoadingDetailPatch.remark,
+          truck: await truckRepo.findOne({ id: record.truck.id }),
+          block: await blockRepo.findOne({ id: record.block.id }),
+          ramp: await rampRepo.findOne({ id: record.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)
+
+    // await updatePlantationInventory(domain, dailyLoading, updatedDailyLoadingDetails, user, tx)
   }
 
   if (newDailyLoadingDetail?.length > 0) {
@@ -114,14 +95,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,70 +110,10 @@ 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,
+  updatedDailyLoadingDetails: DailyLoadingDetail[],
   user: User,
   tx?: EntityManager
 ): Promise<void> {
@@ -201,110 +121,4 @@ export async function updatePlantationInventory(
     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']
-  })
-
-  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
-        )
-      }
-    })
-  )
 }

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

@@ -0,0 +1,96 @@
+// import { EntityManager } from 'typeorm'
+
+// 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) {
+    if (blockId == 'ALL_BLOCKS') {
+      // should remove block filter
+      // 'ALL_BLOCKS' was hardcoded from dashboard
+    }
+
+    const year: string = yearAndMonth.substring(0, 4)
+    const month: string = yearAndMonth.substring(4)
+
+    let data = []
+
+    for (let i = 1, l = new Date(Number(year), Number(month), 0).getDate(); i <= l; i++) {
+      let theDate = new Date(`${year}-${month}-${i}`)
+      theDate.setHours(8, 0, 0, 0)
+
+      data.push({
+        blockId,
+        tonnage: Math.floor(Math.random() * 1000) + 200, // generate random value within 200-1000
+        year,
+        month,
+        date: theDate.toLocaleString('default', { day: '2-digit', month: 'short' })
+      })
+    }
+
+    return data.sort((a, b) => (a.date > b.date ? 1 : -1))
+  },
+
+  async monthlyYields(_: any, { blockId, yearAndMonth }, context: any) {
+    if (blockId == 'ALL_BLOCKS') {
+      // should remove block filter
+      // 'ALL_BLOCKS' was hardcoded from dashboard
+    }
+
+    const year: string = yearAndMonth.substring(0, 4)
+    const month: string = yearAndMonth.substring(4)
+
+    let data = []
+
+    for (let i = 1, l = new Date(Number(year), Number(month), 0).getDate(); i <= l; i++) {
+      let theDate = new Date(`${year}-${month}-${i}`)
+      theDate.setHours(8, 0, 0, 0)
+
+      data.push({
+        blockId,
+        yield: Math.floor(Math.random() * 1000) + 200, // generate random value within 200-1000
+        year,
+        month,
+        date: theDate.toLocaleString('default', { day: '2-digit', month: 'short' })
+      })
+    }
+
+    return data.sort((a, b) => (a.date > b.date ? 1 : -1))
+  },
+
+  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: 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: Math.floor(Math.random() * 10000) + 500,
+      tonnage: Math.floor(Math.random() * 10000) + 500
+    }
+  },
+
+  async productionsOverview(_: any, { something }, context: any) {
+    return {
+      averageBunchWeight: Math.floor(Math.random() * 150) + 70,
+      bunchesCount: Math.floor(Math.random() * 10000) + 500,
+      tonnageWeighed: Math.floor(Math.random() * 10000) + 500
+    }
+  }
+}

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'