@open3cl/engine 1.0.0

package/core/assets/domain/synchronize-valeur-tables.js

@@ -0,0 +1,146 @@
+import { ObjectUtil } from '../../util/infrastructure/object-util.js';
+
+/**
+ * Download the `valeur_tables.xlsx` file from the official ademe repository and generates a new `enums.js` file
+ * Please see @link https://gitlab.com/observatoire-dpe/observatoire-dpe/-/tree/master
+ * - Convert the file into a json object
+ * - Extract, format data and then generate a new tv.js file
+ */
+export class SynchronizeValeurTables {
+  /**
+   * @type {FileStore}
+   */
+  #fileStore;
+
+  /**
+   * @type {ApplicationConfig}
+   */
+  #appConfig;
+
+  /**
+   * @type {SynchronizeSolicitationsTables}
+   */
+  #synchronizeSolicitationsTables;
+
+  /**
+   * @type {SynchronizeDpeGesLimitValuesTables}
+   */
+  #synchronizeDpeGesLimitValuesTables;
+
+  /**
+   * @type {AddAdditionnalUeValuesTables}
+   */
+  #addAdditionnalUeValuesTables;
+
+  /**
+   * @type {SynchronizeC1Tables}
+   */
+  #synchronizeC1Tables;
+
+  /**
+   * @param fileStore {FileStore}
+   * @param appConfig {ApplicationConfig}
+   * @param synchronizeSolicitationsTables {SynchronizeSolicitationsTables}
+   * @param synchronizeDpeGesLimitValuesTables {SynchronizeDpeGesLimitValuesTables}
+   * @param addAdditionnalUeValuesTables {AddAdditionnalUeValuesTables}
+   * @param synchronizeC1Tables {SynchronizeC1Tables}
+   */
+  constructor(
+    fileStore,
+    appConfig,
+    synchronizeSolicitationsTables,
+    synchronizeDpeGesLimitValuesTables,
+    addAdditionnalUeValuesTables,
+    synchronizeC1Tables
+  ) {
+    this.#fileStore = fileStore;
+    this.#appConfig = appConfig;
+    this.#synchronizeSolicitationsTables = synchronizeSolicitationsTables;
+    this.#synchronizeDpeGesLimitValuesTables = synchronizeDpeGesLimitValuesTables;
+    this.#addAdditionnalUeValuesTables = addAdditionnalUeValuesTables;
+    this.#synchronizeC1Tables = synchronizeC1Tables;
+  }
+
+  /**
+   * @return {Promise<void>}
+   */
+  execute() {
+    return this.#fileStore
+      .downloadXlsxFileAndConvertToJson(this.#appConfig.ademeValeurTablesFileUrl)
+      .then(
+        /** @param excelSheets {any} xlsx content file grouped by tab */
+        (excelSheets) => {
+          // transform Excel sheets to match actual `tv.js` file
+          excelSheets = ObjectUtil.deepObjectTransform(
+            excelSheets,
+            (key) => {
+              if (key.includes('ditribution')) {
+                // Fix typo in xlsx file
+                return key.replace('ditribution', 'distribution');
+              }
+              return key;
+            },
+            (value, key) => {
+              if (typeof value === 'string') {
+                // Remove 'kW' to be compatible with the legacy `tv.js` file
+                if (value.endsWith('kW')) {
+                  return value.replace(/kW/g, '').replace(/\s/g, '');
+                }
+              }
+
+              // By default, the Excel parsing ignore property with 0 value,
+              // so we force it to be compatible with the legacy `tv.js` file
+              if (key === 'q4pa_conv' && Array.isArray(value)) {
+                return value.map((v) => {
+                  if (!v.isolation_surfaces) {
+                    v.isolation_surfaces = '0';
+                  }
+                  return v;
+                });
+              }
+
+              // Reformat all number with only one decimal to be compatible with the legacy `tv.js` file
+              if (!isNaN(Number(value)) && value.endsWith('0') && value.includes('.')) {
+                return `${Math.round(value * 10) / 10}`;
+              }
+
+              return value;
+            }
+          );
+
+          return excelSheets;
+        }
+      )
+      .then((valeurTablesValues) => {
+        return Promise.all([
+          this.#synchronizeSolicitationsTables.execute(),
+          this.#synchronizeDpeGesLimitValuesTables.execute(),
+          this.#synchronizeC1Tables.execute()
+        ]).then((tablesValues) => {
+          const solicitationsTablesValues = tablesValues[0];
+          const dpeGesLimitTablesValues = tablesValues[1];
+          const c1TablesValues = tablesValues[2];
+
+          // Merge content from "valeur_tables.xlsx" file with "18.2_sollicitations_ext.ods" file
+          let tableValues = Object.assign(
+            {},
+            valeurTablesValues,
+            solicitationsTablesValues,
+            dpeGesLimitTablesValues,
+            c1TablesValues
+          );
+
+          // Ajout de valeurs supplémentaires pour le calcul du facteur Ue pour les déperditions plancher_bas
+          if (tableValues['ue']) {
+            tableValues = this.#addAdditionnalUeValuesTables.execute(tableValues);
+          }
+
+          // Overwrite the tv.js file in filesystem
+          return this.#fileStore.writeFileToLocalSystem(
+            `${this.#appConfig.assetsOutputFolder}/tv.js`,
+            `/** @type {TableValeur} **/\nexport const tvs = ${JSON.stringify(tableValues, null, 2)};\n export default tvs;`
+          );
+        });
+      });
+  }
+}

package/core/assets/domain/synchronize-valeur-tables.spec.js

@@ -0,0 +1,54 @@
+import { SynchronizeValeurTables } from './synchronize-valeur-tables.js';
+import { FileStore } from '../../file/infrastructure/adapter/file.store.js';
+import { ApplicationConfig } from '../../conf/infrastructure/application.config.js';
+import { SynchronizeC1Tables } from './synchronize-c1-tables.js';
+import { SynchronizeSolicitationsTables } from './synchronize-solicitations-tables.js';
+import { ValeurTablesFixture } from '../../../../test/fixtures/core/assets/valeur-tables.fixture.js';
+import { jest } from '@jest/globals';
+import { SynchronizeDpeGesLimitValuesTables } from './synchronize-dpe-ges-limit-values-tables.js';
+import { AddAdditionnalUeValuesTables } from './add-additionnal-ue-values-tables.js';
+
+describe('SynchronizeValeurTables unit tests', () => {
+  it('should download, parse and convert valeur_tables.xlsx file', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeC1Tables = new SynchronizeC1Tables(fileStore, appConfig);
+    const synchronizeSolicitationTables = new SynchronizeSolicitationsTables(fileStore, appConfig);
+    const synchronizeDpeGesLimitValuesTables = new SynchronizeDpeGesLimitValuesTables(
+      fileStore,
+      appConfig
+    );
+    const addAdditionnalUeValuesTables = new AddAdditionnalUeValuesTables(fileStore, appConfig);
+    const synchronizeValeurTables = new SynchronizeValeurTables(
+      fileStore,
+      appConfig,
+      synchronizeSolicitationTables,
+      synchronizeDpeGesLimitValuesTables,
+      addAdditionnalUeValuesTables,
+      synchronizeC1Tables
+    );
+
+    const valeurTablesData = ValeurTablesFixture.aValeurTableExample();
+    jest
+      .spyOn(ApplicationConfig.prototype, 'ademeValeurTablesFileUrl', 'get')
+      .mockReturnValue('http://localhost/file.xlsx');
+    jest
+      .spyOn(ApplicationConfig.prototype, 'assetsOutputFolder', 'get')
+      .mockReturnValue('src/assets');
+
+    jest.spyOn(fileStore, 'downloadXlsxFileAndConvertToJson').mockResolvedValue(valeurTablesData);
+    jest.spyOn(fileStore, 'writeFileToLocalSystem').mockResolvedValue(null);
+    jest.spyOn(synchronizeC1Tables, 'execute').mockResolvedValue({});
+    jest.spyOn(synchronizeSolicitationTables, 'execute').mockResolvedValue({});
+    jest.spyOn(synchronizeDpeGesLimitValuesTables, 'execute').mockResolvedValue({});
+    jest.spyOn(addAdditionnalUeValuesTables, 'execute').mockResolvedValue({});
+
+    return synchronizeValeurTables.execute().then(() => {
+      expect(fileStore.downloadXlsxFileAndConvertToJson).toHaveBeenCalled();
+      expect(fileStore.writeFileToLocalSystem).toHaveBeenCalledWith(
+        'src/assets/tv.js',
+        expect.any(String)
+      );
+    });
+  });
+});

package/core/conf/infrastructure/application.config.js

@@ -0,0 +1,33 @@
+export class ApplicationConfig {
+  get ademeRepositoryVersion() {
+    return 'dpe-mdd-v8.2.1-controle-1.21.8-audit-mdd-v4.4.0-controle-1.9.9-ajout-nom-organisme-qualification';
+  }
+
+  get ademeRepositoryUrl() {
+    return 'https://gitlab.com/observatoire-dpe/observatoire-dpe';
+  }
+
+  get ademeEnumTablesFileUrl() {
+    return `${this.ademeRepositoryUrl}/-/raw/${this.ademeRepositoryVersion}/modele_donnee/enum_tables.xlsx?ref_type=tags&inline=false`;
+  }
+
+  get ademeValeurTablesFileUrl() {
+    return `${this.ademeRepositoryUrl}/-/raw/${this.ademeRepositoryVersion}/modele_donnee/valeur_tables.xlsx?ref_type=tags&inline=false`;
+  }
+
+  get solicitationsExtFilePath() {
+    return 'src/tv/18.2_sollicitations_ext.ods';
+  }
+
+  get c1FilePath() {
+    return 'src/tv/18.5_c1.ods';
+  }
+
+  get dpeGesLimitValuesFilePath() {
+    return 'src/tv/dpe_ges_limit_values.ods';
+  }
+
+  get assetsOutputFolder() {
+    return 'src';
+  }
+}

package/core/file/infrastructure/adapter/file.store.js

@@ -0,0 +1,75 @@
+import { writeFile, readFile } from 'fs';
+import * as XLSX from 'xlsx';
+
+export class FileStore {
+  /**
+   * Download a xlsx file and convert it to json
+   *
+   * @param url {string} url of the xlsx file to download and convert
+   *
+   * @return {Promise<any>}
+   */
+  async downloadXlsxFileAndConvertToJson(url) {
+    return fetch(url)
+      .then((res) => res.arrayBuffer())
+      .then((buffer) =>
+        this.#excelWorkBookToJson(XLSX.read(buffer, { type: 'string', raw: false }))
+      );
+  }
+
+  readLocalOdsFileAndConvertToJson(filePath) {
+    return new Promise((resolve, reject) => {
+      readFile(filePath, (err, data) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(data);
+        }
+      });
+    }).then((fileContent) =>
+      this.#excelWorkBookToJson(XLSX.read(fileContent, { type: 'buffer', raw: false }))
+    );
+  }
+
+  /**
+   * @param filePath {string}
+   * @param content {string}
+   * @return {Promise<void>}
+   */
+  writeFileToLocalSystem(filePath, content) {
+    return new Promise((resolve, reject) => {
+      writeFile(filePath, content, { encoding: 'utf-8' }, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  #excelWorkBookToJson(workBook) {
+    const jsonOutput = {};
+    workBook.SheetNames.forEach((sheetName) => {
+      /**
+       * @type {import('xlsx').WorkSheet}
+       */
+      const sheet = workBook.Sheets[sheetName];
+      if (sheet['!merges']) {
+        sheet['!merges'].forEach((merge) => {
+          const columnStart = XLSX.utils.encode_col(merge.s.c);
+          const rowStart = XLSX.utils.encode_row(merge.s.r);
+
+          const nbMergedRows = merge.e.r - merge.s.r;
+          const firstCell = sheet[`${columnStart}${rowStart}`];
+          for (let i = 0; i < nbMergedRows; i++) {
+            const newRowStart = XLSX.utils.encode_row(merge.s.r + i + 1);
+            sheet[`${columnStart}${newRowStart}`] = firstCell;
+          }
+        });
+      }
+      jsonOutput[sheetName] = XLSX.utils.sheet_to_json(sheet, { raw: false });
+    });
+    return jsonOutput;
+  }
+}

package/core/file/infrastructure/adapter/file.store.spec.js

@@ -0,0 +1,30 @@
+import { FileStore } from './file.store.js';
+
+global.fetch = jest.fn(() =>
+  Promise.resolve({
+    arrayBuffer: () => Promise.resolve(new ArrayBuffer(1))
+  })
+);
+
+describe('FileStore unit tests', () => {
+  it('should be able to download and parse an xlsx file', () => {
+    const fileStore = new FileStore();
+
+    return fileStore.downloadXlsxFileAndConvertToJson('http://localhost:8080').then((output) => {
+      expect(output).toEqual({ Sheet1: [] });
+    });
+  });
+
+  it('should be able to read and parse local ods file', () => {
+    const fileStore = new FileStore();
+
+    return fileStore.readLocalOdsFileAndConvertToJson('file.ods').then((output) => {
+      expect(output).toEqual({ Sheet1: [] });
+    });
+  });
+
+  it('should write file to local system', () => {
+    const fileStore = new FileStore();
+    return fileStore.writeFileToLocalSystem('src/output.js', 'filecontent');
+  });
+});

package/core/tv/infrastructure/assets/additional-ue-values.js

@@ -0,0 +1,69 @@
+export const UPB_ADDITIONAL_VALUES = [
+  {
+    type_adjacence_plancher: 'terre plein bâtiment construit avant 2001',
+    enum_periode_construction_id: '1|2|3|4|5|6',
+    periode_construction: '<2001',
+    type_adjacence: 'terre-plein',
+    enum_type_adjacence_id: '5',
+    values: [
+      { '2s_p': '1', upb: '3.4', ue: '0.98' },
+      { '2s_p': '1', upb: '1.5', ue: '0.66' },
+      { '2s_p': '1', upb: '0.85', ue: '0.49' },
+      { '2s_p': '1', upb: '0.59', ue: '0.39' },
+      { '2s_p': '1', upb: '0.46', ue: '0.34' },
+      { '2s_p': '2', upb: '3.4', ue: '0.88' },
+      { '2s_p': '2', upb: '1.5', ue: '0.61' },
+      { '2s_p': '2', upb: '0.85', ue: '0.46' },
+      { '2s_p': '2', upb: '0.59', ue: '0.37' },
+      { '2s_p': '2', upb: '0.46', ue: '0.32' }
+    ]
+  },
+  {
+    type_adjacence_plancher: 'terre plein bâtiment construit à partir de 2001',
+    enum_type_adjacence_id: '5',
+    type_adjacence: 'terre-plein',
+    enum_periode_construction_id: '7|8|9|10',
+    periode_construction: '>=2001',
+    values: [
+      { '2s_p': '1', upb: '3.4', ue: '0.8' },
+      { '2s_p': '1', upb: '1.5', ue: '0.7' },
+      { '2s_p': '1', upb: '0.85', ue: '0.57' },
+      { '2s_p': '1', upb: '0.6', ue: '0.45' },
+      { '2s_p': '1', upb: '0.46', ue: '0.37' },
+      { '2s_p': '1', upb: '0.37', ue: '0.32' },
+      { '2s_p': '1', upb: '0.31', ue: '0.29' },
+      { '2s_p': '2', upb: '3.4', ue: '0.75' },
+      { '2s_p': '2', upb: '1.5', ue: '0.65' },
+      { '2s_p': '2', upb: '0.85', ue: '0.53' },
+      { '2s_p': '2', upb: '0.6', ue: '0.42' },
+      { '2s_p': '2', upb: '0.46', ue: '0.35' },
+      { '2s_p': '2', upb: '0.37', ue: '0.3' },
+      { '2s_p': '2', upb: '0.31', ue: '0.27' }
+    ]
+  },
+  {
+    type_adjacence_plancher: 'plancher sur vide sanitaire ou sous-sol non chauffé',
+    enum_type_adjacence_id: '3|6',
+    type_adjacence: 'vide sanitaire ou sous-sol non chauffé',
+    enum_periode_construction_id: '1|2|3|4|5|6|7|8|9|10',
+    periode_construction: 'toutes',
+    values: [
+      { '2s_p': '1', upb: '3.33', ue: '0.49' },
+      { '2s_p': '1', upb: '1.43', ue: '0.46' },
+      { '2s_p': '1', upb: '0.83', ue: '0.43' },
+      { '2s_p': '1', upb: '0.45', ue: '0.4' },
+      { '2s_p': '1', upb: '0.41', ue: '0.37' },
+      { '2s_p': '1', upb: '0.37', ue: '0.32' },
+      { '2s_p': '1', upb: '0.34', ue: '0.3' },
+      { '2s_p': '1', upb: '0.31', ue: '0.28' },
+      { '2s_p': '2', upb: '3.33', ue: '0.47' },
+      { '2s_p': '2', upb: '1.43', ue: '0.44' },
+      { '2s_p': '2', upb: '0.83', ue: '0.41' },
+      { '2s_p': '2', upb: '0.45', ue: '0.38' },
+      { '2s_p': '2', upb: '0.41', ue: '0.35' },
+      { '2s_p': '2', upb: '0.37', ue: '0.31' },
+      { '2s_p': '2', upb: '0.34', ue: '0.29' },
+      { '2s_p': '2', upb: '0.31', ue: '0.27' }
+    ]
+  }
+];

package/core/tv/infrastructure/tvs.store.js

@@ -0,0 +1,40 @@
+import tvs from '../../../tv.js';
+
+const TV_RENDEMENT_DISTRIBUTION_CH_PROPERTY = 'rendement_distribution_ch';
+
+/**
+ * @type {RendementDistributionCh[]}
+ */
+const RENDEMENT_DISTRIBUTION_CH_LIST = tvs[TV_RENDEMENT_DISTRIBUTION_CH_PROPERTY];
+
+export class TvsStore {
+  /**
+   * @param enumTypeEmissionDistributionId {string}
+   * @param reseauDistributionIsole {number?}
+   * @return {RendementDistributionCh}
+   */
+  getRendementDistributionCh(enumTypeEmissionDistributionId, reseauDistributionIsole) {
+    return RENDEMENT_DISTRIBUTION_CH_LIST.find((rendement) => {
+      const hasTypeEmissionId = rendement.enum_type_emission_distribution_id
+        .split('|')
+        .includes(enumTypeEmissionDistributionId);
+
+      if (hasTypeEmissionId && reseauDistributionIsole !== undefined) {
+        return rendement.reseau_distribution_isole === reseauDistributionIsole.toString();
+      }
+
+      return hasTypeEmissionId;
+    });
+  }
+
+  /**
+   * @param tv_rendement_distribution_ch_id {number}
+   * @return {RendementDistributionCh}
+   */
+  getRendementDistributionChById(tv_rendement_distribution_ch_id) {
+    return RENDEMENT_DISTRIBUTION_CH_LIST.find(
+      (rendement) =>
+        rendement.tv_rendement_distribution_ch_id === tv_rendement_distribution_ch_id.toString()
+    );
+  }
+}

package/core/tv/infrastructure/tvs.store.spec.js

@@ -0,0 +1,34 @@
+import { TvsStore } from './tvs.store.js';
+
+describe('TvsStore unit tests', () => {
+  it('should get rendement distribution ch id', () => {
+    const store = new TvsStore();
+
+    expect(store.getRendementDistributionCh('41', '0')).toMatchObject({
+      tv_rendement_distribution_ch_id: '2'
+    });
+
+    expect(store.getRendementDistributionCh('41', 0)).toMatchObject({
+      tv_rendement_distribution_ch_id: '2'
+    });
+
+    expect(store.getRendementDistributionCh('41')).toMatchObject({
+      tv_rendement_distribution_ch_id: '1'
+    });
+
+    expect(store.getRendementDistributionCh('15', 1)).toMatchObject({
+      tv_rendement_distribution_ch_id: '8'
+    });
+    expect(store.getRendementDistributionCh('42')).toMatchObject({
+      tv_rendement_distribution_ch_id: '12'
+    });
+  });
+
+  it('should get rendement distribution ch by id', () => {
+    const store = new TvsStore();
+
+    expect(store.getRendementDistributionChById('10')).toMatchObject({
+      tv_rendement_distribution_ch_id: '10'
+    });
+  });
+});

package/core/util/infrastructure/object-util.js

@@ -0,0 +1,23 @@
+export class ObjectUtil {
+  /**
+   *  Apply transformation on object properties or nested properties
+   * @param obj {any}
+   * @param keyTransformFn  {(key: string) => string}
+   * @param valueTransformFn {(value: any, key?: string) => string}
+   */
+  static deepObjectTransform(obj, keyTransformFn, valueTransformFn) {
+    return Array.isArray(obj)
+      ? obj.map((val) => ObjectUtil.deepObjectTransform(val, keyTransformFn, valueTransformFn))
+      : typeof obj === 'object'
+        ? Object.keys(obj).reduce((acc, current) => {
+            const key = keyTransformFn(current);
+            const val = valueTransformFn(obj[current], key);
+            acc[key] =
+              val !== null && typeof val === 'object'
+                ? ObjectUtil.deepObjectTransform(val, keyTransformFn, valueTransformFn)
+                : val;
+            return acc;
+          }, {})
+        : obj;
+  }
+}

package/core/util/infrastructure/object-util.spec.js

@@ -0,0 +1,25 @@
+import { ObjectUtil } from './object-util.js';
+
+describe('ObjectUtil unit tests', () => {
+  it('should be able to deeply transform an object keys and values', () => {
+    expect(
+      ObjectUtil.deepObjectTransform(
+        { key1: 'Value1', key2: 'Value2', nested: [{ key3: 'Value3' }] },
+        (key) => {
+          return key.toUpperCase();
+        },
+        (value) => {
+          return typeof value === 'string' ? value.toLowerCase() : value;
+        }
+      )
+    ).toEqual({
+      KEY1: 'value1',
+      KEY2: 'value2',
+      NESTED: [
+        {
+          KEY3: 'value3'
+        }
+      ]
+    });
+  });
+});