homebridge-http-webhooks-plus 0.2.1

package/src/homekit/accessories/HttpWebHookValveAccessory.js

@@ -0,0 +1,151 @@
+const Constants = require('../../Constants');
+const Util = require('../../Util');
+
+function HttpWebHookValveAccessory(ServiceParam, CharacteristicParam, platform, valveConfig) {
+    Service = ServiceParam;
+    Characteristic = CharacteristicParam;
+
+    this.platform = platform;
+    this.log = platform.log;
+    this.storage = platform.storage;
+
+    this.id = valveConfig["id"];
+    this.name = valveConfig["name"];
+    this.type = "valve";
+    this.rejectUnauthorized = valveConfig["rejectUnauthorized"] === undefined ? true: valveConfig["rejectUnauthorized"] === true;
+    this.onURL = valveConfig["on_url"] || "";
+    this.onMethod = valveConfig["on_method"] || "GET";
+    this.onBody = valveConfig["on_body"] || "";
+    this.onForm = valveConfig["on_form"] || "";
+    this.onHeaders = valveConfig["on_headers"] || "{}";
+    this.offURL = valveConfig["off_url"] || "";
+    this.offMethod = valveConfig["off_method"] || "GET";
+    this.offBody = valveConfig["off_body"] || "";
+    this.offForm = valveConfig["off_form"] || "";
+    this.offHeaders = valveConfig["off_headers"] || "{}";
+
+    this.informationService = new Service.AccessoryInformation();
+    this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+    this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookValveAccessory-" + this.name);
+    this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookValveAccessory-" + this.id);
+
+    var valveType = 0;
+    switch(valveConfig.type) {
+        default:
+        case "generic valve":
+            valveType = 0; // ValveType.GENERIC_VALVE
+            break;
+        case "irrigation":
+            valveType = 1; // ValveType.IRRIGATION
+            break;
+        case "shower head":
+            valveType = 2; // ValveType.SHOWER_HEAD
+            break;
+        case "water faucet":
+            valveType = 3; // ValveType.WATER_FAUCET
+            break;
+    }
+
+    this.service = new Service.Valve(this.name);
+    this.service.setCharacteristic(Characteristic.ValveType, valveType);
+    this.service.getCharacteristic(Characteristic.Active).on('get', this.getState.bind(this)).on('set', this.setState.bind(this));
+    this.service.getCharacteristic(Characteristic.InUse).on('get', this.getState.bind(this)).on('set', this.setState.bind(this));
+    this.service.getCharacteristic(Characteristic.StatusFault).on('get', this.getStatusFault.bind(this));
+
+    this.category = 30;
+}
+
+HttpWebHookValveAccessory.prototype.changeFromServer = function(urlParams) {
+    var cachedState = this.storage.getItemSync("http-webhook-" + this.id);
+    if (cachedState === undefined) {
+        cachedState = 0;
+    }
+    var cachedStatusFault = this.storage.getItemSync("http-webhook-" + this.id + "-statusFault");
+    if (cachedStatusFault === undefined) {
+        cachedStatusFault = 0;
+    }
+    if (!urlParams.state && !urlParams.statusFault) {
+        return {
+            "success" : true,
+            "state" : cachedState,
+            "statusFault" : cachedStatusFault
+        };
+    }
+    else {
+        if (urlParams.state) {
+            var state = urlParams.state;
+            var stateNumber = state === "true" ? 1 : 0;
+            this.storage.setItemSync("http-webhook-" + this.id, stateNumber);
+            this.log.info("Change HomeKit value for " + this.type + " state to '%s'.", stateNumber);
+
+            if (cachedState !== stateNumber) {
+                this.log(this.name + ": Change HomeKit state for valve to '%s'.", stateNumber);
+                this.service.getCharacteristic(Characteristic.Active).updateValue(stateNumber, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+                this.service.getCharacteristic(Characteristic.InUse).updateValue(stateNumber, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+            }
+        }
+        if (urlParams.statusFault) {
+            var statusFault = urlParams.statusFault;
+            var statusFaultNumber = statusFault === "true" ? 1 : 0;
+            this.storage.setItemSync("http-webhook-" + this.id + "-statusFault", statusFaultNumber);
+            this.log.info("Change HomeKit value for " + this.type + " statusFault to '%s'.", statusFaultNumber);
+
+            if (cachedStatusFault !== statusFaultNumber) {
+                this.log(this.name + ": Change HomeKit statusFault for valve to '%s'.", statusFault);
+                this.service.getCharacteristic(Characteristic.StatusFault).updateValue(statusFaultNumber, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+            }
+        }
+        return {
+            "success" : true
+        };
+    }
+};
+
+HttpWebHookValveAccessory.prototype.getState = function(callback) {
+    this.log.debug(this.name + ": Getting current state for", this.id);
+    var state = this.storage.getItemSync("http-webhook-" + this.id);
+    if (state === undefined) {
+        state = 0;
+    }
+
+    callback(null, state);
+};
+
+HttpWebHookValveAccessory.prototype.getStatusFault = function(callback) {
+    this.log.debug(this.name + ": Getting status fault for", this.id);
+    var statusFault = this.storage.getItemSync("http-webhook-" + this.id + "-statusFault");
+    if (statusFault === undefined) {
+        statusFault = 0;
+    }
+
+    callback(null, statusFault);
+};
+
+HttpWebHookValveAccessory.prototype.setState = function(active, callback, context) {
+    this.log.info("Set valve state for", this.id, "to", active);
+    this.storage.setItemSync("http-webhook-" + this.id, active);
+
+    this.service.getCharacteristic(Characteristic.Active).updateValue(active, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    this.service.getCharacteristic(Characteristic.InUse).updateValue(active, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+
+    var urlToCall = this.onURL;
+    var urlMethod = this.onMethod;
+    var urlBody = this.onBody;
+    var urlForm = this.onForm;
+    var urlHeaders = this.onHeaders;
+    if (!active) {
+        urlToCall = this.offURL;
+        urlMethod = this.offMethod;
+        urlBody = this.offBody;
+        urlForm = this.offForm;
+        urlHeaders = this.offHeaders;
+    }
+
+    Util.callHttpApi(this.log, urlToCall, urlMethod, urlBody, urlForm, urlHeaders, this.rejectUnauthorized, callback, context);
+};
+
+HttpWebHookValveAccessory.prototype.getServices = function() {
+    return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookValveAccessory;

package/src/homekit/accessories/HttpWebHookWindowCoveringAccessory.js

@@ -0,0 +1,203 @@
+const Constants = require('../../Constants');
+const Util = require('../../Util');
+
+function HttpWebHookWindowCoveringAccessory(ServiceParam, CharacteristicParam, platform, windowcoveringConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = windowcoveringConfig["id"];
+  this.name = windowcoveringConfig["name"];
+  this.type = "windowcovering";
+  this.rejectUnauthorized = windowcoveringConfig["rejectUnauthorized"] === undefined ? true: windowcoveringConfig["rejectUnauthorized"] === true;
+  this.setTargetPositionOpenURL = windowcoveringConfig["open_url"] || "";
+  this.setTargetPositionOpenMethod = windowcoveringConfig["open_method"] || "GET";
+  this.setTargetPositionOpenBody = windowcoveringConfig["open_body"] || "";
+  this.setTargetPositionOpenForm = windowcoveringConfig["open_form"] || "";
+  this.setTargetPositionOpenHeaders = windowcoveringConfig["open_headers"] || "{}";
+  this.setTargetPositionOpen20URL = windowcoveringConfig["open_20_url"] || "";
+  this.setTargetPositionOpen20Method = windowcoveringConfig["open_20_method"] || "GET";
+  this.setTargetPositionOpen20Body = windowcoveringConfig["open_20_body"] || "";
+  this.setTargetPositionOpen20Form = windowcoveringConfig["open_20_form"] || "";
+  this.setTargetPositionOpen20Headers = windowcoveringConfig["open_20_headers"] || "{}";
+  this.setTargetPositionOpen40URL = windowcoveringConfig["open_40_url"] || "";
+  this.setTargetPositionOpen40Method = windowcoveringConfig["open_40_method"] || "GET";
+  this.setTargetPositionOpen40Body = windowcoveringConfig["open_40_body"] || "";
+  this.setTargetPositionOpen40Form = windowcoveringConfig["open_40_form"] || "";
+  this.setTargetPositionOpen40Headers = windowcoveringConfig["open_40_headers"] || "{}";
+  this.setTargetPositionOpen60URL = windowcoveringConfig["open_60_url"] || "";
+  this.setTargetPositionOpen60Method = windowcoveringConfig["open_60_method"] || "GET";
+  this.setTargetPositionOpen60Body = windowcoveringConfig["open_60_body"] || "";
+  this.setTargetPositionOpen60Form = windowcoveringConfig["open_60_form"] || "";
+  this.setTargetPositionOpen60Headers = windowcoveringConfig["open_60_headers"] || "{}";
+  this.setTargetPositionOpen80URL = windowcoveringConfig["open_80_url"] || "";
+  this.setTargetPositionOpen80Method = windowcoveringConfig["open_80_method"] || "GET";
+  this.setTargetPositionOpen80Body = windowcoveringConfig["open_80_body"] || "";
+  this.setTargetPositionOpen80Form = windowcoveringConfig["open_80_form"] || "";
+  this.setTargetPositionOpen80Headers = windowcoveringConfig["open_80_headers"] || "{}";
+  this.setTargetPositionCloseURL = windowcoveringConfig["close_url"] || "";
+  this.setTargetPositionCloseMethod = windowcoveringConfig["close_method"] || "GET";
+  this.setTargetPositionCloseBody = windowcoveringConfig["close_body"] || "";
+  this.setTargetPositionCloseForm = windowcoveringConfig["close_form"] || "";
+  this.setTargetPositionCloseHeaders = windowcoveringConfig["close_headers"] || "{}";
+  this.autoSetCurrentPosition = windowcoveringConfig["auto_set_current_position"] || false;
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookWindowCoveringAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookWindowCoveringAccessory-" + this.id);
+
+  this.service = new Service.WindowCovering(this.name);
+  this.service.getCharacteristic(Characteristic.TargetPosition).on('get', this.getTargetPosition.bind(this)).on('set', this.setTargetPosition.bind(this));
+  this.service.getCharacteristic(Characteristic.CurrentPosition).on('get', this.getCurrentPosition.bind(this));
+  this.service.getCharacteristic(Characteristic.PositionState).on('get', this.getPositionState.bind(this));
+}
+
+HttpWebHookWindowCoveringAccessory.prototype.changeFromServer = function(urlParams) {
+  if (urlParams.currentposition != null) {
+    var cachedCurrentPosition = this.storage.getItemSync("http-webhook-current-position-" + this.id);
+    if (cachedCurrentPosition === undefined) {
+      cachedCurrentPosition = 100;
+    }
+    this.storage.setItemSync("http-webhook-current-position-" + this.id, urlParams.currentposition);
+    if (cachedCurrentPosition !== urlParams.currentposition) {
+      this.log(this.name + ": Change Current Window Covering for covers to '%s'.", urlParams.currentposition);
+      this.service.getCharacteristic(Characteristic.CurrentPosition).updateValue(urlParams.currentposition, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+  }
+
+  if (urlParams.targetposition != null) {
+    var cachedTargetPosition = this.storage.getItemSync("http-webhook-target-position-" + this.id);
+    if (cachedTargetPosition === undefined) {
+      cachedTargetPosition = 100;
+    }
+    this.storage.setItemSync("http-webhook-target-position-" + this.id, urlParams.targetposition);
+    if (cachedTargetPosition !== urlParams.targetposition) {
+      if (urlParams.targetposition) {
+        this.log(this.name + ": Change Target Position for covers to '%s'.", urlParams.targetposition);
+        this.service.getCharacteristic(Characteristic.TargetPosition).updateValue(urlParams.targetposition, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      }
+    }
+  }
+  if (urlParams.positionstate != null) {
+    var cachedPositionState = this.storage.getItemSync("http-webhook-position-state-" + this.id);
+    if (cachedPositionState === undefined) {
+      cachedPositionState = false;
+    }
+    this.storage.setItemSync("http-webhook-position-state-" + this.id, urlParams.positionstate);
+    if (cachedPositionState !== urlParams.positionstate) {
+      if (urlParams.positionstate) {
+        this.log(this.name + ": Change Position State for covers to '%s'.", urlParams.positionstate);
+        this.service.getCharacteristic(Characteristic.PositionState).updateValue(urlParams.positionstate, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      }
+    }
+  }
+  return {
+    "success" : true,
+    "CurrentPosition" : cachedCurrentPosition,
+    "TargetPosition" : cachedTargetPosition,
+    "PositionState" : cachedPositionState
+  };
+}
+
+HttpWebHookWindowCoveringAccessory.prototype.getTargetPosition = function(callback) {
+  this.log.debug(this.name + ": Getting current Target Position for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-target-position-" + this.id);
+  if (state === undefined) {
+    state = 100;
+  }
+  callback(null, state);
+};
+
+HttpWebHookWindowCoveringAccessory.prototype.setTargetPosition = function(newState, callback, context) {
+  this.log(this.name + ": Target Position State for '%s'...", this.id);
+  this.log(this.name + ": New target state is: " + newState);
+  this.storage.setItemSync("http-webhook-target-position-" + this.id, newState);
+  if(this.autoSetCurrentPosition) {
+    this.storage.setItemSync("http-webhook-current-position-" + this.id, newState);
+  }
+  var urlToCall = this.setTargetPositionCloseURL;
+  var urlMethod = this.setTargetPositionCloseMethod;
+  var urlBody = this.setTargetPositionCloseBody;
+  var urlForm = this.setTargetPositionCloseForm;
+  var urlHeaders = this.setTargetPositionCloseHeaders;
+  if (newState === 0) {
+    urlToCall = this.setTargetPositionOpenURL;
+    urlMethod = this.setTargetPositionOpenMethod;
+    urlBody = this.setTargetPositionOpenBody;
+    urlForm = this.setTargetPositionOpenForm;
+    urlHeaders = this.setTargetPositionOpenHeaders;
+  }
+  if (newState >= 1 && newState <= 25) {
+    urlToCall = this.setTargetPositionOpen20URL;
+    urlMethod = this.setTargetPositionOpen20Method;
+    urlBody = this.setTargetPositionOpen20Body;
+    urlForm = this.setTargetPositionOpen20Form;
+    urlHeaders = this.setTargetPositionOpen20Headers;
+  }
+  if (newState >= 26 && newState <= 45) {
+    urlToCall = this.setTargetPositionOpen40URL;
+    urlMethod = this.setTargetPositionOpen40Method;
+    urlBody = this.setTargetPositionOpen40Body;
+    urlForm = this.setTargetPositionOpen40Form;
+    urlHeaders = this.setTargetPositionOpen40Headers;
+  }
+  if (newState >= 46 && newState <= 65) {
+    urlToCall = this.setTargetPositionOpen60URL;
+    urlMethod = this.setTargetPositionOpen60Method;
+    urlBody = this.setTargetPositionOpen60Body;
+    urlForm = this.setTargetPositionOpen60Form;
+    urlHeaders = this.setTargetPositionOpen60Headers;
+  }
+  if (newState >= 66 && newState <= 94) {
+    urlToCall = this.setTargetPositionOpen80URL;
+    urlMethod = this.setTargetPositionOpen80Method;
+    urlBody = this.setTargetPositionOpen80Body;
+    urlForm = this.setTargetPositionOpen80Form;
+    urlHeaders = this.setTargetPositionOpen80Headers;
+  }
+  if (newState >= 95) {
+    urlToCall = this.setTargetPositionCloseURL;
+    urlMethod = this.setTargetPositionCloseMethod;
+    urlBody = this.setTargetPositionCloseBody;
+    urlForm = this.setTargetPositionCloseForm;
+    urlHeaders = this.setTargetPositionCloseHeaders;
+  }
+
+  Util.callHttpApi(this.log, urlToCall, urlMethod, urlBody, urlForm, urlHeaders, this.rejectUnauthorized, callback, context, (function() {
+    this.service.getCharacteristic(Characteristic.TargetPosition).updateValue(newState, undefined, null);
+    if(this.autoSetCurrentPosition) {
+      this.log(this.name + ": New current state is: " + newState);
+      setTimeout(function() {
+        this.service.getCharacteristic(Characteristic.CurrentPosition).updateValue(newState, undefined, null);
+      }.bind(this), 1000);
+    }
+  }).bind(this), null, Constants.COVERS_REQUEST_TIMEOUT);
+};
+
+HttpWebHookWindowCoveringAccessory.prototype.getCurrentPosition = function(callback) {
+  this.log.debug(this.name + ": Getting Current Position for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-current-position-" + this.id);
+  if (state === undefined) {
+    state = 100;
+  }
+  callback(null, state);
+};
+
+HttpWebHookWindowCoveringAccessory.prototype.getPositionState = function(callback) {
+  this.log.debug(this.name + ": Getting position state for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-position-state-" + this.id);
+  if (state === undefined) {
+    state = Characteristic.PositionState.STOPPED;
+  }
+  callback(null, state);
+};
+
+HttpWebHookWindowCoveringAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookWindowCoveringAccessory;