node-red-contrib-alice 2.2.4 → 2.3.2

package/nodes/alice-event.js

@@ -1,115 +1,111 @@
-module.exports = function(RED) {
-// ************** ON/OFF *******************
-function AliceEvent(config){
-    RED.nodes.createNode(this,config);
-    const device = RED.nodes.getNode(config.device);
-    device.setMaxListeners(device.getMaxListeners() + 1); // увеличиваем лимит для event
-    const id =JSON.parse(JSON.stringify(this.id));
-    const name = config.name;
-    const stype = 'devices.properties.event';
-    const instance = config.instance;
-    const reportable = true;
-    const retrievable = false;
-    const events = config.events;
-    let initState = false;
-    let curentState = {
-      type:stype,
-      state:{
-        instance: instance,
-        value: ''
-      }
-    };
-    this.status({fill:"red",shape:"dot",text:"offline"});
-
-    const init = ()=>{
-      this.debug("Starting sensor initilization ...");
-      let objEvents=[]
-      events.forEach(v => {
-        objEvents.push({value:v})
-      });
-      let sensor = {
-        type: stype,
-        reportable: reportable,
-        retrievable: retrievable,
-        parameters: {
-          instance: instance,
-          events: objEvents
-        }
-      };
-
-      device.setSensor(id,sensor)
-        .then(res=>{
-          this.debug("Sensor initilization - success!");
-          this.status({fill:"green",shape:"dot",text:"online"});
-          initState = true;
-        })
-        .catch(err=>{
-          this.error("Error on create sensor: " +err.message);
-          this.status({fill:"red",shape:"dot",text:"error"});
+"use strict";
+module.exports = (RED) => {
+    function AliceEvent(config) {
+        RED.nodes.createNode(this, config);
+        const device = RED.nodes.getNode(config.device);
+        device.setMaxListeners(device.getMaxListeners() + 1);
+        const id = JSON.parse(JSON.stringify(this.id));
+        const stype = 'devices.properties.event';
+        const instance = config.instance;
+        const events = config.events;
+        let initState = false;
+        const curentState = {
+            type: stype,
+            state: {
+                instance: instance,
+                value: ''
+            }
+        };
+        this.status({ fill: "red", shape: "dot", text: "offline" });
+        const init = () => {
+            this.debug("Starting sensor initilization ...");
+            const objEvents = events.map(v => ({ value: v }));
+            const sensor = {
+                type: stype,
+                reportable: true,
+                retrievable: false,
+                parameters: {
+                    instance: instance,
+                    events: objEvents
+                }
+            };
+            device.setSensor(id, sensor)
+                .then(() => {
+                this.debug("Sensor initilization - success!");
+                this.status({ fill: "green", shape: "dot", text: "online" });
+                initState = true;
+            })
+                .catch(err => {
+                this.error("Error on create sensor: " + err.message);
+                this.status({ fill: "red", shape: "dot", text: "error" });
+            });
+        };
+        if (device.initState)
+            init();
+        device.on("online", () => {
+            if (!initState) {
+                init();
+            }
+            else {
+                this.status({ fill: "green", shape: "dot", text: curentState.state.value });
+            }
         });
-    };
-
-// Проверяем сам девайс уже инициирован 
-    if (device.initState) init();
-
-    device.on("online",()=>{
-      if (!initState){
-        init();
-      }else{
-        this.status({fill:"green",shape:"dot",text: curentState.state.value});
-      };
-    });
-
-    device.on("offline",()=>{
-      this.status({fill:"red",shape:"dot",text:"offline"});
-    });
-
-    this.on('input', (msg, send, done)=>{
-      if (!events.includes(msg.payload)){
-        this.error("Wrong type! msg.payload must be from the list of allowed events.");
-        if (done) {done();}
-        return;
-      };
-      if (curentState.state.value==msg.payload){
-        this.debug("Value not changed. Cancel update");
-        if (done) {done();}
-        return;
-      }else{
-        curentState.state.value = msg.payload;
-      };
-      // для кнопок обнуляем значение через 1 сек
-      if (instance=='button'){
-        setTimeout(() => {
-          curentState.state.value = null;
-          this.status({fill:"green",shape:"dot",text:""});
-        }, 1000);
-      };
-      device.updateSensorState(id,curentState)
-        .then(ref=>{
-          this.status({fill:"green",shape:"dot",text: curentState.state.value});
-          if (done) {done();}
-        })
-        .catch(err=>{
-          this.error("Error on update sensor state: " +err.message);
-          this.status({fill:"red",shape:"dot",text:"Error"});
-          if (done) {done();}
-        })
-    });
-
-    this.on('close', function(removed, done) {
-      if (removed) {
-        device.delSensor(id)
-        .then(res=>{
-          done()
-        })
-        .catch(err=>{
-          this.error("Error on delete property: " +err.message);
-          done();
-        })
-      }else{
-        done();
-      }
-    });
-  }  
-  RED.nodes.registerType("Event",AliceEvent);
-};
+        device.on("offline", () => {
+            this.status({ fill: "red", shape: "dot", text: "offline" });
+        });
+        this.on('input', (msg, _send, done) => {
+            if (!events.includes(msg.payload)) {
+                this.error("Wrong type! msg.payload must be from the list of allowed events.");
+                if (done) {
+                    done();
+                }
+                return;
+            }
+            if (curentState.state.value == msg.payload) {
+                this.debug("Value not changed. Cancel update");
+                if (done) {
+                    done();
+                }
+                return;
+            }
+            else {
+                curentState.state.value = msg.payload;
+            }
+            if (instance == 'button') {
+                setTimeout(() => {
+                    curentState.state.value = null;
+                    this.status({ fill: "green", shape: "dot", text: "" });
+                }, 1000);
+            }
+            device.updateSensorState(id, curentState)
+                .then(() => {
+                this.status({ fill: "green", shape: "dot", text: curentState.state.value });
+                if (done) {
+                    done();
+                }
+            })
+                .catch(err => {
+                this.error("Error on update sensor state: " + err.message);
+                this.status({ fill: "red", shape: "dot", text: "Error" });
+                if (done) {
+                    done();
+                }
+            });
+        });
+        this.on('close', (removed, done) => {
+            if (removed) {
+                device.delSensor(id)
+                    .then(() => { done(); })
+                    .catch(err => {
+                    this.error("Error on delete property: " + err.message);
+                    done();
+                });
+            }
+            else {
+                done();
+            }
+        });
+    }
+    RED.nodes.registerType("Event", AliceEvent);
+};
+//# sourceMappingURL=alice-event.js.map

package/nodes/alice-get.html

@@ -0,0 +1,91 @@
+<script type="text/javascript">
+    let udyaconfig={};
+    RED.nodes.registerType('Alice-Get',{
+        category: 'alice',
+        inputs:1,
+        outputs:1,
+        icon: "alice.png",
+        color: "#D8BFD8",
+        defaults:{
+            service: {value:"", type:"alice-service"},
+            device: {value:undefined}
+        },
+        label: function(){
+            return this.name || "Alice-Get";
+        },
+        oneditprepare: ()=>{
+            $("#node-input-service").change(function(e){
+                if (this.value &&this.value!='_ADD_'){
+                    $.ajax({
+                        url: "/noderedhome/"+this.value+"/getfullconfig",
+                        type:"GET"
+                    })
+                    .done(result=>{
+                        // RED.notify("Full Alice SmartHome config successfully retrieved", {type:"success"});
+                        console.log(result);
+                        udyaconfig=result;
+                        updateHouse(result.households);
+                    })
+                    .fail(error=>{
+                        RED.notify("Error when retrieve Alice SmartHome config", {type:"error"});
+                    });
+                }
+            });
+            $('#node-input-home')
+                .prop('disabled', 'disabled')
+                .change((e)=>{
+                    let val = $('#node-input-home').find(":selected").val();
+                    console.log(val);
+                });
+
+            $('#node-input-room').prop('disabled', 'disabled');
+            $('#node-input-device').prop('disabled', 'disabled');
+
+        }
+    });
+    function updateHouse(data){
+        $('#node-input-home')
+            .find('option')
+            .remove()
+            .end();
+        udyaconfig.households.forEach(h => {
+            $('#node-input-home')
+                .append('<option value="'+h.id+'">'+h.name+'</option>');
+        });
+        $('#node-input-home')
+            .prop('disabled', false);
+    };
+    function updaterooms(house){
+        $('#node-input-room')
+            .find('option')
+            .remove()
+            .end();
+        udyaconfig.households.forEach(h => {
+            if (h.household_id==house){
+                $('#node-input-room')
+                    .append('<option value="'+h.id+'">'+h.name+'</option>');
+            }
+        });
+        $('#node-input-room').prop('disabled', false);
+    };
+
+</script>
+
+<script type="text/x-red" data-template-name="Alice-Get">
+    <div class="form-row">
+        <label for="node-input-service">Account</label>
+        <input id="node-input-service">
+    </div>
+    <div class="form-row">
+        <label for="node-input-home">Home</label>
+        <select id="node-input-home" style="width: 70%;"></select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-room">Room</label>
+        <select id="node-input-room" style="width: 70%;"></select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-device">Room</label>
+        <select id="node-input-device" style="width: 70%;"></select>
+    </div>
+</script>

package/nodes/alice-get.js

@@ -0,0 +1,9 @@
+"use strict";
+module.exports = (RED) => {
+    function AliceGet(config) {
+        RED.nodes.createNode(this, config);
+        const _service = RED.nodes.getNode(config.service);
+    }
+    RED.nodes.registerType("Alice-Get", AliceGet);
+};
+//# sourceMappingURL=alice-get.js.map

package/nodes/alice-mode.js

@@ -1,146 +1,137 @@
-module.exports = function(RED) {
-      // ************** Modes  *******************
-  function AliceMode(config){
-    RED.nodes.createNode(this,config);
-    this.device = RED.nodes.getNode(config.device);
-    this.name = config.name;
-    this.ctype = 'devices.capabilities.mode';
-    this.retrievable = true;
-    this.random_access = true;
-    this.response = config.response;
-    this.instance = config.instance;
-    this.modes = config.modes;
-    this.initState = false;
-    this.value;
-
-    if (config.response === undefined){
-      this.response = true;
-    }
-
-    this.init = _=>{
-      if (this.modes.length<1){
-        this.status({fill:"red",shape:"dot",text:"error"});
-        this.error("In the list of supported commands, there must be at least one command");
-        return;
-      };
-      if (!this.instance){
-        this.status({fill:"red",shape:"dot",text:"error"});
-        this.error("Mode type not selected");
-        return;
-      };
-      var cfgModes = [];
-      this.modes.forEach(v=>{
-        cfgModes.push({value:v});
-      });
-      let capab = {
-        type: this.ctype,
-        retrievable: this.retrievable,
-        reportable: true,
-        parameters: {
-          instance: this.instance,
-          modes: cfgModes
-        }
-      };
-      this.device.setCapability(this.id,capab)
-      .then(res=>{
-        this.initState = true;
-        this.status({fill:"green",shape:"dot",text:"online"});
-      })
-      .catch(err=>{
-        this.error("Error on create capability: " + err.message);
-        this.status({fill:"red",shape:"dot",text:"error"});
-      });
-    };
-
-    // Проверяем сам девайс уже инициирован 
-    if (this.device.initState) this.init();
-
-    this.device.on("online",()=>{
-      this.init();
-    });
-
-    this.device.on("offline",()=>{
-      this.status({fill:"red",shape:"dot",text:"offline"});
-    });
-
-    this.device.on(this.id,(val,fullstate)=>{
-      let value = val;
-      this.send({
-        payload: value
-      });
-      let state= {
-        type:this.ctype,
-        state:{
-          instance: this.instance,
-          value: value
+"use strict";
+module.exports = (RED) => {
+    function AliceMode(config) {
+        RED.nodes.createNode(this, config);
+        const device = RED.nodes.getNode(config.device);
+        const ctype = 'devices.capabilities.mode';
+        const instance = config.instance || '';
+        const modes = config.modes;
+        let response = config.response;
+        let value;
+        if (config.response === undefined) {
+            response = true;
         }
-      };
-      if (this.response){
-        this.device.updateCapabState(this.id,state)
-        .then (res=>{
-          this.value = value;
-          this.status({fill:"green",shape:"dot",text:"online"});
-        })
-        .catch(err=>{
-          this.error("Error on update capability state: " + err.message);
-          this.status({fill:"red",shape:"dot",text:"Error"});
-        })
-      };
-    })
-
-    this.on('input', (msg, send, done)=>{
-      const value = msg.payload;
-      if (typeof value != 'string'){
-        this.error("Wrong type! msg.payload must be String.");
-        this.status({fill:"red",shape:"dot",text:"Error"});
-        if (done) {done();}
-        return;
-      };
-      if (this.modes.indexOf(value)<0){
-        this.error("Error! Unsupported command.");
-        this.status({fill:"red",shape:"dot",text:"Error"});
-        if (done) {done();}
-        return;
-      };
-      if (value === this.value){
-        this.debug("Value not changed. Cancel update");
-        if (done) {done();}
-        return;
-      };
-      let state= {
-        type:this.ctype,
-        state:{
-          instance: this.instance,
-          value: value
-        }
-      };
-      this.device.updateCapabState(this.id,state)
-      .then(ref=>{
-        this.value = value;
-        this.status({fill:"green",shape:"dot",text:value});
-        if (done) {done();}
-      })
-      .catch(err=>{
-        this.error("Error on update capability state: " + err.message);
-        this.status({fill:"red",shape:"dot",text:"Error"});
-        if (done) {done();}
-      });
-    });
-
-    this.on('close', function(removed, done) {
-      if (removed) {
-        this.device.delCapability(this.id)
-        .then(res=>{
-          done()
-        })
-        .catch(err=>{
-          this.error("Error on delete capability: " + err.message);
-          done();
-        })
-      }else{
-        done();
-      }
-    });
-  }  
-  RED.nodes.registerType("Mode",AliceMode);
-};
+        const init = () => {
+            if (modes.length < 1) {
+                this.status({ fill: "red", shape: "dot", text: "error" });
+                this.error("In the list of supported commands, there must be at least one command");
+                return;
+            }
+            if (!instance) {
+                this.status({ fill: "red", shape: "dot", text: "error" });
+                this.error("Mode type not selected");
+                return;
+            }
+            const cfgModes = modes.map(v => ({ value: v }));
+            const capab = {
+                type: ctype,
+                retrievable: true,
+                reportable: true,
+                parameters: {
+                    instance: instance,
+                    modes: cfgModes
+                }
+            };
+            device.setCapability(this.id, capab)
+                .then(() => {
+                this.status({ fill: "green", shape: "dot", text: "online" });
+            })
+                .catch(err => {
+                this.error("Error on create capability: " + err.message);
+                this.status({ fill: "red", shape: "dot", text: "error" });
+            });
+        };
+        if (device.initState)
+            init();
+        device.on("online", () => {
+            init();
+        });
+        device.on("offline", () => {
+            this.status({ fill: "red", shape: "dot", text: "offline" });
+        });
+        device.on(this.id, (val) => {
+            this.send({ payload: val });
+            const state = {
+                type: ctype,
+                state: {
+                    instance: instance,
+                    value: val
+                }
+            };
+            if (response) {
+                device.updateCapabState(this.id, state)
+                    .then(() => {
+                    value = val;
+                    this.status({ fill: "green", shape: "dot", text: "online" });
+                })
+                    .catch(err => {
+                    this.error("Error on update capability state: " + err.message);
+                    this.status({ fill: "red", shape: "dot", text: "Error" });
+                });
+            }
+        });
+        this.on('input', (msg, _send, done) => {
+            const newValue = msg.payload;
+            if (typeof newValue != 'string') {
+                this.error("Wrong type! msg.payload must be String.");
+                this.status({ fill: "red", shape: "dot", text: "Error" });
+                if (done) {
+                    done();
+                }
+                return;
+            }
+            if (modes.indexOf(newValue) < 0) {
+                this.error("Error! Unsupported command.");
+                this.status({ fill: "red", shape: "dot", text: "Error" });
+                if (done) {
+                    done();
+                }
+                return;
+            }
+            if (newValue === value) {
+                this.debug("Value not changed. Cancel update");
+                if (done) {
+                    done();
+                }
+                return;
+            }
+            const state = {
+                type: ctype,
+                state: {
+                    instance: instance,
+                    value: newValue
+                }
+            };
+            device.updateCapabState(this.id, state)
+                .then(() => {
+                value = newValue;
+                this.status({ fill: "green", shape: "dot", text: newValue });
+                if (done) {
+                    done();
+                }
+            })
+                .catch(err => {
+                this.error("Error on update capability state: " + err.message);
+                this.status({ fill: "red", shape: "dot", text: "Error" });
+                if (done) {
+                    done();
+                }
+            });
+        });
+        this.on('close', (removed, done) => {
+            if (removed) {
+                device.delCapability(this.id)
+                    .then(() => { done(); })
+                    .catch(err => {
+                    this.error("Error on delete capability: " + err.message);
+                    done();
+                });
+            }
+            else {
+                done();
+            }
+        });
+    }
+    RED.nodes.registerType("Mode", AliceMode);
+};
+//# sourceMappingURL=alice-mode.js.map