homebridge-http-webhooks-plus 0.2.1

package/src/homekit/accessories/HttpWebHookLightBulbAccessory.js

@@ -0,0 +1,153 @@
+const Constants = require('../../Constants');
+const Util = require('../../Util');
+
+function HttpWebHookLightBulbAccessory(ServiceParam, CharacteristicParam, platform, lightConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = lightConfig["id"];
+  this.type = "lightbulb";
+  this.name = lightConfig["name"];
+  this.rejectUnauthorized = lightConfig["rejectUnauthorized"] === undefined ? true: lightConfig["rejectUnauthorized"] === true;
+  this.onURL = lightConfig["on_url"] || "";
+  this.onMethod = lightConfig["on_method"] || "GET";
+  this.onBody = lightConfig["on_body"] || "";
+  this.onForm = lightConfig["on_form"] || "";
+  this.onHeaders = lightConfig["on_headers"] || "{}";
+  this.offURL = lightConfig["off_url"] || "";
+  this.offMethod = lightConfig["off_method"] || "GET";
+  this.offBody = lightConfig["off_body"] || "";
+  this.offForm = lightConfig["off_form"] || "";
+  this.offHeaders = lightConfig["off_headers"] || "{}";
+  this.brightnessURL = lightConfig["brightness_url"] || "";
+  this.brightnessMethod = lightConfig["brightness_method"] || "GET";
+  this.brightnessBody = lightConfig["brightness_body"] || "";
+  this.brightnessForm = lightConfig["brightness_form"] || "";
+  this.brightnessHeaders = lightConfig["brightness_headers"] || "{}";
+  this.brightnessFactor = lightConfig["brightness_factor"] || 1;
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookLightAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookLightAccessory-" + this.id);
+
+  this.service = new Service.Lightbulb(this.name);
+  this.service.getCharacteristic(Characteristic.On).on('get', this.getState.bind(this)).on('set', this.setState.bind(this));
+  this.service.getCharacteristic(Characteristic.Brightness).on('get', this.getBrightness.bind(this)).on('set', this.setBrightness.bind(this));
+}
+
+HttpWebHookLightBulbAccessory.prototype.changeFromServer = function(urlParams) {
+  var cachedState = this.storage.getItemSync("http-webhook-" + this.id);
+  if (cachedState === undefined) {
+    cachedState = false;
+  }
+  var cachedBrightness = this.storage.getItemSync("http-webhook-brightness-" + this.id);
+  if (cachedBrightness === undefined) {
+    cachedBrightness = -1;
+  }
+  if (!urlParams.state && !urlParams.value) {
+    return {
+      "success" : true,
+      "brightness" : cachedBrightness,
+      "state" : cachedState
+    };
+  }
+  else {
+    var brightness = urlParams.value || cachedBrightness;
+    var state = urlParams.state || cachedState;
+    var stateBool = state === "true" || state === true;
+    this.storage.setItemSync("http-webhook-" + this.id, stateBool);
+    var brightnessInt = parseInt(brightness);
+    this.storage.setItemSync("http-webhook-brightness-" + this.id, brightnessInt);
+    if (cachedState !== stateBool || cachedBrightness != brightnessInt) {
+      var brightnessToSet = Math.ceil(brightnessInt / this.brightnessFactor);
+      this.log(this.name + ": Change HomeKit state for light to '%s'.", stateBool);
+      this.log(this.name + ": Change HomeKit brightness for light to '%s'.", brightnessToSet);
+      this.service.getCharacteristic(Characteristic.On).updateValue(stateBool, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      this.service.getCharacteristic(Characteristic.Brightness).updateValue(brightnessToSet, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+    return {
+      "success" : true
+    };
+  }
+};
+
+HttpWebHookLightBulbAccessory.prototype.getState = function(callback) {
+  this.log.debug(this.name + ": Getting current state for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-" + this.id);
+  if (state === undefined) {
+    state = false;
+  }
+  callback(null, state);
+};
+
+HttpWebHookLightBulbAccessory.prototype.setState = function(powerOn, callback, context) {
+  this.log(this.name + ": Light state for '%s'...", this.id);
+  this.storage.setItemSync("http-webhook-" + this.id, powerOn);
+  var urlToCall = this.onURL;
+  var urlMethod = this.onMethod;
+  var urlBody = this.onBody;
+  var urlForm = this.onForm;
+  var urlHeaders = this.onHeaders;
+  if (!powerOn) {
+    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);
+};
+
+HttpWebHookLightBulbAccessory.prototype.getBrightness = function(callback) {
+  this.log.debug(this.name + ": Getting current brightness for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-" + this.id);
+  if (state === undefined) {
+    state = false;
+  }
+  var brightness = 0;
+  if (state) {
+    brightness = this.storage.getItemSync("http-webhook-brightness-" + this.id);
+    if (brightness === undefined) {
+      brightness = 100;
+    }
+  }
+  callback(null, parseInt(brightness));
+};
+
+HttpWebHookLightBulbAccessory.prototype.setBrightness = function(brightness, callback, context) {
+  this.log(this.name + ": Light brightness for '%s'...", this.id);
+  var newState = brightness > 0;
+  this.storage.setItemSync("http-webhook-" + this.id, newState);
+  this.storage.setItemSync("http-webhook-brightness-" + this.id, brightness);
+  var brightnessFactor = this.brightnessFactor;
+  var brightnessToSet = Math.ceil(brightness * brightnessFactor);
+  var urlToCall = this.replaceVariables(this.brightnessURL, newState, brightnessToSet);
+  var urlMethod = this.brightnessMethod;
+  var urlBody = this.brightnessBody;
+  var urlForm = this.brightnessForm;
+  var urlHeaders = this.brightnessHeaders;
+
+  if (urlForm) {
+    urlForm = this.replaceVariables(urlForm, newState, brightnessToSet);
+  }
+  else if (urlBody) {
+    urlBody = this.replaceVariables(urlBody, newState, brightnessToSet);
+  }
+
+  Util.callHttpApi(this.log, urlToCall, urlMethod, urlBody, urlForm, urlHeaders, this.rejectUnauthorized, callback, context);
+};
+
+HttpWebHookLightBulbAccessory.prototype.replaceVariables = function(text, state, brightness) {
+  return text.replace("%statusPlaceholder", state).replace("%brightnessPlaceholder", brightness);
+};
+
+HttpWebHookLightBulbAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookLightBulbAccessory;

package/src/homekit/accessories/HttpWebHookLockMechanismAccessory.js

@@ -0,0 +1,125 @@
+const Constants = require('../../Constants');
+const Util = require('../../Util');
+
+function HttpWebHookLockMechanismAccessory(ServiceParam, CharacteristicParam, platform, lockMechanismOpenerConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = lockMechanismOpenerConfig["id"];
+  this.name = lockMechanismOpenerConfig["name"];
+  this.type = "lockmechanism";
+  this.rejectUnauthorized = lockMechanismOpenerConfig["rejectUnauthorized"] === undefined ? true: lockMechanismOpenerConfig["rejectUnauthorized"] === true;
+  this.setLockTargetStateOpenURL = lockMechanismOpenerConfig["open_url"] || "";
+  this.setLockTargetStateOpenMethod = lockMechanismOpenerConfig["open_method"] || "GET";
+  this.setLockTargetStateOpenBody = lockMechanismOpenerConfig["open_body"] || "";
+  this.setLockTargetStateOpenForm = lockMechanismOpenerConfig["open_form"] || "";
+  this.setLockTargetStateOpenHeaders = lockMechanismOpenerConfig["open_headers"] || "{}";
+  this.setLockTargetStateCloseURL = lockMechanismOpenerConfig["close_url"] || "";
+  this.setLockTargetStateCloseMethod = lockMechanismOpenerConfig["close_method"] || "GET";
+  this.setLockTargetStateCloseBody = lockMechanismOpenerConfig["close_body"] || "";
+  this.setLockTargetStateCloseForm = lockMechanismOpenerConfig["close_form"] || "";
+  this.setLockTargetStateCloseHeaders = lockMechanismOpenerConfig["close_headers"] || "{}";
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookLockMechanismAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookLockMechanismAccessory-" + this.id);
+
+  this.service = new Service.LockMechanism(this.name);
+  this.service.getCharacteristic(Characteristic.LockTargetState).on('get', this.getLockTargetState.bind(this)).on('set', this.setLockTargetState.bind(this));
+  this.service.getCharacteristic(Characteristic.LockCurrentState).on('get', this.getLockCurrentState.bind(this));
+}
+
+HttpWebHookLockMechanismAccessory.prototype.changeFromServer = function(urlParams) {
+  if (urlParams.lockcurrentstate != null) {
+    var cachedLockCurrentState = this.storage.getItemSync("http-webhook-lock-current-state-" + this.id);
+    if (cachedLockCurrentState === undefined) {
+      cachedLockCurrentState = Characteristic.LockCurrentState.SECURED;
+    }
+    this.storage.setItemSync("http-webhook-lock-current-state-" + this.id, urlParams.lockcurrentstate);
+    if (cachedLockCurrentState !== urlParams.lockcurrentstate) {
+      if (urlParams.lockcurrentstate) {
+        this.log(this.name + ": Change Current Lock State for locking to '%s'.", urlParams.lockcurrentstate);
+        this.service.getCharacteristic(Characteristic.LockCurrentState).updateValue(urlParams.lockcurrentstate, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      }
+    }
+  }
+  if (urlParams.locktargetstate != null) {
+    var cachedLockTargetState = this.storage.getItemSync("http-webhook-lock-target-state-" + this.id);
+    if (cachedLockTargetState === undefined) {
+      cachedLockTargetState = Characteristic.LockTargetState.SECURED;
+    }
+    this.storage.setItemSync("http-webhook-lock-target-state-" + this.id, urlParams.locktargetstate);
+    if (cachedLockTargetState !== urlParams.locktargetstate) {
+      if (urlParams.locktargetstate) {
+        this.log(this.name + ": Change Target Lock State for locking to '%s'.", urlParams.locktargetstate);
+        this.service.getCharacteristic(Characteristic.LockTargetState).updateValue(urlParams.locktargetstate, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      }
+    }
+  }
+  return {
+    "success" : true,
+    "currentState" : cachedLockCurrentState,
+    "targetState" : cachedLockTargetState
+  };
+}
+
+HttpWebHookLockMechanismAccessory.prototype.getLockTargetState = function(callback) {
+  this.log.debug(this.name + ": Getting current Target Lock State for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-lock-target-state-" + this.id);
+  if (state === undefined) {
+    state = Characteristic.LockTargetState.SECURED;
+  }
+  callback(null, state);
+};
+
+HttpWebHookLockMechanismAccessory.prototype.setLockTargetState = function(homeKitState, callback, context) {
+  var doLock = homeKitState === Characteristic.LockTargetState.SECURED;
+  var newHomeKitState = doLock ? Characteristic.LockCurrentState.SECURED : Characteristic.LockCurrentState.UNSECURED;
+  var newHomeKitStateTarget = doLock ? Characteristic.LockTargetState.SECURED : Characteristic.LockTargetState.UNSECURED;
+
+  this.log(this.name + ": Target Lock State for '%s' to '%s'...", this.id, doLock);
+  this.storage.setItemSync("http-webhook-lock-target-state-" + this.id, homeKitState);
+  var urlToCall = this.setLockTargetStateCloseURL;
+  var urlMethod = this.setLockTargetStateCloseMethod;
+  var urlBody = this.setLockTargetStateCloseBody;
+  var urlForm = this.setLockTargetStateCloseForm;
+  var urlHeaders = this.setLockTargetStateCloseHeaders;
+
+  if (!doLock) {
+    urlToCall = this.setLockTargetStateOpenURL;
+    urlMethod = this.setLockTargetStateOpenMethod;
+    urlBody = this.setLockTargetStateOpenBody;
+    urlForm = this.setLockTargetStateOpenForm;
+    urlHeaders = this.setLockTargetStateOpenHeaders;
+  }
+
+  Util.callHttpApi(this.log, urlToCall, urlMethod, urlBody, urlForm, urlHeaders, this.rejectUnauthorized, callback, context, (function() {
+    this.storage.setItemSync("http-webhook-lock-current-state-" + this.id, newHomeKitState);
+    this.service.getCharacteristic(Characteristic.LockTargetState).updateValue(newHomeKitStateTarget, undefined, null);
+    this.service.getCharacteristic(Characteristic.LockCurrentState).updateValue(newHomeKitState, undefined, null);
+  }).bind(this), (function() {
+    this.storage.setItemSync("http-webhook-lock-current-state-" + this.id, Characteristic.LockCurrentState.UNKNOWN);
+    this.service.getCharacteristic(Characteristic.LockTargetState).updateValue(newHomeKitStateTarget, undefined, null);
+    this.service.getCharacteristic(Characteristic.LockCurrentState).updateValue(Characteristic.LockCurrentState.UNKNOWN, undefined, null);
+  }).bind(this));
+};
+
+HttpWebHookLockMechanismAccessory.prototype.getLockCurrentState = function(callback) {
+  this.log.debug(this.name + ": Getting Current Lock State for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-lock-current-state-" + this.id);
+  if (state === undefined) {
+    state = Characteristic.LockCurrentState.SECURED;
+  }
+  callback(null, state);
+};
+
+HttpWebHookLockMechanismAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookLockMechanismAccessory;

package/src/homekit/accessories/HttpWebHookOutletAccessory.js

@@ -0,0 +1,125 @@
+const Constants = require('../../Constants');
+const Util = require('../../Util');
+
+function HttpWebHookOutletAccessory(ServiceParam, CharacteristicParam, platform, outletConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = outletConfig["id"];
+  this.name = outletConfig["name"];
+  this.type = "outlet";
+  this.rejectUnauthorized = outletConfig["rejectUnauthorized"] === undefined ? true: outletConfig["rejectUnauthorized"] === true;
+  this.onURL = outletConfig["on_url"] || "";
+  this.onMethod = outletConfig["on_method"] || "GET";
+  this.onBody = outletConfig["on_body"] || "";
+  this.onForm = outletConfig["on_form"] || "";
+  this.onHeaders = outletConfig["on_headers"] || "{}";
+  this.offURL = outletConfig["off_url"] || "";
+  this.offMethod = outletConfig["off_method"] || "GET";
+  this.offBody = outletConfig["off_body"] || "";
+  this.offForm = outletConfig["off_form"] || "";
+  this.offHeaders = outletConfig["off_headers"] || "{}";
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookOutletAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookOutletAccessory-" + this.id);
+
+  this.service = new Service.Outlet(this.name);
+  this.service.getCharacteristic(Characteristic.On).on('get', this.getState.bind(this)).on('set', this.setState.bind(this));
+  this.service.getCharacteristic(Characteristic.OutletInUse).on('get', this.getStateInUse.bind(this));
+}
+
+HttpWebHookOutletAccessory.prototype.changeFromServer = function(urlParams) {
+  var cachedState = this.storage.getItemSync("http-webhook-" + this.id);
+  if (cachedState === undefined) {
+    cachedState = false;
+  }
+  var cachedStateInUse = this.storage.getItemSync("http-webhook-" + this.id + "-inUse");
+  if (cachedStateInUse === undefined) {
+    cachedStateInUse = false;
+  }
+  if (!urlParams.state && !urlParams.stateOutletInUse) {
+    return {
+      "success" : true,
+      "state" : cachedState,
+      "stateOutletInUse" : cachedStateInUse
+    };
+  }
+  else {
+    if (urlParams.state) {
+      var state = urlParams.state;
+      var stateBool = state === "true";
+      this.storage.setItemSync("http-webhook-" + this.id, stateBool);
+      // this.log("[INFO Http WebHook Server] State change of
+      // '%s'
+      // to '%s'.",accessory.id,stateBool);
+      if (cachedState !== stateBool) {
+        this.log(this.name + ": Change HomeKit state for outlet to '%s'.", stateBool);
+        this.service.getCharacteristic(Characteristic.On).updateValue(stateBool, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      }
+    }
+    if (urlParams.stateOutletInUse) {
+      var stateOutletInUse = urlParams.stateOutletInUse;
+      var stateOutletInUseBool = stateOutletInUse === "true";
+      this.storage.setItemSync("http-webhook-" + this.id + "-inUse", stateOutletInUseBool);
+      // this.log("[INFO Http WebHook Server] State change of
+      // '%s'
+      // to '%s'.",accessory.id,stateBool);
+      if (cachedStateInUse !== stateOutletInUseBool) {
+        this.log(this.name + ": Change HomeKit stateInUse for outlet to '%s'.", stateOutletInUseBool);
+        this.service.getCharacteristic(Characteristic.OutletInUse).updateValue(stateOutletInUseBool, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      }
+    }
+    return {
+      "success" : true
+    };
+  }
+}
+
+HttpWebHookOutletAccessory.prototype.getState = function(callback) {
+  this.log.debug(this.name + ": Getting current state for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-" + this.id);
+  if (state === undefined) {
+    state = false;
+  }
+  callback(null, state);
+};
+
+HttpWebHookOutletAccessory.prototype.getStateInUse = function(callback) {
+  this.log.debug(this.name + ": Getting current state for '%s'...", this.id);
+  var stateInUse = this.storage.getItemSync("http-webhook-" + this.id + "-inUse");
+  if (stateInUse === undefined) {
+    stateInUse = false;
+  }
+  callback(null, stateInUse);
+};
+
+HttpWebHookOutletAccessory.prototype.setState = function(powerOn, callback, context) {
+  this.log(this.name + ": Switch outlet state for '%s'...", this.id);
+  this.storage.setItemSync("http-webhook-" + this.id, powerOn);
+  var urlToCall = this.onURL;
+  var urlMethod = this.onMethod;
+  var urlBody = this.onBody;
+  var urlForm = this.onForm;
+  var urlHeaders = this.onHeaders;
+  if (!powerOn) {
+    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);
+};
+
+HttpWebHookOutletAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookOutletAccessory;

package/src/homekit/accessories/HttpWebHookPushButtonAccessory.js

@@ -0,0 +1,93 @@
+const Constants = require('../../Constants');
+const Util = require('../../Util');
+
+function HttpWebHookPushButtonAccessory(ServiceParam, CharacteristicParam, platform, pushButtonConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = pushButtonConfig["id"];
+  this.type = "pushbutton";
+  this.name = pushButtonConfig["name"];
+  this.rejectUnauthorized = pushButtonConfig["rejectUnauthorized"] === undefined ? true: pushButtonConfig["rejectUnauthorized"] === true;
+  this.pushURL = pushButtonConfig["push_url"] || "";
+  this.pushMethod = pushButtonConfig["push_method"] || "GET";
+  this.pushBody = pushButtonConfig["push_body"] || "";
+  this.pushForm = pushButtonConfig["push_form"] || "";
+  this.pushHeaders = pushButtonConfig["push_headers"] || "{}";
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookPushButtonAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookPushButtonAccessory-" + this.id);
+
+  this.service = new Service.Switch(this.name);
+  this.service.getCharacteristic(Characteristic.On).on('get', this.getState.bind(this)).on('set', this.setState.bind(this));
+}
+
+HttpWebHookPushButtonAccessory.prototype.changeFromServer = function(urlParams) {
+  if (!urlParams.state) {
+    return {
+      "success" : true
+    };
+  }
+  else {
+    var state = urlParams.state;
+    var stateBool = state === "true";
+    // this.log("[INFO Http WebHook Server] State change of '%s'
+    // to '%s'.",accessory.id,stateBool);
+    if (stateBool) {
+      this.log(this.name + ": Change HomeKit state for push button to '%s'.", stateBool);
+      this.service.getCharacteristic(Characteristic.On).updateValue(stateBool, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      setTimeout(function() {
+        this.service.getCharacteristic(Characteristic.On).updateValue(false, undefined, Constants.CONTEXT_FROM_TIMEOUTCALL);
+      }.bind(this), 1000);
+    }
+    return {
+      "success" : true
+    };
+  }
+}
+
+HttpWebHookPushButtonAccessory.prototype.getState = function(callback) {
+  this.log.debug(this.name + ": Getting current state for '%s'...", this.id);
+  var state = false;
+  callback(null, state);
+};
+
+HttpWebHookPushButtonAccessory.prototype.setState = function(powerOn, callback, context) {
+  this.log(this.name + ": Push buttons state change for '%s'...", this.id);
+  if (!powerOn) {
+    callback(null);
+  }
+  else if (this.pushURL === "" || context === Constants.CONTEXT_FROM_WEBHOOK) {
+    callback(null);
+    setTimeout(function() {
+      this.service.getCharacteristic(Characteristic.On).updateValue(false, undefined, Constants.CONTEXT_FROM_TIMEOUTCALL);
+    }.bind(this), 1000);
+  }
+  else {
+    var urlToCall = this.pushURL;
+    var urlMethod = this.pushMethod;
+    var urlBody = this.pushBody;
+    var urlForm = this.pushForm;
+    var urlHeaders = this.pushHeaders;
+
+    var onSuccessAndFailureCallback = (function() {
+      setTimeout(function() {
+        this.service.getCharacteristic(Characteristic.On).updateValue(false, undefined, Constants.CONTEXT_FROM_TIMEOUTCALL);
+      }.bind(this), 1000);
+    }).bind(this);
+
+    Util.callHttpApi(this.log, urlToCall, urlMethod, urlBody, urlForm, urlHeaders, this.rejectUnauthorized, callback, context, onSuccessAndFailureCallback, onSuccessAndFailureCallback);
+  }
+};
+
+HttpWebHookPushButtonAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookPushButtonAccessory;

package/src/homekit/accessories/HttpWebHookSecurityAccessory.js

@@ -0,0 +1,104 @@
+const Constants = require('../../Constants');
+const Util = require('../../Util');
+
+function HttpWebHookSecurityAccessory(ServiceParam, CharacteristicParam, platform, securityConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = securityConfig["id"];
+  this.name = securityConfig["name"];
+  this.type = "security";
+  this.rejectUnauthorized = securityConfig["rejectUnauthorized"] === undefined ? true: securityConfig["rejectUnauthorized"] === true;
+  this.setStateURL = securityConfig["set_state_url"] || "";
+  this.setStateMethod = securityConfig["set_state_method"] || "GET";
+  this.setStateBody = securityConfig["set_state_body"] || "";
+  this.setStateForm = securityConfig["set_state_form"] || "";
+  this.setStateHeaders = securityConfig["set_state_headers"] || "{}";
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookSecurityAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookSecurityAccessory-" + this.id);
+
+  this.service = new Service.SecuritySystem(this.name);
+  this.service.getCharacteristic(Characteristic.SecuritySystemTargetState).on('get', this.getTargetSecurityState.bind(this)).on('set', this.setTargetSecurityState.bind(this));
+  this.service.getCharacteristic(Characteristic.SecuritySystemCurrentState).on('get', this.getCurrentSecurityState.bind(this));
+}
+
+HttpWebHookSecurityAccessory.prototype.changeFromServer = function(urlParams) {
+  var cachedCurrentState = this.storage.getItemSync("http-webhook-current-security-state-" + this.id);
+  if (cachedCurrentState === undefined) {
+    cachedCurrentState = Characteristic.SecuritySystemCurrentState.DISARMED;
+  }
+  if (!urlParams.currentstate && !urlParams.targetstate) {
+    return {
+      "success" : true,
+      "currentState" : cachedCurrentState
+    };
+  }
+
+  if (urlParams.currentstate != null) {
+    this.storage.setItemSync("http-webhook-current-security-state-" + this.id, urlParams.currentstate);
+    if (cachedCurrentState !== urlParams.currentstate) {
+      this.log(this.name + ": Change current state for security to '%d'.", urlParams.currentstate);
+      this.service.getCharacteristic(Characteristic.SecuritySystemCurrentState).updateValue(urlParams.currentstate, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+  }
+
+  if (urlParams.targetstate != null) {
+    var cachedState = this.storage.getItemSync("http-webhook-target-security-state-" + this.id);
+    if (cachedState === undefined) {
+      cachedState = Characteristic.SecuritySystemTargetState.DISARM;
+    }
+    this.storage.setItemSync("http-webhook-target-security-state-" + this.id, urlParams.targetstate);
+    if (cachedState !== urlParams.targetstate) {
+      this.log(this.name + ": Change target state for security to '%d'.", urlParams.targetstate);
+      this.service.getCharacteristic(Characteristic.SecuritySystemTargetState).updateValue(urlParams.targetstate, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+  }
+  return {
+    "success" : true
+  };
+}
+
+HttpWebHookSecurityAccessory.prototype.getTargetSecurityState = function(callback) {
+  this.log.debug(this.name + ": Getting Target Security state for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-target-security-state-" + this.id);
+  if (state === undefined) {
+    state = Characteristic.SecuritySystemTargetState.DISARM;
+  }
+  callback(null, state);
+};
+
+HttpWebHookSecurityAccessory.prototype.setTargetSecurityState = function(newState, callback, context) {
+  this.log(this.name + ": Target Security state for '%s'...", this.id);
+  this.storage.setItemSync("http-webhook-target-security-state-" + this.id, newState);
+  this.storage.setItemSync("http-webhook-current-security-state-" + this.id, newState);
+  var urlToCall = this.setStateURL.replace("%d", newState);
+  var urlMethod = this.setStateMethod;
+  var urlBody = this.setStateBody;
+  var urlForm = this.setStateForm;
+  var urlHeaders = this.setStateHeaders;
+  Util.callHttpApi(this.log, urlToCall, urlMethod, urlBody, urlForm, urlHeaders, this.rejectUnauthorized, callback, context, (function() {
+    this.service.getCharacteristic(Characteristic.SecuritySystemCurrentState).updateValue(newState, undefined, null);
+  }).bind(this));
+};
+
+HttpWebHookSecurityAccessory.prototype.getCurrentSecurityState = function(callback) {
+  this.log.debug(this.name + ": Getting Current Security state for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-current-security-state-" + this.id);
+  if (state === undefined) {
+    state = Characteristic.SecuritySystemCurrentState.DISARMED;
+  }
+  callback(null, state);
+};
+
+HttpWebHookSecurityAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookSecurityAccessory;