node-red-contrib-alice 2.2.4 → 2.3.2

package/src/alice-device.ts

@@ -0,0 +1,301 @@
+import { NodeAPI } from "node-red";
+import axios from "axios";
+import pjson from "../package.json";
+import {
+  AliceDeviceConfig,
+  AliceDeviceNode,
+  AliceServiceNode,
+  CapabilityRegistration,
+  CapabilityState,
+  SensorRegistration,
+  SensorState,
+  DeviceConfig,
+  DeviceStates
+} from "./types.js";
+
+export = (RED: NodeAPI): void => {
+  function AliceDevice(this: AliceDeviceNode, config: AliceDeviceConfig): void {
+    RED.nodes.createNode(this, config);
+    const service = RED.nodes.getNode(config.service) as AliceServiceNode;
+    service.setMaxListeners(service.getMaxListeners() + 1);
+
+    this.initState = false;
+    let updating = false;
+    let needSendEvent = false;
+    const capabilites: Record<string, string> = {};
+    const sensors: Record<string, string> = {};
+
+    const deviceconfig: DeviceConfig = {
+      id: this.id,
+      name: config.name,
+      description: config.description,
+      room: config.room,
+      type: config.dtype,
+      device_info: {
+        manufacturer: "NodeRed Home",
+        model: "virtual device",
+        sw_version: pjson.version
+      },
+      capabilities: [],
+      properties: []
+    };
+
+    const states: DeviceStates = {
+      id: this.id,
+      capabilities: [],
+      properties: []
+    };
+
+    if (service.isOnline) {
+      this.emit("online");
+      this.initState = true;
+    }
+
+    // функция обновления информации об устройстве
+    const _updateDeviceInfo = (): void => {
+      if (deviceconfig.capabilities.length == 0 && deviceconfig.properties.length == 0) {
+        this.debug("DELETE Device config from gateway ...");
+        axios.request({
+          timeout: 5000,
+          method: 'POST',
+          url: 'https://api.nodered-home.ru/gtw/device/config',
+          headers: {
+            'content-type': 'application/json',
+            'Authorization': "Bearer " + service.getToken()
+          },
+          data: {
+            id: this.id,
+            config: deviceconfig
+          }
+        })
+        .then(() => {
+          this.trace("Device config deleted on gateway successfully");
+        })
+        .catch(error => {
+          this.debug("Error when delete device config on gateway: " + error.message);
+        });
+        return;
+      }
+
+      if (!updating) {
+        updating = true;
+        setTimeout(() => {
+          this.debug("Updating Device config ...");
+          updating = false;
+          axios.request({
+            timeout: 5000,
+            method: 'POST',
+            url: 'https://api.nodered-home.ru/gtw/device/config',
+            headers: {
+              'content-type': 'application/json',
+              'Authorization': "Bearer " + service.getToken()
+            },
+            data: {
+              id: this.id,
+              config: deviceconfig
+            }
+          })
+          .then(() => {
+            this.trace("Device config updated successfully");
+          })
+          .catch(error => {
+            this.debug("Error when update device config: " + error.message);
+          });
+        }, 1000);
+      }
+    };
+
+    // функция обновления состояния устройства (умений и сенсоров)
+    const _updateDeviceState = (event: Record<string, any> | null = null): void => {
+      axios.request({
+        timeout: 5000,
+        method: 'POST',
+        url: 'https://api.nodered-home.ru/gtw/device/state',
+        headers: {
+          'content-type': 'application/json',
+          'Authorization': "Bearer " + service.getToken()
+        },
+        data: {
+          id: this.id,
+          event: event,
+          state: states
+        }
+      })
+      .then(() => {
+        this.trace("Device state updated successfully");
+      })
+      .catch(error => {
+        this.debug("Error when update device state: " + error.message);
+      });
+    };
+
+    // отправка эвентов
+    const _sendEvent = (event: CapabilityState): void => {
+      const data = JSON.stringify(event);
+      service.send2gate('$me/device/events/' + this.id, data, false);
+    };
+
+    // Установка параметров умения
+    this.setCapability = (capId: string, capab: CapabilityRegistration): Promise<boolean> => {
+      return new Promise((resolve, reject) => {
+        const instance = capab.parameters.instance || '';
+        const capabIndex = capab.type + "." + instance;
+        if (capabilites[capabIndex] && capabilites[capabIndex] != capId) {
+          reject(new Error("Dublicated capability on same device!"));
+          return;
+        }
+        // проверям было ли такое умение раньше и удаляем перед обновлением
+        if (deviceconfig.capabilities.findIndex(a => a.id === capId) > -1) {
+          this.delCapability(capId);
+        }
+        capabilites[capabIndex] = capId;
+        capab.id = capId;
+        deviceconfig.capabilities.push(capab);
+        _updateDeviceInfo();
+        resolve(true);
+      });
+    };
+
+    // Установка параметров сенсора
+    this.setSensor = (sensId: string, sensor: SensorRegistration): Promise<boolean> => {
+      return new Promise((resolve, reject) => {
+        const sensorIndex = sensor.type + "." + sensor.parameters.instance;
+        if (sensors[sensorIndex] && sensors[sensorIndex] != sensId) {
+          reject(new Error("Dublicated sensor on same device!"));
+          return;
+        }
+        // проверяем было ли такой сенсор раньше и удаляем перед обновлением
+        if (deviceconfig.properties.findIndex(a => a.id === sensId) > -1) {
+          this.delSensor(sensId);
+        }
+        sensors[sensorIndex] = sensId;
+        sensor.id = sensId;
+        deviceconfig.properties.push(sensor);
+        _updateDeviceInfo();
+        resolve(true);
+      });
+    };
+
+    // обновление текущего state умения
+    this.updateCapabState = (capId: string, state: CapabilityState): Promise<boolean> => {
+      return new Promise((resolve) => {
+        state.id = capId;
+        if (needSendEvent) {
+          _sendEvent(state);
+        }
+        const index = states.capabilities.findIndex(a => a.id === capId);
+        if (index > -1) {
+          states.capabilities.splice(index, 1);
+        }
+        states.capabilities.push(state);
+        const currentevent = {
+          id: this.id,
+          capabilities: [state]
+        };
+        _updateDeviceState(currentevent);
+        resolve(true);
+      });
+    };
+
+    // обновление текущего state сенсора
+    this.updateSensorState = (sensID: string, state: SensorState): Promise<boolean> => {
+      return new Promise((resolve) => {
+        state.id = sensID;
+        const index = states.properties.findIndex(a => a.id === sensID);
+        if (index > -1) {
+          states.properties.splice(index, 1);
+        }
+        states.properties.push(state);
+        const currentevent = {
+          id: this.id,
+          properties: [state]
+        };
+        _updateDeviceState(currentevent);
+        resolve(true);
+      });
+    };
+
+    // удаление умения
+    this.delCapability = (capId: string): Promise<boolean> => {
+      return new Promise((resolve) => {
+        const index = deviceconfig.capabilities.findIndex(a => a.id === capId);
+        if (index > -1) {
+          deviceconfig.capabilities.splice(index, 1);
+        }
+        const capabIndex = Object.keys(capabilites).find(key => capabilites[key] === capId);
+        if (capabIndex) delete capabilites[capabIndex];
+        _updateDeviceInfo();
+        const stateindex = states.capabilities.findIndex(a => a.id === capId);
+        if (stateindex > -1) {
+          states.capabilities.splice(stateindex, 1);
+        }
+        _updateDeviceState();
+        resolve(true);
+      });
+    };
+
+    // удаление сенсора
+    this.delSensor = (sensID: string): Promise<boolean> => {
+      return new Promise((resolve) => {
+        const index = deviceconfig.properties.findIndex(a => a.id === sensID);
+        if (index > -1) {
+          deviceconfig.properties.splice(index, 1);
+        }
+        const sensorIndex = Object.keys(sensors).find(key => sensors[key] === sensID);
+        if (sensorIndex) delete sensors[sensorIndex];
+        _updateDeviceInfo();
+        const stateindex = states.properties.findIndex(a => a.id === sensID);
+        if (stateindex > -1) {
+          states.properties.splice(stateindex, 1);
+        }
+        _updateDeviceState();
+        resolve(true);
+      });
+    };
+
+    service.on("online", () => {
+      this.debug("Received a signal online from the service");
+      this.emit("online");
+      this.initState = true;
+    });
+
+    service.on("offline", () => {
+      this.debug("Received a signal offline from the service");
+      this.emit("offline");
+      this.initState = false;
+      this.status({ fill: "red", shape: "dot", text: "offline" });
+    });
+
+    service.on(this.id, (incomingStates: any[]) => {
+      setTimeout(() => {
+        needSendEvent = false;
+      }, 2000);
+      needSendEvent = true;
+      incomingStates.forEach(cap => {
+        let capabIndex = cap.type + "." + cap.state.instance;
+        if (cap.type === "devices.capabilities.color_setting") {
+          capabIndex = cap.type + ".";
+        }
+        const capId = capabilites[capabIndex];
+        this.emit(capId, cap.state.value, cap.state);
+      });
+    });
+
+    this.on('close', (removed: boolean, done: () => void) => {
+      this.emit('offline');
+      if (removed) {
+        deviceconfig.capabilities = [];
+        deviceconfig.properties = [];
+        states.capabilities = [];
+        states.properties = [];
+        _updateDeviceState();
+        _updateDeviceInfo();
+      }
+      setTimeout(() => {
+        done();
+      }, 500);
+    });
+  }
+
+  RED.nodes.registerType("alice-device", AliceDevice);
+};

package/src/alice-event.html

@@ -0,0 +1,148 @@
+<script type="text/javascript">
+    RED.nodes.registerType('Event',{
+        category: 'alice',
+        defaults:{
+            device: {value:"", type:"alice-device"},
+            name: {value:"Event"},
+            stype: {value:'devices.properties.event'},
+            instance: {value:undefined, validate: (v)=>{
+                if (v){
+                    return true;
+                }else{
+                    return false;
+                }
+            }},
+            events:{value:[]}
+        },
+        inputs:1,
+        outputs:0,
+        icon: "alice.png",
+        color: "#D8BFD8",
+        label: function(){
+            return this.name;
+        },
+        oneditprepare: function(){
+            $("#node-input-instance").typedInput({
+                types: [
+                    {
+                        options: [
+                            { value: "vibration", label: "Vibration"},
+                            { value: "open", label: "Open"},
+                            { value: "button", label: "Button"},
+                            { value: "motion", label: "Motion"},
+                            { value: "smoke", label: "Smoke"},
+                            { value: "gas", label: "Gas"},
+                            { value: "battery_level", label: "Battery level"},
+                            { value: "water_level", label: "Water level"},
+                            { value: "water_leak", label: "Water leak"}
+                        ]
+                    }
+                ]
+            });
+            $('#node-input-instance').on('change',()=>{
+                let val= $("#node-input-instance").val();
+                $("#node-input-eventslist").editableList('empty');
+
+                switch (val) {
+                    case "vibration":
+                        $("#node-input-eventslist").editableList('addItems',["tilt","fall","vibration"]);
+                        break;
+                    case "open":
+                        $("#node-input-eventslist").editableList('addItems',["opened","closed"]);
+                        break;
+                    case "button":
+                        $("#node-input-eventslist").editableList('addItems',["click","double_click","long_press"]);
+                        break;
+                    case "motion":
+                        $("#node-input-eventslist").editableList('addItems',["detected","not_detected"]);
+                        break;
+                    case "smoke":
+                        $("#node-input-eventslist").editableList('addItems',["detected","not_detected","high"]);
+                        break;
+                    case "gas":
+                        $("#node-input-eventslist").editableList('addItems',["detected","not_detected","high"]);
+                        break;
+                    case "battery_level":
+                        $("#node-input-eventslist").editableList('addItems',["low","normal"]);
+                        break;
+                    case "water_level":
+                        $("#node-input-eventslist").editableList('addItems',["low","normal"]);
+                        break;
+                    case "water_leak":
+                        $("#node-input-eventslist").editableList('addItems',["dry","leak"]);
+                        break;
+                    default:
+                        break;
+                }
+            });
+            $("#node-input-eventslist").editableList({
+                addButton: false,
+                height: 150,
+                addItem: function(container,i,opt){
+                    var row = $('<div style="padding-left: 3px; class="event_name">'+opt+'</div>').appendTo(container);
+                }
+            });
+        },
+        oneditsave: function(){
+            deivcename = $('#node-input-device option:selected').text();
+            instance = $("#node-input-instance").val();
+            $('#node-input-name').val(deivcename+":"+instance);
+            let events = $("#node-input-eventslist").editableList('items');
+            let node = this;
+            node.events= [];
+            events.each(function(i) {
+                let name = $(this).text(); 
+                node.events.push(name);
+            })
+        }
+    })
+</script>
+
+<script type="text/x-red" data-template-name="Event">
+    <input type="hidden" id="node-input-name">
+    <div class="form-row">
+        <label for="node-input-device">Device</label>
+        <input id="node-input-device">
+    </div>
+    <div class="form-row">
+        <label for="node-input-instance">Event Type</label>
+        <input type="text" id="node-input-instance">
+    </div>
+    <div class="form-row node-input-rule-container-row">
+        <label for="node-input-modes" style="width:auto">Supported events</label>
+        <ol id="node-input-eventslist"></ol>
+    </div>
+</script>
+
+<script type="text/x-red" data-help-name="Event">
+    <p>Transmits event from sensors built into the device.</p>
+    
+    <h3>Property</h3>
+    <dl class="message-properties">
+        <dt>Device
+            <span class="property-type">Select</span>
+        </dt>
+        <dd> The device to which this sensor is connected </dd>
+        <dt>Event Type
+            <span class="property-type">Select</span>
+        </dt>
+        <dd>a type of event that helps to better understand the area of its use and the data it collects</dd>
+        <dt>Supported events
+            <span class="property-type">Read only</span>
+        </dt>
+        <dd>list of events that the sensor can send</dd>
+    </dl>
+
+    <h3>Inputs</h3>
+        <dl class="message-properties">
+            <dt>payload
+                <span class="property-type">string</span>
+            </dt>
+            <dd>events can only be from the allowed list</dd>
+        </dl>
+    
+    <h3>References</h3>
+        <ul>
+            <li><a href="https://yandex.ru/dev/dialogs/smart-home/doc/concepts/event.html"> - Yandex documentation</a></li>
+        </ul>
+    </script>

package/src/alice-event.ts

@@ -0,0 +1,112 @@
+import { NodeAPI, Node } from "node-red";
+import { AliceEventConfig, AliceDeviceNode, SensorState } from "./types.js";
+
+export = (RED: NodeAPI): void => {
+  function AliceEvent(this: Node, config: AliceEventConfig): void {
+    RED.nodes.createNode(this, config);
+    const device = RED.nodes.getNode(config.device) as AliceDeviceNode;
+    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: SensorState = {
+      type: stype,
+      state: {
+        instance: instance,
+        value: ''
+      }
+    };
+
+    this.status({ fill: "red", shape: "dot", text: "offline" });
+
+    const init = (): void => {
+      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 });
+      }
+    });
+
+    device.on("offline", () => {
+      this.status({ fill: "red", shape: "dot", text: "offline" });
+    });
+
+    this.on('input', (msg, _send, done) => {
+      if (!events.includes(msg.payload as string)) {
+        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(() => {
+          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: boolean, done: () => void) => {
+      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);
+};

package/src/alice-get.html

@@ -1,4 +1,5 @@
 <script type="text/javascript">
+    let udyaconfig={};
     RED.nodes.registerType('Alice-Get',{
         category: 'alice',
         inputs:1,
@@ -7,24 +8,84 @@
         color: "#D8BFD8",
         defaults:{
             service: {value:"", type:"alice-service"},
-            name: {value:null, required: false},
+            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">Credentials</label>
+        <label for="node-input-service">Account</label>
         <input id="node-input-service">
     </div>
     <div class="form-row">
-        <label for="node-config-input-name">Name</label>
-        <input type="text" id="node-config-input-name" placeholder="Name">
+        <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/src/alice-get.ts

@@ -1,18 +1,15 @@
-import {NodeAPI, Node, NodeDef } from "node-red";
-import axios from "axios";
+import { NodeAPI, Node, NodeDef } from "node-red";
 
+interface NodeAliceGetConfig extends NodeDef {
+  service: string;
+  name: string;
+}
 
-interface NodeAliceGetConfig
-    extends NodeDef {
-    service: string;
-    name:string;
-};
-
-export = (RED: NodeAPI):void =>{
-    function AliceGet(this:Node, config:NodeAliceGetConfig):void {
-        RED.nodes.createNode(this,config);
-        const service = RED.nodes.getNode(config.service);
-    };
+export = (RED: NodeAPI): void => {
+  function AliceGet(this: Node, config: NodeAliceGetConfig): void {
+    RED.nodes.createNode(this, config);
+    const _service = RED.nodes.getNode(config.service);
+  }
 
-    RED.nodes.registerType("Alice-Get",AliceGet);
-}
+  RED.nodes.registerType("Alice-Get", AliceGet);
+};