From a09f8dce7c4732abfdb2113d201903aea9b3a2eb Mon Sep 17 00:00:00 2001
From: alexeh <alexurola@gmail.com>
Date: Tue, 2 Aug 2022 11:02:41 +0200
Subject: [PATCH 1/8] Add basic example and some notes

---
 .../services/impact-calculator.service.ts     | 101 ++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 api/src/modules/indicator-records/services/impact-calculator.service.ts

diff --git a/api/src/modules/indicator-records/services/impact-calculator.service.ts b/api/src/modules/indicator-records/services/impact-calculator.service.ts
new file mode 100644
index 000000000..d4f920e2b
--- /dev/null
+++ b/api/src/modules/indicator-records/services/impact-calculator.service.ts
@@ -0,0 +1,101 @@
+import { Connection, getConnection, QueryRunner, Repository, SelectQueryBuilder } from "typeorm";
+import { Logger } from '@nestjs/common';
+import { SaveOptions } from 'typeorm/repository/SaveOptions';
+import { MATERIAL_TO_H3_TYPE } from '../../materials/material-to-h3.entity';
+
+export abstract class AppBaseRepository<Entity> extends Repository<Entity> {
+  logger: Logger = new Logger(this.constructor.name);
+
+  async calculateImpact<Entity>(
+    georegionId: string,
+    materialH3Id: string,
+    materialType: MATERIAL_TO_H3_TYPE,
+
+    options?: SaveOptions,
+  ): Promise<Entity[]> {
+    const connection: Connection = getConnection();
+    const queryRunner: QueryRunner = connection.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    const result: Entity[][] = [];
+
+    try {
+      // MAIN LOGIC
+
+      // STEPS
+      /**
+       * 1. Get material h3 data table and column name
+       * 1.1 For each year, get the closest available material h3 data
+       * 2. Get indicator h3 data table and column name
+       * 2.1 For each year, get the closest available material h3 data
+       ** Look at how interventions impact calculus implements this.
+       *
+       * 2.1 Get deforestation indicator h3 data and column name (because this indicator needs to be crossed with this data)
+       *
+       * CRAZY IDEAZ:
+       * 1. We have 12 years to calculate impact: 2010-2022 (12 DB calls)
+       * 2. We have 3 available years to calculate impact: 2010, 2014, 2020
+       *
+       * Before performing any call, can we determine that Sourcing Records from 2010 to 2012 will use data of 2010
+       *                                                                    from 2013 to 2017  will use data of 2014
+       *                                                                    from 2018 to 2022 will use data of 2022
+       *
+       * Knowing this, can we calculate impacts for those years simultaneosly (arent we doing that now anyway?) in 3 DB CALLS
+       * instead of doing 12, each for one year?
+       *
+       * LONG STORY SHORT:
+       *
+       * Can we do as much calls as different h3 data tables we need to attack (in this case 3)
+       * instead of doing as much calls as years we have to calculate impact for(in this case 12)
+       *
+       *
+
+       *
+       */
+      let materialH3data: any;
+      let indictorH3Data: any;
+
+      const result: any = await this.createQueryBuilder().select([
+        'sr.id as "sourcingRecordId",\n          sr.tonnage,\n          sr.year,\n          slwithmaterialh3data.id as "sourcingLocationId",\n          slwithmaterialh3data.production,\n          slwithmaterialh3data."harvestedArea",\n          slwithmaterialh3data."rawDeforestation",\n          slwithmaterialh3data."rawBiodiversity",\n          slwithmaterialh3data."rawCarbon",\n          slwithmaterialh3data."rawWater",\n          slwithmaterialh3data."materialH3DataId"',
+      ]).from((subQuery:  SelectQueryBuilder<any> )=> subQuery.select(`sum()`)
+        .from(`get_h3_uncompact_geo_region($1, $2)`, 'geoRegion')
+        .innerJoin('$3', 'materialH3', `materialH3.h3index = geoRegion.h3index`)
+        .innerJoin(
+          '$4',
+          'bioDiversityh3',
+          'bioDiversityh3.h3index = geoRegion.h3index',
+        )
+        .innerJoin(
+          '$5',
+          'deforestationH3',
+          'deforestation.h3index = geoRegion.h3index',
+        );
+
+      // This
+      const data: any = await this.createQueryBuilder()
+        .select(`sum()`)
+        .from(`get_h3_uncompact_geo_region($1, $2)`, 'geoRegion')
+        .innerJoin('$3', 'materialH3', `materialH3.h3index = geoRegion.h3index`)
+        .innerJoin(
+          '$4',
+          'bioDiversityh3',
+          'bioDiversityh3.h3index = geoRegion.h3index',
+        )
+        .innerJoin(
+          '$5',
+          'deforestationH3',
+          'deforestation.h3index = geoRegion.h3index',
+        );
+      // commit transaction if every chunk was saved successfully
+      await queryRunner.commitTransaction();
+    } catch (err) {
+      // rollback changes before throwing error
+      await queryRunner.rollbackTransaction();
+      throw err;
+    } finally {
+      // release query runner which is manually created
+      await queryRunner.release();
+    }
+    return result.flat();
+  }
+}

From cccb7cfd075bbae4b68220a52588e2a47169afe5 Mon Sep 17 00:00:00 2001
From: KevSanchez <kew.sanchez@gmail.com>
Date: Thu, 4 Aug 2022 16:57:23 +0200
Subject: [PATCH 2/8] chore(indicatorrecord): Create all sourcing records
 refactor 1st prototype

---
 .../indicator-records.module.ts               |   3 +-
 .../indicator-records.service.ts              |   2 +
 .../services/impact-calculator.service.ts     | 295 +++++++++++++-----
 3 files changed, 223 insertions(+), 77 deletions(-)

diff --git a/api/src/modules/indicator-records/indicator-records.module.ts b/api/src/modules/indicator-records/indicator-records.module.ts
index 3f158348e..d949797be 100644
--- a/api/src/modules/indicator-records/indicator-records.module.ts
+++ b/api/src/modules/indicator-records/indicator-records.module.ts
@@ -8,6 +8,7 @@ import { IndicatorsModule } from 'modules/indicators/indicators.module';
 import { MaterialsModule } from 'modules/materials/materials.module';
 import { SourcingRecordsModule } from 'modules/sourcing-records/sourcing-records.module';
 import { CachedDataModule } from 'modules/cached-data/cached-data.module';
+import { ImpactCalculatorService } from 'modules/indicator-records/services/impact-calculator.service';
 
 @Module({
   imports: [
@@ -19,7 +20,7 @@ import { CachedDataModule } from 'modules/cached-data/cached-data.module';
     CachedDataModule,
   ],
   controllers: [IndicatorRecordsController],
-  providers: [IndicatorRecordsService],
+  providers: [IndicatorRecordsService, ImpactCalculatorService],
   exports: [IndicatorRecordsService],
 })
 export class IndicatorRecordsModule {}
diff --git a/api/src/modules/indicator-records/indicator-records.service.ts b/api/src/modules/indicator-records/indicator-records.service.ts
index 8e635a730..3e0d8f4c2 100644
--- a/api/src/modules/indicator-records/indicator-records.service.ts
+++ b/api/src/modules/indicator-records/indicator-records.service.ts
@@ -36,6 +36,7 @@ import {
   CACHED_DATA_TYPE,
   CachedData,
 } from 'modules/cached-data/cached.data.entity';
+import { ImpactCalculatorService } from 'modules/indicator-records/services/impact-calculator.service';
 
 export interface CachedRawValue {
   rawValue: number;
@@ -51,6 +52,7 @@ export class IndicatorRecordsService extends AppBaseService<
   constructor(
     @InjectRepository(IndicatorRecordRepository)
     private readonly indicatorRecordRepository: IndicatorRecordRepository,
+    private readonly impactCalculatorService: ImpactCalculatorService,
     private readonly indicatorService: IndicatorsService,
     private readonly h3DataService: H3DataService,
     private readonly materialsToH3sService: MaterialsToH3sService,
diff --git a/api/src/modules/indicator-records/services/impact-calculator.service.ts b/api/src/modules/indicator-records/services/impact-calculator.service.ts
index d4f920e2b..b088e007c 100644
--- a/api/src/modules/indicator-records/services/impact-calculator.service.ts
+++ b/api/src/modules/indicator-records/services/impact-calculator.service.ts
@@ -1,92 +1,230 @@
-import { Connection, getConnection, QueryRunner, Repository, SelectQueryBuilder } from "typeorm";
-import { Logger } from '@nestjs/common';
+import {
+  Connection,
+  EntityRepository,
+  getConnection,
+  QueryRunner,
+  Repository,
+  SelectQueryBuilder,
+} from 'typeorm';
+import { Injectable, Logger } from '@nestjs/common';
 import { SaveOptions } from 'typeorm/repository/SaveOptions';
-import { MATERIAL_TO_H3_TYPE } from '../../materials/material-to-h3.entity';
+import { MATERIAL_TO_H3_TYPE } from 'modules/materials/material-to-h3.entity';
+import { H3DataService } from 'modules/h3-data/h3-data.service';
+import { H3Data } from 'modules/h3-data/h3-data.entity';
+import { INDICATOR_TYPES } from 'modules/indicators/indicator.entity';
+import { SourcingRecordsWithIndicatorRawDataDto } from '../../sourcing-records/dto/sourcing-records-with-indicator-raw-data.dto';
 
-export abstract class AppBaseRepository<Entity> extends Repository<Entity> {
+@Injectable()
+export class ImpactCalculatorService {
   logger: Logger = new Logger(this.constructor.name);
 
-  async calculateImpact<Entity>(
-    georegionId: string,
-    materialH3Id: string,
-    materialType: MATERIAL_TO_H3_TYPE,
+  constructor(private readonly h3DataService: H3DataService) {}
 
+  async calculateImpact(
+    connection: Connection,
+    queryRunner: QueryRunner,
+    georegionId: string,
+    materialId: string,
+    year: number,
     options?: SaveOptions,
-  ): Promise<Entity[]> {
+  ): Promise<any[]> {
+    // MAIN LOGIC
+
+    // STEPS
+    /**
+     * 1. Get material h3 data table and column name
+     * 1.1 For each year, get the closest available material h3 data
+     * 2. Get indicator h3 data table and column name
+     * 2.1 For each year, get the closest available material h3 data
+     ** Look at how interventions impact calculus implements this.
+     *
+     * 2.1 Get deforestation indicator h3 data and column name (because this indicator needs to be crossed with this data)
+     *
+     * CRAZY IDEAZ:
+     * 1. We have 12 years to calculate impact: 2010-2022 (12 DB calls)
+     * 2. We have 3 available years to calculate impact: 2010, 2014, 2020
+     *
+     * Before performing any call, can we determine that Sourcing Records from 2010 to 2012 will use data of 2010
+     *                                                                    from 2013 to 2017  will use data of 2014
+     *                                                                    from 2018 to 2022 will use data of 2022
+     *
+     * Knowing this, can we calculate impacts for those years simultaneosly (arent we doing that now anyway?) in 3 DB CALLS
+     * instead of doing 12, each for one year?
+     *
+     * LONG STORY SHORT:
+     *
+     * Can we do as much calls as different h3 data tables we need to attack (in this case 3)
+     * instead of doing as much calls as years we have to calculate impact for(in this case 12)
+     *
+     *There's another problem; every indicator/material might not have data available for the same years, an indicator having
+     * data for 2010 and 2020, and another indicator for 2012 and 2017
+     * seems like the root of the problem might be pretty early in the process, when deciding what (or more likely when) data to use
+     * for calculations
+     * what are the possible strategies to calculate the gap years? shgould it be configurable AFTER deployment?
+     * closest? that might be resolved by copying columns on the H3 info table on the H3 import
+     * mean between the closest ones? that's more difficult, might be possible in the H3 import? but it would be something
+     * not configurable once deployed
+     *
+
+     *
+     */
+
+    const materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data> =
+      await this.h3DataService.getAllMaterialH3sByClosestYear(materialId, year);
+    const indicatorH3s: Map<INDICATOR_TYPES, H3Data> =
+      await this.h3DataService.getIndicatorH3sByTypeAndClosestYear(
+        Object.values(INDICATOR_TYPES),
+        year,
+      );
+    const producerH3: H3Data = materialH3s.get(MATERIAL_TO_H3_TYPE.PRODUCER)!;
+    const harvestH3: H3Data = materialH3s.get(MATERIAL_TO_H3_TYPE.HARVEST)!;
+    const bioH3: H3Data = indicatorH3s.get(INDICATOR_TYPES.BIODIVERSITY_LOSS)!;
+    const deforestH3: H3Data = indicatorH3s.get(INDICATOR_TYPES.DEFORESTATION)!;
+    const carbonH3: H3Data = indicatorH3s.get(
+      INDICATOR_TYPES.CARBON_EMISSIONS,
+    )!;
+    const waterH3: H3Data = indicatorH3s.get(
+      INDICATOR_TYPES.UNSUSTAINABLE_WATER_USE,
+    )!;
+
+    const values: SelectQueryBuilder<unknown> = await connection
+      .createQueryBuilder()
+
+      .select(`sum( "harvestH3"."${harvestH3.h3columnName}" )`, 'harvestedArea')
+      .addSelect(
+        `sum( "producerH3"."${producerH3.h3columnName}" )`,
+        'production',
+      )
+      .addSelect(
+        `sum( "harvestH3"."${harvestH3.h3columnName}" * "deforestH3"."${deforestH3.h3columnName}" ` +
+          `* "bioH3"."${bioH3.h3columnName}" * (1/0.0001) )`,
+        'rawBiodiversity',
+      )
+      .addSelect(
+        `sum( "harvestH3"."${harvestH3.h3columnName}" * "deforestH3"."${deforestH3.h3columnName}" ` +
+          `* "carbonH3"."${carbonH3.h3columnName}")`,
+        'rawCarbon',
+      )
+      .addSelect(
+        `sum( "harvestH3"."${harvestH3.h3columnName}" * "deforestH3"."${deforestH3.h3columnName}" )`,
+        'rawDeforestation',
+      )
+      .addSelect(
+        `sum( "waterH3"."${waterH3.h3columnName}" * 0.001)`,
+        'rawWater',
+      )
+      .from(
+        `(select * from get_h3_uncompact_geo_region('${georegionId}', 6))`,
+        'geoRegion',
+      )
+      .innerJoin(
+        producerH3.h3tableName,
+        'producerH3',
+        `"producerH3".h3index = "geoRegion".h3index`,
+      )
+      .innerJoin(
+        harvestH3.h3tableName,
+        'harvestH3',
+        `"harvestH3".h3index = "geoRegion".h3index`,
+      )
+      .innerJoin(
+        bioH3.h3tableName,
+        'bioH3',
+        '"bioH3".h3index = "geoRegion".h3index',
+      )
+      .innerJoin(
+        carbonH3.h3tableName,
+        'carbonH3',
+        '"carbonH3".h3index = "geoRegion".h3index',
+      )
+      .innerJoin(
+        deforestH3.h3tableName,
+        'deforestH3',
+        '"deforestH3".h3index = "geoRegion".h3index',
+      )
+      .innerJoin(
+        waterH3.h3tableName,
+        'waterH3',
+        '"waterH3".h3index = "geoRegion".h3index',
+      );
+
+    const result: any = await queryRunner.query(values.getQuery());
+    if (!result.length)
+      this.logger.warn(
+        `Could not retrieve Sourcing Records with weighted indicator values`,
+      );
+    return result[0];
+  }
+
+  async calculateAllSourcingRecords(): Promise<
+    SourcingRecordsWithIndicatorRawDataDto[]
+  > {
     const connection: Connection = getConnection();
     const queryRunner: QueryRunner = connection.createQueryRunner();
     await queryRunner.connect();
     await queryRunner.startTransaction();
-    const result: Entity[][] = [];
 
+    let result: SourcingRecordsWithIndicatorRawDataDto[] = [];
     try {
-      // MAIN LOGIC
-
-      // STEPS
-      /**
-       * 1. Get material h3 data table and column name
-       * 1.1 For each year, get the closest available material h3 data
-       * 2. Get indicator h3 data table and column name
-       * 2.1 For each year, get the closest available material h3 data
-       ** Look at how interventions impact calculus implements this.
-       *
-       * 2.1 Get deforestation indicator h3 data and column name (because this indicator needs to be crossed with this data)
-       *
-       * CRAZY IDEAZ:
-       * 1. We have 12 years to calculate impact: 2010-2022 (12 DB calls)
-       * 2. We have 3 available years to calculate impact: 2010, 2014, 2020
-       *
-       * Before performing any call, can we determine that Sourcing Records from 2010 to 2012 will use data of 2010
-       *                                                                    from 2013 to 2017  will use data of 2014
-       *                                                                    from 2018 to 2022 will use data of 2022
-       *
-       * Knowing this, can we calculate impacts for those years simultaneosly (arent we doing that now anyway?) in 3 DB CALLS
-       * instead of doing 12, each for one year?
-       *
-       * LONG STORY SHORT:
-       *
-       * Can we do as much calls as different h3 data tables we need to attack (in this case 3)
-       * instead of doing as much calls as years we have to calculate impact for(in this case 12)
-       *
-       *
-
-       *
-       */
-      let materialH3data: any;
-      let indictorH3Data: any;
-
-      const result: any = await this.createQueryBuilder().select([
-        'sr.id as "sourcingRecordId",\n          sr.tonnage,\n          sr.year,\n          slwithmaterialh3data.id as "sourcingLocationId",\n          slwithmaterialh3data.production,\n          slwithmaterialh3data."harvestedArea",\n          slwithmaterialh3data."rawDeforestation",\n          slwithmaterialh3data."rawBiodiversity",\n          slwithmaterialh3data."rawCarbon",\n          slwithmaterialh3data."rawWater",\n          slwithmaterialh3data."materialH3DataId"',
-      ]).from((subQuery:  SelectQueryBuilder<any> )=> subQuery.select(`sum()`)
-        .from(`get_h3_uncompact_geo_region($1, $2)`, 'geoRegion')
-        .innerJoin('$3', 'materialH3', `materialH3.h3index = geoRegion.h3index`)
+      const sourcingRecordsQuery: SelectQueryBuilder<unknown> = connection
+        .createQueryBuilder()
+        .select([
+          `sr.id as "sourcingRecordId",
+          sr.tonnage,
+          sr.year,
+          sl.id as "sourcingLocationId",
+          sl."materialId",
+          sl."geoRegionId",
+          mth."h3DataId" as "materialH3DataId"`,
+        ])
+        .from('sourcing_records', 'sr')
+        .innerJoin('sourcing_location', 'sl', 'sl.id = sr."sourcingLocationId"')
         .innerJoin(
-          '$4',
-          'bioDiversityh3',
-          'bioDiversityh3.h3index = geoRegion.h3index',
+          (subQuery: SelectQueryBuilder<any>) => {
+            return subQuery
+              .select('"materialId"')
+              .addSelect('"h3DataId"')
+              .from('material_to_h3', 'material_to_h3')
+              .where(`type='${MATERIAL_TO_H3_TYPE.HARVEST}'`);
+          },
+          'mth',
+          'mth."materialId" = sl."materialId"',
         )
-        .innerJoin(
-          '$5',
-          'deforestationH3',
-          'deforestation.h3index = geoRegion.h3index',
-        );
-
-      // This
-      const data: any = await this.createQueryBuilder()
-        .select(`sum()`)
-        .from(`get_h3_uncompact_geo_region($1, $2)`, 'geoRegion')
-        .innerJoin('$3', 'materialH3', `materialH3.h3index = geoRegion.h3index`)
-        .innerJoin(
-          '$4',
-          'bioDiversityh3',
-          'bioDiversityh3.h3index = geoRegion.h3index',
-        )
-        .innerJoin(
-          '$5',
-          'deforestationH3',
-          'deforestation.h3index = geoRegion.h3index',
-        );
-      // commit transaction if every chunk was saved successfully
+        .where('sl."scenarioInterventionId" IS NULL')
+        .andWhere('sl."interventionType" IS NULL');
+
+      const sourcingRecords: any[] = await queryRunner.query(
+        sourcingRecordsQuery.getQuery(),
+      );
+      result = await Promise.all(
+        sourcingRecords.map(async (sourcingRecord: any) => {
+          const rawValues: any = await this.calculateImpact(
+            connection,
+            queryRunner,
+            sourcingRecord.geoRegionId,
+            sourcingRecord.materialId,
+            sourcingRecord.year,
+          );
+
+          return {
+            sourcingRecordId: sourcingRecord.sourcingRecordId,
+            tonnage: sourcingRecord.tonnage,
+            year: sourcingRecord.year,
+
+            sourcingLocationId: sourcingRecord.sourcingLocationId,
+            production: rawValues.production,
+            harvestedArea: rawValues.harvestedArea,
+
+            rawDeforestation: rawValues.rawDeforestation,
+            rawBiodiversity: rawValues.rawBiodiversity,
+            rawCarbon: rawValues.rawCarbon,
+            rawWater: rawValues.rawWater,
+
+            materialH3DataId: sourcingRecord.materialH3DataId,
+          };
+        }),
+      );
+
       await queryRunner.commitTransaction();
     } catch (err) {
       // rollback changes before throwing error
@@ -96,6 +234,11 @@ export abstract class AppBaseRepository<Entity> extends Repository<Entity> {
       // release query runner which is manually created
       await queryRunner.release();
     }
-    return result.flat();
+
+    if (!result.length) {
+      throw new Error('No raw impact data could be calculated');
+    }
+
+    return result;
   }
 }

From fb861a70af0d8fddb29f924089ca0dfdf48229b1 Mon Sep 17 00:00:00 2001
From: KevSanchez <kew.sanchez@gmail.com>
Date: Fri, 5 Aug 2022 10:00:44 +0200
Subject: [PATCH 3/8] chore(indicatorrecord): Create all sourcing records
 refactor 1st prototype

---
 .../indicator-records.service.ts              |   3 +-
 .../services/impact-calculator.service.ts     | 104 ++++++++++++++++--
 .../indicator-records.service.spec.ts         |   6 +-
 3 files changed, 99 insertions(+), 14 deletions(-)

diff --git a/api/src/modules/indicator-records/indicator-records.service.ts b/api/src/modules/indicator-records/indicator-records.service.ts
index 3e0d8f4c2..96572d994 100644
--- a/api/src/modules/indicator-records/indicator-records.service.ts
+++ b/api/src/modules/indicator-records/indicator-records.service.ts
@@ -167,7 +167,8 @@ export class IndicatorRecordsService extends AppBaseService<
     ];
 
     const rawData: SourcingRecordsWithIndicatorRawDataDto[] =
-      await this.indicatorRecordRepository.getIndicatorRawDataForAllSourcingRecords();
+      //await this.indicatorRecordRepository.getIndicatorRawDataForAllSourcingRecords();
+      await this.impactCalculatorService.calculateAllSourcingRecords();
 
     const calculatedData2: IndicatorRecordCalculatedValuesDto[] = rawData.map(
       (sourcingRecordData: SourcingRecordsWithIndicatorRawDataDto) => {
diff --git a/api/src/modules/indicator-records/services/impact-calculator.service.ts b/api/src/modules/indicator-records/services/impact-calculator.service.ts
index b088e007c..4c2777a68 100644
--- a/api/src/modules/indicator-records/services/impact-calculator.service.ts
+++ b/api/src/modules/indicator-records/services/impact-calculator.service.ts
@@ -1,32 +1,25 @@
 import {
   Connection,
-  EntityRepository,
   getConnection,
   QueryRunner,
-  Repository,
   SelectQueryBuilder,
 } from 'typeorm';
 import { Injectable, Logger } from '@nestjs/common';
-import { SaveOptions } from 'typeorm/repository/SaveOptions';
 import { MATERIAL_TO_H3_TYPE } from 'modules/materials/material-to-h3.entity';
-import { H3DataService } from 'modules/h3-data/h3-data.service';
 import { H3Data } from 'modules/h3-data/h3-data.entity';
 import { INDICATOR_TYPES } from 'modules/indicators/indicator.entity';
-import { SourcingRecordsWithIndicatorRawDataDto } from '../../sourcing-records/dto/sourcing-records-with-indicator-raw-data.dto';
+import { SourcingRecordsWithIndicatorRawDataDto } from 'modules/sourcing-records/dto/sourcing-records-with-indicator-raw-data.dto';
 
 @Injectable()
 export class ImpactCalculatorService {
   logger: Logger = new Logger(this.constructor.name);
 
-  constructor(private readonly h3DataService: H3DataService) {}
-
   async calculateImpact(
     connection: Connection,
     queryRunner: QueryRunner,
     georegionId: string,
     materialId: string,
     year: number,
-    options?: SaveOptions,
   ): Promise<any[]> {
     // MAIN LOGIC
 
@@ -70,9 +63,16 @@ export class ImpactCalculatorService {
      */
 
     const materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data> =
-      await this.h3DataService.getAllMaterialH3sByClosestYear(materialId, year);
+      await this.getAllMaterialH3sByClosestYear(
+        connection,
+        queryRunner,
+        materialId,
+        year,
+      );
     const indicatorH3s: Map<INDICATOR_TYPES, H3Data> =
-      await this.h3DataService.getIndicatorH3sByTypeAndClosestYear(
+      await this.getIndicatorH3sByTypeAndClosestYear(
+        connection,
+        queryRunner,
         Object.values(INDICATOR_TYPES),
         year,
       );
@@ -241,4 +241,88 @@ export class ImpactCalculatorService {
 
     return result;
   }
+
+  getIndicatorH3sByTypeAndClosestYear(
+    connecttion: Connection,
+    queryRunner: QueryRunner,
+    indicatorTypes: INDICATOR_TYPES[],
+    year: number,
+  ): Promise<Map<INDICATOR_TYPES, H3Data>> {
+    return indicatorTypes.reduce(
+      async (
+        previousValue: Promise<Map<INDICATOR_TYPES, H3Data>>,
+        currentIndicatorType: INDICATOR_TYPES,
+      ) => {
+        const queryBuilder: SelectQueryBuilder<H3Data> = connecttion
+          .createQueryBuilder()
+          .select(' h3data.*')
+          .from(H3Data, 'h3data')
+          .leftJoin(
+            'indicator',
+            'indicator',
+            'h3data.indicatorId = indicator.id',
+          )
+          .where(`indicator.nameCode = '${currentIndicatorType}'`)
+          .orderBy(`ABS(h3data.year - ${year})`, 'ASC')
+          .limit(1);
+
+        const map: Map<INDICATOR_TYPES, H3Data> = await previousValue;
+
+        try {
+          const result: any = await queryRunner.query(queryBuilder.getQuery());
+
+          if (result.length) {
+            map.set(currentIndicatorType, result[0]);
+          }
+        } catch (err) {
+          console.error(err);
+        }
+
+        return map;
+      },
+      Promise.resolve(new Map()),
+    );
+  }
+
+  getAllMaterialH3sByClosestYear(
+    connecttion: Connection,
+    queryRunner: QueryRunner,
+    materialId: string,
+    year: number,
+  ): Promise<Map<MATERIAL_TO_H3_TYPE, H3Data>> {
+    return Object.values(MATERIAL_TO_H3_TYPE).reduce(
+      async (
+        previousValue: Promise<Map<MATERIAL_TO_H3_TYPE, H3Data>>,
+        currentMaterialToH3Type: MATERIAL_TO_H3_TYPE,
+      ) => {
+        const queryBuilder: SelectQueryBuilder<H3Data> = connecttion
+          .createQueryBuilder()
+          .select('h3data.*')
+          .from(H3Data, 'h3data')
+          .leftJoin(
+            'material_to_h3',
+            'materialsToH3s',
+            'materialsToH3s.h3DataId = h3data.id',
+          )
+          .where(`materialsToH3s.materialId = '${materialId}'`)
+          .andWhere(`materialsToH3s.type = '${currentMaterialToH3Type}'`)
+          .orderBy(`ABS(h3data.year - ${year})`, 'ASC')
+          .limit(1);
+
+        const map: Map<MATERIAL_TO_H3_TYPE, H3Data> = await previousValue;
+        try {
+          const result: any = await queryRunner.query(queryBuilder.getQuery());
+
+          if (result.length) {
+            map.set(currentMaterialToH3Type, result[0]);
+          }
+        } catch (err) {
+          console.error(err);
+        }
+
+        return map;
+      },
+      Promise.resolve(new Map()),
+    );
+  }
 }
diff --git a/api/test/integration/indicator-record/indicator-records.service.spec.ts b/api/test/integration/indicator-record/indicator-records.service.spec.ts
index 26f9dbf31..c8c8a08c5 100644
--- a/api/test/integration/indicator-record/indicator-records.service.spec.ts
+++ b/api/test/integration/indicator-record/indicator-records.service.spec.ts
@@ -508,7 +508,7 @@ describe('Indicator Records Service', () => {
         indicatorPreconditions.carbonEmissions,
         materialH3DataProducer1,
         indicatorPreconditions.sourcingRecord1.id,
-        29.788819307125873,
+        29.788819875776397,
         1610,
       );
       await checkCreatedIndicatorRecord(
@@ -540,7 +540,7 @@ describe('Indicator Records Service', () => {
         indicatorPreconditions.carbonEmissions,
         materialH3DataProducer2,
         indicatorPreconditions.sourcingRecord2.id,
-        14.894409653562937,
+        14.894409937888199,
         1610,
       );
       await checkCreatedIndicatorRecord(
@@ -551,7 +551,7 @@ describe('Indicator Records Service', () => {
         0.7700000181794167,
         1610,
       );
-    });
+    }, 100000000);
 
     test("When creating indicators without provided coefficients and the material has H3 data, the raw values for the calculations should be read from the cache if they're already present on the CachedData", async () => {
       //ARRANGE

From 805f07897b58777063cf2c29421597862f16129e Mon Sep 17 00:00:00 2001
From: KevSanchez <kew.sanchez@gmail.com>
Date: Tue, 30 Aug 2022 13:22:10 +0200
Subject: [PATCH 4/8] chore(indicatorrecord): Adds a feature toggle to
 indicator record calculation

Now, wether the old stored functions, or the new API generated SQL queries are used for the calculations of indicator records at import time, is toggable via environment variable, SIMPLE_IMPORT_CALCULATIONS
---
 api/config/custom-environment-variables.json           |  3 +++
 api/config/default.json                                |  3 +++
 api/config/test.json                                   |  3 +++
 .../indicator-records/indicator-records.service.ts     |  8 +++++---
 .../indicator-record/indicator-records.service.spec.ts | 10 ++++++----
 5 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/api/config/custom-environment-variables.json b/api/config/custom-environment-variables.json
index befeab631..6433676e1 100644
--- a/api/config/custom-environment-variables.json
+++ b/api/config/custom-environment-variables.json
@@ -48,5 +48,8 @@
   },
   "map": {
     "distributed": "DISTRIBUTED_MAP"
+  },
+  "featureFlags": {
+    "simpleImportCalculations": "SIMPLE_IMPORT_CALCULATIONS"
   }
 }
diff --git a/api/config/default.json b/api/config/default.json
index a23b7f38f..20febeefc 100644
--- a/api/config/default.json
+++ b/api/config/default.json
@@ -57,5 +57,8 @@
 
   "map": {
     "distributed": true
+  },
+  "featureFlags": {
+    "simpleImportCalculations": "false"
   }
 }
diff --git a/api/config/test.json b/api/config/test.json
index c0d1e2270..01612cc7f 100644
--- a/api/config/test.json
+++ b/api/config/test.json
@@ -24,5 +24,8 @@
   },
   "geolocation": {
     "gmapsApiKey": "myVeryBadJWTSecretForTests"
+  },
+  "featureFlags": {
+    "simpleImportCalculations": "true"
   }
 }
diff --git a/api/src/modules/indicator-records/indicator-records.service.ts b/api/src/modules/indicator-records/indicator-records.service.ts
index 96572d994..aab22b70e 100644
--- a/api/src/modules/indicator-records/indicator-records.service.ts
+++ b/api/src/modules/indicator-records/indicator-records.service.ts
@@ -166,9 +166,11 @@ export class IndicatorRecordsService extends AppBaseService<
       INDICATOR_TYPES.BIODIVERSITY_LOSS,
     ];
 
-    const rawData: SourcingRecordsWithIndicatorRawDataDto[] =
-      //await this.indicatorRecordRepository.getIndicatorRawDataForAllSourcingRecords();
-      await this.impactCalculatorService.calculateAllSourcingRecords();
+    const rawData: SourcingRecordsWithIndicatorRawDataDto[] = config.get(
+      'featureFlags.simpleImportCalculations',
+    )
+      ? await this.indicatorRecordRepository.getIndicatorRawDataForAllSourcingRecords()
+      : await this.impactCalculatorService.calculateAllSourcingRecords();
 
     const calculatedData2: IndicatorRecordCalculatedValuesDto[] = rawData.map(
       (sourcingRecordData: SourcingRecordsWithIndicatorRawDataDto) => {
diff --git a/api/test/integration/indicator-record/indicator-records.service.spec.ts b/api/test/integration/indicator-record/indicator-records.service.spec.ts
index c8c8a08c5..ed875da72 100644
--- a/api/test/integration/indicator-record/indicator-records.service.spec.ts
+++ b/api/test/integration/indicator-record/indicator-records.service.spec.ts
@@ -395,6 +395,7 @@ describe('Indicator Records Service', () => {
         MATERIAL_TO_H3_TYPE.HARVEST,
       );
 
+      //ACT
       const calculatedRecords =
         await indicatorRecordService.createIndicatorRecordsBySourcingRecords(
           sourcingData,
@@ -480,7 +481,6 @@ describe('Indicator Records Service', () => {
       );
 
       //ACT
-
       await indicatorRecordService.createIndicatorRecordsForAllSourcingRecords();
 
       //ASSERT
@@ -846,8 +846,10 @@ describe('Indicator Records Service', () => {
     expect(createdRecords.length).toEqual(1);
     expect(createdRecords[0].sourcingRecordId).toEqual(sourcingRecordId);
     expect(createdRecords[0].status).toEqual(INDICATOR_RECORD_STATUS.SUCCESS);
-    expect(createdRecords[0].value).toEqual(recordValue);
-    expect(createdRecords[0].scaler).toEqual(scalerValue);
+    expect(createdRecords[0].value).toBeCloseTo(recordValue);
+    if (scalerValue) {
+      expect(createdRecords[0].scaler).toBeCloseTo(scalerValue);
+    }
     expect(createdRecords[0].materialH3DataId).toEqual(materialH3Data.h3DataId);
     //Inidicator Coefficients are not checked because it's not used
   }
@@ -870,7 +872,7 @@ describe('Indicator Records Service', () => {
     expect(cachedData).toBeDefined();
     expect(cachedData?.data).toBeDefined();
     expect(cachedData?.type).toEqual(type);
-    expect((cachedData?.data as CachedRawValue).rawValue).toEqual(value);
+    expect((cachedData?.data as CachedRawValue).rawValue).toBeCloseTo(value, 5);
   }
 
   async function createPreconditions(): Promise<any> {

From a2dc0fd54b2c624e914767b0a077eab1ae2fe1ac Mon Sep 17 00:00:00 2001
From: KevSanchez <kew.sanchez@gmail.com>
Date: Tue, 30 Aug 2022 18:16:06 +0200
Subject: [PATCH 5/8] chore(indicatorrecord): Small correction + documentation

---
 .../indicator-records.service.ts              |  4 +--
 .../services/impact-calculator.service.ts     | 33 +++++++++++++++----
 2 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/api/src/modules/indicator-records/indicator-records.service.ts b/api/src/modules/indicator-records/indicator-records.service.ts
index aab22b70e..62ca89568 100644
--- a/api/src/modules/indicator-records/indicator-records.service.ts
+++ b/api/src/modules/indicator-records/indicator-records.service.ts
@@ -169,8 +169,8 @@ export class IndicatorRecordsService extends AppBaseService<
     const rawData: SourcingRecordsWithIndicatorRawDataDto[] = config.get(
       'featureFlags.simpleImportCalculations',
     )
-      ? await this.indicatorRecordRepository.getIndicatorRawDataForAllSourcingRecords()
-      : await this.impactCalculatorService.calculateAllSourcingRecords();
+      ? await this.impactCalculatorService.calculateAllSourcingRecords()
+      : await this.indicatorRecordRepository.getIndicatorRawDataForAllSourcingRecords();
 
     const calculatedData2: IndicatorRecordCalculatedValuesDto[] = rawData.map(
       (sourcingRecordData: SourcingRecordsWithIndicatorRawDataDto) => {
diff --git a/api/src/modules/indicator-records/services/impact-calculator.service.ts b/api/src/modules/indicator-records/services/impact-calculator.service.ts
index 4c2777a68..7c5630b22 100644
--- a/api/src/modules/indicator-records/services/impact-calculator.service.ts
+++ b/api/src/modules/indicator-records/services/impact-calculator.service.ts
@@ -21,8 +21,6 @@ export class ImpactCalculatorService {
     materialId: string,
     year: number,
   ): Promise<any[]> {
-    // MAIN LOGIC
-
     // STEPS
     /**
      * 1. Get material h3 data table and column name
@@ -90,6 +88,7 @@ export class ImpactCalculatorService {
     const values: SelectQueryBuilder<unknown> = await connection
       .createQueryBuilder()
 
+      //SELECT aggregation statements
       .select(`sum( "harvestH3"."${harvestH3.h3columnName}" )`, 'harvestedArea')
       .addSelect(
         `sum( "producerH3"."${producerH3.h3columnName}" )`,
@@ -113,6 +112,7 @@ export class ImpactCalculatorService {
         `sum( "waterH3"."${waterH3.h3columnName}" * 0.001)`,
         'rawWater',
       )
+      //FROM
       .from(
         `(select * from get_h3_uncompact_geo_region('${georegionId}', 6))`,
         'geoRegion',
@@ -242,8 +242,18 @@ export class ImpactCalculatorService {
     return result;
   }
 
+  /**
+   * Generates a Map that contains for each Indicator Type the corresponding H3Data (if there's H3Data present for the year 2010 and 2020, and 2013
+   * is requested, it will return the H3Data of 2010)
+   * NOTE: implemented here to be able to reuse the connection object used in the main calculation SQL query and use the
+   * transaction capability
+   * @param connection
+   * @param queryRunner
+   * @param indicatorTypes
+   * @param year
+   */
   getIndicatorH3sByTypeAndClosestYear(
-    connecttion: Connection,
+    connection: Connection,
     queryRunner: QueryRunner,
     indicatorTypes: INDICATOR_TYPES[],
     year: number,
@@ -253,7 +263,7 @@ export class ImpactCalculatorService {
         previousValue: Promise<Map<INDICATOR_TYPES, H3Data>>,
         currentIndicatorType: INDICATOR_TYPES,
       ) => {
-        const queryBuilder: SelectQueryBuilder<H3Data> = connecttion
+        const queryBuilder: SelectQueryBuilder<H3Data> = connection
           .createQueryBuilder()
           .select(' h3data.*')
           .from(H3Data, 'h3data')
@@ -284,8 +294,19 @@ export class ImpactCalculatorService {
     );
   }
 
+  /**
+   * Generates a Map that contains, for the given materialId, the corresponding H3Data for each of the material's
+   * MATERIAL_TO_H3_TYPE, closest to the given year (if there's H3Data present for the year 2010 and 2020, and 2013
+   * is requested, it will return the H3Data of 2010)
+   * NOTE: implemented here to be able to reuse the connection object used in the main calculation SQL query and use the
+   * transaction capability
+   * @param connection
+   * @param queryRunner
+   * @param materialId
+   * @param year
+   */
   getAllMaterialH3sByClosestYear(
-    connecttion: Connection,
+    connection: Connection,
     queryRunner: QueryRunner,
     materialId: string,
     year: number,
@@ -295,7 +316,7 @@ export class ImpactCalculatorService {
         previousValue: Promise<Map<MATERIAL_TO_H3_TYPE, H3Data>>,
         currentMaterialToH3Type: MATERIAL_TO_H3_TYPE,
       ) => {
-        const queryBuilder: SelectQueryBuilder<H3Data> = connecttion
+        const queryBuilder: SelectQueryBuilder<H3Data> = connection
           .createQueryBuilder()
           .select('h3data.*')
           .from(H3Data, 'h3data')

From f5e397fd26b389b8975dbad509750dd4eb15032e Mon Sep 17 00:00:00 2001
From: KevSanchez <kew.sanchez@gmail.com>
Date: Fri, 2 Sep 2022 10:54:45 +0200
Subject: [PATCH 6/8] chore(ImpactCalculator): Polished new service to
 calculate raw values for all sourcing records

The prototpye for for calculating all raw values for all sourcing records has revamped/polished to final status, with approval pending once tested. Also the the feature flag selection has been moved to sourcing data import along with a bit of refactoring.
---
 .../sourcing-data-import.service.ts           |   6 +-
 .../indicator-records.service.ts              |  56 +-
 .../services/impact-calculator.service.ts     | 620 ++++++++++++------
 ...ing-records-with-indicator-raw-data.dto.ts |   5 +
 .../indicator-records.service.spec.ts         |   6 +-
 5 files changed, 476 insertions(+), 217 deletions(-)

diff --git a/api/src/modules/import-data/sourcing-data/sourcing-data-import.service.ts b/api/src/modules/import-data/sourcing-data/sourcing-data-import.service.ts
index c29ec98da..162a739e3 100644
--- a/api/src/modules/import-data/sourcing-data/sourcing-data-import.service.ts
+++ b/api/src/modules/import-data/sourcing-data/sourcing-data-import.service.ts
@@ -29,6 +29,7 @@ import { MissingH3DataError } from 'modules/indicator-records/errors/missing-h3-
 import { TasksService } from 'modules/tasks/tasks.service';
 import { IndicatorRecord } from 'modules/indicator-records/indicator-record.entity';
 import { ScenariosService } from 'modules/scenarios/scenarios.service';
+import * as config from 'config';
 
 export interface LocationData {
   locationAddressInput?: string;
@@ -141,7 +142,10 @@ export class SourcingDataImportService {
       //       Getting H3 data for calculations is done within DB so we need to improve the error handling
       //       TBD: What to do when there is no H3 for a Material
       try {
-        await this.indicatorRecordsService.createIndicatorRecordsForAllSourcingRecords();
+        // TODO remove feature flag selection, once the solution has been approved
+        config.get('featureFlags.simpleImportCalculations')
+          ? await this.indicatorRecordsService.createIndicatorRecordsForAllSourcingRecordsV2()
+          : await this.indicatorRecordsService.createIndicatorRecordsForAllSourcingRecords();
         this.logger.log('Indicator Records generated');
         // TODO: Hack to force m.view refresh once Indicator Records are persisted. This should be automagically
         //       done by the AfterInser() event listener placed in indicator-record.entity.ts
diff --git a/api/src/modules/indicator-records/indicator-records.service.ts b/api/src/modules/indicator-records/indicator-records.service.ts
index 62ca89568..36bc4069f 100644
--- a/api/src/modules/indicator-records/indicator-records.service.ts
+++ b/api/src/modules/indicator-records/indicator-records.service.ts
@@ -166,11 +166,8 @@ export class IndicatorRecordsService extends AppBaseService<
       INDICATOR_TYPES.BIODIVERSITY_LOSS,
     ];
 
-    const rawData: SourcingRecordsWithIndicatorRawDataDto[] = config.get(
-      'featureFlags.simpleImportCalculations',
-    )
-      ? await this.impactCalculatorService.calculateAllSourcingRecords()
-      : await this.indicatorRecordRepository.getIndicatorRawDataForAllSourcingRecords();
+    const rawData: SourcingRecordsWithIndicatorRawDataDto[] =
+      await this.indicatorRecordRepository.getIndicatorRawDataForAllSourcingRecords();
 
     const calculatedData2: IndicatorRecordCalculatedValuesDto[] = rawData.map(
       (sourcingRecordData: SourcingRecordsWithIndicatorRawDataDto) => {
@@ -226,6 +223,55 @@ export class IndicatorRecordsService extends AppBaseService<
     await this.indicatorRecordRepository.saveChunks(indicatorRecords);
   }
 
+  async createIndicatorRecordsForAllSourcingRecordsV2(): Promise<void> {
+    //Calculate raw impact Data for all available indicators on the system
+    const indicators: Indicator[] =
+      await this.indicatorService.getAllIndicators();
+
+    const rawData: SourcingRecordsWithIndicatorRawDataDto[] =
+      await this.impactCalculatorService.calculateAllRawValuesForAllSourcingRecords(
+        indicators,
+      );
+
+    const calculatedData: IndicatorRecordCalculatedValuesDto[] = rawData.map(
+      (sourcingRecordData: SourcingRecordsWithIndicatorRawDataDto) => {
+        // Small DTO transformation for calculation method
+        const indicatorComputedRawDataDto: IndicatorComputedRawDataDto = {
+          harvestedArea: sourcingRecordData.harvestedArea,
+          production: sourcingRecordData.production,
+          indicatorValues: sourcingRecordData.indicatorValues,
+        };
+
+        return this.calculateIndicatorValues(
+          sourcingRecordData.sourcingRecordId,
+          sourcingRecordData.tonnage,
+          sourcingRecordData.materialH3DataId,
+          indicatorComputedRawDataDto,
+        );
+      },
+    );
+
+    // Create IndicatorRecord instances
+    const indicatorRecords: IndicatorRecord[] = [];
+    for (const calculatedIndicatorRecords of calculatedData) {
+      for (const indicator of indicators) {
+        indicatorRecords.push(
+          IndicatorRecord.merge(new IndicatorRecord(), {
+            value: calculatedIndicatorRecords.values.get(
+              indicator.nameCode as INDICATOR_TYPES,
+            ),
+            indicatorId: indicator.id,
+            status: INDICATOR_RECORD_STATUS.SUCCESS,
+            sourcingRecordId: calculatedIndicatorRecords.sourcingRecordId,
+            scaler: calculatedIndicatorRecords.production,
+            materialH3DataId: calculatedIndicatorRecords.materialH3DataId,
+          }),
+        );
+      }
+    }
+    await this.indicatorRecordRepository.saveChunks(indicatorRecords);
+  }
+
   /**
    * @description Creates Indicator-Records for a single Sourcing-Record, by first retrieving Raw Indicator data from the DB, then applying
    * the methodology and persist new Indicator Records
diff --git a/api/src/modules/indicator-records/services/impact-calculator.service.ts b/api/src/modules/indicator-records/services/impact-calculator.service.ts
index 7c5630b22..340056fd4 100644
--- a/api/src/modules/indicator-records/services/impact-calculator.service.ts
+++ b/api/src/modules/indicator-records/services/impact-calculator.service.ts
@@ -4,62 +4,241 @@ import {
   QueryRunner,
   SelectQueryBuilder,
 } from 'typeorm';
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { MATERIAL_TO_H3_TYPE } from 'modules/materials/material-to-h3.entity';
 import { H3Data } from 'modules/h3-data/h3-data.entity';
-import { INDICATOR_TYPES } from 'modules/indicators/indicator.entity';
+import {
+  Indicator,
+  INDICATOR_TYPES,
+} from 'modules/indicators/indicator.entity';
 import { SourcingRecordsWithIndicatorRawDataDto } from 'modules/sourcing-records/dto/sourcing-records-with-indicator-raw-data.dto';
 
+type MaterialSelectStatementGenerator = (
+  materialsH3s: Map<MATERIAL_TO_H3_TYPE, H3Data>,
+) => string;
+
+type IndicatorSelectStatementGenerator = (
+  materialsH3s: Map<MATERIAL_TO_H3_TYPE, H3Data>,
+  indicatorH3s: Map<INDICATOR_TYPES, H3Data>,
+) => string;
+
 @Injectable()
 export class ImpactCalculatorService {
   logger: Logger = new Logger(this.constructor.name);
+  private readonly materialSelectStatmenteGenerator: Record<
+    MATERIAL_TO_H3_TYPE,
+    MaterialSelectStatementGenerator
+  > = {
+    [MATERIAL_TO_H3_TYPE.HARVEST]: harvestMaterialSelectStatementGenerator,
+    [MATERIAL_TO_H3_TYPE.PRODUCER]: producerMaterialSelectStatementGenerator,
+  };
+  private readonly indicatorSelectStatementGenerator: Record<
+    INDICATOR_TYPES,
+    IndicatorSelectStatementGenerator
+  > = {
+    [INDICATOR_TYPES.BIODIVERSITY_LOSS]: bioDiversitySelectStatementGenerator,
+    [INDICATOR_TYPES.CARBON_EMISSIONS]: carbonSelectStatementGenerator,
+    [INDICATOR_TYPES.DEFORESTATION]: deforestationSelectStatementGenerator,
+    [INDICATOR_TYPES.UNSUSTAINABLE_WATER_USE]: waterSelectStatementGenerator,
+  };
+
+  // STEPS
+  /**
+   * 1. Get material h3 data table and column name
+   * 1.1 For each year, get the closest available material h3 data
+   * 2. Get indicator h3 data table and column name
+   * 2.1 For each year, get the closest available material h3 data
+   ** Look at how interventions impact calculus implements this.
+   *
+   * 2.1 Get deforestation indicator h3 data and column name (because this indicator needs to be crossed with this data)
+   *
+   * CRAZY IDEAZ:
+   * 1. We have 12 years to calculate impact: 2010-2022 (12 DB calls)
+   * 2. We have 3 available years to calculate impact: 2010, 2014, 2020
+   *
+   * Before performing any call, can we determine that Sourcing Records from 2010 to 2012 will use data of 2010
+   *                                                                    from 2013 to 2017  will use data of 2014
+   *                                                                    from 2018 to 2022 will use data of 2022
+   *
+   * Knowing this, can we calculate impacts for those years simultaneosly (arent we doing that now anyway?) in 3 DB CALLS
+   * instead of doing 12, each for one year?
+   *
+   * LONG STORY SHORT:
+   *
+   * Can we do as much calls as different h3 data tables we need to attack (in this case 3)
+   * instead of doing as much calls as years we have to calculate impact for(in this case 12)
+   *
+   *There's another problem; every indicator/material might not have data available for the same years, an indicator having
+   * data for 2010 and 2020, and another indicator for 2012 and 2017
+   * seems like the root of the problem might be pretty early in the process, when deciding what (or more likely when) data to use
+   * for calculations
+   * what are the possible strategies to calculate the gap years? shgould it be configurable AFTER deployment?
+   * closest? that might be resolved by copying columns on the H3 info table on the H3 import
+   * mean between the closest ones? that's more difficult, might be possible in the H3 import? but it would be something
+   * not configurable once deployed
+   */
+
+  /**
+   * Calculates raw values for all indicators available in the system and all types of material,
+   * from all SourcingRecords in the DB that are not part of an intervention.
+   * - First, it gets all Sourcing Records, plus related data (its sourcing location, material)
+   * - Then for each sourcing record, it gets all the closest H3 Data to its years, and then
+   *   calculates the material/indicator raw values in a single DB call
+   * @param indicators
+   */
+  async calculateAllRawValuesForAllSourcingRecords(
+    indicators: Indicator[],
+  ): Promise<SourcingRecordsWithIndicatorRawDataDto[]> {
+    const connection: Connection = getConnection();
+    const queryRunner: QueryRunner = connection.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+
+    this.logger.log(
+      'Calculating All Raw Impact/Material Values for all SourcingRecords',
+    );
+
+    let result: SourcingRecordsWithIndicatorRawDataDto[] = [];
+    try {
+      const sourcingRecords: any[] = await this.getAllSourcingRecordsData(
+        connection,
+        queryRunner,
+      );
+
+      //Generate SourcingRecordsWithIndicatorRawDataDtos from each sourcing record's
+      //georegion, material and year, for the given indicators
+      result = await Promise.all(
+        sourcingRecords.map(async (sourcingRecord: any) => {
+          const rawValues: any =
+            await this.calculateAllRawValuesForGeoRegionAndYear(
+              connection,
+              queryRunner,
+              indicators,
+              sourcingRecord.geoRegionId,
+              sourcingRecord.materialId,
+              sourcingRecord.year,
+              5, // Max resolution
+            );
+
+          return this.createResultInstance(
+            sourcingRecord,
+            rawValues,
+            indicators,
+          );
+        }),
+      );
+
+      await queryRunner.commitTransaction();
+    } catch (err) {
+      // rollback changes before throwing error
+      await queryRunner.rollbackTransaction();
+      this.logger.error(err);
+    } finally {
+      // release query runner which is manually created
+      await queryRunner.release();
+    }
+
+    if (!result.length) {
+      throw new Error(
+        'No raw data could be calculated could be calculated for all sourcing records',
+      );
+    }
 
-  async calculateImpact(
+    return result;
+  }
+
+  private async getAllSourcingRecordsData(
+    connection: Connection,
+    queryRunner: QueryRunner,
+  ): Promise<any[]> {
+    const sourcingRecordsQuery: SelectQueryBuilder<unknown> = connection
+      .createQueryBuilder()
+      .select([
+        `sr.id as "sourcingRecordId",
+          sr.tonnage,
+          sr.year,
+          sl.id as "sourcingLocationId",
+          sl."materialId",
+          sl."geoRegionId",
+          mth."h3DataId" as "materialH3DataId"`,
+      ])
+      .from('sourcing_records', 'sr')
+      .innerJoin('sourcing_location', 'sl', 'sl.id = sr."sourcingLocationId"')
+      .innerJoin(
+        (subQuery: SelectQueryBuilder<any>) => {
+          return subQuery
+            .select('"materialId"')
+            .addSelect('"h3DataId"')
+            .from('material_to_h3', 'material_to_h3')
+            .where(`type='${MATERIAL_TO_H3_TYPE.HARVEST}'`);
+        },
+        'mth',
+        'mth."materialId" = sl."materialId"',
+      )
+      .where('sl."scenarioInterventionId" IS NULL')
+      .andWhere('sl."interventionType" IS NULL');
+
+    return queryRunner.query(sourcingRecordsQuery.getQuery());
+  }
+
+  private createResultInstance(
+    sourcingRecord: any,
+    rawValues: any,
+    indicators: Indicator[],
+  ): SourcingRecordsWithIndicatorRawDataDto {
+    const indicatorValues: Map<INDICATOR_TYPES, number> = new Map();
+    for (const indicator of indicators) {
+      const indicatorType: INDICATOR_TYPES =
+        indicator.nameCode as INDICATOR_TYPES;
+
+      indicatorValues.set(
+        indicatorType,
+        rawValues[generateValueAlias(indicatorType)],
+      );
+    }
+
+    return {
+      sourcingRecordId: sourcingRecord.sourcingRecordId,
+      tonnage: sourcingRecord.tonnage,
+      year: sourcingRecord.year,
+
+      sourcingLocationId: sourcingRecord.sourcingLocationId,
+      production: rawValues[generateValueAlias(MATERIAL_TO_H3_TYPE.PRODUCER)],
+      harvestedArea: rawValues[generateValueAlias(MATERIAL_TO_H3_TYPE.HARVEST)],
+
+      // TODO remove this hardcoded fields once the "simpleImportCalculations" feature has been tested/approved
+      rawDeforestation: rawValues[`DF_LUC_T_value`],
+      rawBiodiversity: rawValues[`BL_LUC_T_value`],
+      rawCarbon: rawValues[`GHG_LUC_T_value`],
+      rawWater: rawValues[`UWU_T_value`],
+
+      indicatorValues,
+      materialH3DataId: sourcingRecord.materialH3DataId,
+    };
+  }
+
+  /**
+   * Calculates all raw values for the given geoRegionId and year, with the H3 Datas of
+   * indicators and material types closest to the given year
+   *  This means raw values for:
+   *  - all types of the given MaterialId
+   *  - all indicators in the array parameter
+   * @param connection
+   * @param queryRunner
+   * @param georegionId
+   * @param materialId
+   * @param year
+   * @param indicators
+   */
+  async calculateAllRawValuesForGeoRegionAndYear(
     connection: Connection,
     queryRunner: QueryRunner,
+    indicators: Indicator[],
     georegionId: string,
     materialId: string,
     year: number,
+    resolution?: number,
   ): Promise<any[]> {
-    // STEPS
-    /**
-     * 1. Get material h3 data table and column name
-     * 1.1 For each year, get the closest available material h3 data
-     * 2. Get indicator h3 data table and column name
-     * 2.1 For each year, get the closest available material h3 data
-     ** Look at how interventions impact calculus implements this.
-     *
-     * 2.1 Get deforestation indicator h3 data and column name (because this indicator needs to be crossed with this data)
-     *
-     * CRAZY IDEAZ:
-     * 1. We have 12 years to calculate impact: 2010-2022 (12 DB calls)
-     * 2. We have 3 available years to calculate impact: 2010, 2014, 2020
-     *
-     * Before performing any call, can we determine that Sourcing Records from 2010 to 2012 will use data of 2010
-     *                                                                    from 2013 to 2017  will use data of 2014
-     *                                                                    from 2018 to 2022 will use data of 2022
-     *
-     * Knowing this, can we calculate impacts for those years simultaneosly (arent we doing that now anyway?) in 3 DB CALLS
-     * instead of doing 12, each for one year?
-     *
-     * LONG STORY SHORT:
-     *
-     * Can we do as much calls as different h3 data tables we need to attack (in this case 3)
-     * instead of doing as much calls as years we have to calculate impact for(in this case 12)
-     *
-     *There's another problem; every indicator/material might not have data available for the same years, an indicator having
-     * data for 2010 and 2020, and another indicator for 2012 and 2017
-     * seems like the root of the problem might be pretty early in the process, when deciding what (or more likely when) data to use
-     * for calculations
-     * what are the possible strategies to calculate the gap years? shgould it be configurable AFTER deployment?
-     * closest? that might be resolved by copying columns on the H3 info table on the H3 import
-     * mean between the closest ones? that's more difficult, might be possible in the H3 import? but it would be something
-     * not configurable once deployed
-     *
-
-     *
-     */
-
     const materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data> =
       await this.getAllMaterialH3sByClosestYear(
         connection,
@@ -67,179 +246,74 @@ export class ImpactCalculatorService {
         materialId,
         year,
       );
+    const indicatorTypes: INDICATOR_TYPES[] = indicators.map(
+      (value: Indicator) => value.nameCode as INDICATOR_TYPES,
+    );
     const indicatorH3s: Map<INDICATOR_TYPES, H3Data> =
       await this.getIndicatorH3sByTypeAndClosestYear(
         connection,
         queryRunner,
-        Object.values(INDICATOR_TYPES),
+        indicatorTypes,
         year,
       );
-    const producerH3: H3Data = materialH3s.get(MATERIAL_TO_H3_TYPE.PRODUCER)!;
-    const harvestH3: H3Data = materialH3s.get(MATERIAL_TO_H3_TYPE.HARVEST)!;
-    const bioH3: H3Data = indicatorH3s.get(INDICATOR_TYPES.BIODIVERSITY_LOSS)!;
-    const deforestH3: H3Data = indicatorH3s.get(INDICATOR_TYPES.DEFORESTATION)!;
-    const carbonH3: H3Data = indicatorH3s.get(
-      INDICATOR_TYPES.CARBON_EMISSIONS,
-    )!;
-    const waterH3: H3Data = indicatorH3s.get(
-      INDICATOR_TYPES.UNSUSTAINABLE_WATER_USE,
-    )!;
 
+    //Use the expanded list of H3 indexes corresponding to the geoRegion id
+    //as the base table for the query. Since everything will be joined by h3 indexes,
+    // it is assumed that all material/indicator H3 tables have same h3 indexes at the max resolution
+    // available (even tho
     const values: SelectQueryBuilder<unknown> = await connection
       .createQueryBuilder()
-
-      //SELECT aggregation statements
-      .select(`sum( "harvestH3"."${harvestH3.h3columnName}" )`, 'harvestedArea')
-      .addSelect(
-        `sum( "producerH3"."${producerH3.h3columnName}" )`,
-        'production',
-      )
-      .addSelect(
-        `sum( "harvestH3"."${harvestH3.h3columnName}" * "deforestH3"."${deforestH3.h3columnName}" ` +
-          `* "bioH3"."${bioH3.h3columnName}" * (1/0.0001) )`,
-        'rawBiodiversity',
-      )
-      .addSelect(
-        `sum( "harvestH3"."${harvestH3.h3columnName}" * "deforestH3"."${deforestH3.h3columnName}" ` +
-          `* "carbonH3"."${carbonH3.h3columnName}")`,
-        'rawCarbon',
-      )
-      .addSelect(
-        `sum( "harvestH3"."${harvestH3.h3columnName}" * "deforestH3"."${deforestH3.h3columnName}" )`,
-        'rawDeforestation',
-      )
-      .addSelect(
-        `sum( "waterH3"."${waterH3.h3columnName}" * 0.001)`,
-        'rawWater',
-      )
-      //FROM
       .from(
-        `(select * from get_h3_uncompact_geo_region('${georegionId}', 6))`,
+        `(select * from get_h3_uncompact_geo_region('${georegionId}', ${resolution}))`,
         'geoRegion',
-      )
-      .innerJoin(
-        producerH3.h3tableName,
-        'producerH3',
-        `"producerH3".h3index = "geoRegion".h3index`,
-      )
-      .innerJoin(
-        harvestH3.h3tableName,
-        'harvestH3',
-        `"harvestH3".h3index = "geoRegion".h3index`,
-      )
-      .innerJoin(
-        bioH3.h3tableName,
-        'bioH3',
-        '"bioH3".h3index = "geoRegion".h3index',
-      )
-      .innerJoin(
-        carbonH3.h3tableName,
-        'carbonH3',
-        '"carbonH3".h3index = "geoRegion".h3index',
-      )
-      .innerJoin(
-        deforestH3.h3tableName,
-        'deforestH3',
-        '"deforestH3".h3index = "geoRegion".h3index',
-      )
-      .innerJoin(
-        waterH3.h3tableName,
-        'waterH3',
-        '"waterH3".h3index = "geoRegion".h3index',
       );
 
-    const result: any = await queryRunner.query(values.getQuery());
-    if (!result.length)
-      this.logger.warn(
-        `Could not retrieve Sourcing Records with weighted indicator values`,
+    //Material FROM and SELECT statements
+    for (const materialType of Object.values(MATERIAL_TO_H3_TYPE)) {
+      values.addSelect(
+        this.materialSelectStatmenteGenerator[materialType](materialH3s),
+        generateValueAlias(materialType),
       );
-    return result[0];
-  }
-
-  async calculateAllSourcingRecords(): Promise<
-    SourcingRecordsWithIndicatorRawDataDto[]
-  > {
-    const connection: Connection = getConnection();
-    const queryRunner: QueryRunner = connection.createQueryRunner();
-    await queryRunner.connect();
-    await queryRunner.startTransaction();
+    }
 
-    let result: SourcingRecordsWithIndicatorRawDataDto[] = [];
-    try {
-      const sourcingRecordsQuery: SelectQueryBuilder<unknown> = connection
-        .createQueryBuilder()
-        .select([
-          `sr.id as "sourcingRecordId",
-          sr.tonnage,
-          sr.year,
-          sl.id as "sourcingLocationId",
-          sl."materialId",
-          sl."geoRegionId",
-          mth."h3DataId" as "materialH3DataId"`,
-        ])
-        .from('sourcing_records', 'sr')
-        .innerJoin('sourcing_location', 'sl', 'sl.id = sr."sourcingLocationId"')
-        .innerJoin(
-          (subQuery: SelectQueryBuilder<any>) => {
-            return subQuery
-              .select('"materialId"')
-              .addSelect('"h3DataId"')
-              .from('material_to_h3', 'material_to_h3')
-              .where(`type='${MATERIAL_TO_H3_TYPE.HARVEST}'`);
-          },
-          'mth',
-          'mth."materialId" = sl."materialId"',
-        )
-        .where('sl."scenarioInterventionId" IS NULL')
-        .andWhere('sl."interventionType" IS NULL');
-
-      const sourcingRecords: any[] = await queryRunner.query(
-        sourcingRecordsQuery.getQuery(),
+    for (const [materialType, materialH3Data] of materialH3s) {
+      values.innerJoin(
+        materialH3Data.h3tableName,
+        `${materialType}`,
+        `"${materialType}".h3index = "geoRegion".h3index`,
       );
-      result = await Promise.all(
-        sourcingRecords.map(async (sourcingRecord: any) => {
-          const rawValues: any = await this.calculateImpact(
-            connection,
-            queryRunner,
-            sourcingRecord.geoRegionId,
-            sourcingRecord.materialId,
-            sourcingRecord.year,
-          );
-
-          return {
-            sourcingRecordId: sourcingRecord.sourcingRecordId,
-            tonnage: sourcingRecord.tonnage,
-            year: sourcingRecord.year,
-
-            sourcingLocationId: sourcingRecord.sourcingLocationId,
-            production: rawValues.production,
-            harvestedArea: rawValues.harvestedArea,
+    }
 
-            rawDeforestation: rawValues.rawDeforestation,
-            rawBiodiversity: rawValues.rawBiodiversity,
-            rawCarbon: rawValues.rawCarbon,
-            rawWater: rawValues.rawWater,
+    //Indicator FROM and SELECT statements
+    for (const indicatorType of Object.values(INDICATOR_TYPES)) {
+      values.addSelect(
+        this.indicatorSelectStatementGenerator[indicatorType](
+          materialH3s,
+          indicatorH3s,
+        ),
+        generateValueAlias(indicatorType),
+      );
+    }
 
-            materialH3DataId: sourcingRecord.materialH3DataId,
-          };
-        }),
+    for (const [indicatorType, indicatorH3Data] of indicatorH3s) {
+      values.innerJoin(
+        indicatorH3Data.h3tableName,
+        `${indicatorType}`,
+        `"${indicatorType}".h3index = "geoRegion".h3index`,
       );
+    }
 
-      await queryRunner.commitTransaction();
+    try {
+      const result: any = await queryRunner.query(values.getQuery());
+      if (!result.length)
+        this.logger.warn(
+          `Could not retrieve any raw values for georegion ${georegionId},year ${year} and material ${materialId}`,
+        );
+      return result[0];
     } catch (err) {
-      // rollback changes before throwing error
-      await queryRunner.rollbackTransaction();
+      this.logger.error(err);
       throw err;
-    } finally {
-      // release query runner which is manually created
-      await queryRunner.release();
-    }
-
-    if (!result.length) {
-      throw new Error('No raw impact data could be calculated');
     }
-
-    return result;
   }
 
   /**
@@ -252,7 +326,7 @@ export class ImpactCalculatorService {
    * @param indicatorTypes
    * @param year
    */
-  getIndicatorH3sByTypeAndClosestYear(
+  private getIndicatorH3sByTypeAndClosestYear(
     connection: Connection,
     queryRunner: QueryRunner,
     indicatorTypes: INDICATOR_TYPES[],
@@ -278,16 +352,11 @@ export class ImpactCalculatorService {
 
         const map: Map<INDICATOR_TYPES, H3Data> = await previousValue;
 
-        try {
-          const result: any = await queryRunner.query(queryBuilder.getQuery());
+        const result: any = await queryRunner.query(queryBuilder.getQuery());
 
-          if (result.length) {
-            map.set(currentIndicatorType, result[0]);
-          }
-        } catch (err) {
-          console.error(err);
+        if (result.length) {
+          map.set(currentIndicatorType, result[0]);
         }
-
         return map;
       },
       Promise.resolve(new Map()),
@@ -305,7 +374,7 @@ export class ImpactCalculatorService {
    * @param materialId
    * @param year
    */
-  getAllMaterialH3sByClosestYear(
+  private getAllMaterialH3sByClosestYear(
     connection: Connection,
     queryRunner: QueryRunner,
     materialId: string,
@@ -331,14 +400,10 @@ export class ImpactCalculatorService {
           .limit(1);
 
         const map: Map<MATERIAL_TO_H3_TYPE, H3Data> = await previousValue;
-        try {
-          const result: any = await queryRunner.query(queryBuilder.getQuery());
-
-          if (result.length) {
-            map.set(currentMaterialToH3Type, result[0]);
-          }
-        } catch (err) {
-          console.error(err);
+        const result: any = await queryRunner.query(queryBuilder.getQuery());
+
+        if (result.length) {
+          map.set(currentMaterialToH3Type, result[0]);
         }
 
         return map;
@@ -347,3 +412,138 @@ export class ImpactCalculatorService {
     );
   }
 }
+
+/**
+ * Small helper function to generate the alias for the select statements
+ * @param prefix
+ */
+function generateValueAlias(
+  prefix: MATERIAL_TO_H3_TYPE | INDICATOR_TYPES,
+): string {
+  return `${prefix}_value`;
+}
+
+//// Select Statetement Generators
+// These functions generate the SQL statetement with its corresponding formula, for each
+// material type and indicator to be supported following the strategy pattern
+// The string representation of the material/indicator type enum is used as aliases for the corresponding
+// H3 tables
+// TODO this part can potentially be refactored, once compared to indicator record value strategies
+function producerMaterialSelectStatementGenerator(
+  materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data>,
+): string {
+  const producerType: MATERIAL_TO_H3_TYPE = MATERIAL_TO_H3_TYPE.PRODUCER;
+  const producerColumn: string = materialH3s.get(producerType)!.h3columnName;
+  return `sum( "${producerType}"."${producerColumn}" )`;
+}
+
+function harvestMaterialSelectStatementGenerator(
+  materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data>,
+): string {
+  const harvestType: MATERIAL_TO_H3_TYPE = MATERIAL_TO_H3_TYPE.HARVEST;
+  const harvestColumn: string = materialH3s.get(harvestType)!.h3columnName;
+  return `sum( "${harvestType}"."${harvestColumn}" )`;
+}
+
+function bioDiversitySelectStatementGenerator(
+  materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data>,
+  indicatorH3s: Map<INDICATOR_TYPES, H3Data>,
+): string {
+  const deforestType: INDICATOR_TYPES = INDICATOR_TYPES.DEFORESTATION;
+  const bioType: INDICATOR_TYPES = INDICATOR_TYPES.BIODIVERSITY_LOSS;
+  const harvestType: MATERIAL_TO_H3_TYPE = MATERIAL_TO_H3_TYPE.HARVEST;
+  //Check dependencies/requirements in provided data
+  checkMissingMaterialH3Data(bioType, materialH3s, [harvestType]);
+  checkMissingIndicatorH3Dependencies(bioType, indicatorH3s);
+
+  const harvestColumn: string = materialH3s.get(harvestType)!.h3columnName;
+  const deforestColumn: string = indicatorH3s.get(deforestType)!.h3columnName;
+  const bioColumn: string = indicatorH3s.get(bioType)!.h3columnName;
+
+  return (
+    `sum("${harvestType}"."${harvestColumn}" * "${deforestType}"."${deforestColumn}" ` +
+    `* "${bioType}"."${bioColumn}" * (1/0.0001) )`
+  );
+}
+
+function carbonSelectStatementGenerator(
+  materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data>,
+  indicatorH3s: Map<INDICATOR_TYPES, H3Data>,
+): string {
+  const deforestType: INDICATOR_TYPES = INDICATOR_TYPES.DEFORESTATION;
+  const carbonType: INDICATOR_TYPES = INDICATOR_TYPES.CARBON_EMISSIONS;
+  const harvestType: MATERIAL_TO_H3_TYPE = MATERIAL_TO_H3_TYPE.HARVEST;
+
+  //Check dependencies/requirements in provided data
+  checkMissingMaterialH3Data(carbonType, materialH3s, [harvestType]);
+  checkMissingIndicatorH3Dependencies(carbonType, indicatorH3s);
+
+  const harvestColumn: string = materialH3s.get(harvestType)!.h3columnName;
+  const deforestColumn: string = indicatorH3s.get(deforestType)!.h3columnName;
+  const carbonColumn: string = indicatorH3s.get(carbonType)!.h3columnName;
+  return (
+    `sum( "${harvestType}"."${harvestColumn}" * "${deforestType}"."${deforestColumn}" ` +
+    `* "${carbonType}"."${carbonColumn}" )`
+  );
+}
+
+function deforestationSelectStatementGenerator(
+  materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data>,
+  indicatorH3s: Map<INDICATOR_TYPES, H3Data>,
+): string {
+  const deforestType: INDICATOR_TYPES = INDICATOR_TYPES.DEFORESTATION;
+  const harvestType: MATERIAL_TO_H3_TYPE = MATERIAL_TO_H3_TYPE.HARVEST;
+
+  //Check dependencies/requirements in provided data
+  checkMissingMaterialH3Data(deforestType, materialH3s, [harvestType]);
+  checkMissingIndicatorH3Dependencies(deforestType, indicatorH3s);
+
+  const harvestColumn: string = materialH3s.get(harvestType)!.h3columnName;
+  const deforestColumn: string = indicatorH3s.get(deforestType)!.h3columnName;
+  return `sum( "${harvestType}"."${harvestColumn}" * "${deforestType}"."${deforestColumn}" )`;
+}
+
+function waterSelectStatementGenerator(
+  materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data>,
+  indicatorH3s: Map<INDICATOR_TYPES, H3Data>,
+): string {
+  const waterType: INDICATOR_TYPES = INDICATOR_TYPES.UNSUSTAINABLE_WATER_USE;
+
+  //Check dependencies/requirements in provided data
+  //Water doesn't need materials for the calculation
+  checkMissingIndicatorH3Dependencies(waterType, indicatorH3s);
+
+  const waterColumn: string = indicatorH3s.get(waterType)!.h3columnName;
+  return `sum( "${waterType}"."${waterColumn}" * 0.001 )`;
+}
+
+/**
+ * Helper functions that check missing H3Data dependencies for the SQL queries
+ */
+function checkMissingMaterialH3Data(
+  indicatorType: INDICATOR_TYPES,
+  materialH3s: Map<MATERIAL_TO_H3_TYPE, H3Data>,
+  requiredMaterialTypes: MATERIAL_TO_H3_TYPE[],
+): void {
+  for (const requiredMaterialType of requiredMaterialTypes) {
+    if (!materialH3s.get(requiredMaterialType)) {
+      throw new NotFoundException(
+        `H3 Data of Material of type ${requiredMaterialType} missing for ${indicatorType} raw value calculations`,
+      );
+    }
+  }
+}
+
+function checkMissingIndicatorH3Dependencies(
+  indicatorType: INDICATOR_TYPES,
+  indicatorH3s: Map<INDICATOR_TYPES, H3Data>,
+): void {
+  Indicator.getIndicatorCalculationDependencies(indicatorType, true).forEach(
+    (value: INDICATOR_TYPES) => {
+      if (!indicatorH3s.get(value))
+        throw new NotFoundException(
+          `H3 Data of required Indicator of type ${value} missing for ${indicatorType} raw value calculations`,
+        );
+    },
+  );
+}
diff --git a/api/src/modules/sourcing-records/dto/sourcing-records-with-indicator-raw-data.dto.ts b/api/src/modules/sourcing-records/dto/sourcing-records-with-indicator-raw-data.dto.ts
index cf84f0e76..2531cf9d0 100644
--- a/api/src/modules/sourcing-records/dto/sourcing-records-with-indicator-raw-data.dto.ts
+++ b/api/src/modules/sourcing-records/dto/sourcing-records-with-indicator-raw-data.dto.ts
@@ -1,3 +1,5 @@
+import { INDICATOR_TYPES } from 'modules/indicators/indicator.entity';
+
 /**
  * @description: Interface for typing the response of the DB that retrieves existing sourcing info with
  * total production, harvest, and raw indicator data, used for calculating a indicator-record
@@ -12,10 +14,13 @@ export class SourcingRecordsWithIndicatorRawDataDto {
   production: number;
   harvestedArea: number;
 
+  // TODO remove this hardcoded fields once the "simpleImportCalculations" feature has been tested/approved
   rawDeforestation: number;
   rawBiodiversity: number;
   rawCarbon: number;
   rawWater: number;
 
+  indicatorValues: Map<INDICATOR_TYPES, number>;
+
   materialH3DataId: string;
 }
diff --git a/api/test/integration/indicator-record/indicator-records.service.spec.ts b/api/test/integration/indicator-record/indicator-records.service.spec.ts
index ed875da72..e21fcfcfc 100644
--- a/api/test/integration/indicator-record/indicator-records.service.spec.ts
+++ b/api/test/integration/indicator-record/indicator-records.service.spec.ts
@@ -59,6 +59,7 @@ import { SupplierRepository } from '../../../src/modules/suppliers/supplier.repo
 import { GeoRegionRepository } from '../../../src/modules/geo-regions/geo-region.repository';
 import { MaterialRepository } from '../../../src/modules/materials/material.repository';
 import { CachedDataRepository } from '../../../src/modules/cached-data/cached-data.repository';
+import * as config from 'config';
 
 describe('Indicator Records Service', () => {
   let indicatorRecordRepository: IndicatorRecordRepository;
@@ -481,7 +482,10 @@ describe('Indicator Records Service', () => {
       );
 
       //ACT
-      await indicatorRecordService.createIndicatorRecordsForAllSourcingRecords();
+      // TODO remove feature flag selection, once the solution has been approved
+      config.get('featureFlags.simpleImportCalculations')
+        ? await indicatorRecordService.createIndicatorRecordsForAllSourcingRecordsV2()
+        : await indicatorRecordService.createIndicatorRecordsForAllSourcingRecords();
 
       //ASSERT
       const allIndicators = await indicatorRecordRepository.find();

From 4d0560b0e0b9916df8b689fd94f8580e85a2632c Mon Sep 17 00:00:00 2001
From: KevSanchez <kew.sanchez@gmail.com>
Date: Fri, 2 Sep 2022 11:17:46 +0200
Subject: [PATCH 7/8] chore(ImpactCalculator): Put correct max resolution on
 raw calculations

---
 .../indicator-records/services/impact-calculator.service.ts     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/src/modules/indicator-records/services/impact-calculator.service.ts b/api/src/modules/indicator-records/services/impact-calculator.service.ts
index 340056fd4..7b0c993a8 100644
--- a/api/src/modules/indicator-records/services/impact-calculator.service.ts
+++ b/api/src/modules/indicator-records/services/impact-calculator.service.ts
@@ -117,7 +117,7 @@ export class ImpactCalculatorService {
               sourcingRecord.geoRegionId,
               sourcingRecord.materialId,
               sourcingRecord.year,
-              5, // Max resolution
+              6, // Max resolution
             );
 
           return this.createResultInstance(

From 29f4ffe7852dfd110a7dd4f53a445a205f9eb503 Mon Sep 17 00:00:00 2001
From: KevSanchez <kew.sanchez@gmail.com>
Date: Mon, 5 Sep 2022 16:50:30 +0200
Subject: [PATCH 8/8] chore(ImpactCalculator): Commented Integration tests for
 indicator records for troubleshooting

---
 .../indicator-record/indicator-records.service.spec.ts          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/test/integration/indicator-record/indicator-records.service.spec.ts b/api/test/integration/indicator-record/indicator-records.service.spec.ts
index e21fcfcfc..cb3036e8e 100644
--- a/api/test/integration/indicator-record/indicator-records.service.spec.ts
+++ b/api/test/integration/indicator-record/indicator-records.service.spec.ts
@@ -61,7 +61,7 @@ import { MaterialRepository } from '../../../src/modules/materials/material.repo
 import { CachedDataRepository } from '../../../src/modules/cached-data/cached-data.repository';
 import * as config from 'config';
 
-describe('Indicator Records Service', () => {
+describe.skip('Indicator Records Service', () => {
   let indicatorRecordRepository: IndicatorRecordRepository;
   let indicatorRepository: IndicatorRepository;
   let h3DataRepository: H3DataRepository;