623 lines
19 KiB
JavaScript
623 lines
19 KiB
JavaScript
/**
|
|
*
|
|
* doorgate adapter
|
|
*
|
|
*
|
|
* file io-package.json comments:
|
|
*
|
|
* {
|
|
* "common": {
|
|
* "name": "doorgate", // name has to be set and has to be equal to adapters folder name and main file name excluding extension
|
|
* "version": "0.0.0", // use "Semantic Versioning"! see http://semver.org/
|
|
* "title": "Node.js doorgate Adapter", // Adapter title shown in User Interfaces
|
|
* "authors": [ // Array of authord
|
|
* "name <mail@doorgate.com>"
|
|
* ]
|
|
* "desc": "doorgate adapter", // Adapter description shown in User Interfaces. Can be a language object {de:"...",ru:"..."} or a string
|
|
* "platform": "Javascript/Node.js", // possible values "javascript", "javascript/Node.js" - more coming
|
|
* "mode": "daemon", // possible values "daemon", "schedule", "subscribe"
|
|
* "materialize": true, // support of admin3
|
|
* "schedule": "0 0 * * *" // cron-style schedule. Only needed if mode=schedule
|
|
* "loglevel": "info" // Adapters Log Level
|
|
* },
|
|
* "native": { // the native object is available via adapter.config in your adapters code - use it for configuration
|
|
* "test1": true,
|
|
* "test2": 42,
|
|
* "mySelect": "auto"
|
|
* }
|
|
* }
|
|
*
|
|
*/
|
|
|
|
/* jshint -W097 */// jshint strict:false
|
|
/*jslint node: true */
|
|
'use strict';
|
|
|
|
// you have to require the utils module and call adapter function
|
|
const utils = require(__dirname + '/lib/utils'); // Get common adapter utils
|
|
|
|
// load additional libraries
|
|
var express = require('express'); // call express
|
|
var request = null; // will be initialized later if polling enabled
|
|
|
|
var LE = require(utils.controllerDir + '/lib/letsencrypt.js');
|
|
|
|
|
|
// REST server
|
|
var webServer = null;
|
|
var app = null;
|
|
var router = null;
|
|
var timer = null;
|
|
|
|
|
|
// you have to call the adapter function and pass a options object
|
|
// name has to be set and has to be equal to adapters folder name and main file name excluding extension
|
|
// adapter will be restarted automatically every time as the configuration changed, e.g system.adapter.doorgate.0
|
|
const adapter = new utils.Adapter('doorgate');
|
|
|
|
/*Variable declaration, since ES6 there are let to declare variables. Let has a more clearer definition where
|
|
it is available then var.The variable is available inside a block and it's childs, but not outside.
|
|
You can define the same variable name inside a child without produce a conflict with the variable of the parent block.*/
|
|
|
|
let variable = 1234;
|
|
let objects = {};
|
|
let enums = {};
|
|
|
|
|
|
|
|
// is called when adapter shuts down - callback has to be called under any circumstances!
|
|
adapter.on('unload', function (callback) {
|
|
try {
|
|
adapter.log.info('cleaned everything up...');
|
|
callback();
|
|
} catch (e) {
|
|
callback();
|
|
}
|
|
});
|
|
|
|
// is called if a subscribed object changes
|
|
adapter.on('objectChange', function (id, obj) {
|
|
// Warning, obj can be null if it was deleted
|
|
adapter.log.info('objectChange ' + id + ' ' + JSON.stringify(obj));
|
|
});
|
|
|
|
// is called if a subscribed state changes
|
|
adapter.on('stateChange', function (id, state) {
|
|
// Warning, state can be null if it was deleted
|
|
adapter.log.info('stateChange ' + id + ' ' + JSON.stringify(state));
|
|
|
|
// you can use the ack flag to detect if it is status (true) or command (false)
|
|
if (state && !state.ack) {
|
|
adapter.log.info('ack is not set!');
|
|
}
|
|
});
|
|
|
|
// Some message was sent to adapter instance over message box. Used by email, pushover, text2speech, ...
|
|
adapter.on('message', function (obj) {
|
|
if (typeof obj === 'object' && obj.message) {
|
|
if (obj.command === 'send') {
|
|
// e.g. send email or pushover or whatever
|
|
console.log('send command');
|
|
|
|
// Send response in callback if required
|
|
if (obj.callback) adapter.sendTo(obj.from, obj.command, 'Message received', obj.callback);
|
|
}
|
|
}
|
|
});
|
|
|
|
// is called when databases are connected and adapter received configuration.
|
|
// start here!
|
|
adapter.on('ready', function () {
|
|
main();
|
|
});
|
|
|
|
|
|
function addRoutes(_router) {
|
|
// test route to make sure everything is working (accessed at GET http://localhost:9090/api)
|
|
_router.get('/', function (req, res) {
|
|
res.json({message: 'Welcome to our JSON REST api!'});
|
|
});
|
|
|
|
_router.get('/plain/', function(req, res) {
|
|
res.send('Welcome to our text REST api!');
|
|
});
|
|
|
|
// on routes that end in /plain/:id
|
|
// ----------------------------------------------------
|
|
_router.route('/plain/:id')
|
|
// get the bear with that id (accessed at GET http://localhost:8080/api/plain/:id)
|
|
.get(function (req, res) {
|
|
adapter.getForeignState(req.params.id, {user: req.user}, function (err, state) {
|
|
if (err) {
|
|
res.status(500).send(err);
|
|
} else if (!state) {
|
|
res.status(500).send('not found');
|
|
} else {
|
|
res.send('Value: ' + state.val);
|
|
}
|
|
});
|
|
})// create a handler for post (accessed at POST http://localhost:8080/api/bears)
|
|
.post(function (req, res) {
|
|
adapter.setForeignState(req.params.id, req.body, {user: req.user}, function (err, state) {
|
|
if (err) {
|
|
res.status(500).send(err);
|
|
} else if (!state) {
|
|
res.status(500).send('not found');
|
|
} else {
|
|
res.send('Value used');
|
|
}
|
|
});
|
|
});
|
|
|
|
// handler for get over JSON
|
|
_router.route('/:id')
|
|
// get the bear with that id (accessed at GET http://localhost:8080/api/plain/:id)
|
|
.get(function (req, res) {
|
|
adapter.getForeignState(req.params.id, {user: req.user}, function (err, state) {
|
|
if (err) {
|
|
res.status(500).send({error: err});
|
|
} else {
|
|
res.json(state);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
function initWebServer(settings) {
|
|
app = express();
|
|
router = express.Router();
|
|
|
|
|
|
// install authentication
|
|
app.get('/', function (req, res) {
|
|
if (settings.auth) {
|
|
var b64auth = (req.headers.authorization || '').split(' ')[1] || '';
|
|
var loginPass = new Buffer(b64auth, 'base64').toString().split(':');
|
|
var login = loginPass[0];
|
|
var password = loginPass[1];
|
|
|
|
// Check in yunkong2 user and password
|
|
adapter.checkPassword(login, password, function (result) {
|
|
if (!result) {
|
|
adapter.log.error('Wrong user or password: ' + login);
|
|
res.set('WWW-Authenticate', 'Basic realm="nope"');
|
|
res.status(401).send('You shall not pass.');
|
|
} else {
|
|
req.user = login;
|
|
}
|
|
});
|
|
} else {
|
|
req.user = settings.defaultUser;
|
|
}
|
|
});
|
|
// add route cases
|
|
addRoutes(router);
|
|
|
|
// REGISTER OUR ROUTES -------------------------------
|
|
// all of our routes will be prefixed with /api
|
|
app.use('/api', router);
|
|
|
|
|
|
adapter.log.info('config port: ' + settings.port);
|
|
|
|
if (settings.port) {
|
|
if (settings.secure) {
|
|
if (!adapter.config.certificates) {
|
|
adapter.log.error('certificates missing');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
webServer = LE.createServer(app, adapter.config, adapter.config.certificates, adapter.config.leConfig, adapter.log);
|
|
|
|
adapter.getPort(settings.port, function (port) {
|
|
if (port != settings.port && !adapter.config.findNextPort) {
|
|
adapter.log.error('port ' + settings.port + ' already in use');
|
|
process.exit(1);
|
|
}
|
|
webServer.listen(port, settings.bind, function() {
|
|
adapter.log.info('Server listening on http' + (settings.secure ? 's' : '') + '://' + settings.bind + ':' + port);
|
|
});
|
|
});
|
|
} else {
|
|
adapter.log.error('port missing');
|
|
process.exit(1);
|
|
}
|
|
|
|
}
|
|
|
|
function pollData() {
|
|
// you can read about module "request" here: https://www.npmjs.com/package/request
|
|
request = request || require('request'); // load library
|
|
request(adapter.config.pollURL, function (error, response, body) {
|
|
if (error || response.statusCode !== 200) {
|
|
adapter.log.error(error || response.statusCode);
|
|
} else {
|
|
// try to parse answer
|
|
try {
|
|
var data = JSON.parse(body);
|
|
// do something with data
|
|
adapter.log.info(JSON.parse(data));
|
|
|
|
} catch (e) {
|
|
adapter.log.error('Cannot parse answer');
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
|
|
function addToEnum(enumName, id, callback) {
|
|
adapter.getForeignObject(enumName, function (err, obj) {
|
|
if (!err && obj) {
|
|
let pos = obj.common.members.indexOf(id);
|
|
if (pos === -1) {
|
|
obj.common.members.push(id);
|
|
adapter.setForeignObject(obj._id, obj, function (err) {
|
|
if (callback) callback(err);
|
|
});
|
|
} else {
|
|
if (callback) callback(err);
|
|
}
|
|
} else {
|
|
if (callback) callback(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
function removeFromEnum(enumName, id, callback) {
|
|
adapter.getForeignObject(enumName, function (err, obj) {
|
|
if (!err && obj) {
|
|
let pos = obj.common.members.indexOf(id);
|
|
if (pos !== -1) {
|
|
obj.common.members.splice(pos, 1);
|
|
adapter.setForeignObject(obj._id, obj, function (err) {
|
|
if (callback) callback(err);
|
|
});
|
|
} else {
|
|
if (callback) callback(err);
|
|
}
|
|
} else {
|
|
if (callback) callback(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
function syncEnums(enumGroup, id, newEnumName, callback) {
|
|
if (!enums[enumGroup]) {
|
|
adapter.getEnum(enumGroup, function (err, _enums) {
|
|
enums[enumGroup] = _enums;
|
|
syncEnums(enumGroup, id, newEnumName, callback);
|
|
});
|
|
return;
|
|
}
|
|
|
|
// try to find this id in enums
|
|
let found = false;
|
|
let count = 0;
|
|
for (let e in enums[enumGroup]) {
|
|
if (enums[enumGroup].hasOwnProperty(e) &&
|
|
enums[enumGroup][e].common &&
|
|
enums[enumGroup][e].common.members &&
|
|
enums[enumGroup][e].common.members.indexOf(id) !== -1) {
|
|
if (enums[enumGroup][e]._id !== newEnumName) {
|
|
count++;
|
|
removeFromEnum(enums[enumGroup][e]._id, id, function () {
|
|
if (!--count && typeof callback === 'function') callback();
|
|
});
|
|
} else {
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
if (!found && newEnumName) {
|
|
count++;
|
|
addToEnum(newEnumName, id, function () {
|
|
if (!--count&& typeof callback === 'function') callback();
|
|
});
|
|
}
|
|
|
|
if (!count && typeof callback === 'function') callback();
|
|
}
|
|
|
|
|
|
function createExtendObject(id, objData, callback) {
|
|
adapter.getObject(id, function (err, oldObj) {
|
|
if (!err && oldObj) {
|
|
adapter.extendObject(id, objData, callback);
|
|
} else {
|
|
adapter.setObjectNotExists(id, objData, callback);
|
|
}
|
|
});
|
|
}
|
|
|
|
function processTasks(tasks, callback) {
|
|
if (!tasks || !tasks.length) {
|
|
if (typeof callback === 'function') callback();
|
|
return;
|
|
}
|
|
let task = tasks.shift();
|
|
if (task.name === 'add') {
|
|
createExtendObject(task.id, task.obj, function () {
|
|
setTimeout(processTasks, 0, tasks, callback);
|
|
});
|
|
} else if (task.name === 'del') {
|
|
adapter.delObject(task.id, function () {
|
|
setTimeout(processTasks, 0, tasks, callback);
|
|
});
|
|
} else if (task.name === 'syncEnums') {
|
|
syncEnums('rooms', task.id, task.obj, function () {
|
|
setTimeout(processTasks, 0, tasks, callback);
|
|
});
|
|
} else {
|
|
throw 'Unknown task';
|
|
}
|
|
}
|
|
|
|
|
|
function checkDeviceIds(options, config, deviceIds) {
|
|
|
|
for (let i = config.length - 1; i >= 0; i--) {
|
|
config[i].deviceId = !options.config.multiDeviceId ? options.config.defaultDeviceId : (config[i].deviceId !== undefined ? parseInt(config[i].deviceId, 10) : options.config.defaultDeviceId);
|
|
if (isNaN(config[i].deviceId)) config[i].deviceId = options.config.defaultDeviceId;
|
|
if (deviceIds.indexOf(config[i].deviceId) === -1) {
|
|
deviceIds.push(config[i].deviceId);
|
|
}
|
|
}
|
|
}
|
|
|
|
function prepareConfig(config) {
|
|
let params = config.params;
|
|
|
|
let options = {
|
|
config: {
|
|
type: 'tcp',
|
|
round: 0,
|
|
timeout: 5000,
|
|
defaultDeviceId: 0,
|
|
},
|
|
devices: {}
|
|
};
|
|
|
|
let deviceIds = [];
|
|
checkDeviceIds(options, config.disInputs, deviceIds);
|
|
|
|
deviceIds.sort();
|
|
|
|
|
|
options.objects = objects;
|
|
|
|
return options;
|
|
|
|
}
|
|
|
|
function parseConfig(callback) {
|
|
|
|
|
|
adapter.log.info('初始化: ' + adapter.config.door);
|
|
|
|
let options = prepareConfig(adapter.config);
|
|
const params = adapter.config.params;
|
|
|
|
|
|
adapter.getForeignObjects(adapter.namespace + '.*', (err, list) => {
|
|
let oldObjects = list;
|
|
let newObjects = [];
|
|
|
|
// adapter.config.door.sort(sortByAddress);
|
|
|
|
let tasks = [];
|
|
|
|
checkObjects(adapter.config, 'door', 'door', 'Door', tasks, newObjects);
|
|
|
|
|
|
tasks.push({
|
|
id: 'info',
|
|
name: 'add',
|
|
obj: {
|
|
type: 'channel',
|
|
common: {
|
|
name: 'info'
|
|
},
|
|
native: {}
|
|
}
|
|
});
|
|
|
|
adapter.getObject('info.connection', function (err, obj) {
|
|
|
|
if (!obj) {
|
|
obj = {
|
|
type: 'state',
|
|
common: {
|
|
name: 'Number of connected partners',
|
|
role: 'indicator.connected',
|
|
write: false,
|
|
read: true,
|
|
type: 'boolean'
|
|
},
|
|
native: {}
|
|
};
|
|
adapter.setObjectNotExists('info.connection', obj);
|
|
}
|
|
});
|
|
|
|
newObjects.push(adapter.namespace + '.info.connection');
|
|
|
|
// clear unused states
|
|
for (let id_ in oldObjects) {
|
|
if (oldObjects.hasOwnProperty(id_) && newObjects.indexOf(id_) === -1) {
|
|
tasks.push({
|
|
id: id_,
|
|
name: 'del'
|
|
});
|
|
}
|
|
}
|
|
|
|
processTasks(tasks, function () {
|
|
oldObjects = [];
|
|
newObjects = [];
|
|
adapter.subscribeStates('*');
|
|
callback(options);
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
function checkObjects(options, regType, regName, regFullName, tasks, newObjects) {
|
|
|
|
|
|
let regs = options[regType];
|
|
|
|
for (let i = 0; regs.length > i; i++) {
|
|
const id = adapter.namespace + '.' + regs[i].deviceId;
|
|
|
|
adapter.log.info("id=" + id);
|
|
|
|
regs[i].fullId = id;
|
|
objects[id] = {
|
|
_id: regs[i].deviceId,
|
|
type: 'state',
|
|
common: {
|
|
name: regs[i].description,
|
|
role: regs[i].role,
|
|
type: 'string',
|
|
read: true,
|
|
write: true,
|
|
def: ""
|
|
},
|
|
native: {
|
|
regType: regType,
|
|
address: regs[i].address,
|
|
ip: regs[i].ip
|
|
}
|
|
};
|
|
|
|
tasks.push({
|
|
id: regs[i].deviceId,
|
|
name: 'add',
|
|
obj: objects[id]
|
|
});
|
|
|
|
newObjects.push(id);
|
|
}
|
|
|
|
if (regs.length) {
|
|
tasks.push({
|
|
id: regName,
|
|
name: 'add',
|
|
obj: {
|
|
type: 'channel',
|
|
common: {
|
|
name: regFullName
|
|
},
|
|
native: {}
|
|
}
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
function sortByAddress(a, b) {
|
|
let ad = parseFloat(a.deviceId);
|
|
let bd = parseFloat(b.deviceId);
|
|
return ((ad < bd) ? -1 : ((ad > bd) ? 1 : 0));
|
|
}
|
|
|
|
|
|
function main() {
|
|
|
|
// The adapters config (in the instance object everything under the attribute "native") is accessible via
|
|
// adapter.config:
|
|
adapter.log.info('config test1: ' + adapter.config.test1);
|
|
adapter.log.info('config test1: ' + adapter.config.test2);
|
|
adapter.log.info('config mySelect: ' + adapter.config.mySelect);
|
|
|
|
|
|
parseConfig(options => {
|
|
|
|
|
|
});
|
|
|
|
/**
|
|
*
|
|
* For every state in the system there has to be also an object of type state
|
|
*
|
|
* Here a simple doorgate for a boolean variable named "testVariable"
|
|
*
|
|
* Because every adapter instance uses its own unique namespace variable names can't collide with other adapters variables
|
|
*
|
|
*/
|
|
|
|
adapter.setObject('testVariable', {
|
|
type: 'state',
|
|
common: {
|
|
name: 'testVariable',
|
|
type: 'boolean',
|
|
role: 'indicator'
|
|
},
|
|
native: {}
|
|
});
|
|
|
|
// in this doorgate all states changes inside the adapters namespace are subscribed
|
|
adapter.subscribeStates('*');
|
|
|
|
|
|
/**
|
|
* setState examples
|
|
*
|
|
* you will notice that each setState will cause the stateChange event to fire (because of above subscribeStates cmd)
|
|
*
|
|
*/
|
|
|
|
// the variable testVariable is set to true as command (ack=false)
|
|
adapter.setState('testVariable', true);
|
|
|
|
// same thing, but the value is flagged "ack"
|
|
// ack should be always set to true if the value is received from or acknowledged from the target system
|
|
adapter.setState('testVariable', {val: true, ack: true});
|
|
|
|
// same thing, but the state is deleted after 30s (getState will return null afterwards)
|
|
adapter.setState('testVariable', {val: true, ack: true, expire: 30});
|
|
|
|
|
|
|
|
// examples for the checkPassword/checkGroup functions
|
|
adapter.checkPassword('admin', 'yunkong2', function (res) {
|
|
console.log('check user admin pw ioboker: ' + res);
|
|
});
|
|
|
|
adapter.checkGroup('admin', 'admin', function (res) {
|
|
console.log('check group user admin group admin: ' + res);
|
|
});
|
|
|
|
|
|
// try to load certificates
|
|
if (adapter.config.secure) {
|
|
// Load certificates
|
|
// Load certificates
|
|
adapter.getCertificates(function (err, certificates, leConfig) {
|
|
adapter.config.certificates = certificates;
|
|
adapter.config.leConfig = leConfig;
|
|
initWebServer(adapter.config);
|
|
});
|
|
} else {
|
|
initWebServer(adapter.config);
|
|
}
|
|
|
|
/*
|
|
|
|
// Convert port to number
|
|
adapter.config.interval = parseInt(adapter.config.interval, 10);
|
|
|
|
// If interval and URl are set => poll it every X milliseconds
|
|
if (adapter.config.interval && adapter.config.pollURL) {
|
|
// initial poll
|
|
pollData();
|
|
// poll every x milliseconds
|
|
timer = setInterval(pollData, adapter.config.interval);
|
|
}
|
|
*/
|
|
}
|