homebridge-easy-mqtt 1.4.1-beta.1 → 1.5.0-beta.1

package/lib/fakegato-history/fakegato-storage.js

@@ -0,0 +1,178 @@
+/*jshint esversion: 6,node: true,-W041: false */
+'use strict';
+
+const DEBUG = true;
+
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+var hostname = os.hostname().split(".")[0];
+
+// Not needed for homebridge-easy-mqtt
+// var googleDrive = require('./lib/googleDrive').drive;
+
+var fileSuffix = '_persist.json';
+
+var thisStorage;
+
+class FakeGatoStorage {
+	constructor(params) {
+		if (!params)
+			params = {};
+
+		this.writers = [];
+
+		this.log = params.log || {};
+		if (!this.log.debug) {
+			this.log.debug = DEBUG ? console.log : function () { };
+		}
+		thisStorage = this;
+		this.addingWriter = false;
+	}
+
+	addWriter(service, params) {
+		if (!this.addingWriter) {
+			this.addingWriter = true;
+			if (!params)
+				params = {};
+
+			this.log.debug("** Fakegato-storage AddWriter :", service.accessoryName);
+
+			let newWriter = {
+				'service': service,
+				'callback': params.callback,
+				'storage': params.storage || 'fs',
+				'fileName': params.filename || hostname + "_" + service.accessoryName + fileSuffix		// Unique filename per homebridge server.  Allows test environments on other servers not to break prod.
+			};
+			var onReady = typeof (params.onReady) == 'function' ? params.onReady : function () { }.bind(this);
+
+			switch (newWriter.storage) {
+				case 'fs':
+					newWriter.storageHandler = fs;
+					newWriter.path = params.path || path.join(os.homedir(), '.homebridge');
+					this.writers.push(newWriter);
+					this.addingWriter = false;
+					onReady();
+					break;
+				// Not needed for homebridge-easy-mqtt
+				// case 'googleDrive':
+				// 	newWriter.path = params.path || 'fakegato';
+				// 	newWriter.keyPath = params.keyPath || path.join(os.homedir(), '.homebridge');
+				// 	newWriter.storageHandler = new googleDrive({
+				// 		keyPath: newWriter.keyPath, callback: function () {
+				// 			this.addingWriter = false;
+				// 			onReady(arguments);
+				// 		}.bind(this), folder: newWriter.path
+				// 	});
+				// 	this.writers.push(newWriter);
+				// 	break;
+				/*
+				case 'memcached' :
+
+				break;
+				*/
+			}
+		} else {
+			setTimeout(function () {
+				this.addWriter(service, params);
+			}.bind(this), 100);
+		}
+	}
+	getWriter(service) {
+		let findServ = function (element) {
+			return element.service === service;
+		};
+		return this.writers.find(findServ);
+	}
+	_getWriterIndex(service) {
+		let findServ = function (element) {
+			return element.service === service;
+		};
+		return this.writers.findIndex(findServ);
+	}
+	getWriters() {
+		return this.writers;
+	}
+	delWriter(service) {
+		let index = this._getWriterIndex(service);
+		this.writers.splice(index, 1);
+	}
+
+	write(params) { // must be asynchronous
+		if (!this.writing) {
+			this.writing = true;
+			let writer = this.getWriter(params.service);
+			let callBack = typeof (params.callback) == 'function' ? params.callback : (typeof (writer.callback) == 'function' ? writer.callback : function () { }); // use parameter callback or writer callback or empty function
+			switch (writer.storage) {
+				case 'fs':
+					this.log.debug("** Fakegato-storage write FS file:", path.join(writer.path, writer.fileName), params.data.substr(1, 80));
+					writer.storageHandler.writeFile(path.join(writer.path, writer.fileName), params.data, 'utf8', function () {
+						this.writing = false;
+						callBack(arguments);
+					}.bind(this));
+					break;
+				// Not needed for homebridge-easy-mqtt
+				// case 'googleDrive':
+				// 	this.log.debug("** Fakegato-storage write googleDrive file:", writer.path, writer.fileName, params.data.substr(1, 80));
+				// 	writer.storageHandler.writeFile(writer.path, writer.fileName, params.data, function () {
+				// 		this.writing = false;
+				// 		callBack(arguments);
+				// 	}.bind(this));
+				// 	break;
+				/*
+				case 'memcached' :
+
+				break;
+				*/
+			}
+		} else {
+			setTimeout(function () { // retry in 100ms
+				this.write(params);
+			}.bind(this), 100);
+		}
+	}
+	read(params) {
+		let writer = this.getWriter(params.service);
+		let callBack = typeof (params.callback) == 'function' ? params.callback : (typeof (writer.callback) == 'function' ? writer.callback : function () { }); // use parameter callback or writer callback or empty function
+		switch (writer.storage) {
+			case 'fs':
+				this.log.debug("** Fakegato-storage read FS file:", path.join(writer.path, writer.fileName));
+				writer.storageHandler.readFile(path.join(writer.path, writer.fileName), 'utf8', callBack);
+				break;
+			// Not needed for homebridge-easy-mqtt
+			// case 'googleDrive':
+			// 	this.log.debug("** Fakegato-storage read googleDrive file: %s/%s", writer.path, writer.fileName);
+			// 	writer.storageHandler.readFile(writer.path, writer.fileName, callBack);
+			// 	break;
+			/*
+			case 'memcached' :
+
+			break;
+			*/
+		}
+	}
+	remove(params) {
+		let writer = this.getWriter(params.service);
+		let callBack = typeof (params.callback) == 'function' ? params.callback : (typeof (writer.callback) == 'function' ? writer.callback : function () { }); // use parameter callback or writer callback or empty function
+		switch (writer.storage) {
+			case 'fs':
+				this.log.debug("** Fakegato-storage delete FS file:", path.join(writer.path, writer.fileName));
+				writer.storageHandler.unlink(path.join(writer.path, writer.fileName), callBack);
+				break;
+			// Not needed for homebridge-easy-mqtt
+			// case 'googleDrive':
+			// 	this.log.debug("** Fakegato-storage delete googleDrive file:", writer.path, writer.fileName);
+			// 	writer.storageHandler.deleteFile(writer.path, writer.fileName, callBack);
+			// 	break;
+			/*
+			case 'memcached' :
+
+			break;
+			*/
+		}
+	}
+}
+
+module.exports = {
+	FakeGatoStorage: FakeGatoStorage
+};

package/lib/fakegato-history/fakegato-timer.js

@@ -0,0 +1,133 @@
+/*jshint esversion: 6,node: true,-W041: false */
+'use strict';
+
+const DEBUG = true;
+
+class FakeGatoTimer {
+	constructor(params) {
+		if (!params)
+			params = {};
+		this.subscribedServices = [];
+		this.minutes = params.minutes || 10;
+
+		this.intervalID = null;
+		this.running = false;
+		this.log = params.log || {};
+		if (!this.log.debug) {
+			this.log.debug = DEBUG ? console.log : function () { };
+		}
+	}
+
+	// Subscription management
+	subscribe(service, callback) {
+		this.log.debug("** Fakegato-timer Subscription :", service.accessoryName);
+		let newService = {
+			'service': service,
+			'callback': callback,
+			'backLog': [],
+			'previousBackLog': [],
+			'previousAvrg': {}
+		};
+
+		this.subscribedServices.push(newService);
+	}
+	getSubscriber(service) {
+		let findServ = function (element) {
+			return element.service === service;
+		};
+		return this.subscribedServices.find(findServ);
+	}
+	_getSubscriberIndex(service) {
+		let findServ = function (element) {
+			return element.service === service;
+		};
+		return this.subscribedServices.findIndex(findServ);
+	}
+	getSubscribers() {
+		return this.subscribedServices;
+	}
+	unsubscribe(service) {
+		let index = this._getSubscriberIndex(service);
+		this.subscribedServices.splice(index, 1);
+		if (this.subscribedServices.length === 0 && this.running)
+			this.stop();
+	}
+
+	// Timer management
+	start() {
+		this.log.debug("**Start Global Fakegato-Timer - " + this.minutes + "min**");
+		if (this.running)
+			this.stop();
+		this.running = true;
+		this.intervalID = setInterval(this.executeCallbacks.bind(this), this.minutes * 60 * 1000);
+	}
+	stop() {
+		this.log.debug("**Stop Global Fakegato-Timer****");
+		clearInterval(this.intervalID);
+		this.running = false;
+		this.intervalID = null;
+	}
+
+	// Data management
+	executeCallbacks() {
+		this.log.debug("**Fakegato-timer: executeCallbacks**");
+		if (this.subscribedServices.length !== 0) {
+			for (let s in this.subscribedServices) {
+				if (this.subscribedServices.hasOwnProperty(s)) {
+
+					let service = this.subscribedServices[s];
+					if (typeof (service.callback) == 'function') {
+						service.previousAvrg = service.callback({
+							'backLog': service.backLog,
+							'previousAvrg': service.previousAvrg,
+							'timer': this,
+							'immediate': false
+						});
+					}
+				}
+			}
+		}
+	}
+	executeImmediateCallback(service) {
+		this.log.debug("**Fakegato-timer: executeImmediateCallback**");
+
+		if (typeof (service.callback) == 'function' && service.backLog.length)
+			service.callback({
+				'backLog': service.backLog,
+				'timer': this,
+				'immediate': true
+			});
+	}
+	addData(params) {
+		let data = params.entry;
+		let service = params.service;
+		let immediateCallback = params.immediateCallback || false;
+
+		this.log.debug("**Fakegato-timer: addData ", service.accessoryName, data, " immediate: ", immediateCallback);
+
+		if (immediateCallback) // door or motion -> replace
+			this.getSubscriber(service).backLog[0] = data;
+		else
+			this.getSubscriber(service).backLog.push(data);
+
+		if (immediateCallback) {
+			//setTimeout(this.executeImmediateCallback.bind(this), 0,service);
+			this.executeImmediateCallback(this.getSubscriber(service));
+		}
+
+		if (this.running === false)
+			this.start();
+	}
+	emptyData(service) {
+		this.log.debug("**Fakegato-timer: emptyData **", service.accessoryName);
+		let source = this.getSubscriber(service);
+
+		if (source.backLog.length) source.previousBackLog = source.backLog;
+		source.backLog = [];
+	}
+
+}
+
+module.exports = {
+	FakeGatoTimer: FakeGatoTimer
+};

package/lib/fakegato-history/lib/uuid.js

@@ -0,0 +1,25 @@
+// https://github.com/homebridge/HAP-NodeJS/blob/master/src/lib/util/uuid.ts
+
+const VALID_UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function isValid(UUID) {
+  return VALID_UUID_REGEX.test(UUID);
+}
+const VALID_SHORT_REGEX = /^[0-9a-f]{1,8}$/i;
+
+function toLongFormUUID(uuid, base = '-0000-1000-8000-0026BB765291') {
+  if (isValid(uuid)) return uuid.toUpperCase();
+  if (!VALID_SHORT_REGEX.test(uuid)) throw new TypeError('uuid was not a valid UUID or short form UUID');
+  if (!isValid('00000000' + base)) throw new TypeError('base was not a valid base UUID');
+
+  return (('00000000' + uuid).substr(-8) + base).toUpperCase();
+}
+
+function toShortFormUUID(uuid, base = '-0000-1000-8000-0026BB765291') {
+  uuid = toLongFormUUID(uuid, base);
+  return (uuid.substr(0, 8));
+}
+
+exports.isValid = isValid;
+exports.toLongFormUUID = toLongFormUUID;
+exports.toShortFormUUID = toShortFormUUID;

package/lib/fakegato-history/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "fakegato-history",
+  "version": "0.6.7",
+  "main": "fakegato-history.js"
+}

package/package.json

@@ -4,7 +4,7 @@
   "displayName": "Homebridge Easy MQTT",
   "description": "Homebridge plugin for easy control of MQTT devices",
   "type": "module",
-  "version": "1.4.1-beta.1",
+  "version": "1.5.0-beta.1",
   "homepage": "https://github.com/mpatfield/homebridge-easy-mqtt#readme",
   "repository": {
     "type": "git",
@@ -40,6 +40,7 @@
   },
   "dependencies": {
     "@homebridge/plugin-ui-utils": "^2.0.2",
+    "fakegato-history": "file:./lib/fakegato-history",
     "homebridge-lib": "^7.1.6",
     "lodash.merge": "^4.6.2",
     "mqtt": "^5.7.0",