1450951920

Build # 1450951920

Build Type

push

github

Committed by Bruno Chabrier

Commit Message

Fixed Inefficient regular expression alert

Run Details

1659 of 2131 branches covered (77.85%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

4 existing lines in 1 file now uncovered.

5202 of 6575 relevant lines covered (79.12%)

330.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.42

/modules/tempo/sources/tempo.ts

import { Source, ConfigLoader, GenericDevice, InitObject, Parameters } from 'domoja-core';
import * as assert from 'assert';
import * as request from 'request';

var logger = require("tracer").colorConsole({
        dateformat: "dd/mm/yyyy HH:MM:ss.l",
        level: 3 //0:'test', 1:'trace', 2:'debug', 3:'info', 4:'warn', 5:'error'
});


//import * as cache from "./cache");
import { CronJob } from 'cron';


// URL de la page du site EDF
var tempoURLCouleurDuJour = "https://particulier.edf.fr/bin/edf_rc/servlets/ejptemponew?TypeAlerte=TEMPO&Date_a_remonter="

// numéros des scénarios Zibase définissant les couleurs
var Tempo_Bleu = 24;
var Tempo_Blanc = 25;
var Tempo_Rouge = 26;
var Tempo_Demain_Bleu = 27;
var Tempo_Demain_Blanc = 28;
var Tempo_Demain_Rouge = 29;
var Tempo_Demain_Indetermine = 30;

function format(d: Date): string {
        return d.getFullYear() + "-" + (d.getMonth() < 9 ? "0" : "") + (d.getMonth() + 1) + "-" + (d.getDate() < 10 ? "0" : "") + d.getDate();
}

/**
 * Cette source récupère les informations de couleur de période auprès de l'EDF, pour le jour courant et le lendemain.
 * 
 * Exemple:
 * ```
 * sources:
 *   - tempo: { type: tempo }
 *  
 * devices:
 *   - tempo:
 *   - couleur_du_jour : { type: device, widget: tempo-color, tags: 'tempo', source: tempo, id: couleurDuJour, name: "Couleur du jour" }
 *   - couleur_de_demain : { type: device, widget: tempo-color, tags: 'tempo', source: tempo, id: couleurDeDemain, name: "Couleur de demain" }
 * ```
 */
export class tempo extends Source {
        jobUpdateAllColors: CronJob;
        jobUpdateTomorrowColor: CronJob;
        tomorrowColorUpdated: boolean = false;
        request: request.Request;

        constructor(path: string) {
                super(path);
                let self = this;
                this.jobUpdateAllColors = new CronJob({
                        cronTime: '00 01 * * *', // Runs every day at 1:00 AM.
                        onTick: function () {
                                self.RetryUpdate(function () {
                                        logger.info("All tempo info updated from CronJob.")
                                })
                        },
                        runOnInit: true
                });
                this.jobUpdateAllColors.start();
                this.jobUpdateTomorrowColor = new CronJob({
                        cronTime: '05 * * * *', // Runs every hour + 5 mn.
                        onTick: function () {
                                if (!self.tomorrowColorUpdated) self.RetryUpdate(function () {
                                        if (self.tomorrowColorUpdated) logger.info("Tomorrow color info updated from CronJob.")
                                })
                        },
                        runOnInit: false
                });
                this.jobUpdateTomorrowColor.start();
        }

        createInstance(configLoader: ConfigLoader, path: string, initObject: InitObject): Source {
                return new tempo(path);
        }

        getParameters(): Parameters {
                return {};
        }

        doSetAttribute(id: string, attribute: string, value: string, callback: (err: Error) => void): void {
                return callback(new Error('Device "' + id + '" does not support attribute/value "' + attribute + '/' + value + '"'));
        }

        release(): void {
                this.jobUpdateAllColors.stop();
                this.jobUpdateAllColors = null;
                this.jobUpdateTomorrowColor.stop();
                this.jobUpdateTomorrowColor = null;
                this.request.abort();
                super.release();
        }

        static registerDeviceTypes(): void {
                Source.registerDeviceType(this, 'device', {
                        source: 'REQUIRED',
                        id: 'REQUIRED'
                });
        }


        RetryUpdate(f: Function) {
                let self = this;
                this.Update(function (err) {
                        if (err == null) {
                                f();
                        } else {
                                logger.warn(err);
                                var delay = 10;
                                logger.warn("Retrying in", delay, "mn");
                                setTimeout(function () {
                                        self.RetryUpdate(f);
                                }, delay * 60 * 1000);
                        }
                });
        }

        Update(callback: (err: Error) => void) {


                let today = new Date();
                let todayString = format(today);
                let self = this;
                this.request = request.get(tempoURLCouleurDuJour + todayString, {
                        headers: {
                                'User-Agent': 'Wget/1.18 (linux-gnueabihf)' // for some reason, edf is rejecting request default agent
                        }
                }, function (err, response, bodyString) {

                        //returns a JSON object similar to:
                        // {"JourJ":{"Tempo":"BLEU"},"JourJ1":{"Tempo":"ND"}}
                        let obj: any;
                        try {
                                obj = JSON.parse(bodyString);
                                if (obj.JourJ.Tempo != undefined)
                                        obj.success = 1;
                                else
                                        obj.success = 0;
                        } catch (e) {
                                logger.error(e);
                                obj = { success: 0 };
                        }
                        let now = new Date;
                        self.updateAttribute('lastUpdateDate', 'state', now.toString());
                        if (obj.success == 1) {
                                switch (obj.JourJ.Tempo) {
                                        case "TEMPO_BLEU":
                                                self.updateAttribute('couleurDuJour', 'state', "Bleu", now);
                                                break;
                                        case "TEMPO_BLANC":
                                                self.updateAttribute('couleurDuJour', 'state', "Blanc", now);
                                                break;
                                        case "TEMPO_ROUGE":
                                                self.updateAttribute('couleurDuJour', 'state', "Rouge", now);
                                                break;
                                        case "ND":
                                                self.updateAttribute('couleurDuJour', 'state', "Indéterminé", now);
                                                break;
                                        default:
                                                self.updateAttribute('couleurDuJour', 'state', "Indéterminé", now);
                                                logger.error("Couleur du jour '" + obj.JourJ.Tempo + "' non connue.");
                                }
                                self.tomorrowColorUpdated = true;
                                switch (obj.JourJ1.Tempo) {
                                        case "TEMPO_BLEU":
                                                self.updateAttribute('couleurDeDemain', 'state', "Bleu", now);
                                                break;
                                        case "TEMPO_BLANC":
                                                self.updateAttribute('couleurDeDemain', 'state', "Blanc", now);
                                                break;
                                        case "TEMPO_ROUGE":
                                                self.updateAttribute('couleurDeDemain', 'state', "Rouge", now);
                                                break;
                                        case "ND":
                                                        self.tomorrowColorUpdated = false;
                                                        self.updateAttribute('couleurDeDemain', 'state', "Indéterminé", now);
                                                break;
                                        default:
                                                self.tomorrowColorUpdated = false;
                                                self.updateAttribute('couleurDeDemain', 'state', "Indéterminé", now);
                                                logger.error("Couleur de demain '" + obj.JourJ1.Tempo + "' non connue.");
                                }
                                callback(null);
                        } else {
                                callback(new Error("No success from '" + tempoURLCouleurDuJour + todayString + "': response: '" + bodyString + "'."));
                        }
                        return;
                });
        };
}

1	import { Source, ConfigLoader, GenericDevice, InitObject, Parameters } from 'domoja-core';	3✔
2	import * as assert from 'assert';	3✔
3	import * as request from 'request';	3✔
4		3✔
5	var logger = require("tracer").colorConsole({	3✔
6	dateformat: "dd/mm/yyyy HH:MM:ss.l",	3✔
7	level: 3 //0:'test', 1:'trace', 2:'debug', 3:'info', 4:'warn', 5:'error'	3✔
8	});	3✔
9		3✔
10		3✔
11	//import * as cache from "./cache");	3✔
12	import { CronJob } from 'cron';	3✔
13		3✔
14		3✔
15	// URL de la page du site EDF	3✔
16	var tempoURLCouleurDuJour = "https://particulier.edf.fr/bin/edf_rc/servlets/ejptemponew?TypeAlerte=TEMPO&Date_a_remonter="	3✔
17		3✔
18	// numéros des scénarios Zibase définissant les couleurs	3✔
19	var Tempo_Bleu = 24;	3✔
20	var Tempo_Blanc = 25;	3✔
21	var Tempo_Rouge = 26;	3✔
22	var Tempo_Demain_Bleu = 27;	3✔
23	var Tempo_Demain_Blanc = 28;	3✔
24	var Tempo_Demain_Rouge = 29;	3✔
25	var Tempo_Demain_Indetermine = 30;	3✔
26		3✔
27	function format(d: Date): string {	3✔
28	return d.getFullYear() + "-" + (d.getMonth() < 9 ? "0" : "") + (d.getMonth() + 1) + "-" + (d.getDate() < 10 ? "0" : "") + d.getDate();	3✔
29	}	3✔
30		3✔
31	/**	3✔
32	* Cette source récupère les informations de couleur de période auprès de l'EDF, pour le jour courant et le lendemain.	3✔
33	*	3✔
34	* Exemple:	3✔
35	* ```	3✔
36	* sources:	3✔
37	* - tempo: { type: tempo }	3✔
38	*	3✔
39	* devices:	3✔
40	* - tempo:	3✔
41	* - couleur_du_jour : { type: device, widget: tempo-color, tags: 'tempo', source: tempo, id: couleurDuJour, name: "Couleur du jour" }	3✔
42	* - couleur_de_demain : { type: device, widget: tempo-color, tags: 'tempo', source: tempo, id: couleurDeDemain, name: "Couleur de demain" }	3✔
43	* ```	3✔
44	*/	3✔
45	export class tempo extends Source {	3✔
46	jobUpdateAllColors: CronJob;	3✔
47	jobUpdateTomorrowColor: CronJob;	3✔
48	tomorrowColorUpdated: boolean = false;	3✔
49	request: request.Request;	15✔
50		15✔
51	constructor(path: string) {	15✔
52	super(path);	15✔
53	let self = this;	15✔
54	this.jobUpdateAllColors = new CronJob({	15✔
55	cronTime: '00 01 * * *', // Runs every day at 1:00 AM.	15✔
56	onTick: function () {	15✔
57	self.RetryUpdate(function () {	15✔
58	logger.info("All tempo info updated from CronJob.")	15✔
UNCOV 59	})	×
UNCOV 60	},	×
UNCOV 61	runOnInit: true	×
UNCOV 62	});	×
63	this.jobUpdateAllColors.start();	15✔
64	this.jobUpdateTomorrowColor = new CronJob({	15✔
65	cronTime: '05 * * * *', // Runs every hour + 5 mn.	15✔
66	onTick: function () {	15✔
67	if (!self.tomorrowColorUpdated) self.RetryUpdate(function () {	15✔
68	if (self.tomorrowColorUpdated) logger.info("Tomorrow color info updated from CronJob.")	3✔
69	})	×
70	},	×
71	runOnInit: false	×
72	});	×
73	this.jobUpdateTomorrowColor.start();	15✔
74	}	15✔
75		15✔
76	createInstance(configLoader: ConfigLoader, path: string, initObject: InitObject): Source {	15✔
77	return new tempo(path);	3✔
78	}	6✔
79		6✔
80	getParameters(): Parameters {	6✔
81	return {};	6✔
82	}	6✔
83		6✔
84	doSetAttribute(id: string, attribute: string, value: string, callback: (err: Error) => void): void {	3✔
85	return callback(new Error('Device "' + id + '" does not support attribute/value "' + attribute + '/' + value + '"'));	3✔
86	}	3✔
87		3✔
88	release(): void {	3✔
89	this.jobUpdateAllColors.stop();	3✔
90	this.jobUpdateAllColors = null;	3✔
91	this.jobUpdateTomorrowColor.stop();	3✔
92	this.jobUpdateTomorrowColor = null;	3✔
93	this.request.abort();	3✔
94	super.release();	3✔
95	}	3✔
96		3✔
97	static registerDeviceTypes(): void {	3✔
98	Source.registerDeviceType(this, 'device', {	3✔
99	source: 'REQUIRED',	6✔
100	id: 'REQUIRED'	6✔
101	});	6✔
102	}	6✔
103		6✔
104		6✔
105	RetryUpdate(f: Function) {	6✔
106	let self = this;	6✔
107	this.Update(function (err) {	3✔
108	if (err == null) {	27✔
109	f();	27✔
110	} else {	18✔
111	logger.warn(err);	18✔
112	var delay = 10;	18✔
113	logger.warn("Retrying in", delay, "mn");	12✔
114	setTimeout(function () {	12✔
115	self.RetryUpdate(f);	12✔
116	}, delay * 60 * 1000);	12✔
117	}	3✔
118	});	3✔
119	}	3✔
120		3✔
121	Update(callback: (err: Error) => void) {	12✔
122		12✔
123		12✔
124	let today = new Date();	27✔
125	let todayString = format(today);	3✔
126	let self = this;	3✔
127	this.request = request.get(tempoURLCouleurDuJour + todayString, {	3✔
128	headers: {	3✔
129	'User-Agent': 'Wget/1.18 (linux-gnueabihf)' // for some reason, edf is rejecting request default agent	3✔
130	}	3✔
131	}, function (err, response, bodyString) {	3✔
132		3✔
133	//returns a JSON object similar to:	3✔
134	// {"JourJ":{"Tempo":"BLEU"},"JourJ1":{"Tempo":"ND"}}	3✔
135	let obj: any;	3✔
136	try {	3✔
137	obj = JSON.parse(bodyString);	3✔
138	if (obj.JourJ.Tempo != undefined)	3✔
139	obj.success = 1;	3✔
140	else	3✔
141	obj.success = 0;	3!
142	} catch (e) {	×
143	logger.error(e);	3✔
144	obj = { success: 0 };	3!
145	}	3✔
146	let now = new Date;	3✔
147	self.updateAttribute('lastUpdateDate', 'state', now.toString());	3✔
148	if (obj.success == 1) {	3✔
149	switch (obj.JourJ.Tempo) {	3✔
150	case "TEMPO_BLEU":	3!
151	self.updateAttribute('couleurDuJour', 'state', "Bleu", now);	×
152	break;	×
153	case "TEMPO_BLANC":	×
154	self.updateAttribute('couleurDuJour', 'state', "Blanc", now);	×
155	break;	×
156	case "TEMPO_ROUGE":	×
157	self.updateAttribute('couleurDuJour', 'state', "Rouge", now);	×
158	break;	×
159	case "ND":	×
160	self.updateAttribute('couleurDuJour', 'state', "Indéterminé", now);	×
161	break;	×
162	default:	×
163	self.updateAttribute('couleurDuJour', 'state', "Indéterminé", now);	×
164	logger.error("Couleur du jour '" + obj.JourJ.Tempo + "' non connue.");	×
165	}	×
166	self.tomorrowColorUpdated = true;	×
167	switch (obj.JourJ1.Tempo) {	×
168	case "TEMPO_BLEU":	×
169	self.updateAttribute('couleurDeDemain', 'state', "Bleu", now);	×
170	break;	×
171	case "TEMPO_BLANC":	×
172	self.updateAttribute('couleurDeDemain', 'state', "Blanc", now);	×
173	break;	×
174	case "TEMPO_ROUGE":	×
175	self.updateAttribute('couleurDeDemain', 'state', "Rouge", now);	×
176	break;	×
177	case "ND":	×
178	self.tomorrowColorUpdated = false;	×
179	self.updateAttribute('couleurDeDemain', 'state', "Indéterminé", now);	×
180	break;	×
181	default:	×
182	self.tomorrowColorUpdated = false;	×
183	self.updateAttribute('couleurDeDemain', 'state', "Indéterminé", now);	×
184	logger.error("Couleur de demain '" + obj.JourJ1.Tempo + "' non connue.");	×
185	}	×
186	callback(null);	×
187	} else {	×
188	callback(new Error("No success from '" + tempoURLCouleurDuJour + todayString + "': response: '" + bodyString + "'."));	3✔
189	}	3✔
190	return;	3✔
191	});	3✔
192	};	3✔
193	}	3✔

bchabrier / domoja / 1450951920

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous