@powercalc/power-router 1.0.15 → 1.0.19

package/dist/app.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/dist/app.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = '0';
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const path_1 = require("path");
+const process_1 = require("process");
+const Router_1 = require("./router/controllers/Router");
+const app = (0, express_1.default)();
+const port = 30000;
+const config = {
+    securityToken: '1c608639-afff-4d73-bfe1-a960fe7ea8da',
+    cacheDir: (0, path_1.join)((0, process_1.cwd)(), 'data'),
+    entsoeDomain: "https://web-api.tp.entsoe.eu"
+};
+app.use((0, cors_1.default)());
+app.use('/entsoe', Router_1.PowerRouter.init(config));
+app.use('/public', express_1.default.static('public'));
+// app.use('/config', express.static('dist/config', { maxAge: 100000 }));
+app.listen(port, () => {
+    console.log(`Server listening on port ${port}`);
+});

package/dist/genTypes.d.ts

@@ -0,0 +1,4 @@
+export declare class GenTypes {
+    static getTypes(country: string): Promise<any[]>;
+    static makeGen(gen: any, load: any, price: any): any;
+}

package/dist/genTypes.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenTypes = void 0;
+const node_zlib_1 = require("node:zlib");
+const load_1 = require("./load");
+const promises_1 = require("node:fs/promises");
+class GenTypes {
+    static getTypes(country) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let types = [];
+            const minYear = 2015;
+            const maxYear = 2023;
+            let min;
+            let max;
+            for (let year = minYear; year <= maxYear; year++) {
+                for (let month = 1; month <= 12; month++) {
+                    const gen = yield load_1.Load.getGeneration(country, year, month);
+                    const price = yield load_1.Load.getPrice(country, year, month);
+                    const load = yield load_1.Load.getLoad(country, year, month);
+                    const all = this.makeGen(gen, load, price);
+                    const gzipfilename = `data/gzip/${country}-${year}-${month}.json.gzip`;
+                    const filename = `data/generation/${country}-${year}-${month}.json`;
+                    const buf = Buffer.from(JSON.stringify(all), 'utf-8');
+                    (0, node_zlib_1.gzip)(buf, (_, result) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        yield (0, promises_1.writeFile)(gzipfilename, result, 'utf-8');
+                        // console.log(gen.dataset.map((item:any) => item.label))
+                        types = types.concat(((_a = gen.dataset) === null || _a === void 0 ? void 0 : _a.map((item) => item.psrType)) || []);
+                    }));
+                    yield (0, promises_1.writeFile)(filename, JSON.stringify(all, null, 2), 'utf-8');
+                }
+            }
+            return [...new Set(types)].sort();
+        });
+    }
+    static makeGen(gen, load, price) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const all = {};
+        if ((_a = gen.dataset) === null || _a === void 0 ? void 0 : _a[0]) {
+            all.time = (_d = (_c = (_b = gen.dataset) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.map((item) => item.x);
+            gen.dataset.forEach((dataset) => {
+                all[dataset.psrType] = dataset.data.map((item) => item.y);
+            });
+        }
+        if ((_f = (_e = load === null || load === void 0 ? void 0 : load.dataset) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.data) {
+            all.A05 = load.dataset[0].data.map((item) => item.y);
+        }
+        if ((_g = price === null || price === void 0 ? void 0 : price.dataset) === null || _g === void 0 ? void 0 : _g[0]) {
+            all.price = price.dataset[0].data.map((item) => item.y);
+        }
+        console.log((_h = all.time) === null || _h === void 0 ? void 0 : _h.length, (_j = all.A05) === null || _j === void 0 ? void 0 : _j.length, (_k = all.price) === null || _k === void 0 ? void 0 : _k.length);
+        return all;
+    }
+}
+exports.GenTypes = GenTypes;

package/dist/index.d.ts

@@ -1,2 +1,8 @@
-export { PowerRouter } from './controllers/Router';
-export { Config } from './interfaces/config';
+export declare class Convert {
+    static start(): Promise<void>;
+    static getCountries(): Promise<any>;
+    static getGeneration(countryCode: string): Promise<any>;
+    static getLoad(countryCode: string): Promise<any>;
+    static getPrice(countryCode: string): Promise<any>;
+    static getHydrofill(countryCode: string): Promise<any>;
+}

package/dist/index.js

@@ -1,6 +1,80 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PowerRouter = void 0;
-var Router_1 = require("./controllers/Router");
-Object.defineProperty(exports, "PowerRouter", { enumerable: true, get: function () { return Router_1.PowerRouter; } });
-//# sourceMappingURL=index.js.map
+exports.Convert = void 0;
+const genTypes_1 = require("./genTypes");
+const maxHydrofill_1 = require("./router/services/batch/maxHydrofill");
+const promises_1 = require("node:fs/promises");
+class Convert {
+    static start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const countries = yield this.getCountries();
+            console.log(countries);
+            for (const country of countries) {
+                const types = yield genTypes_1.GenTypes.getTypes(country.code);
+                country.types = types;
+                console.log(country.name, types.join(', '));
+                const h = yield maxHydrofill_1.Hydrofill.getMaxHydrofill(country.code);
+                if (h.max) {
+                    const GW = Math.round(h.max / 1000) + ' GW';
+                    console.log(country.name, GW);
+                    country.hydrofill = {
+                        min: h.min,
+                        max: h.max
+                    };
+                }
+                const gen = yield this.getGeneration(country.code);
+                const load = yield this.getLoad(country.code);
+                const price = yield this.getPrice(country.code);
+                const hydrofill = yield this.getHydrofill(country.code);
+            }
+            console.log(countries);
+            (0, promises_1.writeFile)('data/countrydata.json', JSON.stringify(countries, null, 2), 'utf-8');
+        });
+    }
+    static getCountries() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = 'https://powercalculator.eu/entsoe/datalists/countries';
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+    static getGeneration(countryCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `https://powercalculator.eu/entsoe/${countryCode}/generation?year=2021&month=9`;
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+    static getLoad(countryCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `https://powercalculator.eu/entsoe/${countryCode}/load?year=2021&month=9`;
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+    static getPrice(countryCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `https://powercalculator.eu/entsoe/${countryCode}/prices?year=2021&month=9`;
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+    static getHydrofill(countryCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `https://powercalculator.eu/entsoe/${countryCode}/hydrofill?year=2021`;
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+}
+exports.Convert = Convert;
+Convert.start();

package/dist/load.d.ts

@@ -0,0 +1,7 @@
+export declare class Load {
+    static getCountries(): Promise<any>;
+    static getGeneration(countryCode: string, year: number, month: number): Promise<any>;
+    static getLoad(countryCode: string, year: number, month: number): Promise<any>;
+    static getPrice(countryCode: string, year: number, month: number): Promise<any>;
+    static getHydrofill(countryCode: string, year: number): Promise<any>;
+}

package/dist/load.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Load = void 0;
+class Load {
+    static getCountries() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = 'https://powercalculator.eu/entsoe/datalists/countries';
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+    static getGeneration(countryCode, year, month) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `https://powercalculator.eu/entsoe/${countryCode}/generation?year=${year}&month=${month}`;
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+    static getLoad(countryCode, year, month) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `https://powercalculator.eu/entsoe/${countryCode}/load?year=${year}&month=${month}`;
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+    static getPrice(countryCode, year, month) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `https://powercalculator.eu/entsoe/${countryCode}/prices?year=${year}&month=${month}`;
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+    static getHydrofill(countryCode, year) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `https://powercalculator.eu/entsoe/${countryCode}/hydrofill?year=${year}`;
+            const response = yield fetch(url);
+            return yield response.json();
+        });
+    }
+}
+exports.Load = Load;

package/dist/router/controllers/LoadAndParse.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadAndParse = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const LoadService_1 = require("../services/LoadService");
+const queryoptions_1 = require("../interfaces/queryoptions");
+class LoadAndParse {
+    constructor(config) {
+        this.country = '';
+        const countriesFile = (0, path_1.join)(__dirname, '../config/countries.json'); // Set the path to your config file
+        this.countries = JSON.parse((0, fs_1.readFileSync)(countriesFile, 'utf8')); // Read the config file from disk
+        this.loadService = new LoadService_1.LoadService(config);
+    }
+    get(req, chartType) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const country = req.params.country;
+            if (this.country !== country) {
+                console.log(`=========== ${country} =============`);
+                this.country = country;
+            }
+            const queryOptions = {};
+            const year = parseInt(req.params.year);
+            const month = parseInt(req.params.month);
+            if (req.query.posneg === queryoptions_1.PosNeg.POS || req.query.posneg === queryoptions_1.PosNeg.NEG) {
+                queryOptions.posneg = req.query.posneg;
+            }
+            if (typeof (req.query.format) === 'string' && Object.values(queryoptions_1.Format).includes(req.query.format)) {
+                queryOptions.format = req.query.format;
+            }
+            let reload = false;
+            if (typeof (req.headers.reload) === 'string') {
+                reload = true;
+                queryOptions.reload = true;
+            }
+            const countryCode = (_a = this.countries.find(item => item.name === country)) === null || _a === void 0 ? void 0 : _a.code;
+            if (!countryCode) {
+                throw new Error('Unknown country ' + country);
+            }
+            if (chartType === 'installed') {
+                return yield this.loadService.getInstalled(countryCode, reload);
+            }
+            if (chartType === 'power') {
+                return yield this.loadService.getPower(countryCode, year, month, queryOptions);
+            }
+            if (chartType === 'hydrofill') {
+                return yield this.loadService.getHydrofill(countryCode, reload);
+            }
+            if (chartType === 'fossil') {
+                return yield this.loadService.getFossil(countryCode);
+            }
+            if (chartType === 'countrydata') {
+                return yield this.loadService.getCountrydata(countryCode, reload);
+            }
+        });
+    }
+}
+exports.LoadAndParse = LoadAndParse;

package/dist/router/controllers/Router.js

@@ -0,0 +1,116 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerRouter = void 0;
+const express_1 = require("express");
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const zlib_1 = require("zlib");
+const node_buffer_1 = require("node:buffer");
+const fs_1 = require("fs");
+const LoadAndParse_1 = require("./LoadAndParse");
+const path_1 = require("path");
+class PowerRouter {
+    static init(config) {
+        console.log('init', config);
+        const router = (0, express_1.Router)();
+        router.get(`/:country/:year/:month`, (req, res) => __awaiter(this, void 0, void 0, function* () {
+            yield this.load(config, req, res, 'power');
+        }));
+        router.get(`/:country/fossil`, (req, res) => __awaiter(this, void 0, void 0, function* () {
+            yield this.load(config, req, res, 'fossil');
+        }));
+        router.get(`/:country/installed`, (req, res) => __awaiter(this, void 0, void 0, function* () {
+            yield this.load(config, req, res, 'installed');
+        }));
+        router.get(`/:country/hydrofill`, (req, res) => __awaiter(this, void 0, void 0, function* () {
+            yield this.load(config, req, res, 'hydrofill');
+        }));
+        router.get(`/:country/countrydata`, (req, res) => __awaiter(this, void 0, void 0, function* () {
+            yield this.load(config, req, res, 'countrydata');
+        }));
+        router.get('/types', (req, res) => __awaiter(this, void 0, void 0, function* () {
+            const filePath = (0, path_1.join)(__dirname, '..', 'config', 'types.json');
+            res.set({ 'Cache-Control': 'max-age=86400' });
+            res.sendFile(filePath);
+        }));
+        router.get('/countries', (req, res) => __awaiter(this, void 0, void 0, function* () {
+            const filePath = (0, path_1.join)(__dirname, '..', 'config', 'countrydata.json');
+            res.set({ 'Cache-Control': 'max-age=86400' });
+            res.sendFile(filePath);
+        }));
+        return router;
+    }
+    static load(config, req, res, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entsoeLoader = new LoadAndParse_1.LoadAndParse(config);
+            const cacheTime = this.calcCacheTime(req);
+            const successHeaders = {
+                'Cache-Control': `public, max-age=${cacheTime}`,
+                'Content-Encoding': 'gzip',
+                'Content-Type': 'application/json'
+            };
+            try {
+                let cacheData;
+                const cacheKey = req.url;
+                const cacheFilePath = `${config.cacheDir}/${(0, crypto_1.createHash)('md5').update(cacheKey).digest('hex')}.json.gz`;
+                if (!(req.headers['reload'] === 'full')) {
+                    // check if there is a cache file for this request
+                    try {
+                        const stats = yield (0, promises_1.stat)(cacheFilePath);
+                        const modtime = stats.mtime.getTime();
+                        // Check if the If-Modified-Since header matches the last modified date
+                        const ifModifiedSince = req.headers['if-modified-since'];
+                        if (ifModifiedSince && (modtime - new Date(ifModifiedSince).getTime()) < 5000) {
+                            res.status(304).end();
+                            return;
+                        }
+                        res.setHeader('Last-Modified', (new Date(modtime)).toUTCString());
+                        res.set(successHeaders);
+                        console.log('cached');
+                        (0, fs_1.createReadStream)(cacheFilePath)
+                            .pipe(res);
+                        return;
+                    }
+                    catch (err) {
+                        // no cache file found, continue with request
+                    }
+                }
+                // if no cache hit, load data and store in cache
+                if (!cacheData) {
+                    // LOAD THE DATA  FROM SOURCE
+                    const body = yield entsoeLoader.get(req, type);
+                    const buf = node_buffer_1.Buffer.from(JSON.stringify(body), 'utf-8');
+                    const cacheDataBuffer = (0, zlib_1.gzipSync)(buf);
+                    yield (0, promises_1.writeFile)(cacheFilePath, cacheDataBuffer, 'utf-8');
+                    res.setHeader('Last-Modified', (new Date()).toUTCString());
+                    res.set(successHeaders);
+                    res.send(cacheDataBuffer);
+                }
+            }
+            catch (e) {
+                console.log(e);
+            }
+        });
+    }
+    static calcCacheTime(req) {
+        const reqMonth = `${req.params.year} ${req.params.month}`;
+        const now = new Date();
+        const nowMonth = `${now.getFullYear()} ${now.getMonth() + 1}`;
+        if (reqMonth === nowMonth) {
+            return 5 * 60;
+        }
+        else {
+            return 3600 * 7;
+        }
+    }
+}
+exports.PowerRouter = PowerRouter;

package/dist/router/index.d.ts

@@ -0,0 +1,2 @@
+export { PowerRouter } from './controllers/Router';
+export { Config } from './interfaces/config';

package/dist/router/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerRouter = void 0;
+var Router_1 = require("./controllers/Router");
+Object.defineProperty(exports, "PowerRouter", { enumerable: true, get: function () { return Router_1.PowerRouter; } });

package/dist/{interfaces → router/interfaces}/config.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=config.js.map

package/dist/{interfaces → router/interfaces}/entsoe.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=entsoe.js.map

package/dist/{interfaces → router/interfaces}/queryoptions.js

@@ -13,4 +13,3 @@ var PosNeg;
     PosNeg["POS"] = "pos";
     PosNeg["NEG"] = "neg";
 })(PosNeg = exports.PosNeg || (exports.PosNeg = {}));
-//# sourceMappingURL=queryoptions.js.map

package/dist/{interfaces → router/interfaces}/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/{services → router/services}/CommonTimestamps.js

@@ -171,4 +171,3 @@ class CommonTimestamps {
     }
 }
 exports.CommonTimestamps = CommonTimestamps;
-//# sourceMappingURL=CommonTimestamps.js.map

package/dist/router/services/Eurostat.js

@@ -0,0 +1,85 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EurostatAPI = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = '0';
+class EurostatAPI {
+    constructor() {
+        this.countries = [];
+        this.fuels = {
+            gas: { chartType: 'NRG_CB_GASM', siec: 'G3000', nrg_bal: 'IC_OBS', unit: 'TJ_GCV', freq: 'M' },
+            gas4electricity: { chartType: 'NRG_CB_GASM', siec: 'G3000', nrg_bal: 'TI_EHG_MAP', unit: 'TJ_GCV', freq: 'M' },
+            gasoline: { chartType: 'NRG_CB_OILM', siec: 'O4652', nrg_bal: 'GID_OBS', unit: 'THS_T', freq: 'M' },
+            diesel: { chartType: 'NRG_CB_OILM', siec: 'O46711', nrg_bal: 'GID_OBS', unit: 'THS_T', freq: 'M' },
+            kerosin: { chartType: 'NRG_CB_OILM', siec: 'O4661', nrg_bal: 'GID_OBS', unit: 'THS_T', freq: 'M' }
+        };
+        this.energyConversionFactors = new Map([
+            ['KG_EQ', 12988.48],
+            ['TJ_GCV', Math.pow(10, 12)],
+            ['THS_T', 41868000000000], // joules per thousand metric tons of oil equivalent
+        ]);
+        const countryPath = (0, path_1.join)(__dirname, '..', 'config/countries.json');
+        const countriesString = (0, fs_1.readFileSync)(countryPath, 'utf-8');
+        this.countries = JSON.parse(countriesString);
+    }
+    convertToMWh(value, unit) {
+        const MWh = value * (this.energyConversionFactors.get(unit) || 0) / 3600 / Math.pow(10, 6);
+        return Math.round(MWh);
+    }
+    fetchData(url, type, unit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(url);
+            const data = yield response.json();
+            console.log(data, type, unit);
+            try {
+                const time = Object.keys(data.dimension.time.category.index);
+                return {
+                    time: time.map(item => new Date(item).getTime()),
+                    [type]: Object.values(data.value).map((item) => this.convertToMWh(item, unit))
+                };
+            }
+            catch (e) {
+                return {
+                    [type]: [],
+                    time: []
+                };
+            }
+        });
+    }
+    load(countryCode) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const countryShort = (_a = this.countries.find(item => item.code === countryCode)) === null || _a === void 0 ? void 0 : _a.short;
+            const baseUrl = 'https://ec.europa.eu/eurostat/api/dissemination/sdmx/2.1/data/';
+            const geo = `.${countryShort}`;
+            const promises = [];
+            for (const [type, fuel] of Object.entries(this.fuels)) {
+                const { chartType, siec, nrg_bal, unit, freq } = fuel;
+                const select = `${chartType}/${freq}.${nrg_bal}.${siec}.${unit}`;
+                const rest = `?format=JSON&lang=en&startPeriod=2015-01&endPeriod=2050-12`;
+                const url = `${baseUrl}${select}${geo}${rest}`;
+                console.log(url);
+                promises.push(this.fetchData(url, type, unit));
+            }
+            const res = yield Promise.all(promises);
+            console.log('---res---', res);
+            let merged = {};
+            res.forEach(item => {
+                merged = Object.assign(Object.assign({}, merged), item);
+            });
+            console.log('---merged----', merged);
+            return merged; // this.removeElGas(merged);
+        });
+    }
+}
+exports.EurostatAPI = EurostatAPI;