Beispiel Script für Timer (Shelly 2.5 Plus PM)

function User_Main_Skript() {
/** =============================== CHANGE HERE =============================== */

let AutoAus = NewProject.Create();
AutoAus.AddShelly("SoVielBesser", "Gen_2", "None", "Output_1", "localhost");
AutoAus.AddGroupTrigger("easy", "SoVielBesser", "on");
AutoAus.GroupAction("easy", "SoVielBesser", "on",600);
AutoAus.Run();


/** =============================== STOP CHANGING HERE =============================== */
}
//Work in Progress...
let globalCall_Counter = 0, globalProject_Counter = 0;
let NewProject = {
    knownEvents: ['btn_down', 'btn_up', 'single_push', 'double_push', 'triple_push', 'long_push', 'toggle','on', 'off'],
    shellyList: [],
    groupList: [],
    httpGet_List: [],
    sleepList: [],
    waitingCallList: [],
    callTimeout: 10,
    usedCallCounter: 0,
    sleepCounter: 0,
    sleepHandle: null,
    oldData: null,
    projectLimit: 1,
    activeLimit: 5,
    sleepInUse: false,
    watchDogRunning: false,
    loop: false,
    noActiveSleep: true,
    abort: false,
    debug: false,
    sucess: false,
    Create: function () {
        globalProject_Counter += 1;
        if (globalProject_Counter > this.projectLimit) {
            print('Error: to many Projects created, 'globalProject_Counter', the maximum Number per Skript is ', this.projectLimit);
            this.abort = true;
        }
        let newObj = Object.create(this);
        newObj.Create = null;
        newObj.projectID = globalProject_Counter;
        if (this.abort === false) print('Info: Project: ', newObj.projectID, ' sucessfull created, be happy , dont worry ^^) ');
        return newObj;
    },
    NotString: function (data, flag) {
        let check = false;
        if (typeof (data) !== 'string') check = true;
        if (flag) print('Error: ', data, ' needs to be dataType String');
        return check;
    },
    NotNumber: function (data, flag) {
        let check = false;
        if (typeof (data) !== 'number') check = true;
        if (flag) print('Error: ', data, ' needs to be dataType Number');
        return check;
    },
    NotUndefined: function (data, flag) {
        let check = false;
        if (typeof (data) !== 'undefined') check = true;
        if (flag) print('Error: ', data, ' not undefined');
        return check;
    },
    CheckIP: function (_ip) {
        if (typeof (_ip) === 'undefined' || _ip === 'localhost') _ip = '127.0.0.1';
        if (_ip === 'dataType_Error') print('Error: IP:', _ip, 'needs to be dataType String, falling back to default: "localhost"');
        if (_ip === 'dataType_Error') _ip = '127.0.0.1';
        return _ip;
    },
    CheckGen: function (gen) {
        if (gen === 'Gen_1') gen = 1;
        if (gen === 'Gen_2') gen = 2;
        if (gen === 'BLU') gen = 404;
        if (this.NotNumber(gen)) print('Error: 'gen', only Gen_1 or Gen_2 is supported');
        return gen;
    },
    CheckInput: function (input) {
        let notFound = true;
        if (input === 'Input_1' || input === 'input_1') { input = 0; notFound = false; }
        if (input === 'Input_2' || input === 'input_2') { input = 1; notFound = false; }
        if (input === 'Input_3' || input === 'input_3') { input = 2; notFound = false; }
        if (input === 'Input_4' || input === 'input_4') { input = 3; notFound = false; }
        if (input === 'None' || input === 'none') { input = 420; notFound = false; }
        if (notFound) { print('Error: ', input, ', unknown only Input_1 to Input_4 or None is supported'); input = 420; }
        let _string = JSON.stringify(input);
        let _number = input;
        let input = { number: _number, string: _string };
        return input;
    },
    CheckOutput: function (output) {
        let notFound = true;
        if (output === 'Output_1' || output === 'output_1') { output = 0; notFound = false; }
        if (output === 'Output_2' || output === 'output_1') { output = 1; notFound = false; }
        if (output === 'Output_3' || output === 'output_1') { output = 2; notFound = false; }
        if (output === 'Output_4' || output === 'output_1') { output = 3; notFound = false; }
        if (output === 'None' || output === 'none') { output = 420; notFound = false; }
        if (notFound) { print('Error: ', output, ', unknown only Output_1 to Output_4 or None is supported'); output = 420; }
        let _string = JSON.stringify(output);
        let _number = output;
        let output = { number: _number, string: _string };
        return output;
    },
    ActiveCallLimit: function (limit) {
        if (this.abort) return;
        if (this.NotNumber(limit) || limit < 1 || limit > 5) {
            print('Error: ', limit, ', ActiveCallLimit can only be a Number from 1 to 5, falling back to default: 4');
            return;
        }
        this.activeLimit = limit;
    },
    AddShelly: function (name, gen, inputID, outputID, ip) {
        if (this.abort) return;
        ip = this.CheckIP(ip);
        if (this.NotString(name) || this.NotString(gen) || this.NotString(inputID) || this.NotString(outputID) || this.NotString(ip)) {
            print('Error: Shelly: 'name', AddShelly() parameter needs to be dataType String or AddShelly() missing parameters');
            if (this.NotString(ip)) ip = 'dataType_Error';
            if (this.NotString(gen)) gen = 'dataType_Error';
            if (this.NotString(name)) name = 'dataType_Error';
            if (this.NotString(inputID)) inputID = 'dataType_Error';
            if (this.NotString(outputID)) outputID = 'dataType_Errorype';
        }
        let newShelly = {};
        newShelly.shelly_IP = ip;
        newShelly.shelly_Name = name;
        newShelly.shelly_Gen = this.CheckGen(gen);
        newShelly.shelly_InputID = this.CheckInput(inputID);
        newShelly.shelly_OutputID = this.CheckOutput(outputID);
        this.shellyList.push(newShelly);
        let tmp = JSON.stringify(newShelly);
        if (this.debug) print('Debug: add NewShelly: ', tmp, ' --> Shellys added so far: ', this.shellyList.length);
    },
    Call_ErrorCheck: function (response, shellyCall_error_code, shellyCall_error_message, extra) {
        if (shellyCall_error_code !== 0) {
            print('Error: Shelly.call()');
            print('Response: ', JSON.stringify(response));
            print('eMsg: ', shellyCall_error_message);
            print('Response type is: ', typeof (response));
            if (typeof (response) !== 'object') {
                response = { callError: true, orgResponse: response };
            } else {
                response.callError = true;
            }
        }
        if (typeof (response) !== 'object') {
            response = { changedToObj: true, orgResponse: response };
        }
        if (typeof (extra) !== 'undefined') {
            if (typeof (extra) === 'function') extra(response);
            if (typeof (extra) === 'object') extra.CallBack(response, extra.data);
        }
    },
    HTTP_ErrorCheck: function (response, extra) {
        globalCall_Counter -= 1;
        Shelly.emitEvent('finished_call', { _fakeEvent: true, call_response: response, pending_Global_Calls: globalCall_Counter });
        if (response.code !== 200) {
            print('Error: Http call');
            print('Response: ', JSON.stringify(response));
            print('eMsg: ', response.message);
        }
        if (response.body === 'Bad turn!') print('Error: SetShelly Command not supported, use on, off or toggle');
        if (typeof (extra) !== 'undefined') {
            if (typeof (extra) === 'function') extra(response);
            if (typeof (extra) === 'object') extra.CallBack(response, extra.data);
        }
    },
    Loop: function (flag) {
        if (this.abort) return;
        if (typeof (flag) !== 'boolean') {
            print('Error: Loop(), parameter needs to be boolean, Loop(true) or Loop(false)');
            return;
        }
        this.loop = flag;
    },
    ActionSleep: function (time) {
        if (this.abort) return;
        if (this.NotNumber(time)) print('Error: Sleep(), Time needs to be dataType Number, falling back to Sleep(0)');
        if (this.NotNumber(time)) time = 0;
        this.sleepList.push(time);
        this.sleepInUse = true;
    },
    Run: function () {
        if (this.abort) return;
        let extra = {};
        extra.loop = this.loop;
        extra.noActiveSleep = this.noActiveSleep;
        extra.usedCallCounter = this.usedCallCounter;
        extra.sleepCounter = this.sleepCounter;
        extra.projectID = this.projectID;
        extra.usedCallID = (this.projectID - 1);
        extra.sleepInUse = this.sleepInUse;
        extra.debug = this.debug;
        extra.activeLimit = this.activeLimit;
        extra.oldData = this.oldData;
        extra.sucess = this.sucess;
        extra.CallErrorCheck = this.Call_ErrorCheck;
        extra.HTTPErrorCheck = this.HTTP_ErrorCheck;
        extra.httpGet_List = this.httpGet_List;
        extra.sleepList = this.sleepList;
        extra.groupList = this.groupList;
        extra.callTimeout = this.callTimeout;
        extra.knownEvents = this.knownEvents;
        extra.waitingCallList = this.waitingCallList;
        if (this.debug) print('Debug: Aktion() call List: ', extra.httpGet_List.length);
        function WatchDog(eventData, extraData) {
            if (globalCall_Counter < 0) globalCall_Counter = 0;
            let eventString = JSON.stringify(eventData), index = 0, fake_Event = false, valid_Event = false;
            if (extraData.debug) print('Debug: new Event, ', eventString);
            if (typeof (eventData.info) === 'undefined') return;
            if (typeof (eventData.info.data) !== 'undefined' && typeof (eventData.info.data._fakeEvent) !== 'undefined') fake_Event = eventData.info.data._fakeEvent;
            for (let _index0 in extraData.knownEvents) {
                if (eventData.info.event === extraData.knownEvents[_index0]) valid_Event = true;
            }
            function Sleep_Logic() {
                if (extraData.sleepInUse && extraData.noActiveSleep && extraData.sleepList.length > 0) {
                    let startTimer = false;
                    if (extraData.sleepList.length !== extraData.httpGet_List.length) {
                        //print('Info: ActionSleep(), if used once, each Action needs an ActionSleep above it, these are pairs, ActionSleep(0) also works.');
                        if (extraData.debug) print('Debug: Sleep_Logic(), found Action(): ', extraData.httpGet_List.length, ', found ActionSleep(): ', extraData.sleepList.length);
                        return;
                    }
                    function TimerCB(extraData) {
                        Shelly.emitEvent('finished_sleep', { _fakeEvent: true });
                    }
                    if(extraData.sucess === false)extraData.oldData = extraData.activeLimit;
                    extraData.sucess = true;
                    extraData.activeLimit = 1;
                    if (extraData.sleepList.length === extraData.httpGet_List.length && extraData.sleepList[extraData.usedCallCounter] >= 0) startTimer = true;
                    if (startTimer) Timer.set(extraData.sleepList[extraData.usedCallCounter] * 1000, false, TimerCB);
                    if (startTimer) extraData.sleepCounter += 1;
                    if (extraData.debug && startTimer) print('Project ', extraData.projectID, ' Debug: starting ActionSleep() Nr: ', extraData.sleepCounter);
                    if (startTimer) extraData.noActiveSleep = false;
                }
                if (eventData.info.event === 'finished_sleep' && fake_Event) extraData.noActiveSleep = true;
            }
            function HttpGet_Send() {
                if (extraData.httpGet_List.length > 0 && globalCall_Counter < extraData.activeLimit && extraData.noActiveSleep) {
                    for (index = extraData.usedCallCounter; index < extraData.httpGet_List.length; index += 1) {
                        globalCall_Counter += 1;
                        extraData.usedCallCounter += 1;
                        Shelly.call('HTTP.GET', { url: extraData.httpGet_List[index], timeout: extraData.callTimeout }, extraData.CallErrorCheck, extraData.HTTPErrorCheck);
                        if (extraData.debug) print('Debug: send, HTTP.GET call: ', extraData.httpGet_List[index], 'finished calls so far: ', extraData.usedCallCounter);
                        if (globalCall_Counter > (extraData.activeLimit - 1)) break;
                    }
                    if (extraData.debug) print('Debug: now active global calls: ', globalCall_Counter);
                }
            }
            function Trigger_Logic() {
                let triggerdEvent = false, triggerdState = false;
                if (extraData.groupList.length > 0) {
                    for (let _index1 in extraData.groupList) {
                        if (eventData.info.state === extraData.groupList[_index1].relayState_AsEvent && eventData.info.id === extraData.groupList[_index1].outputID.number) triggerdState = true;
                        if (eventData.info.event === extraData.groupList[_index1].trigger_Event && eventData.info.component === extraData.groupList[_index1].componentStringID) triggerdEvent = true;
                        if (extraData.debug && extraData.groupList[_index1].relayState_AsEvent === null) print('Debug: Group, ', extraData.groupList[_index1].group_Name, 'comp, ',extraData.groupList[_index1].componentStringID,' triggerd:', triggerdEvent, ' by Event: ', eventData.info.event);
                        if (extraData.debug && extraData.groupList[_index1].relayState_AsEvent !== null) print('Debug: Group, ', extraData.groupList[_index1].group_Name, 'RelayID, ',extraData.groupList[_index1].outputID.number,' triggerd:', triggerdState, ' by State: ', eventData.info.state);
                        if (triggerdEvent || triggerdState) {
                            for (let _index2 = 0; _index2 < extraData.groupList[_index1].group_HttpGet_List.length; _index2 += 1) {
                                extraData.waitingCallList.push(extraData.groupList[_index1].group_HttpGet_List[_index2]);
                            }
                        }
                    }
                }
            }
            function Reset_Logic() {
                if (extraData.usedCallCounter === extraData.httpGet_List.length) {
                    if (extraData.debug) print('Debug: finished Run');
                    let addCalls = false;
                    extraData.httpGet_List = [];
                    extraData.usedCallCounter = 0;
                    extraData.sleepCounter = 0;
                    if(extraData.waitingCallList.length > 0)addCalls = true;
                    if(addCalls){
                        if(typeof(extraData.oldData) === 'number')extraData.activeLimit = extraData.oldData;
                        extraData.sleepInUse = false;
                        for (let _index3 = 0; _index3 < extraData.waitingCallList.length; _index3 += 1){
                            extraData.httpGet_List.push(extraData.waitingCallList[_index3]);
                        }
                        if (extraData.debug) print('Debug: added ',extraData.waitingCallList.length,' watingCalls , --> till now active calls',extraData.httpGet_List.length);
                        extraData.waitingCallList = [];
                        Shelly.emitEvent('finityloop', { _fakeEvent: true });
                    }
                    if (extraData.loop) {
                        if (extraData.debug) print('Debug: starting, new Round of infinity loop');
                        Shelly.emitEvent('infinityloop', { _fakeEvent: true });
                    }
                }
            }
            //__Main__
            if (fake_Event) Sleep_Logic();
            if (fake_Event) HttpGet_Send();
            if (valid_Event) Trigger_Logic();
            if (fake_Event || valid_Event) Reset_Logic();
        }
        if(typeof (this.httpGet_List) !== 'array') this.httpGet_List = [];
        WatchDog({ info: { data: { _fakeEvent: true } } }, extra);
        if (this.watchDogRunning) return;
        this.watchDogRunning = true;
        Shelly.addEventHandler(WatchDog, extra);
        if (this.debug) print('Debug: Project: 'this.projectID', WatchDog working fine');
    },
    Action: function (name, command, time) {
        if (this.abort) return;
        if (typeof (name) === 'undefined' || typeof (command) === 'undefined') { print('Error: Action(), missing parameter'); return; }
        if (this.NotNumber(time) && this.NotUndefined(time)) { print('Error: Action(), Toogle_After Time: ', time, ', Toogle_After Time needs to be dataType Number'); return; }
        if (this.NotString(command)) { print('Error: Action(), command: ', command, ', needs to be dataType String'); return; }
        if (this.NotString(name)) { print('Error:  Action(), name: ', name, ', needs to be dataType String'); return; }
        for (let index in this.shellyList) {
            if (this.shellyList[index].shelly_Name === name) {
                let string = '';
                if (typeof (time) === 'number') {
                    time = JSON.stringify(time);
                    string = 'http://' + this.shellyList[index].shelly_IP + '/relay/' + this.shellyList[index].shelly_OutputID.string + '?turn=' + command + '&timer=' + time;
                } else {
                    string = 'http://' + this.shellyList[index].shelly_IP + '/relay/' + this.shellyList[index].shelly_OutputID.string + '?turn=' + command;
                }
                this.httpGet_List.push(string);
                if (this.debug) print('Debug: add Action Call: ', string);
            }
        }
    },
    GroupAction: function (groupName, name, command, time) {
        if (this.abort) return;
        if (typeof (groupName) === 'undefined' || typeof (name) === 'undefined' || typeof (command) === 'undefined') { print('Error: GroupAction(), missing parameter'); return; }
        if (this.NotNumber(time) && this.NotUndefined(time)) { print('Error: GroupAction(), Toogle_After Time: ', time, ', needs to be dataType Number'); return; }
        if (this.NotString(command)) { print('Error: GroupAction(), command: ', command, ', needs to be dataType String'); return; }
        if (this.NotString(name)) { print('Error:  GroupAction(), Shelly_Name: ', name, ', needs to be dataType String'); return; }
        if (this.NotString(groupName)) { print('Error:  GroupAction(), Group_Name: ', groupName, ', needs to be dataType String'); return; }
        let stringCall = '';
        for (let index in this.shellyList) {
            if (this.shellyList[index].shelly_Name === name) {
                if (typeof (time) === 'number') {
                    time = JSON.stringify(time);
                    stringCall = 'http://' + this.shellyList[index].shelly_IP + '/relay/' + this.shellyList[index].shelly_OutputID.string + '?turn=' + command + '&timer=' + time;
                } else {
                    stringCall = 'http://' + this.shellyList[index].shelly_IP + '/relay/' + this.shellyList[index].shelly_OutputID.string + '?turn=' + command;
                }
            }
        }
        let notFound = true;
        let groupNameList = [];
        for (let index in this.groupList) {
            if (groupName === this.groupList[index].group_Name) {
                this.groupList[index].group_HttpGet_List.push(stringCall);
                if (this.debug) print('Debug: add Group ', groupName, ' Action call: ', stringCall,' so far added calls:',this.groupList[index].group_HttpGet_List.length);
                notFound = false;
            }
            groupNameList.push(this.groupList[index].group_Name);
        }
        let tmp = JSON.stringify(groupNameList);
        if (notFound) { print('Error: GroupTrigger(), Group_Name: ', groupName, ', unknown only found: ', tmp, ', AddGroupTrigger() needs to be above first GroupAktion()'); return; }
    },
    AddGroupTrigger: function (groupName, triggerShellyName, triggerEvent) {
        if (this.abort) return;
        if (this.NotString(groupName) || this.NotString(triggerShellyName) || this.NotString(triggerEvent)) {
            print('Error: Group: 'groupName', AddGroupTrigger() parameter needs to be dataType String or AddGroupTrigger() missing parameters');
            if (this.NotString(groupName)) groupName = 'dataType_Error';
            if (this.NotString(triggerEvent)) triggerEvent = 'dataType_Error';
            if (this.NotString(triggerShellyName)) triggerShellyName = 'dataType_Error';
        }
        let notFound = true, tmp_ShellyOutputID = {}, tmp_ShellyInputID = {};
        for (let index in this.shellyList) {
            if (triggerShellyName === this.shellyList[index].shelly_Name) {
                tmp_ShellyInputID = this.shellyList[index].shelly_InputID;
                tmp_ShellyOutputID = this.shellyList[index].shelly_OutputID;
                notFound = false;
            }
        }
        if (notFound) print('Error: GroupTrigger(), Shelly: ', triggerShellyName, ', unknown you need to use AddShelly() before using GroupTrigger()');
        notFound = true;
        for (let index in this.knownEvents) {
            if (triggerEvent === this.knownEvents[index]) notFound = false;
        }
        let tmp = JSON.stringify(this.knownEvents);
        if (notFound) { print('Error: GroupTrigger(), Event: ', triggerEvent, ', unknown only ', tmp, ' are supported'); return; }
        let foundInputEvent = false, foundOutputEvent = false, foundSpecialEvents = false, foundNothing = true;
        let inputEvents = ['btn_down', 'btn_up', 'single_push', 'double_push', 'triple_push', 'toggle'], outputEvents = ['toggle'];
        for (let index in inputEvents) {
            if (inputEvents[index] === triggerEvent) {
                foundInputEvent = true;
                foundNothing = false;
            }
        }
        for (let index in outputEvents) {
            if (outputEvents[index] === triggerEvent) {
                foundOutputEvent = true;
                foundNothing = false;
            }
        }
        let eventStringID = 'none', relayStateAsEvent = null;
        if (foundInputEvent && tmp_ShellyInputID.number < 5) eventStringID = 'input:' + tmp_ShellyInputID.string;
        if (foundOutputEvent && tmp_ShellyOutputID.number < 5) eventStringID = 'switch:' + tmp_ShellyOutputID.string;
        if (tmp_ShellyOutputID.number < 5 && triggerEvent === 'on') relayStateAsEvent = true;
        if (tmp_ShellyOutputID.number < 5 && triggerEvent === 'off') relayStateAsEvent = false;
        if (foundNothing && tmp_ShellyOutputID.number < 5) eventStringID = 'switch:' + tmp_ShellyOutputID.string;
        if (foundNothing && tmp_ShellyInputID.number < 5) eventStringID = 'input:' + tmp_ShellyInputID.string;
        let newGroup = {};
        newGroup.group_Name = groupName;
        newGroup.group_HttpGet_List = [];
        newGroup.inputID = tmp_ShellyInputID;
        newGroup.outputID = tmp_ShellyOutputID;
        newGroup.componentStringID = eventStringID;
        newGroup.relayState_AsEvent = relayStateAsEvent;
        newGroup.trigger_ShellyName = triggerShellyName;
        newGroup.trigger_Event = triggerEvent;
        this.groupList.push(newGroup);
        tmp = JSON.stringify(newGroup);
        if (this.debug) print('Debug: add newGroup: ', tmp, ' --> groupTrigger added so far: ', this.groupList.length);
    },
};
User_Main_Skript();