node-red-contrib-alice 2.2.5 → 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.js

@@ -1,10 +1,9 @@
 "use strict";
-;
 module.exports = (RED) => {
     function AliceGet(config) {
         RED.nodes.createNode(this, config);
-        const service = RED.nodes.getNode(config.service);
+        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