git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.digitalstrom.internal.lib.serverconnection.impl;
  14
  15 import java.util.ArrayList;
  16 import java.util.Arrays;
  17 import java.util.HashMap;
  18 import java.util.Iterator;
  19 import java.util.LinkedList;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.Map.Entry;
  23 import java.util.Set;
  24
  25 import org.openhab.binding.digitalstrom.internal.lib.GeneralLibConstance;
  26 import org.openhab.binding.digitalstrom.internal.lib.climate.jsonresponsecontainer.BaseSensorValues;
  27 import org.openhab.binding.digitalstrom.internal.lib.climate.jsonresponsecontainer.impl.AssignedSensors;
  28 import org.openhab.binding.digitalstrom.internal.lib.climate.jsonresponsecontainer.impl.SensorValues;
  29 import org.openhab.binding.digitalstrom.internal.lib.climate.jsonresponsecontainer.impl.TemperatureControlConfig;
  30 import org.openhab.binding.digitalstrom.internal.lib.climate.jsonresponsecontainer.impl.TemperatureControlInternals;
  31 import org.openhab.binding.digitalstrom.internal.lib.climate.jsonresponsecontainer.impl.TemperatureControlStatus;
  32 import org.openhab.binding.digitalstrom.internal.lib.climate.jsonresponsecontainer.impl.TemperatureControlValues;
  33 import org.openhab.binding.digitalstrom.internal.lib.climate.jsonresponsecontainer.impl.WeatherSensorData;
  34 import org.openhab.binding.digitalstrom.internal.lib.config.Config;
  35 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.DsAPI;
  36 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.HttpTransport;
  37 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.constants.JSONApiResponseKeysEnum;
  38 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.simpledsrequestbuilder.SimpleRequestBuilder;
  39 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.simpledsrequestbuilder.constants.ClassKeys;
  40 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.simpledsrequestbuilder.constants.FunctionKeys;
  41 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.simpledsrequestbuilder.constants.InterfaceKeys;
  42 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.simpledsrequestbuilder.constants.ParameterKeys;
  43 import org.openhab.binding.digitalstrom.internal.lib.structure.Apartment;
  44 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.Circuit;
  45 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.Device;
  46 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.CachedMeteringValue;
  47 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.DeviceConfig;
  48 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.DeviceSceneSpec;
  49 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.constants.DeviceParameterClassEnum;
  50 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.constants.MeteringTypeEnum;
  51 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.constants.MeteringUnitsEnum;
  52 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.constants.SensorEnum;
  53 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.impl.DSID;
  54 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.impl.JSONCachedMeteringValueImpl;
  55 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.impl.JSONDeviceConfigImpl;
  56 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.impl.JSONDeviceSceneSpecImpl;
  57 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.impl.CircuitImpl;
  58 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.impl.DeviceImpl;
  59 import org.openhab.binding.digitalstrom.internal.lib.structure.impl.JSONApartmentImpl;
  60 import org.openhab.binding.digitalstrom.internal.lib.structure.scene.constants.Scene;
  61 import org.openhab.binding.digitalstrom.internal.lib.structure.scene.constants.SceneEnum;
  62 import org.slf4j.Logger;
  63 import org.slf4j.LoggerFactory;
  64
  65 import com.google.gson.JsonArray;
  66 import com.google.gson.JsonElement;
  67 import com.google.gson.JsonObject;
  68
  69 /**
  70  * The {@link DsAPIImpl} is the implementation of the {@link DsAPI}.
  71  *
  72  * @author Alexander Betker - initial contributer
  73  * @author Alex Maier - initial contributer
  74  * @author Michael Ochel - implements new methods, API updates and change SimpleJSON to GSON, add helper methods and
  75  *         requests building with constants to {@link SimpleRequestBuilder}
  76  * @author Matthias Siegele - implements new methods, API updates and change SimpleJSON to GSON, add helper methods and
  77  *         requests building with constants to {@link SimpleRequestBuilder}
  78  */
  79 public class DsAPIImpl implements DsAPI {
  80
  81     private final Logger logger = LoggerFactory.getLogger(DsAPIImpl.class);
  82     private final HttpTransport transport;
  83
  84     public static final String QUERY_GET_METERLIST = "/apartment/dSMeters/*(dSID)";
  85
  86     /**
  87      * Contains methods where no login is required.
  88      */
  89     public static final List<String> METHODS_MUST_NOT_BE_LOGGED_IN = Arrays.asList(FunctionKeys.LOGIN,
  90             FunctionKeys.REQUEST_APPLICATION_TOKEN, FunctionKeys.VERSION, FunctionKeys.TIME, FunctionKeys.GET_DSID,
  91             FunctionKeys.LOGOUT, FunctionKeys.LOGIN_APPLICATION);
  92
  93     /**
  94      * Create a new {@link DsAPIImpl} with the given {@link HttpTransport}.
  95      *
  96      * @param transport for connection, must not be null
  97      */
  98     public DsAPIImpl(HttpTransport transport) {
  99         this.transport = transport;
 100     }
 101
 102     /**
 103      * Creates a new {@link DsAPIImpl} with creating a new {@link HttpTransport}, parameters see
 104      * {@link HttpTransportImpl#HttpTransportImpl(String, int, int)}.
 105      *
 106      * @param uri of the digitalSTROM-Server, must not be null
 107      * @param connectTimeout to set
 108      * @param readTimeout to set
 109      */
 110     public DsAPIImpl(String uri, int connectTimeout, int readTimeout) {
 111         this.transport = new HttpTransportImpl(uri, connectTimeout, readTimeout);
 112     }
 113
 114     /**
 115      * Creates a new {@link DsAPIImpl} with creating a new {@link HttpTransport}, parameters see
 116      * {@link HttpTransportImpl#HttpTransportImpl(String, int, int, boolean)}.
 117      *
 118      * @param uri of the digitalSTROM-Server, must not be null
 119      * @param connectTimeout to set
 120      * @param readTimeout to set
 121      * @param aceptAllCerts yes/no (true/false)
 122      */
 123     public DsAPIImpl(String uri, int connectTimeout, int readTimeout, boolean aceptAllCerts) {
 124         this.transport = new HttpTransportImpl(uri, connectTimeout, readTimeout, aceptAllCerts);
 125     }
 126
 127     private boolean isValidApartmentSceneNumber(int sceneNumber) {
 128         return (sceneNumber > -1 && sceneNumber < 256);
 129     }
 130
 131     private boolean checkBlankField(JsonObject obj, String key) {
 132         return obj != null && obj.get(key) != null;
 133     }
 134
 135     private boolean checkRequiredZone(Integer zoneID, String zoneName) {
 136         return zoneID != null && zoneID > -1 || (zoneName != null && !zoneName.isBlank());
 137     }
 138
 139     private boolean checkRequiredDevice(DSID dsid, String dSUID, String name) {
 140         String objectString = SimpleRequestBuilder.objectToString(dsid);
 141         return (objectString != null && !objectString.isBlank()) || (name != null && !name.isBlank())
 142                 || (dSUID != null && !dSUID.isBlank());
 143     }
 144
 145     @Override
 146     public boolean callApartmentScene(String token, Short groupID, String groupName, Scene sceneNumber, Boolean force) {
 147         if (sceneNumber != null && isValidApartmentSceneNumber(sceneNumber.getSceneNumber())) {
 148             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
 149                     .addFunction(FunctionKeys.CALL_SCENE).addDefaultGroupParameter(token, groupID, groupName)
 150                     .addParameter(ParameterKeys.SCENENUMBER, sceneNumber.getSceneNumber().toString())
 151                     .addParameter(ParameterKeys.FORCE, force.toString()).buildRequestString());
 152             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 153         }
 154         return false;
 155     }
 156
 157     @Override
 158     public boolean undoApartmentScene(String token, Short groupID, String groupName, Scene sceneNumber) {
 159         if (sceneNumber != null && isValidApartmentSceneNumber(sceneNumber.getSceneNumber())) {
 160             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
 161                     .addFunction(FunctionKeys.UNDO_SCENE).addDefaultGroupParameter(token, groupID, groupName)
 162                     .addParameter(ParameterKeys.SCENENUMBER, sceneNumber.getSceneNumber().toString())
 163                     .buildRequestString());
 164             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 165         }
 166         return false;
 167     }
 168
 169     @Override
 170     public Apartment getApartmentStructure(String token) {
 171         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
 172                 .addFunction(FunctionKeys.GET_STRUCTURE).addParameter(ParameterKeys.TOKEN, token).buildRequestString());
 173
 174         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 175
 176         if (JSONResponseHandler.checkResponse(responseObj)) {
 177             JsonObject apartObj = JSONResponseHandler.getResultJsonObject(responseObj);
 178             if (checkBlankField(apartObj, JSONApiResponseKeysEnum.APARTMENT.getKey())) {
 179                 return new JSONApartmentImpl((JsonObject) apartObj.get(JSONApiResponseKeysEnum.APARTMENT.getKey()));
 180             }
 181         }
 182         return null;
 183     }
 184
 185     @Override
 186     public List<Device> getApartmentDevices(String token) {
 187         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
 188                 .addFunction(FunctionKeys.GET_DEVICES).addParameter(ParameterKeys.TOKEN, token).buildRequestString());
 189         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 190         if (JSONResponseHandler.checkResponse(responseObj)
 191                 && responseObj.get(JSONApiResponseKeysEnum.RESULT.getKey()) instanceof JsonArray) {
 192             JsonArray array = (JsonArray) responseObj.get(JSONApiResponseKeysEnum.RESULT.getKey());
 193
 194             List<Device> deviceList = new LinkedList<>();
 195             for (int i = 0; i < array.size(); i++) {
 196                 if (array.get(i) instanceof JsonObject) {
 197                     deviceList.add(new DeviceImpl((JsonObject) array.get(i)));
 198                 }
 199             }
 200             return deviceList;
 201         }
 202         return new LinkedList<>();
 203     }
 204
 205     @Override
 206     public List<Circuit> getApartmentCircuits(String sessionToken) {
 207         String response = transport.execute(
 208                 SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT).addFunction(FunctionKeys.GET_CIRCUITS)
 209                         .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
 210
 211         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 212         if (JSONResponseHandler.checkResponse(responseObj)) {
 213             responseObj = JSONResponseHandler.getResultJsonObject(responseObj);
 214             if (responseObj.get(JSONApiResponseKeysEnum.CIRCUITS.getKey()).isJsonArray()) {
 215                 JsonArray array = responseObj.get(JSONApiResponseKeysEnum.CIRCUITS.getKey()).getAsJsonArray();
 216
 217                 List<Circuit> circuitList = new LinkedList<>();
 218                 for (int i = 0; i < array.size(); i++) {
 219                     if (array.get(i).isJsonObject()) {
 220                         circuitList.add(new CircuitImpl(array.get(i).getAsJsonObject()));
 221                     }
 222                 }
 223                 return circuitList;
 224             }
 225         }
 226         return new LinkedList<>();
 227     }
 228
 229     @Override
 230     public boolean callZoneScene(String token, Integer zoneID, String zoneName, Short groupID, String groupName,
 231             SceneEnum sceneNumber, Boolean force) {
 232         if (checkRequiredZone(zoneID, zoneName)) {
 233             String response = transport.execute(
 234                     SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.ZONE).addFunction(FunctionKeys.CALL_SCENE)
 235                             .addDefaultZoneGroupParameter(token, zoneID, zoneName, groupID, groupName)
 236                             .addParameter(ParameterKeys.SCENENUMBER, sceneNumber.getSceneNumber().toString())
 237                             .addParameter(ParameterKeys.FORCE, force.toString()).buildRequestString());
 238
 239             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 240         }
 241         return false;
 242     }
 243
 244     @Override
 245     public boolean undoZoneScene(String token, Integer zoneID, String zoneName, Short groupID, String groupName,
 246             SceneEnum sceneNumber) {
 247         if (checkRequiredZone(zoneID, zoneName)) {
 248             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 249                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.UNDO_SCENE)
 250                     .addDefaultZoneGroupParameter(token, zoneID, zoneName, groupID, groupName)
 251                     .addParameter(ParameterKeys.SCENENUMBER, sceneNumber.getSceneNumber().toString())
 252                     .buildRequestString());
 253             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 254         }
 255         return false;
 256     }
 257
 258     @Override
 259     public boolean turnDeviceOn(String token, DSID dsid, String dSUID, String name) {
 260         if (checkRequiredDevice(dsid, dSUID, name)) {
 261             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 262                     .addRequestClass(ClassKeys.DEVICE).addFunction(FunctionKeys.TURN_ON)
 263                     .addDefaultDeviceParameter(token, dsid, dSUID, name).buildRequestString());
 264             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 265         }
 266         return false;
 267     }
 268
 269     @Override
 270     public boolean turnDeviceOff(String token, DSID dSID, String dSUID, String name) {
 271         if (checkRequiredDevice(dSID, dSUID, name)) {
 272             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 273                     .addRequestClass(ClassKeys.DEVICE).addFunction(FunctionKeys.TURN_OFF)
 274                     .addDefaultDeviceParameter(token, dSID, dSUID, name).buildRequestString());
 275
 276             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 277
 278         }
 279         return false;
 280     }
 281
 282     @Override
 283     public DeviceConfig getDeviceConfig(String token, DSID dSID, String dSUID, String name,
 284             DeviceParameterClassEnum class_, Integer index) {
 285         if (checkRequiredDevice(dSID, dSUID, name) && class_ != null
 286                 && SimpleRequestBuilder.objectToString(index) != null) {
 287             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.DEVICE)
 288                     .addFunction(FunctionKeys.GET_CONFIG).addDefaultDeviceParameter(token, dSID, dSUID, name)
 289                     .addParameter(ParameterKeys.CLASS, class_.getClassIndex().toString())
 290                     .addParameter(ParameterKeys.INDEX, SimpleRequestBuilder.objectToString(index))
 291                     .buildRequestString());
 292
 293             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 294
 295             if (JSONResponseHandler.checkResponse(responseObj)) {
 296                 JsonObject configObject = JSONResponseHandler.getResultJsonObject(responseObj);
 297
 298                 if (configObject != null) {
 299                     return new JSONDeviceConfigImpl(configObject);
 300                 }
 301             }
 302         }
 303         return null;
 304     }
 305
 306     @Override
 307     public int getDeviceOutputValue(String token, DSID dSID, String dSUID, String name, Short offset) {
 308         if (checkRequiredDevice(dSID, dSUID, name) && SimpleRequestBuilder.objectToString(offset) != null) {
 309             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 310                     .addRequestClass(ClassKeys.DEVICE).addFunction(FunctionKeys.GET_OUTPUT_VALUE)
 311                     .addDefaultDeviceParameter(token, dSID, dSUID, name)
 312                     .addParameter(ParameterKeys.OFFSET, SimpleRequestBuilder.objectToString(offset))
 313                     .buildRequestString());
 314
 315             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 316
 317             if (JSONResponseHandler.checkResponse(responseObj)) {
 318                 JsonObject valueObject = JSONResponseHandler.getResultJsonObject(responseObj);
 319
 320                 if (checkBlankField(valueObject, JSONApiResponseKeysEnum.VALUE.getKey())) {
 321                     return valueObject.get(JSONApiResponseKeysEnum.VALUE.getKey()).getAsInt();
 322                 }
 323             }
 324         }
 325         return -1;
 326     }
 327
 328     @Override
 329     public boolean setDeviceOutputValue(String token, DSID dSID, String dSUID, String name, Short offset,
 330             Integer value) {
 331         if (checkRequiredDevice(dSID, dSUID, name) && SimpleRequestBuilder.objectToString(offset) != null
 332                 && SimpleRequestBuilder.objectToString(value) != null) {
 333             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 334                     .addRequestClass(ClassKeys.DEVICE).addFunction(FunctionKeys.SET_OUTPUT_VALUE)
 335                     .addDefaultDeviceParameter(token, dSID, dSUID, name)
 336                     .addParameter(ParameterKeys.OFFSET, SimpleRequestBuilder.objectToString(offset))
 337                     .addParameter(ParameterKeys.VALUE, SimpleRequestBuilder.objectToString(value))
 338                     .buildRequestString());
 339             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 340         }
 341         return false;
 342     }
 343
 344     @Override
 345     public DeviceSceneSpec getDeviceSceneMode(String token, DSID dSID, String dSUID, String name, Short sceneID) {
 346         if (checkRequiredDevice(dSID, dSUID, name) && SimpleRequestBuilder.objectToString(sceneID) != null) {
 347             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 348                     .addRequestClass(ClassKeys.DEVICE).addFunction(FunctionKeys.GET_SCENE_MODE)
 349                     .addDefaultDeviceParameter(token, dSID, dSUID, name)
 350                     .addParameter(ParameterKeys.SCENE_ID, SimpleRequestBuilder.objectToString(sceneID))
 351                     .buildRequestString());
 352             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 353
 354             if (JSONResponseHandler.checkResponse(responseObj)) {
 355                 JsonObject sceneSpec = JSONResponseHandler.getResultJsonObject(responseObj);
 356
 357                 if (sceneSpec != null) {
 358                     return new JSONDeviceSceneSpecImpl(sceneSpec);
 359                 }
 360             }
 361         }
 362         return null;
 363     }
 364
 365     @Override
 366     public short getDeviceSensorValue(String token, DSID dSID, String dSUID, String name, Short sensorIndex) {
 367         if (checkRequiredDevice(dSID, dSUID, dSUID) && sensorIndex != null) {
 368             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 369                     .addRequestClass(ClassKeys.DEVICE).addFunction(FunctionKeys.GET_SENSOR_VALUE)
 370                     .addDefaultDeviceParameter(token, dSID, dSUID, name)
 371                     .addParameter(ParameterKeys.SENSOR_INDEX, SimpleRequestBuilder.objectToString(sensorIndex))
 372                     .buildRequestString());
 373             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 374
 375             if (JSONResponseHandler.checkResponse(responseObj)) {
 376                 JsonObject valueObject = JSONResponseHandler.getResultJsonObject(responseObj);
 377
 378                 if (checkBlankField(valueObject, JSONApiResponseKeysEnum.SENSOR_VALUE.getKey())) {
 379                     return valueObject.get(JSONApiResponseKeysEnum.SENSOR_VALUE.getKey()).getAsShort();
 380                 }
 381             }
 382         }
 383         return -1;
 384     }
 385
 386     @Override
 387     public boolean callDeviceScene(String token, DSID dSID, String dSUID, String name, Scene sceneNumber,
 388             Boolean force) {
 389         if (checkRequiredDevice(dSID, dSUID, name) && sceneNumber != null) {
 390             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.DEVICE)
 391                     .addFunction(FunctionKeys.CALL_SCENE).addDefaultDeviceParameter(token, dSID, dSUID, name)
 392                     .addParameter(ParameterKeys.SCENENUMBER, sceneNumber.getSceneNumber().toString())
 393                     .addParameter(ParameterKeys.FORCE, force.toString()).buildRequestString());
 394             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 395         }
 396         return false;
 397     }
 398
 399     @Override
 400     public boolean undoDeviceScene(String token, DSID dSID, String dSUID, String name, Scene sceneNumber) {
 401         if (checkRequiredDevice(dSID, dSUID, name) && sceneNumber != null) {
 402             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.DEVICE)
 403                     .addFunction(FunctionKeys.UNDO_SCENE).addDefaultDeviceParameter(token, dSID, dSUID, name)
 404                     .addParameter(ParameterKeys.SCENENUMBER, sceneNumber.getSceneNumber().toString())
 405                     .buildRequestString());
 406             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 407         }
 408         return false;
 409     }
 410
 411     @Override
 412     public boolean subscribeEvent(String token, String name, Integer subscriptionID, int connectionTimeout,
 413             int readTimeout) {
 414         if ((name != null && !name.isBlank()) && SimpleRequestBuilder.objectToString(subscriptionID) != null) {
 415             String response;
 416             response = transport.execute(
 417                     SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.EVENT).addFunction(FunctionKeys.SUBSCRIBE)
 418                             .addParameter(ParameterKeys.TOKEN, token).addParameter(ParameterKeys.NAME, name)
 419                             .addParameter(ParameterKeys.SUBSCRIPTIONID,
 420                                     SimpleRequestBuilder.objectToString(subscriptionID))
 421                             .buildRequestString(),
 422                     connectionTimeout, readTimeout);
 423             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 424         }
 425         return false;
 426     }
 427
 428     @Override
 429     public boolean unsubscribeEvent(String token, String name, Integer subscriptionID, int connectionTimeout,
 430             int readTimeout) {
 431         if (name != null && !name.isBlank() && SimpleRequestBuilder.objectToString(subscriptionID) != null) {
 432             String response;
 433             response = transport.execute(
 434                     SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.EVENT).addFunction(FunctionKeys.UNSUBSCRIBE)
 435                             .addParameter(ParameterKeys.TOKEN, token).addParameter(ParameterKeys.NAME, name)
 436                             .addParameter(ParameterKeys.SUBSCRIPTIONID,
 437                                     SimpleRequestBuilder.objectToString(subscriptionID))
 438                             .buildRequestString(),
 439                     connectionTimeout, readTimeout);
 440             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 441         }
 442         return false;
 443     }
 444
 445     @Override
 446     public String getEvent(String token, Integer subscriptionID, Integer timeout) {
 447         if (SimpleRequestBuilder.objectToString(subscriptionID) != null) {
 448             return transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.EVENT)
 449                     .addFunction(FunctionKeys.GET).addParameter(ParameterKeys.TOKEN, token)
 450                     .addParameter(ParameterKeys.SUBSCRIPTIONID, SimpleRequestBuilder.objectToString(subscriptionID))
 451                     .addParameter(ParameterKeys.TIMEOUT, SimpleRequestBuilder.objectToString(timeout))
 452                     .buildRequestString());
 453         }
 454         return null;
 455     }
 456
 457     @Override
 458     public int getTime(String token) {
 459         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.SYSTEM)
 460                 .addFunction(FunctionKeys.TIME).addParameter(ParameterKeys.TOKEN, token).buildRequestString());
 461         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 462
 463         if (JSONResponseHandler.checkResponse(responseObj)) {
 464             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 465
 466             if (checkBlankField(obj, JSONApiResponseKeysEnum.TIME.getKey())) {
 467                 return obj.get(JSONApiResponseKeysEnum.TIME.getKey()).getAsInt();
 468             }
 469         }
 470         return -1;
 471     }
 472
 473     @Override
 474     public List<Integer> getResolutions(String token) {
 475         String response = transport.execute(
 476                 SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.METERING).addFunction(FunctionKeys.GET_RESOLUTIONS)
 477                         .addParameter(ParameterKeys.TOKEN, token).buildRequestString());
 478
 479         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 480
 481         if (JSONResponseHandler.checkResponse(responseObj)) {
 482             JsonObject resObj = JSONResponseHandler.getResultJsonObject(responseObj);
 483             if (resObj != null && resObj.get(JSONApiResponseKeysEnum.RESOLUTIONS.getKey()) instanceof JsonArray) {
 484                 JsonArray array = (JsonArray) resObj.get(JSONApiResponseKeysEnum.RESOLUTIONS.getKey());
 485
 486                 List<Integer> resolutionList = new LinkedList<>();
 487                 for (int i = 0; i < array.size(); i++) {
 488                     if (array.get(i) instanceof JsonObject) {
 489                         JsonObject jObject = (JsonObject) array.get(i);
 490
 491                         if (jObject.get(JSONApiResponseKeysEnum.RESOLUTION.getKey()) != null) {
 492                             int val = jObject.get(JSONApiResponseKeysEnum.RESOLUTION.getKey()).getAsInt();
 493                             if (val != -1) {
 494                                 resolutionList.add(val);
 495                             }
 496                         }
 497                     }
 498                 }
 499                 return resolutionList;
 500             }
 501         }
 502         return null;
 503     }
 504
 505     @Override
 506     public List<CachedMeteringValue> getLatest(String token, MeteringTypeEnum type, List<String> meterDSIDs,
 507             MeteringUnitsEnum unit) {
 508         if (meterDSIDs != null) {
 509             String jsonMeterList = ".meters(";
 510             for (int i = 0; i < meterDSIDs.size(); i++) {
 511                 if (!meterDSIDs.get(i).isEmpty()) {
 512                     jsonMeterList += meterDSIDs.get(i);
 513                     if (i < meterDSIDs.size() - 1 && !meterDSIDs.get(i + 1).isEmpty()) {
 514                         jsonMeterList += ",";
 515                     } else {
 516                         break;
 517                     }
 518                 }
 519             }
 520             jsonMeterList += ")";
 521             return getLatest(token, type, jsonMeterList, unit);
 522         }
 523         return null;
 524     }
 525
 526     @Override
 527     public List<CachedMeteringValue> getLatest(String token, MeteringTypeEnum type, String meterDSIDs,
 528             MeteringUnitsEnum unit) {
 529         if (type != null && meterDSIDs != null) {
 530             String unitstring = null;
 531             if (unit != null) {
 532                 unitstring = unit.unit;
 533             }
 534             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.METERING)
 535                     .addFunction(FunctionKeys.GET_LATEST).addParameter(ParameterKeys.TOKEN, token)
 536                     .addParameter(ParameterKeys.TYPE, SimpleRequestBuilder.objectToString(type).toLowerCase())
 537                     .addParameter(ParameterKeys.FROM, meterDSIDs).addParameter(ParameterKeys.UNIT, unitstring)
 538                     .buildRequestString());
 539
 540             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 541             if (JSONResponseHandler.checkResponse(responseObj)) {
 542                 JsonObject latestObj = JSONResponseHandler.getResultJsonObject(responseObj);
 543                 if (latestObj != null && latestObj.get(JSONApiResponseKeysEnum.VALUES.getKey()) instanceof JsonArray) {
 544                     JsonArray array = (JsonArray) latestObj.get(JSONApiResponseKeysEnum.VALUES.getKey());
 545
 546                     List<CachedMeteringValue> list = new LinkedList<>();
 547                     for (int i = 0; i < array.size(); i++) {
 548                         if (array.get(i) instanceof JsonObject) {
 549                             list.add(new JSONCachedMeteringValueImpl((JsonObject) array.get(i), type, unit));
 550                         }
 551                     }
 552                     return list;
 553                 }
 554             }
 555         }
 556         return null;
 557     }
 558
 559     @Override
 560     public boolean setDeviceValue(String token, DSID dSID, String dSUID, String name, Integer value) {
 561         if (checkRequiredDevice(dSID, dSUID, name)) {
 562             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.DEVICE)
 563                     .addFunction(FunctionKeys.SET_VALUE).addParameter(ParameterKeys.TOKEN, token)
 564                     .addParameter(ParameterKeys.DSID, SimpleRequestBuilder.objectToString(dSID))
 565                     .addParameter(ParameterKeys.DSUID, dSUID).addParameter(ParameterKeys.NAME, name)
 566                     .addParameter(ParameterKeys.VALUE, value.toString()).buildRequestString());
 567             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 568         }
 569         return false;
 570     }
 571
 572     @Override
 573     public List<String> getMeterList(String token) {
 574         List<String> meterList = new LinkedList<>();
 575         JsonObject responseObj = query(token, QUERY_GET_METERLIST);
 576         if (responseObj != null && responseObj.get(JSONApiResponseKeysEnum.DS_METERS.getKey()).isJsonArray()) {
 577             JsonArray array = responseObj.get(JSONApiResponseKeysEnum.DS_METERS.getKey()).getAsJsonArray();
 578             for (int i = 0; i < array.size(); i++) {
 579                 if (array.get(i) instanceof JsonObject) {
 580                     meterList.add(array.get(i).getAsJsonObject().get("dSID").getAsString());
 581                 }
 582             }
 583         }
 584         return meterList;
 585     }
 586
 587     @Override
 588     public String loginApplication(String loginToken) {
 589         if (loginToken != null && !loginToken.isBlank()) {
 590             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 591                     .addRequestClass(ClassKeys.SYSTEM).addFunction(FunctionKeys.LOGIN_APPLICATION)
 592                     .addParameter(ParameterKeys.LOGIN_TOKEN, loginToken).buildRequestString());
 593             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 594
 595             if (JSONResponseHandler.checkResponse(responseObj)) {
 596                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 597                 String tokenStr = null;
 598
 599                 if (checkBlankField(obj, JSONApiResponseKeysEnum.TOKEN.getKey())) {
 600                     tokenStr = obj.get(JSONApiResponseKeysEnum.TOKEN.getKey()).getAsString();
 601                 }
 602                 if (tokenStr != null) {
 603                     return tokenStr;
 604                 }
 605             }
 606         }
 607         return null;
 608     }
 609
 610     @Override
 611     public String login(String user, String password) {
 612         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.SYSTEM)
 613                 .addFunction(FunctionKeys.LOGIN).addParameter(ParameterKeys.USER, user)
 614                 .addParameter(ParameterKeys.PASSWORD, password).buildRequestString());
 615         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 616
 617         if (JSONResponseHandler.checkResponse(responseObj)) {
 618             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 619             String tokenStr = null;
 620
 621             if (checkBlankField(obj, JSONApiResponseKeysEnum.TOKEN.getKey())) {
 622                 tokenStr = obj.get(JSONApiResponseKeysEnum.TOKEN.getKey()).getAsString();
 623             }
 624             if (tokenStr != null) {
 625                 return tokenStr;
 626             }
 627         }
 628
 629         return null;
 630     }
 631
 632     @Override
 633     public boolean logout() {
 634         String response;
 635         response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.SYSTEM)
 636                 .addFunction(FunctionKeys.LOGOUT).buildRequestString());
 637         return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 638     }
 639
 640     @Override
 641     public Map<String, String> getDSID(String token) {
 642         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.SYSTEM)
 643                 .addFunction(FunctionKeys.GET_DSID).addParameter(ParameterKeys.TOKEN, token).buildRequestString());
 644         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 645
 646         if (JSONResponseHandler.checkResponse(responseObj)) {
 647             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 648             if (obj != null) {
 649                 Map<String, String> dsidMap = new HashMap<>(obj.entrySet().size());
 650                 for (Entry<String, JsonElement> entry : obj.entrySet()) {
 651                     dsidMap.put(entry.getKey(), entry.getValue().getAsString());
 652                 }
 653                 return dsidMap;
 654             }
 655         }
 656         return null;
 657     }
 658
 659     @Override
 660     public boolean enableApplicationToken(String applicationToken, String sessionToken) {
 661         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.SYSTEM)
 662                 .addFunction(FunctionKeys.ENABLE_APPLICATION_TOKEN).addParameter(ParameterKeys.TOKEN, sessionToken)
 663                 .addParameter(ParameterKeys.APPLICATION_TOKEN, applicationToken).buildRequestString(),
 664                 Config.HIGH_CONNECTION_TIMEOUT, Config.HIGH_READ_TIMEOUT);
 665         return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 666     }
 667
 668     @Override
 669     public String requestAppplicationToken(String applicationName) {
 670         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.SYSTEM)
 671                 .addFunction(FunctionKeys.REQUEST_APPLICATION_TOKEN)
 672                 .addParameter(ParameterKeys.APPLICATION_NAME, applicationName).buildRequestString());
 673
 674         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 675         if (JSONResponseHandler.checkResponse(responseObj)) {
 676             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 677             if (obj != null) {
 678                 return obj.get(JSONApiResponseKeysEnum.APPLICATION_TOKEN.getKey()).getAsString();
 679             }
 680         }
 681         return null;
 682     }
 683
 684     @Override
 685     public boolean revokeToken(String applicationToken, String sessionToken) {
 686         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.SYSTEM)
 687                 .addFunction(FunctionKeys.REVOKE_TOKEN).addParameter(ParameterKeys.APPLICATION_TOKEN, applicationToken)
 688                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
 689         return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 690     }
 691
 692     @Override
 693     public int checkConnection(String token) {
 694         return transport.checkConnection(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
 695                 .addFunction(FunctionKeys.GET_NAME).addParameter(ParameterKeys.TOKEN, token).buildRequestString());
 696     }
 697
 698     @Override
 699     public int[] getSceneValue(String token, DSID dSID, String dSUID, String name, Short sceneId) {
 700         int[] value = { -1, -1 };
 701         if (checkRequiredDevice(dSID, dSUID, name)) {
 702             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.DEVICE)
 703                     .addFunction(FunctionKeys.GET_SCENE_VALUE).addDefaultDeviceParameter(token, dSID, dSUID, name)
 704                     .addParameter(ParameterKeys.SCENE_ID, SimpleRequestBuilder.objectToString(sceneId))
 705                     .buildRequestString(), Config.DEFAULT_CONNECTION_TIMEOUT, Config.HIGH_READ_TIMEOUT);
 706             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 707
 708             if (JSONResponseHandler.checkResponse(responseObj)) {
 709                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 710                 if (obj != null && obj.get(JSONApiResponseKeysEnum.VALUE.getKey()) != null) {
 711                     value[GeneralLibConstance.SCENE_ARRAY_INDEX_VALUE] = obj.get(JSONApiResponseKeysEnum.VALUE.getKey())
 712                             .getAsInt();
 713                     if (obj.get(JSONApiResponseKeysEnum.ANGLE.getKey()) != null) {
 714                         value[GeneralLibConstance.SCENE_ARRAY_INDEX_ANGLE] = obj
 715                                 .get(JSONApiResponseKeysEnum.ANGLE.getKey()).getAsInt();
 716                     }
 717                     return value;
 718                 }
 719             }
 720         }
 721         return value;
 722     }
 723
 724     @Override
 725     public boolean increaseValue(String sessionToken, DSID dSID, String dSUID, String name) {
 726         if (checkRequiredDevice(dSID, dSUID, name)) {
 727             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 728                     .addRequestClass(ClassKeys.DEVICE).addFunction(FunctionKeys.INCREASE_VALUE)
 729                     .addDefaultDeviceParameter(sessionToken, dSID, dSUID, name).buildRequestString());
 730             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 731         }
 732         return false;
 733     }
 734
 735     @Override
 736     public boolean decreaseValue(String sessionToken, DSID dSID, String dSUID, String name) {
 737         if (checkRequiredDevice(dSID, dSUID, name)) {
 738             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 739                     .addRequestClass(ClassKeys.DEVICE).addFunction(FunctionKeys.DECREASE_VALUE)
 740                     .addDefaultDeviceParameter(sessionToken, dSID, dSUID, name).buildRequestString());
 741             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 742         }
 743         return false;
 744     }
 745
 746     @Override
 747     public String getInstallationName(String sessionToken) {
 748         String response = null;
 749         try {
 750             response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 751                     .addRequestClass(ClassKeys.APARTMENT).addFunction(FunctionKeys.GET_NAME)
 752                     .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
 753         } catch (Exception e) {
 754             logger.debug("An exception occurred", e);
 755
 756         }
 757         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 758
 759         if (JSONResponseHandler.checkResponse(responseObj)) {
 760             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 761             if (checkBlankField(obj, JSONApiResponseKeysEnum.NAME.getKey())) {
 762                 return obj.get(JSONApiResponseKeysEnum.NAME.getKey()).getAsString();
 763             }
 764         }
 765         return null;
 766     }
 767
 768     @Override
 769     public String getZoneName(String sessionToken, Integer zoneID) {
 770         if (checkRequiredZone(zoneID, null)) {
 771             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 772                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.GET_NAME)
 773                     .addParameter(ParameterKeys.ID, SimpleRequestBuilder.objectToString(zoneID))
 774                     .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
 775             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 776
 777             if (JSONResponseHandler.checkResponse(responseObj)) {
 778                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 779                 if (checkBlankField(obj, JSONApiResponseKeysEnum.NAME.getKey())) {
 780                     return obj.get(JSONApiResponseKeysEnum.NAME.getKey()).getAsString();
 781                 }
 782             }
 783         }
 784         return null;
 785     }
 786
 787     @Override
 788     public String getDeviceName(String sessionToken, DSID dSID, String dSUID) {
 789         if (checkRequiredDevice(dSID, dSUID, null)) {
 790             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 791                     .addRequestClass(ClassKeys.DEVICE).addFunction(FunctionKeys.GET_NAME)
 792                     .addDefaultDeviceParameter(sessionToken, dSID, dSUID, null).buildRequestString());
 793             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 794
 795             if (JSONResponseHandler.checkResponse(responseObj)) {
 796                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 797                 if (checkBlankField(obj, JSONApiResponseKeysEnum.NAME.getKey())) {
 798                     return obj.get(JSONApiResponseKeysEnum.NAME.getKey()).getAsString();
 799                 }
 800             }
 801         }
 802         return null;
 803     }
 804
 805     @Override
 806     public String getCircuitName(String sessionToken, DSID dSID) {
 807         String response = transport
 808                 .execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.CIRCUIT).addFunction(FunctionKeys.GET_NAME)
 809                         .addParameter(ParameterKeys.DSID, SimpleRequestBuilder.objectToString(dSID))
 810                         .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
 811         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 812
 813         if (JSONResponseHandler.checkResponse(responseObj)) {
 814             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 815             if (checkBlankField(obj, JSONApiResponseKeysEnum.NAME.getKey())) {
 816                 return obj.get(JSONApiResponseKeysEnum.NAME.getKey()).getAsString();
 817             }
 818         }
 819
 820         return null;
 821     }
 822
 823     @Override
 824     public String getSceneName(String sessionToken, Integer zoneID, String zoneName, Short groupID, Short sceneID) {
 825         if (checkRequiredZone(zoneID, zoneName)) {
 826             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 827                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.SCENE_GET_NAME)
 828                     .addDefaultZoneGroupParameter(sessionToken, zoneID, zoneName, groupID, null)
 829                     .addParameter(ParameterKeys.SCENENUMBER, SimpleRequestBuilder.objectToString(sceneID))
 830                     .buildRequestString());
 831             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 832
 833             if (JSONResponseHandler.checkResponse(responseObj)) {
 834                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 835                 if (checkBlankField(obj, JSONApiResponseKeysEnum.NAME.getKey())) {
 836                     return obj.get(JSONApiResponseKeysEnum.NAME.getKey()).getAsString();
 837                 }
 838             }
 839         }
 840         return null;
 841     }
 842
 843     @Override
 844     public TemperatureControlStatus getZoneTemperatureControlStatus(String sessionToken, Integer zoneID,
 845             String zoneName) {
 846         if (checkRequiredZone(zoneID, zoneName)) {
 847             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.ZONE)
 848                     .addFunction(FunctionKeys.GET_TEMPERATURE_CONTROL_STATUS)
 849                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName).buildRequestString());
 850             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 851
 852             if (JSONResponseHandler.checkResponse(responseObj)) {
 853                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 854                 return new TemperatureControlStatus(obj, zoneID, zoneName);
 855             }
 856         }
 857         return null;
 858     }
 859
 860     @Override
 861     public TemperatureControlConfig getZoneTemperatureControlConfig(String sessionToken, Integer zoneID,
 862             String zoneName) {
 863         if (checkRequiredZone(zoneID, zoneName)) {
 864             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 865                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.GET_TEMPERATURE_CONTROL_CONFIG)
 866                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName).buildRequestString());
 867             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 868
 869             if (JSONResponseHandler.checkResponse(responseObj)) {
 870                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 871                 return new TemperatureControlConfig(obj, zoneID, zoneName);
 872             }
 873         }
 874         return null;
 875     }
 876
 877     @Override
 878     public TemperatureControlValues getZoneTemperatureControlValues(String sessionToken, Integer zoneID,
 879             String zoneName) {
 880         if (checkRequiredZone(zoneID, zoneName)) {
 881             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 882                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.GET_TEMPERATURE_CONTROL_VALUES)
 883                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName).buildRequestString());
 884             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 885
 886             if (JSONResponseHandler.checkResponse(responseObj)) {
 887                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 888                 return new TemperatureControlValues(obj, zoneID, zoneName);
 889             }
 890         }
 891         return null;
 892     }
 893
 894     @Override
 895     public AssignedSensors getZoneAssignedSensors(String sessionToken, Integer zoneID, String zoneName) {
 896         if (checkRequiredZone(zoneID, zoneName)) {
 897             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 898                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.GET_ASSIGNED_SENSORS)
 899                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName).buildRequestString());
 900             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 901
 902             if (JSONResponseHandler.checkResponse(responseObj)) {
 903                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 904                 return new AssignedSensors(obj, zoneID, zoneName);
 905             }
 906         }
 907         return null;
 908     }
 909
 910     @Override
 911     public boolean setZoneTemperatureControlState(String sessionToken, Integer zoneID, String controlState,
 912             String zoneName) {
 913         if (checkRequiredZone(zoneID, zoneName)) {
 914             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 915                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.SET_TEMEPERATURE_CONTROL_STATE)
 916                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName)
 917                     .addParameter(ParameterKeys.CONTROL_STATE, controlState).buildRequestString());
 918
 919             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 920         }
 921         return false;
 922     }
 923
 924     @Override
 925     public boolean setZoneTemperatureControlValues(String sessionToken, Integer zoneID, String zoneName,
 926             List<Object[]> controlValues) {
 927         if (checkRequiredZone(zoneID, zoneName)) {
 928             if (checkRequiredZone(zoneID, zoneName)) {
 929                 if (controlValues != null) {
 930                     SimpleRequestBuilder builder = SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 931                             .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.SET_TEMEPERATURE_CONTROL_VALUE)
 932                             .addDefaultZoneParameter(sessionToken, zoneID, zoneName);
 933                     for (Object[] objAry : controlValues) {
 934                         if (objAry.length == 2 && objAry[0] instanceof String && objAry[1] instanceof Integer) {
 935                             builder.addParameter((String) objAry[0], SimpleRequestBuilder.objectToString(objAry[1]));
 936                         } else {
 937                             builder.buildRequestString();
 938                             throw new IllegalArgumentException(
 939                                     "The first field of the object array have to be a String and the second have to be an Integer.");
 940                         }
 941                     }
 942                     String response = transport.execute(builder.buildRequestString());
 943
 944                     return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 945                 }
 946             }
 947         }
 948         return false;
 949     }
 950
 951     @Override
 952     public SensorValues getZoneSensorValues(String sessionToken, Integer zoneID, String zoneName) {
 953         if (checkRequiredZone(zoneID, zoneName)) {
 954             String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.ZONE)
 955                     .addFunction(FunctionKeys.GET_SENSOR_VALUES).addParameter(ParameterKeys.TOKEN, sessionToken)
 956                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName).buildRequestString());
 957             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
 958
 959             if (JSONResponseHandler.checkResponse(responseObj)) {
 960                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
 961                 return new SensorValues(obj, zoneID, zoneName);
 962             }
 963         }
 964         return null;
 965     }
 966
 967     @Override
 968     public boolean setZoneTemperatureControlConfig(String sessionToken, Integer zoneID, String zoneName,
 969             String controlDSUID, Short controlMode, Integer referenceZone, Float ctrlOffset, Float emergencyValue,
 970             Float manualValue, Float ctrlKp, Float ctrlTs, Float ctrlTi, Float ctrlKd, Float ctrlImin, Float ctrlImax,
 971             Float ctrlYmin, Float ctrlYmax, Boolean ctrlAntiWindUp, Boolean ctrlKeepFloorWarm) {
 972         if (checkRequiredZone(zoneID, zoneName)) {
 973             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
 974                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.SET_TEMPERATION_CONTROL_CONFIG)
 975                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName)
 976                     .addParameter(ParameterKeys.CONTROL_MODE, SimpleRequestBuilder.objectToString(controlMode))
 977                     .addParameter(ParameterKeys.CONTROL_DSUID, controlDSUID)
 978                     .addParameter(ParameterKeys.REFERENCE_ZONE, SimpleRequestBuilder.objectToString(referenceZone))
 979                     .addParameter(ParameterKeys.CTRL_OFFSET, SimpleRequestBuilder.objectToString(ctrlOffset))
 980                     .addParameter(ParameterKeys.EMERGENCY_VALUE, SimpleRequestBuilder.objectToString(emergencyValue))
 981                     .addParameter(ParameterKeys.MANUAL_VALUE, SimpleRequestBuilder.objectToString(manualValue))
 982                     .addParameter(ParameterKeys.CTRL_KP, SimpleRequestBuilder.objectToString(ctrlKp))
 983                     .addParameter(ParameterKeys.CTRL_TS, SimpleRequestBuilder.objectToString(ctrlTs))
 984                     .addParameter(ParameterKeys.CTRL_TI, SimpleRequestBuilder.objectToString(ctrlTi))
 985                     .addParameter(ParameterKeys.CTRL_KD, SimpleRequestBuilder.objectToString(ctrlKd))
 986                     .addParameter(ParameterKeys.CTRL_I_MIN, SimpleRequestBuilder.objectToString(ctrlImin))
 987                     .addParameter(ParameterKeys.CTRL_I_MAX, SimpleRequestBuilder.objectToString(ctrlImax))
 988                     .addParameter(ParameterKeys.CTRL_Y_MIN, SimpleRequestBuilder.objectToString(ctrlYmin))
 989                     .addParameter(ParameterKeys.CTRL_Y_MAX, SimpleRequestBuilder.objectToString(ctrlYmax))
 990                     .addParameter(ParameterKeys.CTRL_ANTI_WIND_UP, SimpleRequestBuilder.objectToString(ctrlAntiWindUp))
 991                     .addParameter(ParameterKeys.CTRL_KEEP_FLOOR_WARM,
 992                             SimpleRequestBuilder.objectToString(ctrlKeepFloorWarm))
 993                     .buildRequestString());
 994
 995             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
 996         }
 997         return false;
 998     }
 999
1000     @Override
1001     public boolean setZoneSensorSource(String sessionToken, Integer zoneID, String zoneName, SensorEnum sensorType,
1002             DSID dSID) {
1003         if (checkRequiredZone(zoneID, zoneName)) {
1004             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
1005                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.SET_SENSOR_SOURCE)
1006                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName)
1007                     .addParameter(ParameterKeys.SENSOR_TYPE, sensorType.getSensorType().toString())
1008                     .addParameter(ParameterKeys.DSID, SimpleRequestBuilder.objectToString(dSID)).buildRequestString());
1009
1010             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
1011         }
1012         return false;
1013     }
1014
1015     @Override
1016     public boolean clearZoneSensorSource(String sessionToken, Integer zoneID, String zoneName, SensorEnum sensorType) {
1017         if (checkRequiredZone(zoneID, zoneName)) {
1018             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
1019                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.SET_TEMEPERATURE_CONTROL_VALUE)
1020                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName)
1021                     .addParameter(ParameterKeys.SENSOR_TYPE, sensorType.getSensorType().toString())
1022                     .buildRequestString());
1023
1024             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
1025         }
1026         return false;
1027     }
1028
1029     @Override
1030     public TemperatureControlInternals getZoneTemperatureControlInternals(String sessionToken, Integer zoneID,
1031             String zoneName) {
1032         if (checkRequiredZone(zoneID, zoneName)) {
1033             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
1034                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.GET_TEMPERATURE_CONTROL_INTERNALS)
1035                     .addDefaultZoneParameter(sessionToken, zoneID, zoneName).buildRequestString());
1036             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1037
1038             if (JSONResponseHandler.checkResponse(responseObj)) {
1039                 JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
1040                 return new TemperatureControlInternals(obj, zoneID, zoneName);
1041             }
1042         }
1043         return null;
1044     }
1045
1046     @Override
1047     public boolean setZoneOutputValue(String sessionToken, Integer zoneID, String zoneName, Short groupID,
1048             String groupName, Integer value) {
1049         if (value != null && checkRequiredZone(zoneID, zoneName)) {
1050             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
1051                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.SET_OUTPUT_VALUE)
1052                     .addParameter(ParameterKeys.TOKEN, sessionToken).addParameter(ParameterKeys.NAME, zoneName)
1053                     .addDefaultZoneGroupParameter(sessionToken, zoneID, zoneName, groupID, groupName)
1054                     .addParameter(ParameterKeys.VALUE, SimpleRequestBuilder.objectToString(value))
1055                     .buildRequestString());
1056             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1057
1058             if (JSONResponseHandler.checkResponse(responseObj)) {
1059                 return true;
1060             }
1061         }
1062         return false;
1063     }
1064
1065     @Override
1066     public boolean zoneBlink(String sessionToken, Integer zoneID, String zoneName, Short groupID, String groupName) {
1067         if (checkRequiredZone(zoneID, zoneName)) {
1068             String response = transport.execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON)
1069                     .addRequestClass(ClassKeys.ZONE).addFunction(FunctionKeys.BLINK)
1070                     .addDefaultZoneGroupParameter(sessionToken, zoneID, zoneName, groupID, groupName)
1071                     .buildRequestString());
1072             JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1073
1074             if (JSONResponseHandler.checkResponse(responseObj)) {
1075                 return true;
1076             }
1077         }
1078         return false;
1079     }
1080
1081     @Override
1082     public boolean pushZoneSensorValue(String sessionToken, Integer zoneID, String zoneName, Short groupID,
1083             String sourceDSUID, Float sensorValue, SensorEnum sensorType) {
1084         if (checkRequiredZone(zoneID, zoneName) && sensorType != null && sensorValue != null) {
1085             String response = transport
1086                     .execute(SimpleRequestBuilder.buildNewRequest(InterfaceKeys.JSON).addRequestClass(ClassKeys.ZONE)
1087                             .addFunction(FunctionKeys.PUSH_SENSOR_VALUE)
1088                             .addDefaultZoneGroupParameter(sessionToken, zoneID, zoneName, groupID, null)
1089                             .addParameter(ParameterKeys.SOURCE_DSUID, sourceDSUID)
1090                             .addParameter(ParameterKeys.SENSOR_VALUE, SimpleRequestBuilder.objectToString(sensorValue))
1091                             .addParameter(ParameterKeys.SENSOR_TYPE,
1092                                     SimpleRequestBuilder.objectToString(sensorType.getSensorType()))
1093                             .buildRequestString());
1094             return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
1095         }
1096         return false;
1097     }
1098
1099     @Override
1100     public List<TemperatureControlStatus> getApartmentTemperatureControlStatus(String sessionToken) {
1101         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
1102                 .addFunction(FunctionKeys.GET_TEMPERATURE_CONTROL_STATUS)
1103                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1104         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1105
1106         if (JSONResponseHandler.checkResponse(responseObj)) {
1107             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
1108             if (obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).isJsonArray()) {
1109                 JsonArray jArray = obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).getAsJsonArray();
1110                 if (jArray.size() != 0) {
1111                     List<TemperatureControlStatus> list = new ArrayList<>(jArray.size());
1112                     Iterator<JsonElement> iter = jArray.iterator();
1113                     while (iter.hasNext()) {
1114                         TemperatureControlStatus tContStat = new TemperatureControlStatus(
1115                                 iter.next().getAsJsonObject());
1116                         list.add(tContStat);
1117                     }
1118                     return list;
1119                 }
1120             }
1121         }
1122         return null;
1123     }
1124
1125     @Override
1126     public Map<Integer, TemperatureControlConfig> getApartmentTemperatureControlConfig(String sessionToken) {
1127         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
1128                 .addFunction(FunctionKeys.GET_TEMPERATURE_CONTROL_CONFIG)
1129                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1130         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1131
1132         if (JSONResponseHandler.checkResponse(responseObj)) {
1133             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
1134             if (obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).isJsonArray()) {
1135                 JsonArray jArray = obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).getAsJsonArray();
1136                 if (jArray.size() != 0) {
1137                     Map<Integer, TemperatureControlConfig> map = new HashMap<>(jArray.size());
1138                     Iterator<JsonElement> iter = jArray.iterator();
1139                     while (iter.hasNext()) {
1140                         TemperatureControlConfig tContConf = new TemperatureControlConfig(
1141                                 iter.next().getAsJsonObject());
1142                         map.put(tContConf.getZoneID(), tContConf);
1143                     }
1144                     return map;
1145                 }
1146             }
1147         }
1148         return null;
1149     }
1150
1151     @Override
1152     public Map<Integer, TemperatureControlValues> getApartmentTemperatureControlValues(String sessionToken) {
1153         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
1154                 .addFunction(FunctionKeys.GET_TEMPERATURE_CONTROL_VALUES)
1155                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1156         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1157
1158         if (JSONResponseHandler.checkResponse(responseObj)) {
1159             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
1160             if (obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).isJsonArray()) {
1161                 JsonArray jArray = obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).getAsJsonArray();
1162                 if (jArray.size() != 0) {
1163                     Map<Integer, TemperatureControlValues> map = new HashMap<>(jArray.size());
1164                     Iterator<JsonElement> iter = jArray.iterator();
1165                     while (iter.hasNext()) {
1166                         TemperatureControlValues tContVal = new TemperatureControlValues(iter.next().getAsJsonObject());
1167                         map.put(tContVal.getZoneID(), tContVal);
1168                     }
1169                     return map;
1170                 }
1171             }
1172         }
1173         return null;
1174     }
1175
1176     @Override
1177     public Map<Integer, AssignedSensors> getApartmentAssignedSensors(String sessionToken) {
1178         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
1179                 .addFunction(FunctionKeys.GET_ASSIGNED_SENSORS).addParameter(ParameterKeys.TOKEN, sessionToken)
1180                 .buildRequestString());
1181         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1182
1183         if (JSONResponseHandler.checkResponse(responseObj)) {
1184             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
1185             if (obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).isJsonArray()) {
1186                 JsonArray jArray = obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).getAsJsonArray();
1187                 if (jArray.size() != 0) {
1188                     HashMap<Integer, AssignedSensors> map = new HashMap<>(jArray.size());
1189                     Iterator<JsonElement> iter = jArray.iterator();
1190                     while (iter.hasNext()) {
1191                         AssignedSensors assignedSensors = new AssignedSensors(iter.next().getAsJsonObject());
1192                         map.put(assignedSensors.getZoneID(), assignedSensors);
1193                     }
1194                     return map;
1195                 }
1196             }
1197         }
1198         return null;
1199     }
1200
1201     @Override
1202     public Map<Integer, BaseSensorValues> getApartmentSensorValues(String sessionToken) {
1203         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.APARTMENT)
1204                 .addFunction(FunctionKeys.GET_SENSOR_VALUES).addParameter(ParameterKeys.TOKEN, sessionToken)
1205                 .buildRequestString());
1206         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1207
1208         if (JSONResponseHandler.checkResponse(responseObj)) {
1209             JsonObject obj = JSONResponseHandler.getResultJsonObject(responseObj);
1210             if (obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).isJsonArray()) {
1211                 JsonArray jArray = obj.get(JSONApiResponseKeysEnum.ZONES.getKey()).getAsJsonArray();
1212                 WeatherSensorData weather = new WeatherSensorData(obj);
1213                 if (jArray.size() != 0) {
1214                     HashMap<Integer, BaseSensorValues> map = new HashMap<>(jArray.size() + 1);
1215                     Iterator<JsonElement> iter = jArray.iterator();
1216                     while (iter.hasNext()) {
1217                         SensorValues sensorValues = new SensorValues(iter.next().getAsJsonObject());
1218                         map.put(sensorValues.getZoneID(), sensorValues);
1219                     }
1220                     map.put(GeneralLibConstance.BROADCAST_ZONE_GROUP_ID, weather);
1221                     return map;
1222                 }
1223             }
1224         }
1225         return null;
1226     }
1227
1228     @Override
1229     public JsonObject query(String sessionToken, String query) {
1230         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1231                 .addFunction(FunctionKeys.QUERY).addParameter(ParameterKeys.QUERY, query)
1232                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1233
1234         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1235         if (JSONResponseHandler.checkResponse(responseObj)) {
1236             return JSONResponseHandler.getResultJsonObject(responseObj);
1237         }
1238         return null;
1239     }
1240
1241     @Override
1242     public JsonObject query2(String sessionToken, String query) {
1243         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1244                 .addFunction(FunctionKeys.QUERY2).addParameter(ParameterKeys.QUERY, query)
1245                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1246
1247         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1248         if (JSONResponseHandler.checkResponse(responseObj)) {
1249             return JSONResponseHandler.getResultJsonObject(responseObj);
1250         }
1251         return null;
1252     }
1253
1254     @Override
1255     public String propertyTreeGetString(String sessionToken, String path) {
1256         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1257                 .addFunction(FunctionKeys.GET_STRING).addParameter(ParameterKeys.PATH, path)
1258                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1259
1260         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1261         if (JSONResponseHandler.checkResponse(responseObj)) {
1262             responseObj = JSONResponseHandler.getResultJsonObject(responseObj);
1263             return responseObj.get(JSONApiResponseKeysEnum.VALUE.getKey()).getAsString();
1264         }
1265         return null;
1266     }
1267
1268     @Override
1269     public Boolean propertyTreeSetString(String token, String path, String value) {
1270         String response = transport.execute(
1271                 SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE).addFunction(FunctionKeys.SET_STRING)
1272                         .addParameter(ParameterKeys.PATH, path).addParameter(ParameterKeys.TOKEN, token)
1273                         .addParameter(ParameterKeys.VALUE, value).buildRequestString());
1274
1275         return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
1276     }
1277
1278     @Override
1279     public JsonArray propertyTreeGetChildren(String sessionToken, String path) {
1280         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1281                 .addFunction(FunctionKeys.GET_CHILDREN).addParameter(ParameterKeys.PATH, path)
1282                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1283
1284         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1285         if (JSONResponseHandler.checkResponse(responseObj)) {
1286             return responseObj.get(JSONApiResponseKeysEnum.RESULT.getKey()).getAsJsonArray();
1287         }
1288         return null;
1289     }
1290
1291     @Override
1292     public Integer propertyTreeGetInteger(String sessionToken, String path) {
1293         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1294                 .addFunction(FunctionKeys.GET_INTEGER).addParameter(ParameterKeys.PATH, path)
1295                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1296
1297         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1298         if (JSONResponseHandler.checkResponse(responseObj)) {
1299             responseObj = JSONResponseHandler.getResultJsonObject(responseObj);
1300             return responseObj.get(JSONApiResponseKeysEnum.VALUE.getKey()).getAsInt();
1301         }
1302         return null;
1303     }
1304
1305     @Override
1306     public Boolean propertyTreeSetInteger(String sessionToken, String path, Integer value) {
1307         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1308                 .addFunction(FunctionKeys.SET_INTEGER).addParameter(ParameterKeys.PATH, path)
1309                 .addParameter(ParameterKeys.TOKEN, sessionToken)
1310                 .addParameter(ParameterKeys.VALUE, SimpleRequestBuilder.objectToString(value)).buildRequestString());
1311
1312         return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
1313     }
1314
1315     @Override
1316     public Boolean propertyTreeGetBoolean(String sessionToken, String path) {
1317         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1318                 .addFunction(FunctionKeys.GET_BOOLEAN).addParameter(ParameterKeys.PATH, path)
1319                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1320
1321         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1322         if (JSONResponseHandler.checkResponse(responseObj)) {
1323             responseObj = JSONResponseHandler.getResultJsonObject(responseObj);
1324             return responseObj.get(JSONApiResponseKeysEnum.VALUE.getKey()).getAsBoolean();
1325         }
1326         return null;
1327     }
1328
1329     @Override
1330     public Boolean propertyTreeSetBoolean(String sessionToken, String path, Boolean value) {
1331         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1332                 .addFunction(FunctionKeys.SET_BOOLEAN).addParameter(ParameterKeys.PATH, path)
1333                 .addParameter(ParameterKeys.TOKEN, sessionToken)
1334                 .addParameter(ParameterKeys.VALUE, SimpleRequestBuilder.objectToString(value)).buildRequestString());
1335
1336         return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
1337     }
1338
1339     @Override
1340     public String propertyTreeGetType(String sessionToken, String path) {
1341         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1342                 .addFunction(FunctionKeys.GET_TYPE).addParameter(ParameterKeys.PATH, path)
1343                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1344
1345         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1346         if (JSONResponseHandler.checkResponse(responseObj)) {
1347             responseObj = JSONResponseHandler.getResultJsonObject(responseObj);
1348             return responseObj.get(JSONApiResponseKeysEnum.VALUE.getKey()).getAsString();
1349         }
1350         return null;
1351     }
1352
1353     @Override
1354     public Map<String, Boolean> propertyTreeGetFlages(String sessionToken, String path) {
1355         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1356                 .addFunction(FunctionKeys.GET_FLAGS).addParameter(ParameterKeys.PATH, path)
1357                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1358
1359         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1360         if (JSONResponseHandler.checkResponse(responseObj)) {
1361             responseObj = JSONResponseHandler.getResultJsonObject(responseObj);
1362             Set<Entry<String, JsonElement>> flagEntries = responseObj.entrySet();
1363             Map<String, Boolean> flags = new HashMap<>(flagEntries.size());
1364             for (Entry<String, JsonElement> flag : flagEntries) {
1365                 flags.put(flag.getKey(), flag.getValue().getAsBoolean());
1366             }
1367             return flags;
1368         }
1369         return null;
1370     }
1371
1372     @Override
1373     public Boolean propertyTreeSetFlag(String sessionToken, String path, String flag, Boolean value) {
1374         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1375                 .addFunction(FunctionKeys.SET_FLAG).addParameter(ParameterKeys.PATH, path)
1376                 .addParameter(ParameterKeys.TOKEN, sessionToken).addParameter(ParameterKeys.FLAG, flag)
1377                 .addParameter(ParameterKeys.VALUE, SimpleRequestBuilder.objectToString(value)).buildRequestString());
1378
1379         return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
1380     }
1381
1382     @Override
1383     public Boolean propertyTreeRemove(String sessionToken, String path) {
1384         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.PROPERTY_TREE)
1385                 .addFunction(FunctionKeys.REMOVE).addParameter(ParameterKeys.PATH, path)
1386                 .addParameter(ParameterKeys.TOKEN, sessionToken).buildRequestString());
1387
1388         return JSONResponseHandler.checkResponse(JSONResponseHandler.toJsonObject(response));
1389     }
1390
1391     @Override
1392     public Map<String, String> getSystemVersion() {
1393         String response = transport.execute(SimpleRequestBuilder.buildNewJsonRequest(ClassKeys.SYSTEM)
1394                 .addFunction(FunctionKeys.VERSION).buildRequestString());
1395
1396         JsonObject responseObj = JSONResponseHandler.toJsonObject(response);
1397         if (JSONResponseHandler.checkResponse(responseObj)) {
1398             Set<Entry<String, JsonElement>> entries = JSONResponseHandler.getResultJsonObject(responseObj).entrySet();
1399             Map<String, String> versions = new HashMap<>(entries.size());
1400             for (Entry<String, JsonElement> entry : entries) {
1401                 versions.put(entry.getKey(), entry.getValue().getAsString());
1402             }
1403             return versions;
1404         }
1405         return null;
1406     }
1407 }