New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
iobroker.alexa-timer-vis
Advanced tools
iobroker.alexa-timer-vis - npm Package Compare versions
Comparing version 0.1.13 to 0.1.14
@@ -0,0 +0,0 @@ { |
@@ -0,0 +0,0 @@ { |
@@ -0,0 +0,0 @@ { |
@@ -0,0 +0,0 @@ { |
@@ -0,0 +0,0 @@ { |
@@ -0,0 +0,0 @@ { |
@@ -0,0 +0,0 @@ { |
@@ -0,0 +0,0 @@ { |
@@ -40,2 +40,5 @@ { | ||
| "step": 1, | ||
| "sm": 12, | ||
| "md": 6, | ||
| "lg": 6, | ||
| "label": "Intervall" , | ||
@@ -54,2 +57,5 @@ "disabled": "!_alive", | ||
| "step": 1, | ||
| "sm": 12, | ||
| "md": 6, | ||
| "lg": 6, | ||
| "label": "Intervall", | ||
@@ -63,6 +69,45 @@ "disabled": "!_alive", | ||
| } | ||
| } | ||
| }, | ||
| "_settings": { | ||
| "type":"panel", | ||
| "label": "Settings", | ||
| "items":{ | ||
| "entprellen" : { | ||
| "newLine": true, | ||
| "type" : "checkbox", | ||
| "label": { | ||
| "de": "Alle Eingaben Entprellen", | ||
| "en": "Debounce all Input" | ||
| }, | ||
| "sm": 12, | ||
| "md": 6, | ||
| "lg": 6, | ||
| "help": { | ||
| "en": "Debounce", | ||
| "de": "Alle Eingaben sollen entprellt werden" | ||
| } | ||
| }, | ||
| "entprellZeit" : { | ||
| "type" : "number", | ||
| "newLine" :true, | ||
| "min": 1, | ||
| "step": 1, | ||
| "sm": 12, | ||
| "md": 6, | ||
| "lg": 6, | ||
| "label": "Entprellzeit in Sekunden", | ||
| "help": { | ||
| "en": "", | ||
| "de": "Entprellzeit" | ||
| } | ||
| } | ||
| } | ||
| } | ||
| } | ||
| } |
@@ -0,0 +0,0 @@ /*global systemDictionary:true */ |
| { | ||
| "common": { | ||
| "name": "alexa-timer-vis", | ||
| "version": "0.1.13", | ||
| "version": "0.1.14", | ||
| "news": { | ||
| "0.1.14":{ | ||
| "en": "Added debouncing in the adapter configuration" | ||
| }, | ||
| "0.1.13": { | ||
@@ -244,3 +247,5 @@ "en": "Delete of Timers with the same value, fixed", | ||
| "intervall1": 1, | ||
| "intervall2": 1 | ||
| "intervall2": 1, | ||
| "entprellZeit": 10, | ||
| "entprellen": false | ||
| }, | ||
@@ -305,3 +310,3 @@ "objects": [], | ||
| "write": true, | ||
| "def": "0" | ||
| "def": "00" | ||
| }, | ||
@@ -319,3 +324,3 @@ "native": {} | ||
| "write": true, | ||
| "def": "0" | ||
| "def": "00" | ||
| }, | ||
@@ -333,3 +338,3 @@ "native": {} | ||
| "write": true, | ||
| "def": "0" | ||
| "def": "00" | ||
| }, | ||
@@ -347,3 +352,3 @@ "native": {} | ||
| "write": true, | ||
| "def": "00 : 00 : 00 Std" | ||
| "def": "00:00:00 h" | ||
| }, | ||
@@ -350,0 +355,0 @@ "native": {} |
557
main.js
@@ -31,5 +31,10 @@ "use strict"; | ||
| let intervallLess60 = 0; | ||
| let debounce; | ||
| let debounceTime = 0; | ||
| // Variable Funktion | ||
| let writeState; | ||
| // let adapter; | ||
| // Objekt mit Einstellungen und Daten | ||
| // ANCHOR timerObject | ||
| const timerObject = { | ||
@@ -41,6 +46,9 @@ "timerActiv": { | ||
| "activateTimer": ["stunde", "minute", "sekunde","hour","minute", "second"], // Vorselektion hinzufügen | ||
| "extendTimer":["verlängere", "verlänger"],// Timer verlängern | ||
| "shortenTimer":["verkürze", "verkürzen"]// Timer verkürzen | ||
| }, | ||
| "data": { | ||
| "interval": 1000,// Aktualisierungsinterval | ||
| "notNoted": ["timer","timer,","auf","auf,","erstelle","mit","ein", "setze","setz","stell","stelle","den","einen","set","the","a","for"], // Wörter die nicht beachtet werden sollen | ||
| "notNoted": ["timer","timer,","auf","auf,","erstelle","mit","ein", "schalte", "setze","setz","stell","stelle","den","einen","set","the","a","for"], // Wörter die nicht beachtet werden sollen | ||
| "notNotedSentence":["stell ein timer", "stelle einen timer", "stelle ein timer", "stell einen timer"], | ||
| "stopAll": ["alle","all"], // Spezielle Definition zum löschen aller Timer | ||
@@ -58,5 +66,5 @@ "connecter": ["und","and"], // Verbindungsglied im Text, für das ein + eingesetzt werden soll | ||
| "timer1": { | ||
| "hour": "0", | ||
| "minute": "0", | ||
| "second": "0", | ||
| "hour": "00", | ||
| "minute": "00", | ||
| "second": "00", | ||
| "string_Timer": "", | ||
@@ -67,10 +75,18 @@ "onlySec": 0, | ||
| "name_output":"", | ||
| "time_start":"", | ||
| "time_end":"", | ||
| "start_Time":"", | ||
| "end_Time":"", | ||
| "inputDevice":"", | ||
| "serialNumber":"", | ||
| "timerInput":"", | ||
| "timerInterval":0 | ||
| "timerInterval":0, | ||
| "endTime":0 | ||
| }, | ||
| }, | ||
| "brueche1":{ | ||
| "halbe": 0.5 | ||
| }, | ||
| "brueche2":{ | ||
| "viertelstunde": 0.25, | ||
| "dreiviertelstunde": 0.75 | ||
| }, | ||
| "zahlen": { // Zahl als Wort zu Zahl nummerisch | ||
@@ -165,7 +181,9 @@ "eins": 1, | ||
| this.on("ready", this.onReady.bind(this)); | ||
| this.on("stateChange", this.onStateChange.bind(this)); | ||
| //this.on("objectChange", this.onObjectChange.bind(this)); | ||
| // this.on("stateChange", this.onStateChange.bind(this)); | ||
| // this.on("objectChange", this.onObjectChange.bind(this)); | ||
| // this.on("message", this.onMessage.bind(this)); | ||
| this.on("unload", this.onUnload.bind(this)); | ||
| } | ||
@@ -176,2 +194,3 @@ | ||
| */ | ||
| // ANCHOR onReady | ||
| async onReady() { | ||
@@ -191,2 +210,4 @@ | ||
| intervallLess60 = this.config.intervall2; | ||
| debounce = this.config.entprellen; | ||
| debounceTime = this.config.entprellZeit; | ||
| // Suchen nach dem Alexa Datenpunkt, und schaltet den Adapter auf grün | ||
@@ -209,31 +230,72 @@ this.getForeignObject(datapoint, (err, obj) => { | ||
| // Initialisierungsvariable | ||
| let timeout_1 = null; | ||
| // Initialisierungsvariable | ||
| let init = false; | ||
| let valueOld =""; | ||
| let value; | ||
| // Auf Änderung des Datenpunkts reagieren | ||
| this.on("stateChange", (id, state) => { | ||
| this.on("stateChange", async (id, state) => { | ||
| // Nur wenn die aktualisierung aus der Variable "datapoint" kommt soll der Code ausgeführt werden | ||
| if (state && id == datapoint){ | ||
| if (state.val !== "" && init == false) { | ||
| if (state && typeof state.val ==="string" && state.val != "" && id == datapoint){ | ||
| value = state.val; | ||
| this.log.debug("Aktuelle Eingabe ist gleich der vorherigen: " + JSON.stringify(value === valueOld)); | ||
| if (timeout_1 != null){ | ||
| this.log.debug("Timeout ist gesetzt"); | ||
| }else{ | ||
| this.log.debug("Timeout ist nicht gesetzt"); | ||
| } | ||
| let doNothing = false; | ||
| // Bestimmte Aufrufe dürfen keine Aktion ausführen, wenn mehrere Geräte zuhören. #12 und #14 . | ||
| for(const sentence of timerObject.timerActiv.data.notNotedSentence){ | ||
| if(value == sentence){ | ||
| this.log.debug("Eingabe soll nicht beachtet werden!"); | ||
| doNothing = true; | ||
| } | ||
| } | ||
| this.log.debug("Alles Entprellen aktiv " + JSON.stringify(debounce)); | ||
| if (state.val == "" || ((value === valueOld || debounce) && timeout_1 != null) || doNothing){ | ||
| this.log.debug("Es wird keine Aktion durchgeführt!"); | ||
| // Wenn der State existiert und der neue Wert nicht mit dem Alten Wert überein stimmt, wird aufgehoben durch den TimeOut, damit auch mehrere gleiche Timer gestellt werden dürfen | ||
| } else { | ||
| clearTimeout(timeout_1); | ||
| timeout_1 = null; | ||
| this.log.debug("Timer wird erstellt, gelöscht oder geändert"); | ||
| this.log.debug("Aktuelle Eingabe: " + JSON.stringify(value)); | ||
| this.log.debug("Vorherige Eingabe: " + JSON.stringify(valueOld)); | ||
| // Die Init Variable soll verhindern das innerhalb von der eingestellten Zeit nur ein Befehl verarbeitet wird, Alexa Datenpunkt wird zweimal aktualisiert | ||
| init = true; | ||
| this.log.debug("Entprellzeit " + JSON.stringify(debounceTime*1000) + " ms"); | ||
| timeout_1 = setTimeout(() => { | ||
| init = false; | ||
| this.log.debug("Timeout beendet"); | ||
| clearTimeout(timeout_1); | ||
| }, 5000); | ||
| timeout_1 = null; | ||
| }, (debounceTime * 1000)); | ||
| // Code Anfang | ||
| timerObject.timerActiv.data.value = state.val; | ||
| const value = timerObject.timerActiv.data.value; | ||
| // Wert als Alten Wert speichern um beim Trigger zu vergleichen | ||
| valueOld = state.val; | ||
| // Überprüfen ob ein Timer Befehl per Sprache an Alexa übergeben wurde | ||
| if (value.indexOf("timer") >= 0) { | ||
| this.log.info("Command to control the timer, found"); | ||
| // Überprüfen ob ein Timer Befehl per Sprache an Alexa übergeben wurde, oder wenn wie in Issue #10 ohne das Wort "Timer" ein Timer erstellt wird | ||
| if (value.indexOf("timer") >= 0 || value.indexOf("stelle") >= 0 || value.indexOf("stell") >= 0) { | ||
| this.log.info("Kommando gefunden um Timer zu steuern!"); | ||
| // Überprüfen ob ein Timer hinzugefügt wird oder gestoppt wird | ||
| let i = false; // Verhindert das Timer add aufgerufen wird wenn delete aktiv ist | ||
| /**@type{boolean} Sobald auf die Variable auf true gesetzt wird, wird die schleife abgebrochen*/ | ||
| let abortLoop = false; | ||
| /**@type{boolean} Wird auf "true" gesetzt wenn Alexa eine Rückfrage gestellt hat*/ | ||
| let questionAlexa = false; | ||
| for (const array in timerObject.timerActiv.condition) { | ||
| // Solbald in einem Schleifendurchlauf was gefunden wird, soll die erste Schleife abgebrochen werden | ||
| if (abortLoop) break; | ||
| // Jedes Element in activateTimer und deleteTimer durchgehen | ||
| for (const element of timerObject.timerActiv.condition[array]) { | ||
@@ -244,10 +306,12 @@ | ||
| this.log.info("Timer is to be stopped!"); | ||
| this.log.info("Timer soll gestoppt werden!"); | ||
| //Eingabe Text loggen | ||
| this.log.info("Voice input: " + value); | ||
| // Input aus Alexas Spracheingabe zu Array konvertieren | ||
| let timerArray = value.split(","); | ||
| this.log.debug("1 " + JSON.stringify(timerArray)); | ||
| // Ersten Teil des Arrays aufteilen, im zweiten Teil steht die Antwort wenn Alexa nachfragt | ||
| timerArray = timerArray[0].split(" "); | ||
| this.log.debug("2 " + JSON.stringify(timerArray)); | ||
@@ -258,15 +322,24 @@ // RückgabeArray erfassen | ||
| // Name | ||
| let name = returnArray[1]; | ||
| let name = ""; | ||
| if (typeof returnArray[1] == "string"){ | ||
| name = returnArray[1]; | ||
| } | ||
| // Timer in Sekunden ausgeben lassen, damit der passende Timer abgebrochen werden kann | ||
| let timerAbortsec; | ||
| try { | ||
| timerAbortsec = eval(returnArray[0]); | ||
| if (typeof returnArray[0] == "string"){ | ||
| timerAbortsec = eval(returnArray[0]); | ||
| } | ||
| } | ||
| catch(e){ | ||
| this.log.debug("Input is invalid. Call the Developer"); | ||
| this.log.error("Die Eingabe ist ungültig. Bitte Issue erstellen"); | ||
| } | ||
| let deleteTimerIndex; | ||
| this.log.debug("Ist ein Komma vorhanden " + JSON.stringify(value.indexOf(",") > -1)); | ||
| //this.log.debug("Variable i " + JSON.stringify(i)); | ||
| /**@type{number} Index zum Löschen der Timer, Index 1 nur ein Timer, Index 2 alle Timer löschen*/ | ||
| let deleteTimerIndex = 0; | ||
| // Hat Alexa eine Frage gestellt, ergibt sich durch getrennte Antwort mit einem Komma | ||
| this.log.debug("Hat Alexa eine Frage gestellt? " + JSON.stringify(value.indexOf(",") > -1)); | ||
| // Wenn eine Frage gestellt wurde, und die Antwort übergeben wurde | ||
| if(value.indexOf(",") != -1){ | ||
@@ -280,8 +353,11 @@ // Funktion die den bestimmten Timer herausfiltert und löscht, aufrufen | ||
| deleteTimer(timerAbortsec, name , deleteTimerIndex, value, questionAlexa); | ||
| i = true; | ||
| abortLoop = true; | ||
| break; | ||
| }else { | ||
| // Index Timer löschen | ||
| deleteTimerIndex = returnArray[2]; | ||
| this.log.debug("Else wurde aufgerufen"); | ||
| if(typeof returnArray[2] == "number"){ | ||
| deleteTimerIndex = returnArray[2]; | ||
| } | ||
| this.log.debug("Es kann direkt gelöscht werden!"); | ||
| // Timer anhalten | ||
@@ -291,3 +367,3 @@ | ||
| i = true; | ||
| abortLoop = true; | ||
| break; | ||
@@ -298,4 +374,4 @@ } | ||
| // Das gesuchte Element muss vorhanden sein, TimerStop darf nicht aktiv sein | ||
| else if (i == false && value.indexOf(element) >= 0 ) { | ||
| this.log.info("Timer is to be added!"); | ||
| else if (value.indexOf(element) >= 0 && array == "activateTimer" && value.indexOf("verlänger") == -1 ) { | ||
| this.log.info("Timer soll hinzugefügt werden!"); | ||
| //Eingabe Text loggen | ||
@@ -314,11 +390,17 @@ this.log.info(`Voice input: ${value}`); | ||
| try { | ||
| timerSeconds = eval(returnArray[0]); | ||
| if (typeof returnArray[0] == "string") { | ||
| timerSeconds = eval(returnArray[0]); | ||
| } | ||
| } | ||
| catch(e){ | ||
| this.log.debug("Input is invalid. Call the Developer"); | ||
| this.log.error("Die Eingabe ist ungültig. Bitte Issue erstellen"); | ||
| } | ||
| // Prüfung falls man sagt Alexa Pommes Timer, und dann die Frage kommt für wie lange | ||
| if (timerSeconds && timerSeconds != 0 ){ | ||
| // Rückgabewert "Name" des Timers [1] | ||
| const name = returnArray[1]; | ||
| // Rückgabewert "Name" des Timers [1] | ||
| let name = ""; | ||
| if (typeof returnArray[1] == "string"){ | ||
| name = returnArray[1]; | ||
| } | ||
| // Wenn der Name schon existert darf nichts gemacht werden, da nicht 2 Timer mit dem gleichen Namen erstellt werden können | ||
@@ -334,4 +416,7 @@ let nameExist = false; | ||
| if(!nameExist){ | ||
| // Rückgabewert "Input String" des Timers [3] | ||
| const inputString = returnArray[3]; | ||
| // Rückgabewert "Input String" des Timers [3] | ||
| let inputString =""; | ||
| if (typeof returnArray[3] == "string"){ | ||
| inputString = returnArray[3]; | ||
| } | ||
@@ -363,7 +448,44 @@ // Anzahl Aktiver Timer um eins hochzählen | ||
| } | ||
| abortLoop = true; | ||
| break; | ||
| }// Timer soll verlängert werden | ||
| else if (value.indexOf(element) >= 0 && array == "extendTimer" ){ | ||
| this.log.debug("Timer soll verlängert werden"); | ||
| // Version 1 geht nur wenn ein Timer aktiv ist | ||
| if (timerObject.timerActiv.timerCount == 1){ | ||
| break; | ||
| this.log.info("Voice input: " + value); | ||
| // Input aus Alexas Spracheingabe zu Array machen | ||
| const timerArray = value.split(" "); | ||
| // Timer in Sekunden und den Namen ausgeben lassen in einem Array | ||
| const returnArray = zeiterfassung(timerArray); | ||
| this.log.debug("ReturnArray " + JSON.stringify(returnArray)); | ||
| let timerSeconds; | ||
| try { | ||
| if (typeof returnArray[0] == "string") { | ||
| timerSeconds = eval(returnArray[0]); | ||
| } | ||
| } | ||
| catch(e){ | ||
| this.log.error("Die Eingabe ist ungültig. Bitte Issue erstellen"); | ||
| } | ||
| for(const timer in timerObject.timerActiv.timer){ | ||
| if (timerObject.timerActiv.timer[timer] == true){ | ||
| timerObject.timer[timer].endTime += (timerSeconds*1000); | ||
| timerObject.timer[timer].end_Time = time(timerObject.timer[timer].endTime); | ||
| this.log.debug("Time_End " + JSON.stringify(time(timerObject.timer[timer].endTime))); | ||
| this.log.debug("Object " + JSON.stringify(timerObject.timer.timer1)); | ||
| } | ||
| } | ||
| } | ||
| abortLoop = true; | ||
| break; | ||
| }else if (value.indexOf(element) >= 0 && array == "shortenTimer" ){ | ||
| this.log.debug("Timer soll verkürzt werden"); | ||
| // Version 1 geht nur wenn ein Timer aktiv ist | ||
| } | ||
| } | ||
@@ -373,16 +495,27 @@ } | ||
| } | ||
| // Auf Button reagieren | ||
| }else if (id != `alexa-timer-vis.${this.instance}.info.connection` && state && state.val !== false){ | ||
| // Akualisierung aus Reset Datenpunkten | ||
| this.log.info("ID Reset Button " + JSON.stringify(id)); | ||
| // Aus ID den Timer erfassen | ||
| const timerArray = id.split("."); | ||
| const timer = timerArray[2]; | ||
| const timerOb = timerObject.timer[timer]; | ||
| const alexaCommandState = `alexa2.${idInstanze.instanz}.Echo-Devices.${timerOb.serialNumber}.Commands.textCommand`; | ||
| let name = ""; | ||
| // Wenn der Name ungleich nur "Timer" ist soll dieser mit ausgegeben werden | ||
| if (timerOb.name != "Timer") name = timerOb.name; | ||
| const alexaTextToCommand = `stoppe ${name} ${timerOb.inputString} Timer`; | ||
| this.setForeignState(alexaCommandState, alexaTextToCommand,false); | ||
| }else if (id != `alexa-timer-vis.${this.instance}.info.connection` && state && state.val !== false && id !="alexa2.0.History.summary"){ | ||
| try{// Akualisierung aus Reset Datenpunkten | ||
| this.log.info("ID Reset Button " + JSON.stringify(id)); | ||
| // Aus ID den Timer erfassen | ||
| const timerArray = id.split("."); | ||
| const timer = timerArray[2]; | ||
| const timerOb = timerObject.timer[timer]; | ||
| let alexaCommandState; | ||
| if(timerOb.serialNumber != undefined){ | ||
| alexaCommandState = `alexa2.${idInstanze.instanz}.Echo-Devices.${timerOb.serialNumber}.Commands.textCommand`; | ||
| let name = ""; | ||
| // Wenn der Name ungleich nur "Timer" ist soll dieser mit ausgegeben werden | ||
| if (timerOb.name != "Timer") name = timerOb.name; | ||
| const alexaTextToCommand = `stoppe ${name} ${timerOb.inputString} Timer`; | ||
| // Alexa State setzen, Alexa gibt dadurch eine Sprachausgabe | ||
| this.setForeignState(alexaCommandState, alexaTextToCommand,false); | ||
| }} | ||
| catch(e){ | ||
| this.log.error("Serial Error: " + JSON.stringify(e)); | ||
| } | ||
| } | ||
@@ -400,5 +533,9 @@ // Code Ende | ||
| * | ||
| * @param {string} input | ||
| * @param {string} input // Die Spracheingabe auf die reagiert wurde | ||
| * @param {number} timerAbortsec // Sekunden des erstellten Timers | ||
| * @param {string} name // Name des Timers | ||
| * @param {string} inputDevice // Name des EchoDots der Eingabe | ||
| */ | ||
| const oneOfMultiTimerDelete =(input, timerAbortsec, name, inputDevice)=>{ | ||
| // ANCHOR oneOfMultiTimerDelete | ||
| const oneOfMultiTimerDelete = (input, timerAbortsec, name, inputDevice) =>{ | ||
| // Teil hinter dem Komma separieren | ||
@@ -467,2 +604,4 @@ const seperateInput = input.slice(input.indexOf(",")+2, input.length); | ||
| }; | ||
| // ANCHOR firstLetterToUpperCase | ||
| /** | ||
@@ -473,3 +612,3 @@ * Ersetzt den ersten Buchstaben des eingegebenen Wortes durch den selbigen Großbuchstaben | ||
| */ | ||
| const firstLetterToUpperCase = (name) => { | ||
| function firstLetterToUpperCase(name) { | ||
| const firstLetter = name.slice(0, 1); // Ersten Buchstaben selektieren | ||
@@ -480,3 +619,3 @@ const leftoverLetters = name.slice(1); // Restliche Buchstaben selektieren | ||
| return name; | ||
| }; | ||
| } | ||
@@ -489,3 +628,3 @@ //---------------------------------------------------------------------------------------------------------------------------------------------------- | ||
| */ | ||
| const time =(i)=>{ | ||
| function time(i){ | ||
| // Zeit zu String | ||
@@ -496,3 +635,3 @@ const date_string = new Date(i).toString(); | ||
| return time; | ||
| }; | ||
| } | ||
@@ -527,2 +666,7 @@ //---------------------------------------------------------------------------------------------------------------------------------------------------- | ||
| } | ||
| // Werte speichern im Object | ||
| timerObject.timer[index].endTime = endTime; | ||
| timerObject.timer[index].end_Time = end_Time; | ||
| timerObject.timer[index].start_Time = start_Time; | ||
| this.log.debug("Werte schreiben"); | ||
@@ -546,14 +690,71 @@ // Input Device ermitteln, und im Objekt speichern | ||
| // Funktion aufrufen, die das Intervall erzeugt | ||
| interval(endTime, sec, index, start_Time, end_Time, inputString, name, timer,int,onlyOneTimer); | ||
| interval(sec, index, inputString, name, timer,int,onlyOneTimer); | ||
| }; | ||
| // Funktion um die Werte zu erzeugen | ||
| const generateValues = (timer, sec, index, inputString, name) =>{ | ||
| let hour; | ||
| let minutes; | ||
| let seconds; | ||
| const timeLeft = timerObject.timer[index].endTime - new Date().getTime(); // Restlaufzeit errechnen in millisec | ||
| // Aus timeLeft(Millisekunden) glatte Sekunden erstellen | ||
| const timeLeftSec = Math.round(timeLeft / 1000); | ||
| // Wieviel Stunden sind enthalten | ||
| hour = timeLeftSec / (60 * 60); | ||
| hour = Math.floor(hour); | ||
| const hourInSec = hour * 60 * 60; | ||
| // Wieviele Minuten, timeLeft - Stunden in Millisekunden, Rest in Minuten | ||
| minutes = (timeLeftSec - hourInSec) / 60; | ||
| minutes = Math.floor(minutes); | ||
| const minutesInSec = minutes * 60; | ||
| // Sekunden | ||
| seconds = timeLeftSec - hourInSec - minutesInSec; | ||
| seconds = Math.round(seconds); | ||
| // Stunden, Minuten und Sekunden umwandeln so das sie immer zweistellig sind bei > 10 ( 1 => 01 usw.) | ||
| hour = ("0" + hour ).slice(-2); | ||
| minutes = ("0" + minutes ).slice(-2); | ||
| seconds = ("0" + seconds ).slice(-2); | ||
| // String der Zeit erstellen mit dynamischer Einheit | ||
| let unit = ""; | ||
| if (timeLeftSec >= 3600){ | ||
| unit = " h"; | ||
| } else if (timeLeftSec >= 60){ | ||
| unit = " min"; | ||
| } else { | ||
| unit = " s"; | ||
| } | ||
| const time = hour + ":" + minutes + ":" + seconds + unit; | ||
| // Timer Werte zum Objekt hinzufügen | ||
| timer.hour = hour; | ||
| timer.minute = minutes; | ||
| timer.second = seconds; | ||
| timer.string_Timer = time; | ||
| timer.onlySec = sec; | ||
| timer.timeLeftSec = timeLeftSec; | ||
| timer.index = index; | ||
| timer.inputString = inputString; | ||
| // Falls der Timername nicht definiert ist soll er einfach nur "Timer" heissen | ||
| if(name == ""|| name == null || name == undefined){ | ||
| name = "Timer"; | ||
| } | ||
| timerObject.timer[index].name = name; | ||
| return timeLeftSec; | ||
| }; | ||
| //---------------------------------------------------------------------------------------------------------------------------------------------------- | ||
| /** | ||
| * Funktion die ein Intervall erzeugt, und die Werte in einer seperaten Funktion | ||
| * @param {number} endTime | ||
| * @param {number} sec eingegebene Zeit in Sekunden | ||
| * @param {*} index Index, für den Ort wo gespeichert werden soll | ||
| * @param {string} start_Time Startzeit | ||
| * @param {string} end_Time berechnete Endzeit | ||
| * @param {string} inputString | ||
@@ -565,61 +766,10 @@ * @param {string} name | ||
| */ | ||
| const interval = (endTime, sec, index, start_Time, end_Time, inputString, name, timer,int,onlyOneTimer)=>{ | ||
| // Funktion um die Werte zu erzeugen | ||
| const generateValues = () =>{ | ||
| let hour; | ||
| let minutes; | ||
| let seconds; | ||
| const timeLeft = endTime - new Date().getTime(); // Restlaufzeit errechnen in millisec | ||
| const interval = (sec, index, inputString, name, timer,int,onlyOneTimer)=>{ | ||
| // Aus timeLeft(Millisekunden) glatte Sekunden erstellen | ||
| const timeLeftSec = Math.round(timeLeft / 1000); | ||
| // Wieviel Stunden sind enthalten | ||
| hour = timeLeftSec / (60 * 60); | ||
| hour = Math.floor(hour); | ||
| const hourInSec = hour * 60 * 60; | ||
| // Wieviele Minuten, timeLeft - Stunden in Millisekunden, Rest in Minuten | ||
| minutes = (timeLeftSec - hourInSec) / 60; | ||
| minutes = Math.floor(minutes); | ||
| const minutesInSec = minutes * 60; | ||
| // Sekunden | ||
| seconds = timeLeftSec - hourInSec - minutesInSec; | ||
| seconds = Math.round(seconds); | ||
| // Stunden, Minuten und Sekunden umwandeln so das sie immer zweistellig sind bei > 10 ( 1 => 01 usw.) | ||
| hour = ("0" + hour ).slice(-2); | ||
| minutes = ("0" + minutes ).slice(-2); | ||
| seconds = ("0" + seconds ).slice(-2); | ||
| // String der Zeit erstellen | ||
| const time = hour + " : " + minutes + " : " + seconds + " Std"; | ||
| // Timer Werte zum Objekt hinzufügen | ||
| timer.hour = hour; | ||
| timer.minute = minutes; | ||
| timer.second = seconds; | ||
| timer.string_Timer = time; | ||
| timer.onlySec = sec; | ||
| timer.timeLeftSec = timeLeftSec; | ||
| timer.index = index; | ||
| timer.time_start = start_Time; | ||
| timer.time_end = end_Time; | ||
| timer.inputString = inputString; | ||
| // Falls der Timername nicht definiert ist soll er einfach nur "Timer" heissen | ||
| if(name == ""|| name == null || name == undefined){ | ||
| name = "Timer"; | ||
| } | ||
| timerObject.timer[index].name = name; | ||
| return timeLeftSec; | ||
| }; | ||
| // generate Values vor dem Intervall aufrufen, damit die Zahlen direkt erzeugt werden, und nicht erst nach z.b. 5 sek | ||
| generateValues(); | ||
| // Intervall erzeugen | ||
| generateValues(timer, sec, index, inputString, name); | ||
| // Intervall erzeugen und im Object speichern | ||
| timerObject.interval[index.slice(5)] = setInterval(() => { | ||
| // Funktion im Intervall aufrufen | ||
| const timeLeftSec = generateValues(); | ||
| const timeLeftSec = generateValues(timer, sec, index, inputString, name); | ||
@@ -629,4 +779,4 @@ // Timer anhalten | ||
| onlyOneTimer = true; | ||
| clearTimeout(timerObject.interval[index.slice(5)]); | ||
| interval(endTime, sec, index, start_Time, end_Time, inputString, name, timer,timerObject.timer[index].timerInterval,true); | ||
| this.clearInterval(timerObject.interval[index.slice(5)]); | ||
| interval(sec, index, inputString, name, timer,timerObject.timer[index].timerInterval,true); | ||
| } | ||
@@ -644,3 +794,3 @@ | ||
| timer.second = "00"; | ||
| timer.string_Timer = "00 : 00 : 00 Std"; | ||
| timer.string_Timer = "00:00:00 h"; | ||
| timer.onlySec = 0; | ||
@@ -650,4 +800,4 @@ timer.timeLeftSec = 0; | ||
| timer.name = "Timer"; | ||
| timer.time_start = "00:00:00"; | ||
| timer.time_end = "00:00:00"; | ||
| timer.start_Time = "00:00:00"; | ||
| timer.end_Time = "00:00:00"; | ||
| timer.inputDevice =""; | ||
@@ -704,3 +854,3 @@ timer.timerInterval = 0; | ||
| write: true, | ||
| def: "0", | ||
| def: "00", | ||
| }, | ||
@@ -717,3 +867,3 @@ native: {}, | ||
| write: true, | ||
| def: "0", | ||
| def: "00", | ||
| }, | ||
@@ -730,3 +880,3 @@ native: {}, | ||
| write: true, | ||
| def: "0", | ||
| def: "00", | ||
| }, | ||
@@ -743,3 +893,3 @@ native: {}, | ||
| write: true, | ||
| def: "00 : 00 : 00 Std", | ||
| def: "00:00:00 Std", | ||
| }, | ||
@@ -833,8 +983,21 @@ native: {}, | ||
| } else { | ||
| const obj = await this.getForeignStateAsync(`alexa2.${idInstanze.instanz}.History.name`); | ||
| // @ts-ignore | ||
| path.inputDevice = obj.val; | ||
| const serial = await this.getForeignStateAsync(`alexa2.${idInstanze.instanz}.History.serialNumber`); | ||
| // @ts-ignore | ||
| path.serialNumber = serial.val; | ||
| try{ | ||
| const obj = await this.getForeignStateAsync(`alexa2.${idInstanze.instanz}.History.name`); | ||
| let serial; | ||
| if (obj && obj.val){ | ||
| path.inputDevice = obj.val; | ||
| serial = await this.getForeignStateAsync(`alexa2.${idInstanze.instanz}.History.serialNumber`); | ||
| } | ||
| if (serial && serial.val){ | ||
| path.serialNumber = serial.val; | ||
| this.log.debug("SerialNumber: " + JSON.stringify(serial.val)); | ||
| } | ||
| }catch(e){ | ||
| this.log.error("Cannot get Serial: " + JSON.stringify(e)); | ||
| } | ||
| } | ||
@@ -851,4 +1014,4 @@ | ||
| * | ||
| * @param {[]} input Eingabe von Alexa, als Array | ||
| * @return {{}} mit einem String (Evaluieren), dem Namen und dem Index zum Löschen der Timer | ||
| * @param {String[]} input Eingabe von Alexa, als Array | ||
| * @return { (string | number)[]} mit einem String (Evaluieren), dem Namen und dem Index zum Löschen der Timer | ||
| */ | ||
@@ -891,7 +1054,22 @@ const zeiterfassung = (input)=> { | ||
| } | ||
| // Nach Sekunden suchen, um die Klammern zu schliessen( Wichtig für z.B. 120 Minuten) | ||
| else if (data.second.indexOf(element) >= 0){ | ||
| // Nach Sekunden suchen, um die Klammern zu schliessen( Wichtig für z.B. 120 Minuten), aber nur wenn als letztes nicht schon eine Klammer ist | ||
| else if (data.second.indexOf(element) >= 0 && timerString.charAt(timerString.length - 1) != ")"){ | ||
| timerString += ")"; | ||
| inputString += "Sekunden "; | ||
| } | ||
| else if (timerObject.brueche1[element] > 0){ | ||
| // Wenn als letztes vor dem Bruch nichts war, soll die eins hinzugefügt werden | ||
| if (timerString.charAt(timerString.length - 1) == ""){ | ||
| timerString += "(1"; | ||
| } | ||
| timerString += "*" + timerObject.brueche1[element]; | ||
| } | ||
| else if (timerObject.brueche2[element] > 0){ | ||
| // Wenn als letztes vor dem Bruch nichts war, soll die eins hinzugefügt werden | ||
| if (timerString.charAt(timerString.length - 1) == ""){ | ||
| timerString += "(1"; | ||
| } | ||
| timerString += "*" + timerObject.brueche2[element] + ")*3600"; | ||
| } | ||
| // Überprüfen ob es sich um Zahlen handelt | ||
@@ -921,4 +1099,8 @@ else if (timerObject.zahlen[element] > 0) { | ||
| } //this.log.info("TimerString: " + timerString); | ||
| } this.log.debug("TimerString: " + timerString); | ||
| }); | ||
| // Wenn der Fall ist das gesagt wird z.B. "1 Stunde 30" ohne Einheit Minuten, oder "1 Minute 30" ohne Einheit Sekunden | ||
| // Wenn das letzte Zeichen ein + ist soll es entfernt werden | ||
@@ -928,2 +1110,35 @@ if (timerString.charAt(timerString.length - 1) == "+") { | ||
| } | ||
| if (input.length){ | ||
| // const lastValue = input[input.length]; | ||
| // Den Eingabewert überprüfen, ist als letztes eine Einheit vorhanden, Minuten oder Sekunden? | ||
| // Ist als letztes Minuten vorhanden? | ||
| // Sind Stunden vorhanden | ||
| if (timerString.includes("*3600")) { | ||
| this.log.debug("Contains Hours"); | ||
| this.log.debug("TimerString (A): " + timerString); | ||
| // Wenn Minuten nicht vorhanden sind und zum schluss nicht Einheit der Stunden "*3600" steht, und die Klammer nicht geschlossen ist | ||
| this.log.debug(timerString.slice(timerString.length-5, timerString.length)); | ||
| if (!timerString.includes("*60") && timerString.slice(timerString.length-5, timerString.length) != "*3600" && timerString.charAt(timerString.length - 1) != ")"){ | ||
| timerString += ")*60"; | ||
| } | ||
| } | ||
| // Sind Minuten vorhanden | ||
| if (timerString.includes("*60")) { | ||
| this.log.debug("Contains Minutes"); | ||
| this.log.debug("TimerString (B): " + timerString); | ||
| // Wenn zum schluss nicht die Einheit der Minuten "*60" steht | ||
| this.log.debug(timerString.slice(timerString.length-3, timerString.length)); | ||
| // if (timerString.slice(timerString.length-5, timerString.length) != "*60"){ | ||
| // timerString += ")"; | ||
| // } | ||
| } | ||
| this.log.debug("" + JSON.stringify(timerString.charAt(0))); | ||
| if (timerString.charAt(0) == ")"){ | ||
| this.log.debug("Klammer vorhanden"); | ||
| timerString = timerString.slice(2,timerString.length); | ||
| } | ||
| } | ||
| // Leerzeichen von beiden Seiten entfernen | ||
@@ -962,6 +1177,8 @@ name = name.trim(); | ||
| }; | ||
| let inputDevice; | ||
| let inputDevice=""; | ||
| // Device auslesen | ||
| const obj = await this.getForeignStateAsync(`alexa2.${idInstanze.instanz}.History.name`); | ||
| if (obj){inputDevice = obj.val;} | ||
| if (obj && obj.val && typeof obj.val == "string"){ | ||
| inputDevice = obj.val; | ||
| } | ||
@@ -1010,3 +1227,3 @@ let countMatchingNumber = 0; | ||
| else if (countMatchingNumber > 1){ | ||
| const name = ""; | ||
| /** @type{string} Name */const name = ""; | ||
| const inputDevice = ""; | ||
@@ -1131,8 +1348,8 @@ this.log.debug("Mit genauer Zeit mehrmals vorhanden"); | ||
| timerObject.timerActiv.timer[element] = false; | ||
| timer.hour = "0"; | ||
| timer.minute = "0"; | ||
| timer.second = "0"; | ||
| timer.string_Timer = "00:00:00 Std"; | ||
| timer.time_start = "00:00"; | ||
| timer.time_end = "00:00"; | ||
| timer.hour = "00"; | ||
| timer.minute = "00"; | ||
| timer.second = "00"; | ||
| timer.string_Timer = "00:00:00 h"; | ||
| timer.start_Time = "00:00:00"; | ||
| timer.end_Time = "00:00:00"; | ||
| timer.name = "Timer"; | ||
@@ -1152,4 +1369,4 @@ timer.inputDevice =""; | ||
| this.setStateChanged(element + ".string", timer.string_Timer, true); | ||
| this.setStateChanged(element + ".TimeStart", timer.time_start, true); | ||
| this.setStateChanged(element + ".TimeEnd", timer.time_end, true); | ||
| this.setStateChanged(element + ".TimeStart", timer.start_Time, true); | ||
| this.setStateChanged(element + ".TimeEnd", timer.end_Time, true); | ||
| this.setStateChanged(element + ".InputDeviceName", timer.inputDevice, true); | ||
@@ -1217,18 +1434,18 @@ this.setStateChanged("all_Timer.alive", alive, true); | ||
| /** | ||
| * Is called if a subscribed state changes | ||
| * @param {string} id | ||
| * @param {ioBroker.State | null | undefined} state | ||
| */ | ||
| onStateChange(id, state) { | ||
| if (state) { | ||
| // /** | ||
| // * Is called if a subscribed state changes | ||
| // * @param {string} id | ||
| // * @param {ioBroker.State | null | undefined} state | ||
| // */ | ||
| // onStateChange(id, state) { | ||
| // if (state) { | ||
| // The state was changed | ||
| //this.log.info(`state ${id} changed: ${state.val} (ack = ${state.ack})`); | ||
| // // The state was changed | ||
| // //this.log.info(`state ${id} changed: ${state.val} (ack = ${state.ack})`); | ||
| } else { | ||
| // The state was deleted | ||
| this.log.info(`state ${id} deleted`); | ||
| } | ||
| } | ||
| // } else { | ||
| // // The state was deleted | ||
| // this.log.info(`state ${id} deleted`); | ||
| // } | ||
| // } | ||
@@ -1235,0 +1452,0 @@ |
| { | ||
| "name": "iobroker.alexa-timer-vis", | ||
| "version": "0.1.13", | ||
| "version": "0.1.14", | ||
| "description": "Alexa Timer ausgeben um in der Vis anzuzeigen", | ||
@@ -5,0 +5,0 @@ "author": { |
No alert changes
Improved metrics
- Total package byte prevSize
- increased by4.31%
265237
- Lines of code
- increased by16.14%
1590
Worsened metrics
- Number of medium supply chain risk alerts
- increased by50%
3
No dependency changes