node-red-contrib-alice 2.2.5 → 2.3.3

package/src/alice-color.ts

@@ -0,0 +1,227 @@
+import { NodeAPI, Node } from "node-red";
+import { AliceColorConfig, AliceDeviceNode, CapabilityState, CapabilityRegistration } from "./types.js";
+
+interface RGBColor {
+  r: number;
+  g: number;
+  b: number;
+}
+
+interface HSVColor {
+  h: number;
+  s: number;
+  v: number;
+}
+
+export = (RED: NodeAPI): void => {
+  function AliceColor(this: Node, config: AliceColorConfig): void {
+    RED.nodes.createNode(this, config);
+    const device = RED.nodes.getNode(config.device) as AliceDeviceNode;
+    device.setMaxListeners(device.getMaxListeners() + 1);
+
+    const ctype = 'devices.capabilities.color_setting';
+    let scheme = config.scheme;
+    const temperature_k = config.temperature_k;
+    const temperature_min = parseInt(config.temperature_min);
+    const temperature_max = parseInt(config.temperature_max);
+    const color_scene = config.color_scene || [];
+    let needConvert = false;
+    let response = config.response;
+    let color_support = config.color_support;
+    let lastValue: string | undefined;
+
+    if (scheme == "rgb_normal") {
+      scheme = "rgb";
+      needConvert = true;
+    }
+    if (config.response === undefined) {
+      response = true;
+    }
+    if (config.color_support === undefined) {
+      color_support = true;
+    }
+
+    const init = (): void => {
+      const parameters: Record<string, any> = {};
+      const capab: CapabilityRegistration = {
+        type: ctype,
+        retrievable: true,
+        reportable: true,
+        parameters: parameters
+      };
+
+      if (!color_support && !temperature_k && color_scene.length < 1) {
+        this.error("Error on create capability: At least one parameter must be enabled");
+        this.status({ fill: "red", shape: "dot", text: "error" });
+        return;
+      }
+
+      if (color_scene.length > 0) {
+        const scenes = color_scene.map(s => ({ id: s }));
+        parameters.color_scene = { scenes: scenes };
+      }
+
+      if (color_support) {
+        parameters.color_model = scheme;
+      }
+
+      if (temperature_k) {
+        parameters.temperature_k = {
+          min: temperature_min,
+          max: temperature_max
+        };
+      }
+
+      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: any, newstate: { instance: string }) => {
+      // отправляем данные на выход
+      const outmsgs: Array<{ payload: any } | null> = [null, null, null];
+      switch (newstate.instance) {
+        case 'rgb': {
+          const value: RGBColor = {
+            r: val >> 16,
+            g: val >> 8 & 0xFF,
+            b: val & 0xFF
+          };
+          outmsgs[0] = { payload: value };
+          break;
+        }
+        case 'hsv':
+          outmsgs[0] = { payload: val };
+          break;
+        case 'temperature_k':
+          outmsgs[1] = { payload: val };
+          break;
+        case 'scene':
+          outmsgs[2] = { payload: val };
+          break;
+      }
+      this.send(outmsgs);
+
+      // возвращаем подтверждение в базу
+      const state: CapabilityState = {
+        type: ctype,
+        state: {
+          instance: newstate.instance,
+          value: val
+        }
+      };
+      if (response) {
+        device.updateCapabState(this.id, state)
+          .then(() => {
+            lastValue = JSON.stringify(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) => {
+      let value: any = msg.payload;
+      const state: { value?: any; instance?: string } = {};
+
+      switch (typeof value) {
+        case 'object': {
+          const obj = value as RGBColor | HSVColor;
+          if (('r' in obj && 'g' in obj && 'b' in obj) || ('h' in obj && 's' in obj && 'v' in obj)) {
+            if (scheme == 'rgb' && 'r' in obj) {
+              value = (obj as RGBColor).r << 16 | (obj as RGBColor).g << 8 | (obj as RGBColor).b;
+            }
+            state.value = value;
+            state.instance = scheme;
+          } else {
+            this.error("Wrong type! For Color, msg.payload must be RGB or HSV Object.");
+            if (done) { done(); }
+            return;
+          }
+          break;
+        }
+        case 'number': {
+          value = Math.round(value as number);
+          if (value >= temperature_min && value <= temperature_max) {
+            state.value = value;
+            state.instance = 'temperature_k';
+          } else {
+            this.error("Wrong type! For Temperature_k, msg.payload must be >=MIN and <=MAX.");
+            if (done) { done(); }
+            return;
+          }
+          break;
+        }
+        case 'string':
+          if (color_scene.includes(value as string)) {
+            state.value = value;
+            state.instance = 'scene';
+          } else {
+            this.error("Wrong type! For the Scene, the msg.payload must be set in the settings");
+            if (done) { done(); }
+            return;
+          }
+          break;
+        default:
+          this.error("Wrong type! Unsupported msg.payload type");
+          if (done) { done(); }
+          return;
+      }
+
+      if (JSON.stringify(value) === lastValue) {
+        this.debug("Value not changed. Cancel update");
+        if (done) { done(); }
+        return;
+      }
+
+      const upState: CapabilityState = {
+        type: ctype,
+        state: state as CapabilityState['state']
+      };
+      device.updateCapabState(this.id, upState)
+        .then(() => {
+          lastValue = JSON.stringify(value);
+          this.status({ fill: "green", shape: "dot", text: JSON.stringify(msg.payload) });
+          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: boolean, done: () => void) => {
+      if (removed) {
+        device.delCapability(this.id)
+          .then(() => { done(); })
+          .catch(err => {
+            this.error("Error on delete capability: " + err.message);
+            done();
+          });
+      } else {
+        done();
+      }
+    });
+  }
+
+  RED.nodes.registerType("Color", AliceColor);
+};

package/src/alice-device.html

@@ -0,0 +1,94 @@
+<script type="text/javascript">
+    RED.nodes.registerType('alice-device',{
+        category: 'config',
+        defaults:{
+            service: {value:"", type:"alice-service"},
+            name: {value:null, required: true},
+            description: {value:null},
+            room: {value:"Комната"},
+            dtype: {value:"devices.types.light", required: true}
+        },
+        label: function(){
+            return this.room+":"+this.name || "Alice-Device";
+        },
+        oneditprepare: ()=>{
+            $("#node-config-input-dtype").typedInput({
+                types: [
+                    {
+                        options: [
+                            { value: "devices.types.light", label: "Light" },
+                            { value: "devices.types.light.ceiling", label: "Light Сeiling" },
+                            { value: "devices.types.light.strip", label: "Light Strip" },
+                            { value: "devices.types.socket", label: "Socket" },
+                            { value: "devices.types.switch", label: "Switch" },
+                            { value: "devices.types.thermostat", label: "Thermostat"  },
+                            { value: "devices.types.thermostat.ac", label: "Air conditioning"  },
+                            { value: "devices.types.media_device", label: "Multimedia"  },
+                            { value: "devices.types.media_device.tv", label: "TV"  },
+                            { value: "devices.types.media_device.tv_box", label: "TV Box" },
+                            { value: "devices.types.media_device.receiver", label: "AV Receiver" },
+                            { value: "devices.types.camera", label: "Camera" },
+                            { value: "devices.types.cooking", label: "Kitchen appliances" },
+                            { value: "devices.types.cooking.coffee_maker", label: "Coffee machine" },
+                            { value: "devices.types.cooking.kettle", label: "Smart kettle" },
+                            { value: "devices.types.cooking.multicooker", label: "Multicooker" },
+                            { value: "devices.types.openable", label: "Door, gate, window, shutters" },
+                            { value: "devices.types.openable.curtain", label: "Curtains, blinds" },
+                            { value: "devices.types.openable.valve", label: "Valve (ball valve)" },
+                            { value: "devices.types.humidifier", label: "Humidifier" },
+                            { value: "devices.types.purifier", label: "Air purifier" },
+                            { value: "devices.types.ventilation", label: "Ventilation" },
+                            { value: "devices.types.ventilation.fan", label: "Fan" },
+                            { value: "devices.types.vacuum_cleaner", label: "Vacuum cleaner robot" },
+                            { value: "devices.types.washing_machine", label: "Washing machine" },
+                            { value: "devices.types.dishwasher", label: "Dishwasher" },
+                            { value: "devices.types.iron", label: "Iron, steam generator" },
+                            { value: "devices.types.sensor", label: "Sensor" },
+                            { value: "devices.types.sensor.motion", label: "Sensor motion" },
+                            { value: "devices.types.sensor.vibration", label: "Sensor vibration" },
+                            { value: "devices.types.sensor.illumination", label: "Sensor illumination" },
+                            { value: "devices.types.sensor.open", label: "Sensor open" },
+                            { value: "devices.types.sensor.climate", label: "Sensor climate" },
+                            { value: "devices.types.sensor.water_leak", label: "Sensor water_leak" },
+                            { value: "devices.types.sensor.button", label: "Sensor button" },
+                            { value: "devices.types.sensor.gas", label: "Sensor gas" },
+                            { value: "devices.types.sensor.smoke", label: "Sensor smoke" },
+                            { value: "devices.types.smart_meter", label: "Counter" },
+                            { value: "devices.types.smart_meter.cold_water", label: "Cold Water counter" },
+                            { value: "devices.types.smart_meter.hot_water", label: "Hot Water counter" },
+                            { value: "devices.types.smart_meter.electricity", label: "Electricity counter" },
+                            { value: "devices.types.smart_meter.gas", label: "Gas counter" },
+                            { value: "devices.types.smart_meter.heat", label: "Heat Water counter" },
+                            { value: "devices.types.pet_drinking_fountain", label: "Pet drinking fountain" },
+                            { value: "devices.types.pet_feeder", label: "Pet feeder" },
+                            { value: "devices.types.other", label: "Other" },
+                        ]
+                    }
+                ]
+            });
+        }
+    })
+</script>
+
+<script type="text/x-red" data-template-name="alice-device">
+    <div class="form-row">
+        <label for="node-config-input-service">Credentials</label>
+        <input id="node-config-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">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-description">Description</label>
+        <input type="text" id="node-config-input-description" placeholder="">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-room">Room</label>
+        <input type="text" id="node-config-input-room" placeholder="Room">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-dtype">Type</label>
+        <input type="text" id="node-config-input-dtype">
+    </div>
+</script>

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);
+};