@things-factory/operato-pms 3.7.5 → 3.8.13

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-production-reports.ts

@@ -1,5 +1,7 @@
-import { ListParam } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
+
+import { ListParam } from '@things-factory/shell'
+
 import { Block } from '../../../entities'
 
 export const dailyProductionReports = {
@@ -31,25 +33,42 @@ export const dailyProductionReports = {
         .findOneOrFail({ where: { id: params.filters.filter(x => x.name == 'block')[0].value } })
 
       await tx.query(`
-        CREATE TEMP TABLE temp_records AS (	
-          select block_id, coalesce(sum(field_bunches),0) AS today_field_bunches, 
-          coalesce(sum(ramp_weight),0) AS today_ramp_weight,
+        CREATE TEMP TABLE temp_blocks on commit drop AS (
+          WITH RECURSIVE b AS (   
+            SELECT $1::uuid as block_id, * FROM blocks b 
+            WHERE id = $1::uuid
+            AND b.deleted_at IS null
+            UNION ALL
+            SELECT $1::uuid as block_id, cb.* FROM blocks cb
+            INNER JOIN b ON b.id = cb.parent_block_id
+            WHERE cb.deleted_at IS null
+          )
+          SELECT * FROM b
+        );
+      `, [block.id]
+      )
+
+      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' then field_bunches else 0 end) as today_bunch_harvest,
           sum(case when transaction_type = 'LOADING' then -field_bunches else 0 end) as today_bunch_collected,
-          sum(case when transaction_type = 'LOADING' then ramp_weight else 0 end) as today_ramp_weight_collected,
-          sum(case when transaction_type = 'DISPATCHMENT' then -ramp_weight else 0 end) as today_weight_dispatch,	  
+          round(sum(case when transaction_type = 'LOADING' then ramp_weight else 0 end)::numeric,4) as today_ramp_weight_collected,
+          round(sum(case when transaction_type = 'DISPATCHMENT' then -ramp_weight else 0 end)::numeric,4) as today_weight_dispatch,	  
           transaction_date
-          from record_transactions t2 
+          from record_transactions t2
+          inner join temp_blocks blk on blk.id = t2.block_id
           where transaction_date <= $1
-          and block_id = $2
-          group by block_id, transaction_date
+          group by blk.block_id, transaction_date
         )
-      `, 
-      [toDateString, block.id])
+      `,
+        [toDateString]
+      )
 
       await tx.query(
         `
-          create temp table temp_daily_production_data as (
+          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,
@@ -88,60 +107,52 @@ export const dailyProductionReports = {
                 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 
+                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
-                and block_id = $3
-                group by block_id, harvest_date
+                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 
+                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
-                and block_id = $3
-                GROUP BY dh.block_id, dh.harvest_date
+                GROUP BY blk.block_id, dh.harvest_date
               ) as tot ON tot.harvest_date::date = md.dateDay
             ) dt
           )`,
         [fromDateString, toDateString, block.id]
       )
 
-      const result: any = await tx.query(
-        `
+      const result: any = await tx.query(`
             select * from temp_daily_production_data dt
-          `
-      )
+      `)
 
-      const total: any = await tx.query(
-        `
+      const total: any = await tx.query(`
           select count(*) from temp_daily_production_data
-          `
-      )
-
-      await tx.query(
-        `
-            drop table temp_daily_production_data, temp_records
-          `
-      )
+      `)
 
       let items = result.map(itm => {
         return {
           block: itm.block,
           dateDay: itm.date_day,
-          diffInBunches: itm.diff_in_bunches,
-          prevBunchBalInField: itm.prev_bunch_bal_in_field,
-          prevWeightBalInRamp: itm.prev_weight_bal_in_ramp,
-          toDateBunchHarvest: itm.to_date_bunch_harvest,
+          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: itm.to_date_weight_dispatch,
-          todayBunchBalInField: itm.today_bunch_bal_in_field,
-          todayBunchCollected: itm.today_bunch_collected,
-          todayBunchHarvest: itm.today_bunch_harvest,
-          todayBunchInField: itm.today_bunch_in_field,
+          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: itm.today_hectare_cover,
+          todayHectareCover: parseFloat(itm.today_hectare_cover).toFixed(4),
           todayOutTurn: itm.today_out_turn,
-          todayWeightBalInRamp: itm.today_weight_bal_in_ramp,
-          todayWeightDispatch: itm.today_weight_dispatch
+          todayWeightBalInRamp: parseFloat(itm.today_weight_bal_in_ramp).toFixed(4),
+          todayWeightDispatch: parseFloat(itm.today_weight_dispatch).toFixed(4)
         }
       })
 

package/server/graphql/resolvers/report/daily-staff-harvest-reports.ts

@@ -1,5 +1,7 @@
-import { ListParam } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
+
+import { ListParam } from '@things-factory/shell'
+
 import { Block } from '../../../entities'
 
 export const dailyStaffHarvestReports = {
@@ -30,43 +32,49 @@ export const dailyStaffHarvestReports = {
         .getRepository(Block)
         .findOneOrFail({ where: { id: params.filters.filter(x => x.name == 'block')[0].value } })
 
+      await tx.query(`
+        CREATE TEMP TABLE temp_blocks on commit drop AS (
+          WITH RECURSIVE b AS (   
+            SELECT $1::uuid as block_id, * FROM blocks b 
+            WHERE id = $1::uuid 
+            AND b.deleted_at IS null
+            UNION ALL
+            SELECT $1::uuid as block_id, cb.* FROM blocks cb
+            INNER JOIN b ON b.id = cb.parent_block_id
+            WHERE cb.deleted_at IS null
+          )
+          SELECT * FROM b
+        );
+      `, [block.id]
+      )
+
       await tx.query(
         `
-            create temp table temp_daily_staff_harvest_data as (
+            create temp table temp_daily_staff_harvest_data on commit drop as (
               select "harvestDate"::varchar as "harvestDate", "blockName"::varchar, "staffName"::varchar, sum("totalBunchHarvested")::varchar as "totalBunchHarvested" from (
                 select dh.harvest_date::date as "harvestDate", b2."name" as "blockName", os."name" as "staffName",
                 dhd.total_bunch_harvested as "totalBunchHarvested"
                 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
                 inner join organization_staffs os on os.id = dhd.organization_staff_id 
-                inner join blocks b2 on b2.id = dh.block_id
-                where dh.block_id = $1
-                and dh.harvest_date::date between $2 and $3
+                inner join blocks b2 on b2.id = blk.block_id
+                where dh.harvest_date::date between $1 and $2
               ) as dt
               group by "harvestDate", "blockName", "staffName"
               order by "staffName", "harvestDate"
             )
           `,
-        [block.id, fromDateString, toDateString]
+        [fromDateString, toDateString]
       )
 
-      const result: any = await tx.query(
-        `
+      const result: any = await tx.query(`
             select * from temp_daily_staff_harvest_data dt
-          `
-      )
+      `)
 
-      const total: any = await tx.query(
-        `
+      const total: any = await tx.query(`
           select count(*) from temp_daily_staff_harvest_data
-          `
-      )
-
-      await tx.query(
-        `
-            drop table temp_daily_staff_harvest_data
-          `
-      )
+      `)
 
       return { items: result, total: total[0].count }
     } catch (error) {

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

@@ -1,14 +1,20 @@
 import { dailyProductionReports } from './daily-production-reports'
 import { monthlyProductionReports } from './monthly-production-reports'
+import { monthlyDispatchSummaryReports } from './monthly-dispatch-summary-reports'
 import { yearlyProductionReports } from './yearly-production-reports'
 import { dailyStaffHarvestReports } from './daily-staff-harvest-reports'
+import { monthlyBlockDispatchReports } from './monthly-block-dispatch-reports'
+import { monthlyFfbSaleReports } from './monthly-ffb-sale-reports'
 
 export const ReportResolver = {
   Query: {
     ...dailyProductionReports,
     ...monthlyProductionReports,
+    ...monthlyDispatchSummaryReports,
     ...yearlyProductionReports,
-    ...dailyStaffHarvestReports
+    ...dailyStaffHarvestReports,
+    ...monthlyBlockDispatchReports,
+    ...monthlyFfbSaleReports
   },
   Mutation: {}
 }

package/server/graphql/resolvers/report/monthly-block-dispatch-reports.ts

@@ -0,0 +1,112 @@
+import { EntityManager, getRepository, Not, IsNull } from 'typeorm'
+
+import { ListParam, Domain } from '@things-factory/shell'
+import { Ramp } from '../../../entities'
+
+export const monthlyBlockDispatchReports = {
+  async monthlyBlockDispatchReports(_: 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']
+      })
+
+
+      // --  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 dd.id, b.name AS block_name,
+          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::timestamp between $1::timestamp and $2::timestamp
+        )
+        `, [fromDateString, toDateString]
+      )
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE pivot_block_dispatch ON COMMIT DROP AS (
+            SELECT * FROM crosstab(
+              $$SELECT rbd.id, rbd.block_name, round(rbd.weight, 2 )::varchar FROM raw_block_dispatch rbd$$,
+              $$SELECT b.name FROM ramps r INNER JOIN blocks b ON b.id = r.block_id WHERE r.deleted_at IS NULL$$
+            ) AS ("id" uuid,  ${ramps.map(ramp => `"${ramp.block.name}" varchar`).join(',')})
+          );
+        `)
+
+      await tx.query(
+        `
+          CREATE TEMP TABLE temp_monthly_production_data ON COMMIT DROP AS (
+            SELECT 
+            ROW_NUMBER() OVER(
+              PARTITION BY dd.dispatch_at::date
+              ORDER BY dd.dispatch_at
+            ) as rn
+            , dd.id, COALESCE(c.name, 'UNKNOWN') AS "dispatchTo"
+            , dd.transport_no as "lorryNo"
+            , dd.driver_identification as "driverIdentification"
+            , TO_CHAR(dd.dispatch_at:: DATE, 'dd/mm/yyyy') as "date"
+            , row_to_json((SELECT d FROM (SELECT ${ramps.map(ramp => `pbd."${ramp.block.name}"`).join(',')}) d))::varchar as "blockData"
+            , (SELECT sum(weight) FROM raw_block_dispatch rbd WHERE rbd.id = dd.id) AS "today"
+            FROM daily_dispatches dd 
+            INNER JOIN pivot_block_dispatch pbd ON pbd.id = dd.id
+            LEFT JOIN organizations c ON c.id = dd.dispatch_to_id 
+          );
+        `
+      )
+
+      const result: any = await tx.query(
+        `
+          select "id", "dispatchTo", "lorryNo", "driverIdentification", 
+          CASE WHEN "rn" = 1 THEN "date" ELSE '' END AS "date", "blockData", "today",
+          coalesce(sum(today) over (order by date asc rows between unbounded preceding and current row), 0) as "todate"
+          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
+    }
+  }
+}