iobroker.smartfriends 1.0.0

package/lib/comunication/SmartSocketFactory.js

@@ -0,0 +1,119 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+
+const SmartSocket = require("./SmartSocket");
+const fs = require("fs");
+const CommandFactory = require("./CommandFactory");
+const HashHelper = require("./HashHelper");
+const HeloResponse = require("./comModel/responseBody/HeloResponse");
+const LoginResponse = require("./comModel/responseBody/LoginResponse");
+class SmartSocketFactory {
+	static createSocketAndLogin(
+		that,
+		ipAddress,
+		port,
+		caFileName,
+		username,
+		password,
+		cSymbol,
+		shcVersion,
+		shApiVersion,
+		dataHandler,
+		startKeepAlive,
+		ignoreSslErrors,
+	) {
+		const returnPromise = new Promise((resolve, reject) => {
+			if (dataHandler) {
+				this.createSocket(that, ipAddress, port, caFileName, dataHandler, ignoreSslErrors)
+					.catch(reason => {
+						reject(reason);
+					})
+					.then(socket => {
+						if (socket) {
+							socket
+								.sendAndRecieveCommand(CommandFactory.default.createHeloCmd(username))
+								.then(responseHelo => {
+									if (responseHelo.response) {
+										const parsedResponseHelo = HeloResponse.default.fromObject(
+											responseHelo.response,
+										);
+										if (
+											parsedResponseHelo &&
+											parsedResponseHelo.salt &&
+											parsedResponseHelo.sessionSalt
+										) {
+											const digest = HashHelper.default.calculateDigest(
+												password,
+												parsedResponseHelo.salt,
+												parsedResponseHelo.sessionSalt,
+											);
+											socket
+												.sendAndRecieveCommand(
+													CommandFactory.default.createLoginCommand(
+														username,
+														digest,
+														cSymbol,
+														shcVersion,
+														shApiVersion,
+													),
+												)
+												.then(responseLogin => {
+													if (responseLogin.response) {
+														const parsedResponseLogin = LoginResponse.default.fromObject(
+															responseLogin.response,
+														);
+														if (parsedResponseLogin && parsedResponseLogin.sessionID) {
+															dataHandler.handleLoginMessage(parsedResponseLogin);
+															if (startKeepAlive) {
+																socket.startKeepAlive();
+															}
+															resolve(socket);
+														} else {
+															reject("JSON Parsing Message Error 4");
+														}
+													} else {
+														reject("JSON Parsing Message Error 3");
+													}
+												})
+												.catch(reason => {
+													reject(reason);
+												});
+										} else {
+											reject("JSON Parsing Message Error 2");
+										}
+									} else {
+										reject("JSON Parsing Message Error 1");
+									}
+								})
+								.catch(reason => {
+									reject(reason);
+								});
+						}
+					});
+			} else {
+				reject("Missing dataHandler. Needed for Login.");
+			}
+		});
+		return returnPromise;
+	}
+	static createSocket(that, ipAddress, port, caFileName, dataHandler, ignoreSslErrors) {
+		const caText = fs.readFileSync(`${__dirname}/${caFileName}`, "utf8");
+		const socket = new SmartSocket.SmartSocket(that, ipAddress, port, caText, ignoreSslErrors);
+		const returnPromise = new Promise((resolve, reject) => {
+			socket
+				.setupSocket(dataHandler)
+				.then(() => {
+					resolve(socket);
+				})
+				.catch(reason => {
+					reject(reason);
+				});
+		});
+		return returnPromise;
+	}
+}
+exports.default = SmartSocketFactory;

package/lib/comunication/comModel/JSONCommand.js

@@ -0,0 +1,21 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+//Wrapper for easily gernating JSON Commands
+//--------------------------------------------------
+
+class JSONCommand {
+	constructor(methode) {
+		this.command = methode;
+	}
+	toString(sessionID) {
+		if (sessionID) {
+			this.sessionID = sessionID;
+		}
+		return JSON.stringify(this);
+	}
+}
+exports.default = JSONCommand;

package/lib/comunication/comModel/JSONHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+//Helper Class for JSON Encode and Decode
+//--------------------------------------------------
+
+class JSONHelper {
+	static stringToDate(timestamp) {
+		if (timestamp) {
+			const splitTimestamp = timestamp.toString().split(/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/);
+			return new Date(
+				Number.parseInt(splitTimestamp[1]),
+				Number.parseInt(splitTimestamp[2]),
+				Number.parseInt(splitTimestamp[3]),
+				Number.parseInt(splitTimestamp[4]),
+				Number.parseInt(splitTimestamp[5]),
+				Number.parseInt(splitTimestamp[6]),
+			);
+		}
+	}
+	static dateToString(date) {
+		if (date && date.getTime() > 0) {
+			let returnNumber = 0;
+			returnNumber += date.getFullYear();
+			returnNumber *= 100;
+			returnNumber += date.getMonth();
+			returnNumber *= 100;
+			returnNumber += date.getDay();
+			returnNumber *= 100;
+			returnNumber += date.getHours();
+			returnNumber *= 100;
+			returnNumber += date.getMinutes();
+			returnNumber *= 100;
+			returnNumber += date.getSeconds();
+			return returnNumber.toString();
+		}
+		return "0";
+	}
+}
+exports.default = JSONHelper;

package/lib/comunication/comModel/JSONResponse.js

@@ -0,0 +1,43 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+//Wrapper for Response answers
+//--------------------------------------------------
+const JSONHelper = require("./JSONHelper.js");
+class JSONResponse {
+	constructor(currentTimestamp, response, responseCode, responseMessage) {
+		this.currentTimestamp = currentTimestamp;
+		this.response = response;
+		this.responseCode = responseCode;
+		this.responseMessage = responseMessage;
+	}
+	static fromJSONString(json) {
+		const jsonObject = JSON.parse(json);
+		return this.fromObject(jsonObject);
+	}
+	static fromObject(object) {
+		// e.g.: { "error" : { "message" : "The TLS/SSL connection has been closed", "responseCode" : 84 } }
+		if (object.error != null) {
+			return new JSONResponse(null, object.error, object.error.responseCode, object.error.message);
+		}
+
+		// e.g.: { "success" : { "messageId" : "remoteHome.connected", "responseCode" : 203 } }
+		if (object.success != null) {
+			return new JSONResponse(null, object.success, object.success.responseCode, object.success.messageId);
+		}
+
+		// e.g.: { "currentTimestamp" : 20201210140021, "response" : { "remoteHomeActivated" : true, "remoteHomeStatus" : "notConnected" }, "responseCode" : 1, "responseMessage" : "success" }
+		return new JSONResponse(
+			JSONHelper.default.stringToDate(
+				object.currentTimestamp ? object.currentTimestamp : object.response.currentTimestamp,
+			),
+			object.response,
+			object.responseCode,
+			object.responseMessage,
+		);
+	}
+}
+exports.default = JSONResponse;

package/lib/comunication/comModel/responseBody/AllNewDeviceInfos.js

@@ -0,0 +1,38 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+//Wrapper for Response answers
+//--------------------------------------------------
+const JSONHelper = require("../JSONHelper.js");
+const NewCompatibilityConfiguration = require("./NewCompatibilityConfiguration.js");
+const NewDeviceInfos = require("./NewDeviceInfos.js");
+const NewDeviceValues = require("./NewDeviceValues.js");
+const NewLanguageTranslation = require("./NewLanguageTranslation.js");
+class AllNewDeviceInfos {
+	constructor(
+		currentTimestamp,
+		newCompatibilityConfiguration,
+		newDeviceInfos,
+		newDeviceValues,
+		newLanguageTranslation,
+	) {
+		this.currentTimestamp = currentTimestamp;
+		this.newCompatibilityConfiguration = newCompatibilityConfiguration;
+		this.newDeviceInfos = newDeviceInfos;
+		this.newDeviceValues = newDeviceValues;
+		this.newLanguageTranslations = newLanguageTranslation;
+	}
+	static fromObject(object) {
+		return new AllNewDeviceInfos(
+			JSONHelper.default.stringToDate(object.currentTimestamp),
+			NewCompatibilityConfiguration.default.fromObject(object.newCompatibilityConfiguration),
+			NewDeviceInfos.default.fromObject(object.newDeviceInfos),
+			NewDeviceValues.default.fromObject(object.newDeviceValues),
+			NewLanguageTranslation.default.fromObject(object.newLanguageTranslation),
+		);
+	}
+}
+exports.default = AllNewDeviceInfos;

package/lib/comunication/comModel/responseBody/DeviceInfo.js

@@ -0,0 +1,41 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+
+class DeviceInfo {
+	constructor(
+		deviceID,
+		deviceName,
+		masterDeviceID,
+		masterDeviceName,
+		manufacture,
+		deviceDesignation,
+		deviceTypClient,
+		firstLevel,
+	) {
+		this.deviceID = deviceID;
+		this.deviceName = deviceName;
+		this.masterDeviceID = masterDeviceID;
+		this.masterDeviceName = masterDeviceName;
+		this.manufacture = manufacture;
+		this.deviceDesignation = deviceDesignation;
+		this.deviceTypClient = deviceTypClient;
+		this.firstLevel = firstLevel;
+	}
+	static fromObject(object) {
+		return new DeviceInfo(
+			object.deviceID,
+			object.deviceName,
+			object.masterDeviceID,
+			object.masterDeviceName,
+			object.manufacture,
+			object.deviceDesignation,
+			object.deviceTypClient,
+			object.firstLevel,
+		);
+	}
+}
+exports.default = DeviceInfo;

package/lib/comunication/comModel/responseBody/DeviceValue.js

@@ -0,0 +1,24 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+const JSONHelper = require("../JSONHelper.js");
+class DeviceValue {
+	constructor(deviceID, masterDeviceID, value, valueTimestamp) {
+		this.deviceID = deviceID;
+		this.masterDeviceID = masterDeviceID;
+		this.value = value;
+		this.valueTimestamp = valueTimestamp;
+	}
+	static fromObject(object) {
+		return new DeviceValue(
+			object.deviceID,
+			object.masterDeviceID,
+			object.value,
+			JSONHelper.default.stringToDate(object.valueTimestamp),
+		);
+	}
+}
+exports.default = DeviceValue;

package/lib/comunication/comModel/responseBody/HeloResponse.js

@@ -0,0 +1,17 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+
+class HeloResponse {
+	constructor(salt, sessionSalt) {
+		this.salt = salt;
+		this.sessionSalt = sessionSalt;
+	}
+	static fromObject(object) {
+		return new HeloResponse(object.salt, object.sessionSalt);
+	}
+}
+exports.default = HeloResponse;

package/lib/comunication/comModel/responseBody/LanguageTranslation.js

@@ -0,0 +1,17 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+
+class LanguageTranslation {
+	constructor(key, value) {
+		this.key = key;
+		this.value = value;
+	}
+	static fromObject(object) {
+		return new LanguageTranslation(object.key, object.value);
+	}
+}
+exports.default = LanguageTranslation;

package/lib/comunication/comModel/responseBody/LoginResponse.js

@@ -0,0 +1,26 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+
+class LoginResponse {
+	constructor(hardware, macAddress, pushNotificationUrl, sessionID, shsVersion) {
+		this.hardware = hardware;
+		this.macAddress = macAddress;
+		this.pushNotificationUrl = pushNotificationUrl;
+		this.sessionID = sessionID;
+		this.shsVersion = shsVersion;
+	}
+	static fromObject(object) {
+		return new LoginResponse(
+			object.hardware,
+			object.macAddress,
+			object.pushNotificationUrl,
+			object.sessionID,
+			object.shsVersion,
+		);
+	}
+}
+exports.default = LoginResponse;

package/lib/comunication/comModel/responseBody/NewCompatibilityConfiguration.js

@@ -0,0 +1,16 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+
+class NewCompatibilityConfiguration {
+	constructor(compatibilityConfigurationVersion) {
+		this.compatibilityConfigurationVersion = compatibilityConfigurationVersion;
+	}
+	static fromObject(object) {
+		return new NewCompatibilityConfiguration(object.compatibilityConfigurationVersion);
+	}
+}
+exports.default = NewCompatibilityConfiguration;

package/lib/comunication/comModel/responseBody/NewDeviceInfos.js

@@ -0,0 +1,20 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+const DeviceInfo = require("./DeviceInfo");
+class NewDeviceInfos {
+	constructor(values) {
+		this.values = values;
+	}
+	static fromObject(object) {
+		const tempValues = [];
+		for (const valueEntry of object) {
+			tempValues.push(DeviceInfo.default.fromObject(valueEntry));
+		}
+		return new NewDeviceInfos(tempValues);
+	}
+}
+exports.default = NewDeviceInfos;

package/lib/comunication/comModel/responseBody/NewDeviceValues.js

@@ -0,0 +1,20 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+const DeviceValue = require("./DeviceValue");
+class NewDeviceValues {
+	constructor(values) {
+		this.values = values;
+	}
+	static fromObject(object) {
+		const tempValues = [];
+		for (const valueEntry of object) {
+			tempValues.push(DeviceValue.default.fromObject(valueEntry));
+		}
+		return new NewDeviceValues(tempValues);
+	}
+}
+exports.default = NewDeviceValues;

package/lib/comunication/comModel/responseBody/NewLanguageTranslation.js

@@ -0,0 +1,23 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+const LanguageTranslation = require("./LanguageTranslation");
+class NewLanguageTranslation {
+	constructor(languageTranslationVersion, newTranslatedStrings) {
+		this.languageTranslationVersion = languageTranslationVersion;
+		this.newTranslatedStrings = newTranslatedStrings;
+	}
+	static fromObject(object) {
+		const tempValues = [];
+		if (object.newTranslatedStrings && typeof object.newTranslatedStrings[Symbol.iterator] === "function") {
+			for (const valueEntry of object.newTranslatedStrings) {
+				tempValues.push(LanguageTranslation.default.fromObject(valueEntry));
+			}
+		}
+		return new NewLanguageTranslation(object.languageTranslationVersion, tempValues);
+	}
+}
+exports.default = NewLanguageTranslation;

package/lib/helpers/CommonDefines.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.AdapterDatapointIDs = Object.freeze({
+	Info: "info",
+	Gateway: "gateway",
+	Devices: "devices",
+	Control: "control",
+});
+
+exports.AdapterStateIDs = Object.freeze({
+	// info
+	Connection: "connection",
+	DeviceName: "deviceName",
+	// gateway
+	HardwareName: "hardwareName",
+	MacAddress: "macAddress",
+	// devices.XXX.info
+	TypeClient: "typeClient",
+	Designation: "designation",
+	// devices.XXX.control
+	MoveUp: "moveUp",
+	Open: "open",
+	MoveDown: "moveDown",
+	Close: "close",
+	MoveStop: "moveStop",
+});
+
+exports.KnownDeviceTypes = Object.freeze({
+	AwningEngine: { name: "Markisenantrieb Plus", type: "${Awning}" },
+	RollingShutter: { name: "Gurtantrieb", type: "${RollingShutter}" },
+});
+
+exports.DeviceCommands = Object.freeze({
+	MoveDown: { name: "MoveDown", value: 1 },
+	Open: { name: "Open", value: 1 },
+	MoveUp: { name: "MoveUp", value: 2 },
+	Close: { name: "Close", value: 2 },
+	MoveStop: { name: "MoveStop", value: 0 },
+	UNDEF: { name: "UndefinedCommand", value: -1 },
+});

package/lib/helpers/Deffered.js

@@ -0,0 +1,41 @@
+"use strict";
+
+//--------------------------------------------------
+//Copyright 2020 Pascâl Hartmann
+//See LICENSE File
+//--------------------------------------------------
+//Helper Class for promises
+//modified from
+//https://codereview.stackexchange.com/questions/105754/access-resolve-function-outside-of-a-javascript-promise
+//--------------------------------------------------
+
+class Deferred {
+	constructor(executor) {
+		this.timeout = setTimeout(() => {
+			this.reject("timeout");
+		}, 5000);
+		this.promise = new Promise((resolve, reject) => {
+			this._resolveSelf = resolve;
+			this._rejectSelf = reject;
+		});
+		executor.call(this, this._resolveSelf, this._rejectSelf);
+	}
+	then(onfulfilled, onrejected) {
+		return this.promise.then(onfulfilled, onrejected);
+	}
+	catch(onrejected) {
+		return this.promise.then(onrejected);
+	}
+	finally(onfinally) {
+		return this.promise.finally(onfinally);
+	}
+	resolve(val) {
+		clearTimeout(this.timeout);
+		this._resolveSelf(val);
+	}
+	reject(reason) {
+		clearTimeout(this.timeout);
+		this._rejectSelf(reason);
+	}
+}
+exports.default = Deferred;