homebridge-http-webhooks-plus 0.2.1

package/src/homekit/accessories/HttpWebHookSensorAccessory.js

@@ -0,0 +1,169 @@
+const Constants = require('../../Constants');
+
+function HttpWebHookSensorAccessory(ServiceParam, CharacteristicParam, platform, sensorConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = sensorConfig["id"];
+  this.name = sensorConfig["name"];
+  this.type = sensorConfig["type"];
+  this.autoRelease = sensorConfig["autoRelease"];
+  this.autoReleaseTime = sensorConfig["autoReleaseTime"] || Constants.DEFAULT_SENSOR_TIMEOUT;
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookSensorAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookSensorAccessory-" + this.id);
+
+  if (this.type === "contact") {
+    this.service = new Service.ContactSensor(this.name);
+    this.service.getCharacteristic(Characteristic.ContactSensorState).on('get', this.getState.bind(this));
+  }
+  else if (this.type === "motion") {
+    this.service = new Service.MotionSensor(this.name);
+    this.service.getCharacteristic(Characteristic.MotionDetected).on('get', this.getState.bind(this));
+  }
+  else if (this.type === "occupancy") {
+    this.service = new Service.OccupancySensor(this.name);
+    this.service.getCharacteristic(Characteristic.OccupancyDetected).on('get', this.getState.bind(this));
+  }
+  else if (this.type === "smoke") {
+    this.service = new Service.SmokeSensor(this.name);
+    this.service.getCharacteristic(Characteristic.SmokeDetected).on('get', this.getState.bind(this));
+  }
+  else if (this.type === "humidity") {
+    this.service = new Service.HumiditySensor(this.name);
+    this.service.getCharacteristic(Characteristic.CurrentRelativeHumidity).on('get', this.getState.bind(this));
+  }
+  else if (this.type === "temperature") {
+    this.service = new Service.TemperatureSensor(this.name);
+    this.service.getCharacteristic(Characteristic.CurrentTemperature).setProps({
+      minValue : -100,
+      maxValue : 140
+    }).on('get', this.getState.bind(this));
+  }
+  else if (this.type === "airquality") {
+    this.service = new Service.AirQualitySensor(this.name);
+    this.service.getCharacteristic(Characteristic.AirQuality).on('get', this.getState.bind(this));
+  }
+  else if (this.type === "light") {
+    this.service = new Service.LightSensor(this.name);
+    this.service.getCharacteristic(Characteristic.CurrentAmbientLightLevel).on('get', this.getState.bind(this));
+  }
+  else if (this.type === "leak") {
+    this.service = new Service.LeakSensor(this.name);
+    this.service.getCharacteristic(Characteristic.LeakDetected).on('get', this.getState.bind(this));
+  }
+}
+
+HttpWebHookSensorAccessory.prototype.changeFromServer = function(urlParams) {
+  var cached = this.storage.getItemSync("http-webhook-" + this.id);
+  var isNumberBased = this.type === "leak" || this.type === "humidity" || this.type === "temperature" || this.type === "airquality" || this.type === "light";
+  if (cached === undefined) {
+    cached = isNumberBased ? 0 : false;
+  }
+  var noUrlValue = isNumberBased ? urlParams.value === undefined : urlParams.state === undefined;
+  if (noUrlValue) {
+    this.log.debug(this.name + ": No urlValue");
+    return {
+      "success" : true,
+      "state" : cached
+    };
+  }
+  var urlValue = isNumberBased ? urlParams.value : urlParams.state === "true";
+  this.log.debug(this.name + ": urlValue: "+ urlValue);
+  this.storage.setItemSync("http-webhook-" + this.id, urlValue);
+  this.log.debug(this.name + ": cached: "+ cached);
+  this.log.debug(this.name + ": cached !== urlValue: "+ (cached !== urlValue));
+  if (cached !== urlValue) {
+    this.log(this.name + ": Change HomeKit value for " + this.type + " sensor to '%s'.", urlValue);
+
+    if (this.type === "contact") {
+      this.service.getCharacteristic(Characteristic.ContactSensorState).updateValue(urlValue ? Characteristic.ContactSensorState.CONTACT_DETECTED : Characteristic.ContactSensorState.CONTACT_NOT_DETECTED, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      if (this.autoRelease) {
+        setTimeout(function() {
+          this.storage.setItemSync("http-webhook-" + this.id, true);
+          this.service.getCharacteristic(Characteristic.ContactSensorState).updateValue(Characteristic.ContactSensorState.CONTACT_DETECTED, undefined, Constants.CONTEXT_FROM_TIMEOUTCALL);
+        }.bind(this), this.autoReleaseTime);
+      }
+    }
+    else if (this.type === "motion") {
+      this.service.getCharacteristic(Characteristic.MotionDetected).updateValue(urlValue, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      if (this.autoRelease) {
+        setTimeout(function() {
+          this.storage.setItemSync("http-webhook-" + this.id, false);
+          this.service.getCharacteristic(Characteristic.MotionDetected).updateValue(false, undefined, Constants.CONTEXT_FROM_TIMEOUTCALL);
+        }.bind(this), this.autoReleaseTime);
+      }
+    }
+    else if (this.type === "occupancy") {
+      this.service.getCharacteristic(Characteristic.OccupancyDetected).updateValue(urlValue ? Characteristic.OccupancyDetected.OCCUPANCY_DETECTED : Characteristic.OccupancyDetected.OCCUPANCY_NOT_DETECTED, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      if (this.autoRelease) {
+        setTimeout(function() {
+          this.storage.setItemSync("http-webhook-" + this.id, false);
+          this.service.getCharacteristic(Characteristic.OccupancyDetected).updateValue(Characteristic.OccupancyDetected.OCCUPANCY_NOT_DETECTED, undefined, Constants.CONTEXT_FROM_TIMEOUTCALL);
+        }.bind(this), this.autoReleaseTime);
+      }
+    }
+    else if (this.type === "smoke") {
+      this.service.getCharacteristic(Characteristic.SmokeDetected).updateValue(urlValue ? Characteristic.SmokeDetected.SMOKE_DETECTED : Characteristic.SmokeDetected.SMOKE_NOT_DETECTED, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+    else if (this.type === "humidity") {
+      this.service.getCharacteristic(Characteristic.CurrentRelativeHumidity).updateValue(urlValue, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+    else if (this.type === "temperature") {
+      this.service.getCharacteristic(Characteristic.CurrentTemperature).updateValue(urlValue, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+    else if (this.type === "airquality") {
+      this.service.getCharacteristic(Characteristic.AirQuality).updateValue(urlValue, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+    else if (this.type === "light") {
+      urlValue = parseFloat(urlValue)
+      this.service.getCharacteristic(Characteristic.CurrentAmbientLightLevel).updateValue(urlValue, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+    else if (this.type === "leak") {
+      this.service.getCharacteristic(Characteristic.LeakDetected).updateValue(urlValue, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+
+  }
+  return {
+    "success" : true
+  };
+};
+
+HttpWebHookSensorAccessory.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);
+  this.log.debug(this.name + ": State for '%s' is '%s'", this.id, state);
+  if (state === undefined) {
+    state = false; // force default value if undefined
+  }
+  if (this.type === "contact") {
+    callback(null, state ? Characteristic.ContactSensorState.CONTACT_DETECTED : Characteristic.ContactSensorState.CONTACT_NOT_DETECTED);
+  }
+  else if (this.type === "smoke") {
+    callback(null, state ? Characteristic.SmokeDetected.SMOKE_DETECTED : Characteristic.SmokeDetected.SMOKE_NOT_DETECTED);
+  }
+  else if (this.type === "occupancy") {
+    callback(null, state ? Characteristic.OccupancyDetected.OCCUPANCY_DETECTED : Characteristic.OccupancyDetected.OCCUPANCY_NOT_DETECTED);
+  }
+  else if (this.type === "light") {
+    if (state === false) {
+      state = 0.0001 // 0.0001 is minimum valid value for light
+    }
+    callback(null, parseFloat(state));
+  }
+  else {
+    callback(null, state);
+  }
+};
+
+HttpWebHookSensorAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookSensorAccessory;

package/src/homekit/accessories/HttpWebHookStatelessSwitchAccessory.js

@@ -0,0 +1,101 @@
+const Constants = require('../../Constants');
+
+function HttpWebHookStatelessSwitchAccessory(ServiceParam, CharacteristicParam, platform, statelessSwitchConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = statelessSwitchConfig["id"];
+  this.type = "statelessswitch";
+  this.name = statelessSwitchConfig["name"];
+  this.buttons = statelessSwitchConfig["buttons"] || [];
+
+  this.service = [];
+  for (var index = 0; index < this.buttons.length; index++) {
+    var single_press = this.buttons[index]["single_press"] === undefined ? true : this.buttons[index]["single_press"];
+    var double_press = this.buttons[index]["double_press"] === undefined ? true : this.buttons[index]["double_press"];
+    var long_press = this.buttons[index]["long_press"] === undefined ? true : this.buttons[index]["long_press"];
+    var button = new Service.StatelessProgrammableSwitch(this.buttons[index].name, '' + index);
+    button.getCharacteristic(Characteristic.ProgrammableSwitchEvent).setProps(GetStatelessSwitchProps(single_press, double_press, long_press));
+    button.getCharacteristic(Characteristic.ServiceLabelIndex).setValue(index + 1);
+    this.service.push(button);
+  }
+
+  var informationService = new Service.AccessoryInformation();
+  informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  informationService.setCharacteristic(Characteristic.Model, "HttpWebHookStatelessSwitchAccessory-" + this.name);
+  informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookStatelessSwitchAccessory-" + this.id);
+  this.service.push(informationService);
+};
+
+HttpWebHookStatelessSwitchAccessory.prototype.changeFromServer = function(urlParams) {
+  if (urlParams.event && urlParams.event) {
+    for (var index = 0; index < this.service.length; index++) {
+      var serviceName = this.service[index].getCharacteristic(Characteristic.Name).value;
+      if (serviceName === urlParams.buttonName) {
+        this.log(this.name + ": Pressing '%s' with event '%i'", urlParams.buttonName, urlParams.event)
+        this.service[index].getCharacteristic(Characteristic.ProgrammableSwitchEvent).updateValue(urlParams.event, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      }
+    }
+  }
+  return {
+    "success" : true
+  };
+}
+
+function GetStatelessSwitchProps(single_press, double_press, long_press) {
+  var props;
+  if (single_press && !double_press && !long_press) {
+    props = {
+      minValue : Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS,
+      maxValue : Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS
+    };
+  }
+  if (single_press && double_press && !long_press) {
+    props = {
+      minValue : Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS,
+      maxValue : Characteristic.ProgrammableSwitchEvent.DOUBLE_PRESS
+    };
+  }
+  if (single_press && !double_press && long_press) {
+    props = {
+      minValue : Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS,
+      maxValue : Characteristic.ProgrammableSwitchEvent.LONG_PRESS,
+      validValues : [ Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS, Characteristic.ProgrammableSwitchEvent.LONG_PRESS ]
+    };
+  }
+  if (!single_press && double_press && !long_press) {
+    props = {
+      minValue : Characteristic.ProgrammableSwitchEvent.DOUBLE_PRESS,
+      maxValue : Characteristic.ProgrammableSwitchEvent.DOUBLE_PRESS
+    };
+  }
+  if (!single_press && double_press && long_press) {
+    props = {
+      minValue : Characteristic.ProgrammableSwitchEvent.DOUBLE_PRESS,
+      maxValue : Characteristic.ProgrammableSwitchEvent.LONG_PRESS
+    };
+  }
+  if (!single_press && !double_press && long_press) {
+    props = {
+      minValue : Characteristic.ProgrammableSwitchEvent.LONG_PRESS,
+      maxValue : Characteristic.ProgrammableSwitchEvent.LONG_PRESS
+    };
+  }
+  if (single_press && double_press && long_press) {
+    props = {
+      minValue : Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS,
+      maxValue : Characteristic.ProgrammableSwitchEvent.LONG_PRESS
+    };
+  }
+  return props;
+}
+
+HttpWebHookStatelessSwitchAccessory.prototype.getServices = function() {
+  return this.service;
+};
+
+module.exports = HttpWebHookStatelessSwitchAccessory;

package/src/homekit/accessories/HttpWebHookSwitchAccessory.js

@@ -0,0 +1,95 @@
+const Constants = require('../../Constants');
+const Util = require('../../Util');
+
+function HttpWebHookSwitchAccessory(ServiceParam, CharacteristicParam, platform, switchConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = switchConfig["id"];
+  this.name = switchConfig["name"];
+  this.rejectUnauthorized = switchConfig["rejectUnauthorized"] === undefined ? true: switchConfig["rejectUnauthorized"] === true;
+  this.onURL = switchConfig["on_url"] || "";
+  this.onMethod = switchConfig["on_method"] || "GET";
+  this.onBody = switchConfig["on_body"] || "";
+  this.onForm = switchConfig["on_form"] || "";
+  this.onHeaders = switchConfig["on_headers"] || "{}";
+  this.offURL = switchConfig["off_url"] || "";
+  this.offMethod = switchConfig["off_method"] || "GET";
+  this.offBody = switchConfig["off_body"] || "";
+  this.offForm = switchConfig["off_form"] || "";
+  this.offHeaders = switchConfig["off_headers"] || "{}";
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookSwitchAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookSwitchAccessory-" + 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));
+}
+
+HttpWebHookSwitchAccessory.prototype.changeFromServer = function(urlParams) {
+  var cachedState = this.storage.getItemSync("http-webhook-" + this.id);
+  if (cachedState === undefined) {
+    cachedState = false;
+  }
+  if (!urlParams.state) {
+    return {
+      "success" : true,
+      "state" : cachedState
+    };
+  }
+  else {
+    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 switch to '%s'.", stateBool);
+      this.service.getCharacteristic(Characteristic.On).updateValue(stateBool, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+    return {
+      "success" : true
+    };
+  }
+}
+
+HttpWebHookSwitchAccessory.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);
+};
+
+HttpWebHookSwitchAccessory.prototype.setState = function(powerOn, callback, context) {
+  this.log(this.name + ": Switch 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);
+};
+
+HttpWebHookSwitchAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookSwitchAccessory;

package/src/homekit/accessories/HttpWebHookThermostatAccessory.js

@@ -0,0 +1,164 @@
+const Constants = require('../../Constants');
+const Util = require('../../Util');
+
+function HttpWebHookThermostatAccessory(ServiceParam, CharacteristicParam, platform, thermostatConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = thermostatConfig["id"];
+  this.name = thermostatConfig["name"];
+  this.type = "thermostat";
+  this.minValue = thermostatConfig["minTemp"] || 15;
+  this.maxValue = thermostatConfig["maxTemp"] || 30;
+  this.minStep = thermostatConfig["minStep"] || 0.5;
+  this.rejectUnauthorized = thermostatConfig["rejectUnauthorized"] === undefined ? true: thermostatConfig["rejectUnauthorized"] === true;
+  this.setTargetTemperatureURL = thermostatConfig["set_target_temperature_url"] || "";
+  this.setTargetTemperatureMethod = thermostatConfig["set_target_temperature_method"] || "GET";
+  this.setTargetTemperatureBody = thermostatConfig["set_target_temperature_body"] || "";
+  this.setTargetTemperatureForm = thermostatConfig["set_target_temperature_form"] || "";
+  this.setTargetTemperatureHeaders = thermostatConfig["set_target_temperature_headers"] || "{}";
+  this.setTargetHeatingCoolingStateURL = thermostatConfig["set_target_heating_cooling_state_url"] || "";
+  this.setTargetHeatingCoolingStateMethod = thermostatConfig["set_target_heating_cooling_state_method"] || "GET";
+  this.setTargetHeatingCoolingStateBody = thermostatConfig["set_target_heating_cooling_state_body"] || "";
+  this.setTargetHeatingCoolingStateForm = thermostatConfig["set_target_heating_cooling_state_form"] || "";
+  this.setTargetHeatingCoolingStateHeaders = thermostatConfig["set_target_heating_cooling_state_headers"] || "{}";
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookThermostatAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookThermostatAccessory-" + this.id);
+
+  this.service = new Service.Thermostat(this.name);
+  this.service.getCharacteristic(Characteristic.TargetHeatingCoolingState).on('get', this.getTargetHeatingCoolingState.bind(this)).on('set', this.setTargetHeatingCoolingState.bind(this));
+  this.service.getCharacteristic(Characteristic.CurrentHeatingCoolingState).on('get', this.getCurrentHeatingCoolingState.bind(this));
+  this.service.getCharacteristic(Characteristic.TargetTemperature).on('get', this.getTargetTemperature.bind(this)).on('set', this.setTargetTemperature.bind(this)).setProps({
+    minValue: this.minValue,
+    maxValue: this.maxValue,
+    minStep: this.minStep
+   });
+  this.service.getCharacteristic(Characteristic.CurrentTemperature).on('get', this.getCurrentTemperature.bind(this));
+}
+
+HttpWebHookThermostatAccessory.prototype.changeFromServer = function(urlParams) {
+  if (urlParams.currenttemperature != null) {
+    var cachedCurTemp = this.storage.getItemSync("http-webhook-current-temperature-" + this.id);
+    if (cachedCurTemp === undefined) {
+      cachedCurTemp = 0;
+    }
+    this.storage.setItemSync("http-webhook-current-temperature-" + this.id, urlParams.currenttemperature);
+    if (cachedCurTemp !== urlParams.currenttemperature) {
+      this.log(this.name + ": Change current Temperature for thermostat to '%d'.", urlParams.currenttemperature);
+      this.service.getCharacteristic(Characteristic.CurrentTemperature).updateValue(urlParams.currenttemperature, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+  }
+  if (urlParams.targettemperature != null) {
+    var cachedCurTemp = this.storage.getItemSync("http-webhook-target-temperature-" + this.id);
+    if (cachedCurTemp === undefined) {
+      cachedCurTemp = 10;
+    }
+    this.storage.setItemSync("http-webhook-target-temperature-" + this.id, urlParams.targettemperature);
+    if (cachedCurTemp !== urlParams.targettemperature) {
+      this.log(this.name + ": Change target Temperature for thermostat to '%d'.", urlParams.targettemperature);
+      this.service.getCharacteristic(Characteristic.TargetTemperature).updateValue(urlParams.targettemperature, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    }
+  }
+  if (urlParams.currentstate != null) {
+    var cachedState = this.storage.getItemSync("http-webhook-current-heating-cooling-state-" + this.id);
+    if (cachedState === undefined) {
+      cachedState = Characteristic.CurrentHeatingCoolingState.OFF;
+    }
+    this.storage.setItemSync("http-webhook-current-heating-cooling-state-" + this.id, urlParams.currentstate);
+    if (cachedState !== urlParams.currentstate) {
+      if (urlParams.currentstate) {
+        this.log(this.name + ": Change Current Heating Cooling State for thermostat to '%s'.", urlParams.currentstate);
+        this.service.getCharacteristic(Characteristic.CurrentHeatingCoolingState).updateValue(urlParams.currentstate, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      }
+    }
+  }
+  if (urlParams.targetstate != null) {
+    var cachedState = this.storage.getItemSync("http-webhook-target-heating-cooling-state-" + this.id);
+    if (cachedState === undefined) {
+      cachedState = Characteristic.TargetHeatingCoolingState.OFF;
+    }
+    this.storage.setItemSync("http-webhook-target-heating-cooling-state-" + this.id, urlParams.targetstate);
+    if (cachedState !== urlParams.targetstate) {
+      if (urlParams.targetstate) {
+        this.log(this.name + ": Change Target Heating Cooling State for thermostat to '%s'.", urlParams.targetstate);
+        this.service.getCharacteristic(Characteristic.TargetHeatingCoolingState).updateValue(urlParams.targetstate, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+      }
+    }
+  }
+  return {
+    "success" : true
+  };
+}
+
+HttpWebHookThermostatAccessory.prototype.getTargetTemperature = function(callback) {
+  this.log.debug(this.name + ": Getting target temperature for '%s'...", this.id);
+  var temp = this.storage.getItemSync("http-webhook-target-temperature-" + this.id);
+  if (temp === undefined) {
+    temp = 20;
+  }
+  callback(null, temp);
+};
+
+HttpWebHookThermostatAccessory.prototype.setTargetTemperature = function(temp, callback, context) {
+  this.log(this.name + ": Target temperature for '%s'...", this.id);
+  this.storage.setItemSync("http-webhook-target-temperature-" + this.id, temp);
+  var urlToCall = this.setTargetTemperatureURL.replace("%f", temp);
+  var urlMethod = this.setTargetTemperatureMethod;
+  var urlBody = this.setTargetTemperatureBody;
+  var urlForm = this.setTargetTemperatureForm;
+  var urlHeaders = this.setTargetTemperatureHeaders;
+
+  Util.callHttpApi(this.log, urlToCall, urlMethod, urlBody, urlForm, urlHeaders, this.rejectUnauthorized, callback, context);
+};
+
+HttpWebHookThermostatAccessory.prototype.getCurrentTemperature = function(callback) {
+  this.log.debug(this.name + ": Getting current temperature for '%s'...", this.id);
+  var temp = this.storage.getItemSync("http-webhook-current-temperature-" + this.id);
+  if (temp === undefined) {
+    temp = 20;
+  }
+  callback(null, temp);
+};
+
+HttpWebHookThermostatAccessory.prototype.getTargetHeatingCoolingState = function(callback) {
+  this.log.debug(this.name + ": Getting current Target Heating Cooling state for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-target-heating-cooling-state-" + this.id);
+  if (state === undefined) {
+    state = Characteristic.TargetHeatingCoolingState.OFF;
+  }
+  callback(null, state);
+};
+
+HttpWebHookThermostatAccessory.prototype.setTargetHeatingCoolingState = function(newState, callback, context) {
+  this.log(this.name + ": Target Heating Cooling state for '%s'...", this.id);
+  this.storage.setItemSync("http-webhook-target-heating-cooling-state-" + this.id, newState);
+  var urlToCall = this.setTargetHeatingCoolingStateURL.replace("%b", newState);
+  var urlMethod = this.setTargetHeatingCoolingStateMethod;
+  var urlBody = this.setTargetHeatingCoolingStateBody;
+  var urlForm = this.setTargetHeatingCoolingStateForm;
+  var urlHeaders = this.setTargetHeatingCoolingStateHeaders;
+
+  Util.callHttpApi(this.log, urlToCall, urlMethod, urlBody, urlForm, urlHeaders, this.rejectUnauthorized, callback, context);
+};
+
+HttpWebHookThermostatAccessory.prototype.getCurrentHeatingCoolingState = function(callback) {
+  this.log.debug(this.name + ": Getting current Target Heating Cooling state for '%s'...", this.id);
+  var state = this.storage.getItemSync("http-webhook-current-heating-cooling-state-" + this.id);
+  if (state === undefined) {
+    state = Characteristic.CurrentHeatingCoolingState.OFF;
+  }
+  callback(null, state);
+};
+
+HttpWebHookThermostatAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookThermostatAccessory;