//..........Anwesenheitssimulation AWS //..........Initiales Datum: 28.12.2015 //..........Autor: Looxer01 //..........Forum ioBroker //..........https://forum.iobroker.net/topic/1671/vorlage-anwesenheitssimulation-script //..........Version 1.00 25.07.2024. Script modernisiert //..........Version 1.01 27.07.2024 alle Astrozeiten koennen genutzt werden //..........Version 1.10 28.07.2024 Schedules werden nur angelegt, wenn auch AWSAktiv ist. Damit läuft das Programm nur bei aktiver AWS //..........Version 1.20 28.07.2024 Log Meldungen fur schedule create und delete eingeführt (anzahl hinzugefuegt) / Logging überarbeitet //..................Pruefroutine fuer Arrays hinzugefügt //..........Version 1.30 01.08.2024 Code optimierungen / einzelne Dokuzeilen hinzugefügt / StateCheck wenn der State gerade erst angelegt wurde (verhindert warnung) // Das Script wird aktiviert, wenn das Flag "Anwesenheitssteuerung gesetzt wird" // Funktionsweise ist im Forum unter dem o.g. Link erklärt. // HIER Einstellungen vornehmen............................................................................................ // Wichtig: Bei der Einstellung der Gruppen- bzw Gruppenmittlgieder muss darauf geachtet werden, dass all Mitglieder gleich viele Eintragungen haben // z.B. 5 Guppen in den Zeiten - Einschaltdauer - StartDelay - Cron-Interrvall und Geräte - all müssen die gleiche Anzahl von Zeilen erhalten. // Zeilen dürfen aber entfernt oder auch hinzugefügt werden, müssen dann aber in allen Einstellungen identisch gehalten werden // Ebenso müssen die Namen alle mappen: Wenn "Gruppe1" definiert ist, dann müssen alle anderen ebenfalls "Gruppe1" enthalten // eine CheckRoutine überprüft dies und bricht das Programm ab, falls Zeilen oder Namen nicht konsistent erstellt wurden /* List of AstroKeywords "sunrise": sunrise (top edge of the sun appears on the horizon) "sunriseEnd": sunrise ends (bottom edge of the sun touches the horizon) "goldenHourEnd":morning golden hour (soft light, best time for photography) ends "solarNoon": solar noon (sun is in the highest position) "goldenHour": evening golden hour starts "sunsetStart": sunset starts (bottom edge of the sun touches the horizon) "sunset": sunset (sun disappears below the horizon, evening civil twilight starts) "dusk": dusk (evening nautical twilight starts) "nauticalDusk": nautical dusk (evening astronomical twilight starts) "night": night starts (dark enough for astronomical observations) "nightEnd": night ends (morning astronomical twilight starts) "nauticalDawn": nautical dawn (morning nautical twilight starts) "dawn": dawn (morning nautical twilight ends, morning civil twilight starts) "nadir": nadir (darkest moment of the night, sun is in the lowest position) */ // Bittte Gross und Kleinschreibung beachten // Einstellungen der Aktivzeiten je Gruppe von bis //------------------------------------------------------------------------------------------------------------------------------------------------------- const Zeiten = { Gruppe1: { von: "dusk", bis: "dawn" }, //Aktivzeit von Gruppe1 Gruppe2: { von: "goldenHour", bis: "23:30:00" }, //Aktivzeit von Gruppe2 Gruppe3: { von: "sunsetStart", bis: "01:00:00" }, Gruppe4: { von: "21:00:00", bis: "22:00:00" }, Gruppe5: { von: "22:00:00", bis: "23:00:00" }, Gruppe6: { von: "23:00:00", bis: "23:10:00" } }; // Einstellungen der zufaelligen Einschaltdauer je Gruppe von bis const Einschaltdauer = { Gruppe1: { von: 1, bis: 5 }, // Einschaltdauer in Minuten Gruppe1 von--bis Gruppe2: { von: 10, bis: 30 }, Gruppe3: { von: 5, bis: 10 }, Gruppe4: { von: 5, bis: 10 }, Gruppe5: { von: 10, bis: 30 }, Gruppe6: { von: 0, bis: 0 } }; // Maximale zufällige Startverzoegerung in Minuten je Gruppe 1 Beispiel: 1 Minute- Verzögerungen von 0 bis 60 Sekunden nach zufallszahlenermittlung const StartDelay = { Gruppe1: 1, // Startverzoegerung Gruppe1 in Minuten Gruppe2: 5, Gruppe3: 3, Gruppe4: 4, Gruppe5: 0, Gruppe6: 0 }; // Check-schedule Einstellungen -- das Programm wird alle x minuten ausgeführt const CronInterval = { Gruppe1: 10, // Programm laeuft alle x Minuten für Gruppe1 Gruppe2: 15, Gruppe3: 15, Gruppe4: 5, Gruppe5: 99999, Gruppe6: 99999 }; // Einstellung teilnehmende Geräte je Gruppe - zum Beispiel durch Eingabe der Homematic ID // Gruppen und Gruppenmitglieder sind nicht auf 5 beschränkt und kann beliebig geändert werden // leere Gruppenmtglieder mit "" angeben. Diese bewirken bei der Zufallsauswahl Leerzeiten (Zeiten ohne Geräteauswahl) const Geraete = { Gruppe1: [ "javascript.0.TEST.Gruppe11", // Licht Terrassentuere "javascript.0.TEST.Gruppe12", // Licht WZ Esstisch "javascript.0.TEST.Gruppe13", // Licht Flur oben unten; "javascript.0.TEST.Gruppe14", // Licht Kinderbad "javascript.0.TEST.Gruppe15", // Licht Hobbyraum "", //dummy // dummy (leere) GeräteIDs bewirken durch die Zuzfälligkeiten /wenn dies zufällig selektiert werden ) Zeiten ohne Schaltung "", //dummy "" //dummy zur auswahl, ], Gruppe2: [ "hm-rpc.1.0029DF299693EB.3.STATE", // Licht Flur oben Wand; "hm-rpc.1.0034DF298E7B6C.3.STATE", // Licht Wohnzimmer Esstisch "hm-rpc.1.00351F298A58E3.3.STATE" // Licht Terrassentuere ], Gruppe3: [ "hm-rpc.1.0029DF299693EB.3.STATE", // Licht Flur oben Wand; "hm-rpc.0.JEQ0038530.1.STATE", // Licht Flur oben unten; "hm-rpc.1.0008A0C992F8B6.3.STATE", // Licht Kinderbad "" ], Gruppe4: [ "hm-rpc.1.0025A0C9A3AD70.18.STATE", // Licht aussen Steinterrasse "hm-rpc.1.0008A0C992F8B6.3.STATE", // Licht Kinderbad "hm-rpc.1.00259F2995EF4B.10.STATE" // Pool Nebenlicht ], Gruppe5: [], Gruppe6: [] }; // Experteneinstellungen const Config = { logflag: true, // schreibe aktivitäten in externes LOG ausflag: true, // Wenn AWS deaktiviert wird, dann werden alle Teilnehmer ausgeschaltet IDAWSaktiv: "javascript.0.Anwesenheitssteuerung.AWSAktiv", // AWS wird aktiviert, wenn der Datenpunkt true ist / wird benoetigt z.B. bei Abwesenheit mit automatischer Aktivierung LogPath: "/opt/iobroker/log/AWSLog.csv", // Pfad fuer externes log IgnoreWhenOn: false, // bei true: Ignoriert den Schaltvorgang, wenn das Geraet bereits eingeschaltet war EinschaltFlag: true, // nicht dimmergeraete werden einschalten AusschaltFlag: false, // nicht dimmergeraete werden ausschalten DimmAusschalt: 0, // Dimmer Ausschaltwert DimmEinschalt: 100, // Dimmer Einschaltwert debug: false, // ausführliche Ablaufmeldungen wenn auf true MinLog: true, // minimales log wird geschreiben wenn Funktionen ausgeführt werden / false = kein logging CronOnlyIfAWStrue: true, // der schedule wird nur eingeplant im Moment wenn AWS aktiviert wird, bei Deaktivierung wird der schedule geloescht }; // Ende der Einstellungen //------------------------------------------------------------------------------------------------------------------------------------------------------- if(Config.debug) {console.log(`AWS-Logging: Script: AWS Version 1.30 vom 02.08.2024 - DEBUG ist eingeschaltet`)}; checkArrays() // ueberpruefen ob Arrays konsistent sind let SwitchTimes = []; // das Array enthält alle aktuellen Schaltzeiten und wird jedesmal angepasst wenn einer der schedules aktiv ist //Astrotabelle zum check eines gültigen Astrotypes const Astrotype = ["sunrise","sunriseEnd","goldenHourEnd","solarNoon","goldenHour","sunsetStart","sunset","dusk","nauticalDusk","night","nightEnd","nauticalDawn","dawn","nadir"] // V1.3 const instead var Astrozeiten(); // gibt liste der augenblicklichen Astrozeiten aus, wenn debug = true createStateAsync(); // createStateAsync(); // Anlegen des States wenn nicht schon vorhanden if ( existsState(Config.IDAWSaktiv )) { // nur wenn der state bereits angelegt ist if (getState(Config.IDAWSaktiv).val || !Config.CronOnlyIfAWStrue) { CreateSchedules(); // Anlegen der Schedules wenn AWS-Flag aktiv ist } } on({ id: Config.IDAWSaktiv, val: false }, handleAWSDeaktivierung); // Subscription wenn AWS-Flag auf false gesetzt wird on({ id: Config.IDAWSaktiv, val: true }, handleAWSAktivierung); // Subscription wenn AWS-Flag auf true gesetzt wird //----------------------------------------------------------------------------------------------------- // Funktion Ausführung der notwendigen schedules - wird als erstes ausgeführt durch den schedule //----------------------------------------------------------------------------------------------------- function executeSchedule(gruppe, index) { if (getState(Config.IDAWSaktiv).val === true) { if (Config.debug) {log(`AWS-Logging: executeSchedule aufgerufen mit ${gruppe} ${index} AWSAktiv-Flag = true`, "info")}; if (IsTimeInRange(Zeiten[gruppe].von, Zeiten[gruppe].bis, index)) { const zufaelligIndex = zufall(1, Geraete[gruppe].length); const verzoegerung = zufall(0, StartDelay[gruppe] * 60) * 1000; const einschaltdauer = zufall(Einschaltdauer[gruppe].von * 60, Einschaltdauer[gruppe].bis * 60) * 1000; const geraetID = Geraete[gruppe][zufaelligIndex -1 ]; //-1 if (Config.debug) {log(`AWS-Logging: zufälliges gerät ermittelt: ${geraetID} Zufallszahl: ${zufaelligIndex} aufgerufen mit ${gruppe}`, "info")}; if (geraetID && GeraetExists(geraetID)) { AWSSchaltung(geraetID, einschaltdauer, verzoegerung, gruppe); } } } } // endfunction //----------------------------------------------------------------------------------------------------- // Funktion IsTimeInRange - wird durch executeSchedule ausgeführt und berechnet zeiten von und bis (Astro) // Ermittlung ob die aktuelle Zeit in der vorgegebenen Schaltzeit liegt (inkl Astro) //----------------------------------------------------------------------------------------------------- function IsTimeInRange(zeitvon, zeitbis, Gruppe) { const now = new Date(); if (checkSwitchTime(Gruppe)) { // Time range ist aktiv - raus aus der Funktion if (Config.debug) log(`AWS-Logging: Routine IsTimeInRange - Gruppe ${Gruppe} ist im definierten Zeitrange - Schaltung ist aktiv`, "info"); return true; } let lower, upper; const IsAstroVon = Astrotype.some(type => zeitvon.includes(type)); // astro gueltig ? const IsAstroBis = Astrotype.some(type => zeitbis.includes(type)); // astro gueltig ? if ((IsAstroVon || IsAstroBis) && Config.debug) { log(`AWS-Logging: Astrofunktion wird verwemdet fuer gruppe ${Gruppe} zeitvon ${zeitvon} zeitbis ${zeitbis}`,'info' ); } lower = IsAstroVon ? getAstroDate(zeitvon) : addTime(zeitvon); // lower enthält jetzt eine zeit upper = IsAstroBis ? getAstroDate(zeitbis) : addTime(zeitbis); // upper enthält jetzt eine zeit const regex = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/; if (!IsAstroVon) { if (!regex.test(zeitvon) ) { log('AWS-Logging: falsche Zeitangabe von in gruppe {$gruppe} {$zeitvon} Format muss sein: HH:MM:SS','warn' ); return false } lower = addTime(zeitvon); // switch on time im berechenbaren Format } if (!IsAstroBis) { if (!regex.test(zeitbis) ) { log('AWS-Logging: falsche Zeitangabe bis in gruppe {$gruppe} {$zeitbis} Format muss sein: HH:MM:SS','warn' ); return false } upper = addTime(zeitbis); // switch off time im berechenbaren Format } if (upper <= lower) { upper.setDate(upper.getDate() + 1); // eintrag zu upper hinzufügen wenn upper <= lower ist } if (Config.debug) log(`AWS-Logging: Routine IsTimeInRange- Gruppe ${Gruppe} Berechnung der Zeiten: VON ${lower} BIS ${upper}`, "info"); const inRange = now >= lower && now <= upper; if (inRange) { if(Config.debug || Config.MinLog) {log(`AWS-Logging: Routine IsTimeInRange - Gruppe ${Gruppe} aktuelle time range ist von ${lower} bis ${upper} - Gruppe wird geschaltet (true)`)}; UpdateSwitchTime(Gruppe, lower, upper); if(Config.debug ) {listcheckSwitch()}; } else { if(Config.debug || Config.MinLog) { log(`AWS-Logging: Routine IsTimeInRange - Gruppe ${Gruppe} Zeit nicht im Zeitrange - von ${lower} bis ${upper} - keine Schaltung`)}; } return inRange; } // endfunction //----------------------------------------------------------------------------------------------------- // Funktion AWS aktivierung mit einschaltdauer und verzoegerung - wird aus executeSchedule ausgeführt // und wenn funktion IsTimeInRange ein true ermittelt //----------------------------------------------------------------------------------------------------- function AWSSchaltung(id, einschaltdauer, verzoegerung, gruppe) { const obj = getObject(id); if (!obj) return; var logtext = ""; const GeraeteName = getObject(id).common.name; // Name des Geraetes in Klartext const stateFlag = (obj.common.type === 'boolean') ? Config.EinschaltFlag : Config.DimmEinschalt; const ausschaltFlag = (obj.common.type === 'boolean') ? Config.AusschaltFlag : Config.DimmAusschalt; if (getState(id).val === ausschaltFlag) { setStateDelayed(id, stateFlag, verzoegerung); setStateDelayed(id, ausschaltFlag, verzoegerung + einschaltdauer, false); } else if (!Config.IgnoreWhenOn) { setStateDelayed(id, ausschaltFlag, einschaltdauer, true); logtext = "Geraet war bereits eingeschaltet -- uebersteuert - ohne Einschaltverzoegerung - alter schedule geloescht- "; if(Config.debug) { log(`AWS-Logging: Geraet: ${GeraeteName} Gruppe: ${gruppe}: ID: ${id} ${logtext}`)} } else if (Config.IgnoreWhenOn) { logtext = "keine Aktion - Geraet war bereits eingeschaltet"; if(Config.debug) { log('AWS-Logging: Geraet:${GeraeteName} Gruppe: ${gruppe}: ID: ${id} ${logtext}')} } const now = new Date(); // store current date and time const currSec = now.getTime(); // millisekunden seit 01.01.1970 /current millisecs const berechnEinZeit = millisecToDate( currSec + verzoegerung); // millisecs in Zeit umrechnen fuer die Einschaltzeit const berechnAusZeit = millisecToDate(currSec + verzoegerung + einschaltdauer); // millisecs in Zeit umrechnen fuer die Ausschaltzeit writelog (`${gruppe};${id};${GeraeteName};${verzoegerung / 1000};${einschaltdauer / 1000};${berechnEinZeit};${berechnAusZeit};${logtext}`); // bereite LOG vor if (Config.debug || Config.MinLog) { console.log(`AWS-Logging: AWSSchaltungfuer ${gruppe}: ${id} wird in ${verzoegerung / 1000} Sekunden eingeschaltet fuer ${einschaltdauer / 1000} Sekunden. Einschaltzeit: ${berechnEinZeit} Ausschaltzeit: ${berechnAusZeit}`); } } //----------------------------------------------------------------------------------------------------- // Funktion AWS wird deaktiviert //----------------------------------------------------------------------------------------------------- function handleAWSDeaktivierung() { let countobj = 0; if (Config.CronOnlyIfAWStrue) { // schedules werden geloscht DeleteSchedules(); } Object.values(Geraete).flat().forEach((geraetID) => { if (geraetID && !geraetID.match(/\s/)) { const object = getObject(geraetID); if (object) { clearStateDelayed(geraetID); if (Config.ausflag) { const state = (object.common.type === 'boolean') ? Config.AusschaltFlag : Config.DimmAusschalt; setStateDelayed(geraetID, state, countobj); countobj += 300; } } } }); log("EVENT: AWS deaktiviert", "info"); writelog(";;;;;;;AWS wurde deaktiviert"); if (Config.debug) listcheckSwitch(); } //----------------------------------------------------------------------------------------------------- // Funktion AWS wird aktiviert logging //----------------------------------------------------------------------------------------------------- function handleAWSAktivierung() { if (Config.CronOnlyIfAWStrue) { // schedules werden erstellt falls noch nicht gemacht CreateSchedules(); } log("AWS-Logging: EVENT: AWS wurde aktiviert", "info"); writelog(";;;;;;;AWS wurde aktiviert"); if (Config.debug) listcheckSwitch(); } //----------------------------------------------------------------------------------------------------- // Funktion Zufallszahlermittlung fuer zeiten und verzoegerungen //----------------------------------------------------------------------------------------------------- function zufall(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; } //----------------------------------------------------------------------------------------------------- // Funktion checkt dir Richtigkeit der geraete ID //----------------------------------------------------------------------------------------------------- function GeraetExists(id) { return !!getObject(id); } //----------------------------------------------------------------------------------------------------- // Funktion schreibt einen Logeintrag in das Filesystem und auch in das interne Log-System //----------------------------------------------------------------------------------------------------- function writelog(string) { if (!Config.logflag) return; const fs = require('fs'); // enable write for external log const now = new Date(); const [year, month, day, Thour, Tmin, Tsec] = [ now.getFullYear(), addZero(now.getMonth() + 1), addZero(now.getDate()), addZero(now.getHours()), addZero(now.getMinutes()), addZero(now.getSeconds()) ]; const logdate = `${day}.${month}.${year}`; const logtime = `${Thour}:${Tmin}:${Tsec}`; fs.readFile(Config.LogPath, 'utf8', (err, data) => { const entry = `${logdate} ;${logtime} ;${string}\n`; if (!err) { fs.appendFileSync(Config.LogPath, entry); } else { log("AWS-Logging: Routine writelog - Logfile nicht gefunden - wird angelegt", "info"); const headerLine = "Datum;Uhrzeit;Gruppe;GeraeteID;Geraetebezeichnung;Einschaltverzoegerung;LaengeSchaltzeit;ZeitEin berechnet;ZeitAus berechnet;Kommentar"; fs.appendFileSync(Config.LogPath, `${headerLine}\n${entry}`); } }); } //----------------------------------------------------------------------------------------------------- // Funktion checkSwitchTime zum Finden in Tabelle SwitchTimes ob es einen Gueltigen Eintrag innerhalb der Zeit gibt // Struktur SwitchTimes: 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit //----------------------------------------------------------------------------------------------------- function listcheckSwitch() { SwitchTimes.forEach(([grp, vonZeit, bisZeit]) => { log(`AWS-Logging: Routine listcheckSwitch - Gruppe ${grp} Zeitvon ${vonZeit} Zeitbis ${bisZeit}`, "info"); }); } //----------------------------------------------------------------------------------------------------- // Funktion checkSwithTime zum Finden in Tabelle SwitchTimes ob es einen Gueltigen Eintrag innerhalb der Zeit gibt // Struktur SwitchTimes: 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit //----------------------------------------------------------------------------------------------------- function checkSwitchTime(Gruppe) { var now = new Date(); for (var x in SwitchTimes) { const [grp, vonZeit, bisZeit] = SwitchTimes[x]; if(grp === Gruppe) { const vonDate = new Date(`1970-01-01T${vonZeit}Z`); const bisDate = new Date(`1970-01-01T${bisZeit}Z`); if(now >= vonDate && now <= bisDate) { return true; } } } return false; } // Ende Function checkSwitchTime //----------------------------------------------------------------------------------------------------- // Funktion UpdateSwithTime macht einen update auf die Tabelle fuer ausgelaufene Schaltzeiten und fuer neue // Struktur SwitchTimes: 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit //----------------------------------------------------------------------------------------------------- function UpdateSwitchTime(Gruppe, VonZeit, BisZeit) { for (let x = 0; x < SwitchTimes.length; x++) { if (SwitchTimes[x][0] === Gruppe) { if (Config.debug) log(`AWS-Logging: Routine UpdateSwithTime - Gruppe ${Gruppe} Switchtime Update VON ${VonZeit} BIS ${BisZeit}`, "info"); SwitchTimes[x][1] = VonZeit; SwitchTimes[x][2] = BisZeit; return; } } SwitchTimes.push([Gruppe, VonZeit, BisZeit]); if (Config.debug) log(`AWS-Logging: Routine UpdateSwithTime - Gruppe ${Gruppe} Switchtime hinzufuegen VON ${VonZeit} BIS ${BisZeit}`, "info"); } //----------------------------------------------------------------------------------------------------- // Funktion zur Erzeugung von fuehrenden Nullen fuer das Datum Format //----------------------------------------------------------------------------------------------------- function addZero(i) { return i < 10 ? "0" + i : i; } //----------------------------------------------------------------------------------------------------- //Funktion addTime wandelt einen String mit Format 00:00:00 in rechenbare Zeit um //----------------------------------------------------------------------------------------------------- function addTime(strTime) { const [hours, minutes, seconds] = strTime.split(':').map(Number); const d = new Date(); d.setHours(hours, minutes, seconds, 0); return d; } //----------------------------------------------------------------------------------------------------- // Funktion Millisekunden in Datum/Zeit umrechnen /wird für logging benoetigt //----------------------------------------------------------------------------------------------------- function millisecToDate(millisec) { var time = new Date(millisec); var Thour = addZero(time.getHours()); var Tmin = addZero(time.getMinutes()); var Tsec = addZero(time.getSeconds()); return `${Thour}:${Tmin}:${Tsec}`; } // Ende Funktion //----------------------------------------------------------------------------------------------------- // Liste der Astro keywords und der Zeiten wenn debug eingeschaltet ist //----------------------------------------------------------------------------------------------------- function Astrozeiten() { if(!Config.debug) {return}; console.log("AWS-Logging: Liste der gegenwärtigen Astrozeiten") Astrotype.forEach(type => { const date = getAstroDate(type); // getAstroDate für jeden Typ const formattedDate = formatDate(date); // Formatieren des Datums console.log(`AWS-Logging: Astrokeyword ${type}: ${formattedDate}`); }); } //----------------------------------------------------------------------------------------------------- // Datums Formatierung fuer Astrozeiten Funktion: Astrozeiten0 //----------------------------------------------------------------------------------------------------- function formatDate(date) { const day = String(date.getDate()).padStart(2, '0'); // Tag mit führender Null const month = String(date.getMonth() + 1).padStart(2, '0'); // Monat (Monate sind 0-basiert) const hours = String(date.getHours()).padStart(2, '0'); // Stunden mit führender Null const minutes = String(date.getMinutes()).padStart(2, '0'); // Minuten mit führender Null return `Datum: ${day}:${month} ----- Uhrzeit ${hours}:${minutes}`; } //----------------------------------------------------------------------------------------------------- // Funktion zum Anlegen aller Schedules wenn Einflussnehmende Einstellungen: AWSAktiv und Config.CronOnlyIfAWStrue //----------------------------------------------------------------------------------------------------- function CreateSchedules() { var count = 0; var cronJob = ``; Object.keys(CronInterval).forEach((gruppe, idx) => { cronJob = `*/${CronInterval[gruppe]} * * * *`; schedule(cronJob, () => executeSchedule(gruppe, idx + 1)); count ++ }); log(`AWS-Logging: EVENT: schedules angelegt - Anzahl angelegt: ${count} `, "info"); } //----------------------------------------------------------------------------------------------------- // Funktion zum Löschen aller Schedules wenn Config.CronOnlyIfAWStrue = true gesetzt ist und AWSAktiv auf false gestellt wurde //----------------------------------------------------------------------------------------------------- function DeleteSchedules() { // Rufen Sie die clearSchedule-Methode von ioBroker auf var count = 0; var cronJob = ``; Object.keys(CronInterval).forEach((gruppe, idx) => { cronJob = `*/${CronInterval[gruppe]} * * * *`; clearSchedule(cronJob); count ++ }); log(`AWS-Logging: EVENT: schedules geloescht - Anzahl geloescht: ${count}`, "info"); } //----------------------------------------------------------------------------------------------------- // Funktion zum Pruefen ob die arrays korrekt erstellt wurden //----------------------------------------------------------------------------------------------------- function checkArrays() { const arrays = [Zeiten, Einschaltdauer, StartDelay, CronInterval, Geraete]; const groupNames = Object.keys(Zeiten); // Überprüfen, ob alle Arrays die gleiche Anzahl von Zeilen haben const groupCount = groupNames.length; for (const array of arrays) { if (Object.keys(array).length !== groupCount) { console.error('AWS-Logging: Fehler: Nicht alle Arrays haben die gleiche Anzahl von Zeilen.'); process.exit(1); } } // Überprüfen, ob alle Arrays die gleichen Gruppennamen haben for (const array of arrays) { const arrayGroupNames = Object.keys(array); if (JSON.stringify(arrayGroupNames.sort()) !== JSON.stringify(groupNames.sort())) { console.error('AWS-Logging: Fehler: Nicht alle Arrays haben identische Gruppennamen.'); process.exit(1); } } if(Config.debug) {console.log('AWS-Logging: Arrays scheinen konsistent angelegt worden zu sein.')}; } //----------------------------------------------------------------------------------------------------- // Funktion zum anlegen von states //----------------------------------------------------------------------------------------------------- async function createStateAsync() { if ( existsState(Config.IDAWSaktiv )) { if(Config.debug) {console.log(`AWS-Logging: State bereits angelegt ${Config.IDAWSaktiv}` )}; return; } try { await createState(Config.IDAWSaktiv, false, { read: true, write: true, type: 'boolean', name: 'Anwesenheitssteuerungsflag', desc: 'Anwesenheitssteuerungsflag' }); console.log('AWS-Logging: State erfolgreich erstellt.'); } catch (err) { console.error(`Fehler beim Erstellen des States: ${err}`); } }