yunkong2/yunkong2.javascript
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
477172e352
yunkong2.javascript/lib/sandbox.js

2365 lines
105 KiB
JavaScript
Raw Normal View History

Initial commit
2018-07-21 19:30:07 +08:00
'use strict';
// let context = {
// adapter,
// mods,
// errorLogFunction,
// subscriptions,
// subscribedPatterns,
// states,
// adapterSubs,
// objects,
// cacheObjectEnums,
// stateIds,
// logWithLineInfo,
// timers,
// enums,
// channels,
// devices,
// isEnums
// };
/**
* @typedef {Object} SandboxContext
* @property {Record<string, string[]>} channels
* @property {Record<string, string[]>} devices
* @property {string[]} stateIds
*/
/**
* @param {{[prop: string]: any} & SandboxContext} context
*/
function sandBox(script, name, verbose, debug, context) {
const consts = require('./consts');
const words = require('./words');
const eventObj = require('./eventObj');
const patternCompareFunctions = require('./patternCompareFunctions');
const nodeSchedule = require('node-schedule');
const adapter = context.adapter;
const mods = context.mods;
const states = context.states;
const objects = context.objects;
const timers = context.timers;
const enums = context.enums;
function errorInCallback(e) {
context.logError('Error in callback', e);
}
function unsubscribePattern(script, pattern) {
if (adapter.config.subscribe) {
if (script.subscribes[pattern]) {
script.subscribes[pattern]--;
if (!script.subscribes[pattern]) delete script.subscribes[pattern];
}
if (context.subscribedPatterns[pattern]) {
context.subscribedPatterns[pattern]--;
if (!context.subscribedPatterns[pattern]) {
adapter.unsubscribeForeignStates(pattern);
delete context.subscribedPatterns[pattern];
// if pattern was regex or with * some states will stay in RAM, but it is OK.
if (states[pattern]) delete states[pattern];
}
}
}
}
function subscribePattern(script, pattern) {
if (adapter.config.subscribe) {
if (!script.subscribes[pattern]) {
script.subscribes[pattern] = 1;
} else {
script.subscribes[pattern]++;
}
if (!context.subscribedPatterns[pattern]) {
context.subscribedPatterns[pattern] = 1;
adapter.subscribeForeignStates(pattern);
// request current value to deliver old value on change.
if (typeof pattern === 'string' && pattern.indexOf('*') === -1) {
adapter.getForeignState(pattern, function (err, state) {
if (state) states[pattern] = state;
});
} else {
adapter.getForeignStates(pattern, function (err, _states) {
if (_states) {
for (const id in _states) {
if (!_states.hasOwnProperty(id)) continue;
states[id] = _states[id];
}
}
});
}
} else {
context.subscribedPatterns[pattern]++;
}
}
}
/**
* @typedef PatternCompareFunctionArray
* @type {Array<any> & {logic?: string}}
*/
function getPatternCompareFunctions(pattern) {
let func;
/** @type {PatternCompareFunctionArray} */
const functions = [];
functions.logic = pattern.logic || 'and';
//adapter.log.info('## '+JSON.stringify(pattern));
for (const key in pattern) {
if (!pattern.hasOwnProperty(key)) continue;
if (key === 'logic') continue;
if (key === 'change' && pattern.change === 'any') continue;
if (!(func = patternCompareFunctions[key])) continue;
if (typeof (func = func(pattern)) !== 'function') continue;
functions.push(func);
}
return functions;
}
/** @typedef {{attr: string, value: string, idRegExp?: RegExp}} Selector */
/**
* Splits a selector string into attribute and value
* @param {string} selector The selector string to split
* @returns {Selector}
*/
function splitSelectorString(selector) {
const parts = selector.split('=', 2);
if (parts[1] && parts[1][0] === '"') {
parts[1] = parts[1].substring(1);
const len = parts[1].length;
if (parts[1] && parts[1][len - 1] === '"') parts[1] = parts[1].substring(0, len - 1);
}
if (parts[1] && parts[1][0] === "'") {
parts[1] = parts[1].substring(1);
const len = parts[1].length;
if (parts[1] && parts[1][len - 1] === "'") parts[1] = parts[1].substring(0, len - 1);
}
if (parts[1]) parts[1] = parts[1].trim();
parts[0] = parts[0].trim();
return {attr: parts[0], value: parts[1]};
}
/**
* Transforms a selector string with wildcards into a regular expression
* @param {string} str The selector string to transform into a regular expression
*/
function selectorStringToRegExp(str) {
if (str[0] === '*') {
// wildcard at the start, match the end of the string
return new RegExp(str.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
} else if (str[str.length - 1] === '*') {
// wildcard at the end, match the start of the string
return new RegExp('^' + str.replace(/\./g, '\\.').replace(/\*/g, '.*'));
} else {
// wildcard potentially in the middle, match whatever
return new RegExp(str.replace(/\./g, '\\.').replace(/\*/g, '.*'));
}
}
/**
* Adds a regular expression for selectors targeting the state ID
* @param {Selector} selector The selector to apply the transform to
* @returns {Selector}
*/
function addRegExpToIdAttrSelectors(selector) {
if (
(selector.attr === 'id' || selector.attr === 'state.id')
&& (!selector.idRegExp && selector.value)
) {
return {
attr: selector.attr,
value: selector.value,
idRegExp: selectorStringToRegExp(selector.value)
};
} else {
return selector;
}
}
/**
* Tests if a value loosely equals (==) the reference string.
* In contrast to the equality operator, this treats true == "true" aswell
* so we can test common and native attributes for boolean values
* @param {boolean | string | number | undefined} value The value to compare with the reference
* @param {string} reference The reference to compare the value to
*/
function looselyEqualsString(value, reference) {
// For booleans, compare the string representation
// For other types do a loose comparison
return (typeof value === 'boolean')
? (value && reference === 'true') || (!value && reference === 'false')
: value == reference
;
}
const sandbox = {
mods: mods,
_id: script._id,
name: name, // deprecated
scriptName: name,
instance: adapter.instance,
verbose: verbose,
request: mods.request,
exports: {}, // Polyfill for the exports object in TypeScript modules
require: function (md) {
console.log('REQUIRE: ' + md);
if (mods[md]) {
return mods[md];
} else {
try {
mods[md] = require(__dirname + '/../node_modules/' + md);
return mods[md];
} catch (e) {
try {
mods[md] = require(__dirname + '/../../' + md);
return mods[md];
} catch (e) {
context.logError(name, e, 6);
}
}
}
},
Buffer: Buffer,
__engine: {
__subscriptions: 0,
__schedules: 0
},
/**
* @param {string} selector
* @returns {iobJS.QueryResult}
*/
$: function (selector) {
// following is supported
// 'type[commonAttr=something]', 'id[commonAttr=something]', id(enumName="something")', id{nativeName="something"}
// Type can be state, channel or device
// Attr can be any of the common attributes and can have wildcards *
// E.g. "state[id='hm-rpc.0.*]" or "hm-rpc.0.*" returns all states of adapter instance hm-rpc.0
// channel(room="Living room") => all states in room "Living room"
// channel{TYPE=BLIND}[state.id=*.LEVEL]
// Switch all states with .STATE of channels with role "switch" in "Wohnzimmer" to false
// $('channel[role=switch][state.id=*.STATE](rooms=Wohnzimmer)').setState(false);
//
// Following functions are possible, setValue, getValue (only from first), on, each
// Todo CACHE!!!
const result = {};
let name = '';
/** @type {string[]} */
const commonStrings = [];
/** @type {string[]} */
const enumStrings = [];
/** @type {string[]} */
const nativeStrings = [];
let isInsideName = true;
let isInsideCommonString = false;
let isInsideEnumString = false;
let isInsideNativeString = false;
let currentCommonString = '';
let currentNativeString = '';
let currentEnumString = '';
// parse string
let selectorHasInvalidType = false;
if (typeof selector === 'string') {
for (let i = 0; i < selector.length; i++) {
if (selector[i] === '{') {
isInsideName = false;
if (isInsideCommonString || isInsideEnumString || isInsideNativeString) {
// Error
break;
}
isInsideNativeString = true;
} else if (selector[i] === '}') {
isInsideNativeString = false;
nativeStrings.push(currentNativeString);
currentNativeString = '';
} else if (selector[i] === '[') {
isInsideName = false;
if (isInsideCommonString || isInsideEnumString || isInsideNativeString) {
// Error
break;
}
isInsideCommonString = true;
} else if (selector[i] === ']') {
isInsideCommonString = false;
commonStrings.push(currentCommonString);
currentCommonString = '';
} else if (selector[i] === '(') {
isInsideName = false;
if (isInsideCommonString || isInsideEnumString || isInsideNativeString) {
// Error
break;
}
isInsideEnumString = true;
} else if (selector[i] === ')') {
isInsideEnumString = false;
enumStrings.push(currentEnumString);
currentEnumString = '';
} else if (isInsideName) {
name += selector[i];
} else if (isInsideCommonString) {
currentCommonString += selector[i];
} else if (isInsideEnumString) {
currentEnumString += selector[i];
} else if (isInsideNativeString) {
currentNativeString += selector[i];
} //else {
// some error
//}
}
} else {
selectorHasInvalidType = true;
}
// If some error in the selector
if (selectorHasInvalidType || isInsideEnumString || isInsideCommonString || isInsideNativeString) {
result.length = 0;
result.each = function () {
return this;
};
result.getState = function () {
return null;
};
result.setState = function () {
return this;
};
result.on = function () {
return this;
};
}
if (isInsideEnumString) {
adapter.log.warn('Invalid selector: enum close bracket ")" cannot be found in "' + selector + '"');
result.error = 'Invalid selector: enum close bracket ")" cannot be found';
return result;
} else if (isInsideCommonString) {
adapter.log.warn('Invalid selector: common close bracket "]" cannot be found in "' + selector + '"');
result.error = 'Invalid selector: common close bracket "]" cannot be found';
return result;
} else if (isInsideNativeString) {
adapter.log.warn('Invalid selector: native close bracket "}" cannot be found in "' + selector + '"');
result.error = 'Invalid selector: native close bracket "}" cannot be found';
return result;
} else if (selectorHasInvalidType) {
const message = `Invalid selector: selector must be a string but is of type ${typeof selector}`;
adapter.log.warn(message);
result.error = message;
return result;
}
/** @type {Selector[]} */
let commonSelectors = commonStrings.map(selector => splitSelectorString(selector));
let nativeSelectors = nativeStrings.map(selector => splitSelectorString(selector));
const enumSelectorObjects = enumStrings.map(_enum => splitSelectorString(_enum));
const allSelectors = commonSelectors.concat(nativeSelectors, enumSelectorObjects);
// These selectors match the state or object ID and don't belong in the common/native selectors
// Also use RegExp for the ID matching
const stateIdSelectors = allSelectors
.filter(selector => selector.attr === 'state.id')
.map(selector => addRegExpToIdAttrSelectors(selector))
;
const objectIdSelectors = allSelectors
.filter(selector => selector.attr === 'id')
.map(selector => addRegExpToIdAttrSelectors(selector))
;
commonSelectors = commonSelectors.filter(selector => selector.attr !== 'state.id' && selector.attr !== 'id');
nativeSelectors = nativeSelectors.filter(selector => selector.attr !== 'state.id' && selector.attr !== 'id');
const enumSelectors = enumSelectorObjects
.filter(selector => selector.attr !== 'state.id' && selector.attr !== 'id')
// enums are filtered by their enum id, so transform the selector into that
.map(selector => `enum.${selector.attr}.${selector.value}`)
;
name = name.trim();
if (name === 'channel' || name === 'device') {
// Fill the channels and devices objects with the IDs of all their states
// so we can loop over them afterwards
if (!context.channels || !context.devices) {
context.channels = {};
context.devices = {};
for (const _id in objects) {
if (objects.hasOwnProperty(_id) && objects[_id].type === 'state') {
const parts = _id.split('.');
parts.pop();
const chn = parts.join('.');
parts.pop();
const dev = parts.join('.');
context.devices[dev] = context.devices[dev] || [];
context.devices[dev].push(_id);
context.channels[chn] = context.channels[chn] || [];
context.channels[chn].push(_id);
}
}
}
}
/**
* applies all selectors targeting an object or state ID
* @param {string} objId
* @param {Selector[]} selectors
*/
function applyIDSelectors(objId, selectors) {
// Only keep the ID if it matches every ID selector
return selectors.every(selector => {
return selector.idRegExp == null || selector.idRegExp.test(objId);
});
}
/**
* Applies all selectors targeting the Object common properties
* @param {string} objId - The ID of the object in question
*/
function applyCommonSelectors(objId) {
const obj = objects[objId];
if (obj == null || obj.common == null) return false;
const objCommon = obj.common;
// make sure this object satisfies all selectors
return commonSelectors.every(selector => {
return (
// ensure a property exists
(selector.value === undefined && objCommon[selector.attr] !== undefined)
// or match exact values
|| looselyEqualsString(objCommon[selector.attr], selector.value)
);
});
}
/**
* Applies all selectors targeting the Object native properties
* @param {string} objId - The ID of the object in question
*/
function applyNativeSelectors(objId) {
const obj = objects[objId];
if (obj == null || obj.native == null) return false;
const objNative = obj.native;
// make sure this object satisfies all selectors
return nativeSelectors.every(selector => {
return (
// ensure a property exists
(selector.value === undefined && objNative[selector.attr] !== undefined)
// or match exact values
|| looselyEqualsString(objNative[selector.attr], selector.value)
);
});
}
/**
* Applies all selectors targeting the Objects enums
* @param {string} objId - The ID of the object in question
*/
function applyEnumSelectors(objId) {
const enumIds = [];
eventObj.getObjectEnumsSync(context, objId, enumIds);
// make sure this object satisfies all selectors
return enumSelectors.every(_enum => enumIds.indexOf(_enum) > -1);
}
/** @type {string[]} */
let res = [];
if (name === 'channel') {
// go through all channels
res = Object.keys(context.channels)
// filter out those that don't match every ID selector for the channel ID
.filter(channelId => applyIDSelectors(channelId, objectIdSelectors))
// filter out those that don't match every common selector
.filter(channelId => applyCommonSelectors(channelId))
// filter out those that don't match every native selector
.filter(channelId => applyNativeSelectors(channelId))
// filter out those that don't match every enum selector
.filter(channelId => applyEnumSelectors(channelId))
// retrieve the state ID collection for all remaining channels
.map(id => context.channels[id])
// and flatten the array to get only the state IDs
.reduce((acc, next) => acc.concat(next), [])
// now filter out those that don't match every ID selector for the state ID
.filter(stateId => applyIDSelectors(stateId, stateIdSelectors))
;
} else if (name === 'device') {
// go through all devices
res = Object.keys(context.devices)
// filter out those that don't match every ID selector for the channel ID
.filter(deviceId => applyIDSelectors(deviceId, objectIdSelectors))
// filter out those that don't match every common selector
.filter(deviceId => applyCommonSelectors(deviceId))
// filter out those that don't match every native selector
.filter(deviceId => applyNativeSelectors(deviceId))
// filter out those that don't match every enum selector
.filter(deviceId => applyEnumSelectors(deviceId))
// retrieve the state ID collection for all remaining devices
.map(id => context.devices[id])
// and flatten the array to get only the state IDs
.reduce((acc, next) => acc.concat(next), [])
// now filter out those that don't match every ID selector for the state ID
.filter(stateId => applyIDSelectors(stateId, stateIdSelectors))
;
} else {
// go through all states
res = context.stateIds;
// if the "name" is not state then we filter for the ID aswell
if (name && name !== 'state') {
const r = new RegExp('^' + name.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
res = res.filter(id => r.test(id));
}
res = res
// filter out those that don't match every ID selector for the object ID or the state ID
.filter(id => applyIDSelectors(id, objectIdSelectors))
.filter(id => applyIDSelectors(id, stateIdSelectors))
// filter out those that don't match every common selector
.filter(id => applyCommonSelectors(id))
// filter out those that don't match every native selector
.filter(id => applyNativeSelectors(id))
// filter out those that don't match every enum selector
.filter(id => applyEnumSelectors(id))
;
}
for (let i = 0; i < res.length; i++) {
result[i] = res[i];
}
result.length = res.length;
result.each = function (callback) {
if (typeof callback === 'function') {
let r;
for (let i = 0; i < this.length; i++) {
r = callback(result[i], i);
if (r === false) break;
}
}
return this;
};
result.getState = function (callback) {
if (adapter.config.subscribe) {
if (typeof callback !== 'function') {
sandbox.log('You cannot use this function synchronous', 'error');
} else {
adapter.getForeignState(this[0], callback);
}
} else {
if (this[0]) return states[this[0]];
return null;
}
};
result.setState = function (state, isAck, callback) {
if (typeof isAck === 'function') {
callback = isAck;
isAck = undefined;
}
if (isAck === true || isAck === false || isAck === 'true' || isAck === 'false') {
if (typeof state === 'object') {
state.ack = isAck;
} else {
state = {val: state, ack: isAck};
}
}
let cnt = 0;
for (let i = 0; i < this.length; i++) {
cnt++;
adapter.setForeignState(this[i], state, function () {
if (!--cnt && typeof callback === 'function') callback();
});
}
return this;
};
result.on = function (callbackOrId, value) {
for (let i = 0; i < this.length; i++) {
sandbox.subscribe(this[i], callbackOrId, value);
}
return this;
};
return result;
},
log: function (msg, sev) {
if (!sev) sev = 'info';
if (!adapter.log[sev]) {
msg = 'Unknown severity level "' + sev + '" by log of [' + msg + ']';
sev = 'warn';
}
adapter.log[sev](name + ': ' + msg);
},
exec: function (cmd, callback) {
if (!adapter.config.enableExec) {
const error = 'exec is not available. Please enable "Enable Exec" option in instance settings';
adapter.log.error(error);
sandbox.log(error);
if (typeof callback === 'function') {
setImmediate(callback, error);
}
} else {
if (sandbox.verbose) {
sandbox.log('exec: ' + cmd, 'info');
}
if (debug) {
sandbox.log(words._('Command %s was not executed, while debug mode is active', cmd), 'warn');
if (typeof callback === 'function') {
setImmediate(function () {
callback();
});
}
} else {
return mods.child_process.exec(cmd, callback);
}
}
},
email: function (msg) {
if (sandbox.verbose) sandbox.log('email(msg=' + JSON.stringify(msg) + ')', 'info');
adapter.sendTo('email', msg);
},
pushover: function (msg) {
if (sandbox.verbose) sandbox.log('pushover(msg=' + JSON.stringify(msg) + ')', 'info');
adapter.sendTo('pushover', msg);
},
subscribe: function (pattern, callbackOrId, value) {
if (pattern && Array.isArray(pattern)) {
const result = [];
for (let t = 0; t < pattern.length; t++) {
result.push(sandbox.subscribe(pattern[t], callbackOrId, value));
}
return result;
}
if (pattern && pattern.id && Array.isArray(pattern.id)) {
const result_ = [];
for (let tt = 0; tt < pattern.id.length; tt++) {
const pa = JSON.parse(JSON.stringify(pattern));
pa.id = pattern.id[tt];
result_.push(sandbox.subscribe(pa, callbackOrId, value));
}
return result_;
}
// try to detect astro or cron (by spaces)
if (typeof pattern === 'object' || (typeof pattern === 'string' && pattern.match(/[,/\d*]+\s[,/\d*]+\s[,/\d*]+/))) {
if (pattern.astro) {
return sandbox.schedule(pattern, callbackOrId);
} else if (pattern.time) {
return sandbox.schedule(pattern.time, callbackOrId);
}
}
let callback;
sandbox.__engine.__subscriptions += 1;
// source is set by regexp if defined as /regexp/
if (typeof pattern !== 'object' || pattern instanceof RegExp || pattern.source) {
pattern = {id: pattern, change: 'ne'};
}
if (pattern.id !== undefined && !pattern.id) {
adapter.log.error('Error by subscription: empty ID defined. All states matched.');
return;
}
// add adapter namespace if nothing given
if (pattern.id && typeof pattern.id === 'string' && pattern.id.indexOf('.') === -1) {
pattern.id = adapter.namespace + '.' + pattern.id;
}
if (typeof callbackOrId === 'function') {
callback = callbackOrId;
} else {
const that = this;
if (typeof value === 'undefined') {
callback = function (obj) {
that.setState(callbackOrId, obj.newState.val);
};
} else {
callback = function (/* obj */) {
that.setState(callbackOrId, value);
};
}
}
const subs = {
pattern: pattern,
callback: function (obj) {
if (typeof callback === 'function') {
try {
callback.call(sandbox, obj);
} catch (e) {
errorInCallback(e); // adapter.log.error('Error in callback: ' + e);
}
}
},
name: name
};
// try to extract adapter
if (pattern.id && typeof pattern.id === 'string') {
const parts = pattern.id.split('.');
const a = parts[0] + '.' + parts[1];
const _adapter = 'system.adapter.' + a;
if (objects[_adapter] && objects[_adapter].common && objects[_adapter].common.subscribable) {
const alive = 'system.adapter.' + a + '.alive';
context.adapterSubs[alive] = context.adapterSubs[alive] || [];
const subExists = context.adapterSubs[alive].filter(function (sub) {
return sub === pattern.id;
}).length > 0;
if (!subExists) {
context.adapterSubs[alive].push(pattern.id);
adapter.sendTo(a, 'subscribe', pattern.id);
}
}
}
if (sandbox.verbose) sandbox.log('subscribe: ' + JSON.stringify(subs), 'info');
subscribePattern(script, pattern.id);
subs.patternCompareFunctions = getPatternCompareFunctions(pattern);
context.subscriptions.push(subs);
if (pattern.enumName || pattern.enumId) context.isEnums = true;
return subs;
},
getSubscriptions: function () {
const result = {};
for (let s = 0; s < context.subscriptions.length; s++) {
result[context.subscriptions[s].pattern.id] = result[context.subscriptions[s].pattern.id] || [];
result[context.subscriptions[s].pattern.id].push({ name: context.subscriptions[s].name, pattern: context.subscriptions[s].pattern });
}
if (sandbox.verbose) sandbox.log('getSubscriptions() => ' + JSON.stringify(result), 'info');
return result;
},
adapterSubscribe: function (id) {
if (typeof id !== 'string') {
adapter.log.error('adapterSubscribe: invalid type of id' + typeof id);
return;
}
const parts = id.split('.');
const _adapter = 'system.adapter.' + parts[0] + '.' + parts[1];
if (objects[_adapter] && objects[_adapter].common && objects[_adapter].common.subscribable) {
const a = parts[0] + '.' + parts[1];
const alive = 'system.adapter.' + a + '.alive';
context.adapterSubs[alive] = context.adapterSubs[alive] || [];
context.adapterSubs[alive].push(id);
if (sandbox.verbose) sandbox.log('adapterSubscribe: ' + a + ' - ' + id, 'info');
adapter.sendTo(a, 'subscribe', id);
}
},
adapterUnsubscribe: function (id) {
return sandbox.unsubscribe(id);
},
unsubscribe: function (idOrObject) {
if (idOrObject && Array.isArray(idOrObject)) {
const result = [];
for (let t = 0; t < idOrObject.length; t++) {
result.push(sandbox.unsubscribe(idOrObject[t]));
}
return result;
}
if (sandbox.verbose) sandbox.log('adapterUnsubscribe(id=' + idOrObject + ')', 'info');
if (typeof idOrObject === 'object') {
for (let i = context.subscriptions.length - 1; i >= 0; i--) {
if (context.subscriptions[i] === idOrObject) {
unsubscribePattern(context.subscriptions[i].pattern.id);
context.subscriptions.splice(i, 1);
sandbox.__engine.__subscriptions--;
return true;
}
}
} else {
let deleted = 0;
for (let i = context.subscriptions.length - 1; i >= 0; i--) {
if (context.subscriptions[i].name === name && context.subscriptions[i].pattern.id === idOrObject) {
deleted++;
unsubscribePattern(context.subscriptions[i].pattern.id);
context.subscriptions.splice(i, 1);
sandbox.__engine.__subscriptions--;
}
}
return !!deleted;
}
},
on: function (pattern, callbackOrId, value) {
return sandbox.subscribe(pattern, callbackOrId, value);
},
schedule: function (pattern, callback) {
if (typeof callback !== 'function') {
adapter.log.error(name + ': schedule callback missing');
return;
}
sandbox.__engine.__schedules += 1;
if (pattern.astro) {
const nowdate = new Date();
if (adapter.config.latitude === undefined || adapter.config.longitude === undefined ||
adapter.config.latitude === '' || adapter.config.longitude === '' ||
adapter.config.latitude === null || adapter.config.longitude === null) {
adapter.log.error('Longitude or latitude does not set. Cannot use astro.');
return;
}
let ts = mods.suncalc.getTimes(nowdate, adapter.config.latitude, adapter.config.longitude)[pattern.astro];
if (ts.getTime().toString() === 'NaN') {
adapter.log.warn('Cannot calculate "' + pattern.astro + '" for ' + adapter.config.latitude + ', ' + adapter.config.longitude);
ts = new Date(nowdate.getTime());
if (pattern.astro === 'sunriseEnd' ||
pattern.astro === 'goldenHourEnd' ||
pattern.astro === 'sunset' ||
pattern.astro === 'nightEnd' ||
pattern.astro === 'nauticalDusk') {
ts.setMinutes(59);
ts.setHours(23);
ts.setSeconds(59);
} else {
ts.setMinutes(59);
ts.setHours(23);
ts.setSeconds(58);
}
}
if (ts && pattern.shift) {
ts = new Date(ts.getTime() + (pattern.shift * 60000));
}
if (!ts || ts < nowdate) {
const date = new Date(nowdate);
// Event doesn't occur today - try again tomorrow
// Calculate time till 24:00 and set timeout
date.setDate(date.getDate() + 1);
date.setMinutes(1); // Somtimes timer fires at 23:59:59
date.setHours(0);
date.setSeconds(0);
date.setMilliseconds(0);
date.setMinutes(-date.getTimezoneOffset());
// Calculate new schedule in the next day
sandbox.setTimeout(function () {
if (sandbox.__engine.__schedules > 0) sandbox.__engine.__schedules--;
sandbox.schedule(pattern, callback);
}, date.getTime() - nowdate.getTime());
return;
}
sandbox.setTimeout(function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
// Reschedule in 2 seconds
sandbox.setTimeout(function () {
if (sandbox.__engine.__schedules > 0) sandbox.__engine.__schedules--;
sandbox.schedule(pattern, callback);
}, 2000);
}, ts.getTime() - nowdate.getTime());
if (sandbox.verbose) sandbox.log('schedule(astro=' + pattern.astro + ', offset=' + pattern.shift + ')', 'info');
} else {
// fix problem with sunday and 7
if (typeof pattern === 'string') {
const parts = pattern.replace(/\s+/g, ' ').split(' ');
if (parts.length >= 5 && parts[5] >= 7) parts[5] = 0;
pattern = parts.join(' ');
}
const schedule = nodeSchedule.scheduleJob(pattern, function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
});
script.schedules.push(schedule);
if (sandbox.verbose) sandbox.log('schedule(cron=' + pattern + ')', 'info');
return schedule;
}
},
getAstroDate: function (pattern, date, offsetMinutes) {
if (date === undefined) date = new Date();
if (consts.astroList.indexOf(pattern) === -1) {
const pos = consts.astroListLow.indexOf(pattern.toLowerCase());
if (pos !== -1) pattern = consts.astroList[pos];
}
if ((!adapter.config.latitude && adapter.config.latitude !== 0) ||
(!adapter.config.longitude && adapter.config.longitude !== 0)) {
adapter.log.error('Longitude or latitude does not set. Cannot use astro.');
return;
}
let ts = mods.suncalc.getTimes(date, adapter.config.latitude, adapter.config.longitude)[pattern];
if (ts === undefined || ts.getTime().toString() === 'NaN') {
adapter.log.error('Cannot get astro date for "' + pattern + '"');
}
if (sandbox.verbose) sandbox.log('getAstroDate(pattern=' + pattern + ', date=' + date + ') => ' + ts, 'info');
if (offsetMinutes !== undefined) {
ts = new Date(ts.getTime() + (offsetMinutes * 60000));
}
return ts;
},
isAstroDay: function () {
const nowDate = new Date();
const dayBegin = sandbox.getAstroDate('sunrise');
const dayEnd = sandbox.getAstroDate('sunset');
if (dayBegin === undefined || dayEnd === undefined) return;
if (sandbox.verbose) sandbox.log('isAstroDay() => ' + (nowDate >= dayBegin && nowDate <= dayEnd), 'info');
return (nowDate >= dayBegin && nowDate <= dayEnd);
},
clearSchedule: function (schedule) {
for (let i = 0; i < script.schedules.length; i++) {
if (script.schedules[i] === schedule) {
if (!nodeSchedule.cancelJob(script.schedules[i])) {
adapter.log.error('Error by canceling scheduled job');
}
delete script.schedules[i];
script.schedules.splice(i, 1);
if (sandbox.verbose) sandbox.log('clearSchedule() => cleared', 'info');
return true;
}
}
if (sandbox.verbose) sandbox.log('clearSchedule() => invalid handler', 'warn');
return false;
},
setState: function (id, state, isAck, callback) {
if (typeof isAck === 'function') {
callback = isAck;
isAck = undefined;
}
if (state === null) {
state = {val: null};
}
if (isAck === true || isAck === false || isAck === 'true' || isAck === 'false') {
if (typeof state === 'object') {
state.ack = isAck;
} else {
state = {val: state, ack: isAck};
}
}
// Check type of state
if (!objects[id] && objects[adapter.namespace + '.' + id]) {
id = adapter.namespace + '.' + id;
}
const common = objects[id] ? objects[id].common : null;
if (common &&
common.type &&
common.type !== 'mixed' &&
common.type !== 'file' &&
common.type !== 'json') {
if (state && typeof state === 'object' && state.val !== undefined) {
if (common.type !== typeof state.val) {
context.logWithLineInfo.warn('Wrong type of ' + id + ': "' + typeof state.val + '". Please fix, while deprecated and will not work in next versions.');
//return;
}
} else {
if (common.type !== typeof state) {
context.logWithLineInfo.warn('Wrong type of ' + id + ': "' + typeof state + '". Please fix, while deprecated and will not work in next versions.');
//return;
}
}
}
// Check min and max of value
if (typeof state === 'object' && state) {
if (common && typeof state.val === 'number') {
if (common.min !== undefined && state.val < common.min) state.val = common.min;
if (common.max !== undefined && state.val > common.max) state.val = common.max;
}
} else if (common && typeof state === 'number') {
if (common.min !== undefined && state < common.min) state = common.min;
if (common.max !== undefined && state > common.max) state = common.max;
}
if (objects[id]) {
if (sandbox.verbose) sandbox.log('setForeignState(id=' + id + ', state=' + JSON.stringify(state) + ')', 'info');
if (debug) {
sandbox.log('setForeignState(id=' + id + ', state=' + JSON.stringify(state) + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
if (typeof callback === 'function') {
setTimeout(function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, 0);
}
} else {
adapter.setForeignState(id, state, function (err) {
if (err) sandbox.log('setForeignState: ' + err, 'error');
if (typeof callback === 'function') {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
});
}
} else if (objects[adapter.namespace + '.' + id]) {
if (sandbox.verbose) sandbox.log('setState(id=' + id + ', state=' + JSON.stringify(state) + ')', 'info');
if (debug) {
sandbox.log('setState(' + id + ', ' + JSON.stringify(state) + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
if (typeof callback === 'function') {
setTimeout(function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, 0);
}
} else {
adapter.setState(id, state, function (err) {
if (err) sandbox.log('setState: ' + err, 'error');
if (typeof callback === 'function') {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
});
}
} else {
if (objects[id]) {
if (objects[id].type === 'state') {
if (sandbox.verbose) sandbox.log('setForeignState(id=' + id + ', state=' + JSON.stringify(state) + ')', 'info');
if (debug) {
sandbox.log('setForeignState(id=' + id + ', state=' + JSON.stringify(state) + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
if (typeof callback === 'function') {
setTimeout(function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, 0);
}
} else {
adapter.setForeignState(id, state, function (err) {
if (err) sandbox.log('setForeignState: ' + err, 'error');
if (typeof callback === 'function') {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
});
}
} else {
adapter.log.warn('Cannot set value of non-state object "' + id + '"');
if (typeof callback === 'function') {
try {
callback.call(sandbox, 'Cannot set value of non-state object "' + id + '"');
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
}
} else if (objects[adapter.namespace + '.' + id]) {
if (objects[adapter.namespace + '.' + id].type === 'state') {
if (sandbox.verbose) sandbox.log('setState(id=' + id + ', state=' + JSON.stringify(state) + ')', 'info');
if (debug) {
sandbox.log('setState(id=' + id + ', state=' + JSON.stringify(state) + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
if (typeof callback === 'function') {
setTimeout(function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, 0);
}
} else {
adapter.setState(id, state, function (err) {
if (err) sandbox.log('setState: ' + err, 'error');
if (typeof callback === 'function') {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
});
}
} else {
adapter.log.warn('Cannot set value of non-state object "' + adapter.namespace + '.' + id + '"');
if (typeof callback === 'function') {
try {
callback.call(sandbox, 'Cannot set value of non-state object "' + adapter.namespace + '.' + id + '"');
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
}
} else {
context.logWithLineInfo.warn('State "' + id + '" not found');
if (typeof callback === 'function') {
try {
callback.call(sandbox, 'State "' + id + '" not found');
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
}
}
},
setStateDelayed: function (id, state, isAck, delay, clearRunning, callback) {
// find arguments
if (typeof isAck !== 'boolean') {
callback = clearRunning;
clearRunning = delay;
delay = isAck;
isAck = false;
}
if (typeof delay !== 'number') {
callback = clearRunning;
clearRunning = delay;
delay = 0;
}
if (typeof clearRunning !== 'boolean') {
callback = clearRunning;
clearRunning = true;
}
// Check type of state
if (!objects[id] && objects[adapter.namespace + '.' + id]) {
id = adapter.namespace + '.' + id;
}
if (clearRunning === undefined) clearRunning = true;
if (sandbox.verbose) sandbox.log('setStateDelayed(id=' + id + ', state=' + state + ', isAck=' + isAck + ', delay=' + delay + ', clearRunning=' + clearRunning + ')', 'info');
if (clearRunning) {
if (timers[id]) {
if (sandbox.verbose) sandbox.log('setStateDelayed: clear ' + timers[id].length + ' running timers', 'info');
for (let i = 0; i < timers[id].length; i++) {
clearTimeout(timers[id][i].t);
}
delete timers[id];
} else {
if (sandbox.verbose) sandbox.log('setStateDelayed: no running timers', 'info');
}
}
// If no delay => start immediately
if (!delay) {
sandbox.setState(id, state, isAck, callback);
return null;
} else {
// If delay
timers[id] = timers[id] || [];
// calculate timerId
context.timerId++;
if (context.timerId > 0xFFFFFFFE) context.timerId = 0;
// Start timeout
const timer = setTimeout(function (_timerId, _id, _state, _isAck) {
sandbox.setState(_id, _state, _isAck, callback);
// delete timer handler
if (timers[_id]) {
// optimisation
if (timers[_id].length === 1) {
delete timers[_id];
} else {
for (let t = 0; t < timers[_id].length; t++) {
if (timers[_id][t].id === _timerId) {
timers[_id].splice(t, 1);
break;
}
}
if (!timers[_id].length) delete timers[_id];
}
}
}, delay, context.timerId, id, state, isAck);
// add timer handler
timers[id].push({
t: timer,
id: context.timerId,
ts: Date.now(),
delay: delay,
val: typeof state === 'object' && state.val !== undefined ? state.val : state,
ack: typeof state === 'object' && state.val !== undefined && state.ack !== undefined ? state.ack : isAck
});
return context.timerId;
}
},
clearStateDelayed: function (id, timerId) {
// Check type of state
if (!objects[id] && objects[adapter.namespace + '.' + id]) {
id = adapter.namespace + '.' + id;
}
if (sandbox.verbose) sandbox.log('clearStateDelayed(id=' + id + ', timerId=' + timerId + ')', 'info');
if (timers[id]) {
for (let i = timers[id].length - 1; i >= 0; i--) {
if (timerId === undefined || timers[id][i].id === timerId) {
clearTimeout(timers[id][i].t);
if (timerId !== undefined) timers[id].splice(i, 1);
if (sandbox.verbose) sandbox.log('clearStateDelayed: clear timer ' + timers[id][i].id, 'info');
}
}
if (timerId === undefined) {
delete timers[id];
} else {
if (!timers[id].length) delete timers[id];
}
return true;
}
return false;
},
getStateDelayed: function (id) {
let result;
const now = Date.now();
if (id) {
// Check type of state
if (!objects[id] && objects[adapter.namespace + '.' + id]) {
id = adapter.namespace + '.' + id;
}
// If timerId given
if (typeof id === 'number') {
for (const _id_ in timers) {
if (timers.hasOwnProperty(_id_)) {
for (let ttt = 0; ttt < timers[_id_].length; ttt++) {
if (timers[_id_][ttt].id === id) {
return {
id: _id_,
left: timers[_id_][ttt].delay - (now - timers[id][ttt].ts),
delay: timers[_id_][ttt].delay,
val: timers[_id_][ttt].val,
ack: timers[_id_][ttt].ack
};
}
}
}
}
return null;
}
result = [];
if (timers.hasOwnProperty(id) && timers[id] && timers[id].length) {
for (let tt = 0; tt < timers[id].length; tt++) {
result.push({
timerId: timers[id][tt].id,
left: timers[id][tt].delay - (now - timers[id][tt].ts),
delay: timers[id][tt].delay,
val: timers[id][tt].val,
ack: timers[id][tt].ack
});
}
}
return result;
} else {
result = {};
for (const _id in timers) {
if (timers.hasOwnProperty(_id) && timers[_id] && timers[_id].length) {
result[_id] = [];
for (let t = 0; t < timers[_id].length; t++) {
result[_id].push({
timerId: timers[_id][t].id,
left: timers[_id][t].delay - (now - timers[_id][t].ts),
delay: timers[_id][t].delay,
val: timers[_id][t].val,
ack: timers[_id][t].ack
});
}
}
}
}
return result;
},
getState: function (id, callback) {
if (typeof callback === 'function') {
if (id.indexOf('.') === -1) {
adapter.getState(id, callback);
} else {
adapter.getForeignState(id, callback);
}
} else {
if (adapter.config.subscribe) {
sandbox.log('Cannot use sync getState, use callback instead getState("' + id + '", function (err, state){}); or disable the "Do not subscribe all states on start" option in instance configuration.', 'error');
} else {
if (states[id]) {
if (sandbox.verbose) sandbox.log('getState(id=' + id + ', timerId=' + timers[id] + ') => ' + JSON.stringify(states[id]), 'info');
return states[id];
}
if (states[adapter.namespace + '.' + id]) {
if (sandbox.verbose) sandbox.log('getState(id=' + id + ', timerId=' + timers[id] + ') => ' + states[adapter.namespace + '.' + id], 'info');
return states[adapter.namespace + '.' + id];
}
if (sandbox.verbose) sandbox.log('getState(id=' + id + ', timerId=' + timers[id] + ') => not found', 'info');
context.logWithLineInfo.warn('getState "' + id + '" not found (3)' + (states[id] !== undefined ? ' states[id]=' + states[id] : '')); ///xxx
return {val: null, notExist: true};
}
}
},
existsState: function (id) {
return states.get(id) !== undefined;
},
existsObject: function (id) {
return objects.get(id) !== undefined;
},
getIdByName: function (name, alwaysArray) {
if (sandbox.verbose) sandbox.log('getIdByName(name=' + name + ', alwaysArray=' + alwaysArray + ') => ' + context.names[name], 'info');
if (alwaysArray) {
if (typeof context.names[name] === 'string') {
return [context.names[name]];
}
return context.names[name];
} else {
return context.names[name];
}
},
getObject: function (id, enumName, cb) {
if (typeof enumName === 'function') {
cb = enumName;
enumName = null;
}
if (typeof cb === 'function') {
adapter.getForeignObject(id, (err, obj) => {
if (obj) {
objects[id] = obj;
} else if (objects[id]) {
delete objects[id];
}
let result;
try {
result = JSON.parse(JSON.stringify(objects[id]));
} catch (err) {
adapter.log.error('Object "' + id + '" can\'t be copied');
return null;
}
if (sandbox.verbose) sandbox.log('getObject(id=' + id + ', enumName=' + enumName + ') => ' + JSON.stringify(result), 'info');
cb(err, result);
});
} else {
if (!objects[id]) {
if (sandbox.verbose) sandbox.log('getObject(id=' + id + ', enumName=' + enumName + ') => does not exist', 'info');
adapter.log.warn('Object "' + id + '" does not exist');
return null;
} else if (enumName) {
const e = eventObj.getObjectEnumsSync(context, id);
const obj = JSON.parse(JSON.stringify(objects[id]));
obj.enumIds = JSON.parse(JSON.stringify(e.enumIds));
obj.enumNames = JSON.parse(JSON.stringify(e.enumNames));
if (typeof enumName === 'string') {
const r = new RegExp('^enum\\.' + enumName + '\\.');
for (let i = obj.enumIds.length - 1; i >= 0; i--) {
if (!r.test(obj.enumIds[i])) {
obj.enumIds.splice(i, 1);
obj.enumNames.splice(i, 1);
}
}
}
if (sandbox.verbose) sandbox.log('getObject(id=' + id + ', enumName=' + enumName + ') => ' + JSON.stringify(obj), 'info');
return obj;
} else {
let result;
try {
result = JSON.parse(JSON.stringify(objects[id]));
} catch (err) {
adapter.log.error('Object "' + id + '" can\'t be copied');
return null;
}
if (sandbox.verbose) sandbox.log('getObject(id=' + id + ', enumName=' + enumName + ') => ' + JSON.stringify(result), 'info');
return result;
}
}
},
setObject: function (id, obj, callback) {
adapter.log.error('Function "setObject" is not allowed. Use adapter settings to allow it.');
if (typeof callback === 'function') {
try {
callback.call(sandbox, 'Function "setObject" is not allowed. Use adapter settings to allow it.');
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
},
extendObject: function (id, obj, callback) {
adapter.log.error('Function "extendObject" is not allowed. Use adapter settings to allow it.');
if (typeof callback === 'function') {
try {
callback.call(sandbox, 'Function "extendObject" is not allowed. Use adapter settings to allow it.');
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
},
getEnums: function (enumName) {
const result = [];
const r = enumName ? new RegExp('^enum\\.' + enumName + '\\.') : false;
for (let i = 0; i < enums.length; i++) {
if (!r || r.test(enums[i])) {
result.push({
id: enums[i],
members: (objects[enums[i]].common) ? objects[enums[i]].common.members : [],
name: objects[enums[i]].common.name
});
}
}
if (sandbox.verbose) sandbox.log('getEnums(enumName=' + enumName + ') => ' + JSON.stringify(result), 'info');
return JSON.parse(JSON.stringify(result));
},
createState: function (name, initValue, forceCreation, common, native, callback) {
if (typeof native === 'function') {
callback = native;
native = {};
}
if (typeof common === 'function') {
callback = common;
common = undefined;
}
if (typeof initValue === 'function') {
callback = initValue;
initValue = undefined;
}
if (typeof forceCreation === 'function') {
callback = forceCreation;
forceCreation = undefined;
}
if (typeof initValue === 'object') {
common = initValue;
native = forceCreation;
forceCreation = undefined;
initValue = undefined;
}
if (typeof forceCreation === 'object') {
common = forceCreation;
native = common;
forceCreation = undefined;
}
common = common || {};
common.name = common.name || name;
common.role = common.role || 'javascript';
common.type = common.type || 'mixed';
if (initValue === undefined) initValue = common.def;
native = native || {};
// Check min, max and def values for number
if (common.type !== undefined && common.type === 'number') {
let min = 0;
let max = 0;
let def = 0;
let err;
if (common.min !== undefined) {
min = common.min;
if (typeof min !== 'number') {
min = parseFloat(min);
if (isNaN(min)) {
err = 'Wrong type of ' + name + '.common.min';
sandbox.log(err, 'error');
if (typeof callback === 'function') {
try {
callback.call(sandbox, err);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
return;
} else {
common.min = min;
}
}
}
if (common.max !== undefined) {
max = common.max;
if (typeof max !== 'number') {
max = parseFloat(max);
if (isNaN(max)) {
err = 'Wrong type of ' + name + '.common.max';
sandbox.log(err, 'error');
if (typeof callback === 'function') {
try {
callback.call(sandbox, err);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
return;
} else {
common.max = max;
}
}
}
if (common.def !== undefined) {
def = common.def;
if (typeof def !== 'number') {
def = parseFloat(def);
if (isNaN(def)) {
err = 'Wrong type of ' + name + '.common.def';
sandbox.log(err, 'error');
if (typeof callback === 'function') {
try {
callback.call(sandbox, err);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
return;
} else {
common.def = def;
}
}
}
if (common.min !== undefined && common.max !== undefined && min > max) {
common.max = min;
common.min = max;
}
if (common.def !== undefined && common.min !== undefined && def < min) common.def = min;
if (common.def !== undefined && common.max !== undefined && def > max) common.def = max;
}
if (sandbox.verbose) sandbox.log('createState(name=' + name + ', initValue=' + initValue + ', forceCreation=' + forceCreation + ', common=' + JSON.stringify(common) + ', native=' + JSON.stringify(native) + ')', 'debug');
if (forceCreation) {
// todo: store object in objects to have this object directly after callback
adapter.setObject(name, {
common: common,
native: native,
type: 'state'
}, function (err) {
if (err) adapter.log.warn('Cannot set object "' + name + '": ' + err);
if (initValue !== undefined) {
if (typeof initValue === 'object' && initValue.ack !== undefined) {
adapter.setState(name, initValue, callback);
} else {
adapter.setState(name, initValue, true, callback);
}
} else {
if (typeof callback === 'function') {
try {
callback.call(sandbox, name);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
}
});
} else {
adapter.getObject(name, function (err, obj) {
if (err || !obj) {
// todo: store object in objects to have this object directly after callback
// create new one
if (name.match(/^javascript\.\d+\./)) {
adapter.setForeignObject(name, {
common: common,
native: native,
type: 'state'
}, function (err) {
if (err) adapter.log.warn('Cannot set object "' + name + '": ' + err);
if (initValue !== undefined) {
adapter.setForeignState(name, initValue, callback);
if (typeof initValue === 'object' && initValue.ack !== undefined) {
adapter.setForeignState(name, initValue, callback);
} else {
adapter.setForeignState(name, initValue, true, callback);
}
} else {
adapter.setForeignState(name, null, true, callback);
}
});
} else {
adapter.setObject(name, {
common: common,
native: native,
type: 'state'
}, function (err) {
if (err) adapter.log.warn('Cannot set object "' + name + '": ' + err);
if (initValue !== undefined) {
if (typeof initValue === 'object' && initValue.ack !== undefined) {
adapter.setState(name, initValue, callback);
} else {
adapter.setState(name, initValue, true, callback);
}
} else {
adapter.setState(name, null, true, callback);
}
});
}
} else {
if (!adapter.config.subscribe && !states[name] && !states[adapter.namespace + '.' + name]) {
if (name.substring(0, adapter.namespace.length) !== adapter.namespace) {
states[adapter.namespace + '.' + name] = {val: null, ack: true};
} else {
states[name] = {val: null, ack: true};
}
}
// state yet exists
if (typeof callback === 'function') {
try {
callback.call(sandbox, name);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
}
});
}
},
deleteState: function (id, callback) {
// todo: check rights
let found = false;
if (objects[id]) {
found = true;
delete objects[id];
}
if (states[id]) delete states[id];
if (objects[adapter.namespace + '.' + id]) {
delete objects[adapter.namespace + '.' + id];
found = true;
}
if (states[adapter.namespace + '.' + id]) delete states[adapter.namespace + '.' + id];
if (sandbox.verbose) sandbox.log('deleteState(id=' + id + ')', 'debug');
adapter.delObject(id, function (err) {
if (err) adapter.log.warn('Object for state "' + id + '" does not exist: ' + err);
adapter.delState(id, function (err) {
if (err) adapter.log.error('Cannot delete state "' + id + '": ' + err);
if (typeof callback === 'function') {
if (typeof callback === 'function') {
try {
callback.call(sandbox, err, found);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
}
});
});
},
sendTo: function (_adapter, cmd, msg, callback) {
if (sandbox.verbose) sandbox.log('sendTo(adapter=' + _adapter + ', cmd=' + cmd + ', msg=' + JSON.stringify(msg) + ')', 'info');
adapter.sendTo(_adapter, cmd, msg, callback);
},
sendto: function (_adapter, cmd, msg, callback) {
return sandbox.sendTo(_adapter, cmd, msg, callback);
},
sendToHost: function (host, cmd, msg, callback) {
if (!adapter.config.enableSendToHost) {
const error = 'sendToHost is not available. Please enable "Enable SendToHost" option in instance settings';
adapter.log.error(error);
sandbox.log(error);
if (typeof callback === 'function') {
setImmediate(function () {
callback(error);
});
}
} else {
if (sandbox.verbose) sandbox.log('sendToHost(adapter=' + host + ', cmd=' + cmd + ', msg=' + JSON.stringify(msg) + ')', 'info');
adapter.sendToHost(host, cmd, msg, callback);
}
},
setInterval: function (callback, ms, arg1, arg2, arg3, arg4) {
if (typeof callback === 'function') {
const int = setInterval(function (_arg1, _arg2, _arg3, _arg4) {
try {
callback.call(sandbox, _arg1, _arg2, _arg3, _arg4);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, ms, arg1, arg2, arg3, arg4);
script.intervals.push(int);
if (sandbox.verbose) sandbox.log('setInterval(ms=' + ms + ')', 'info');
return int;
} else {
sandbox.log('Invalid callback for setInterval! - ' + typeof callback, 'error');
return null;
}
},
clearInterval: function (id) {
const pos = script.intervals.indexOf(id);
if (pos !== -1) {
if (sandbox.verbose) sandbox.log('clearInterval() => cleared', 'info');
clearInterval(id);
script.intervals.splice(pos, 1);
} else {
if (sandbox.verbose) sandbox.log('clearInterval() => not found', 'warn');
}
},
setTimeout: function (callback, ms, arg1, arg2, arg3, arg4) {
if (typeof callback === 'function') {
const to = setTimeout(function (_arg1, _arg2, _arg3, _arg4) {
// Remove timeout from the list
const pos = script.timeouts.indexOf(to);
if (pos !== -1) script.timeouts.splice(pos, 1);
try {
callback.call(sandbox, _arg1, _arg2, _arg3, _arg4);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, ms, arg1, arg2, arg3, arg4);
if (sandbox.verbose) sandbox.log('setTimeout(ms=' + ms + ')', 'info');
script.timeouts.push(to);
return to;
} else {
sandbox.log('Invalid callback for setTimeout! - ' + typeof callback, 'error');
return null;
}
},
clearTimeout: function (id) {
const pos = script.timeouts.indexOf(id);
if (pos !== -1) {
if (sandbox.verbose) sandbox.log('clearTimeout() => cleared', 'info');
clearTimeout(id);
script.timeouts.splice(pos, 1);
} else {
if (sandbox.verbose) sandbox.log('clearTimeout() => not found', 'warn');
}
},
setImmediate: function (callback, arg1, arg2, arg3, arg4, arg5) {
if (typeof callback === 'function') {
setImmediate(function (_arg1, _arg2, _arg3, _arg4, _arg5) {
try {
callback.call(sandbox, _arg1, _arg2, _arg3, _arg4, _arg5);
} catch (e) {
errorInCallback(e);
}
}, arg1, arg2, arg3, arg4, arg5);
if (sandbox.verbose) sandbox.log('setImmediate()', 'info');
} else {
sandbox.log('Invalid callback for setImmediate! - ' + typeof callback, 'error');
}
},
cb: function (callback) {
return function () {
if (context.scripts[name] && context.scripts[name]._id === sandbox._id) {
if (typeof callback === 'function') {
try {
callback.apply(this, arguments);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}
} else {
adapter.log.warn('Callback for old version of script: ' + name);
}
};
},
compareTime: function (startTime, endTime, operation, time) {
let pos;
if (startTime && typeof startTime === 'string') {
if ((pos = consts.astroListLow.indexOf(startTime.toLowerCase())) !== -1) {
startTime = sandbox.getAstroDate(consts.astroList[pos]);
startTime = startTime.toLocaleTimeString([], {
hour: '2-digit',
minute: '2-digit',
hour12: false
});
}
} else if (startTime && typeof startTime === 'object' && startTime.astro) {
startTime = sandbox.getAstroDate(startTime.astro, startTime.date || new Date(), startTime.offset || 0);
startTime = startTime.toLocaleTimeString([], {
hour: '2-digit',
minute: '2-digit',
hour12: false
});
}
if (endTime && typeof endTime === 'string') {
if ((pos = consts.astroListLow.indexOf(endTime.toLowerCase())) !== -1) {
endTime = sandbox.getAstroDate(consts.astroList[pos]);
endTime = endTime.toLocaleTimeString([], {
hour: '2-digit',
minute: '2-digit',
hour12: false
});
}
} else if (endTime && typeof endTime === 'object' && endTime.astro) {
endTime = sandbox.getAstroDate(endTime.astro, endTime.date || new Date(), endTime.offset || 0);
endTime = endTime.toLocaleTimeString([], {
hour: '2-digit',
minute: '2-digit',
hour12: false
});
}
if (time && typeof time === 'string') {
if ((pos = consts.astroListLow.indexOf(time.toLowerCase())) !== -1) {
time = sandbox.getAstroDate(consts.astroList[pos]);
}
} else if (time && typeof time === 'object' && time.astro) {
time = sandbox.getAstroDate(time.astro, time.date || new Date(), time.offset || 0);
}
let daily = true;
if (time) {
daily = false;
}
if (time && typeof time !== 'object') {
if (typeof time === 'string' && time.indexOf(' ') === -1 && time.indexOf('T') === -1) {
const parts = time.split(':');
time = new Date();
time.setHours(parseInt(parts[0], 10));
time.setMinutes(parseInt(parts[1], 10));
time.setMilliseconds(0);
if (parts.length === 3) {
time.setSeconds(parseInt(parts[2], 10));
} else {
time.setSeconds(0);
}
} else {
time = new Date(time);
}
} else if (!time) {
time = new Date();
time.setMilliseconds(0);
}
if (typeof startTime === 'string') {
if (startTime.indexOf(' ') === -1 && startTime.indexOf('T') === -1) {
const parts = startTime.split(':');
startTime = new Date();
startTime.setHours(parseInt(parts[0], 10));
startTime.setMinutes(parseInt(parts[1], 10));
startTime.setMilliseconds(0);
if (parts.length === 3) {
startTime.setSeconds(parseInt(parts[2], 10));
} else {
startTime.setSeconds(0);
}
} else {
daily = false;
startTime = new Date(startTime);
}
} else {
daily = false;
startTime = new Date(startTime);
}
startTime = startTime.getTime();
if (endTime && typeof endTime === 'string') {
if (endTime.indexOf(' ') === -1 && endTime.indexOf('T') === -1) {
const parts = endTime.split(':');
endTime = new Date();
endTime.setHours(parseInt(parts[0], 10));
endTime.setMinutes(parseInt(parts[1], 10));
endTime.setMilliseconds(0);
if (parts.length === 3) {
endTime.setSeconds(parseInt(parts[2], 10));
} else {
endTime.setSeconds(0);
}
} else {
daily = false;
endTime = new Date(endTime);
}
} else if (endTime) {
daily = false;
endTime = new Date(endTime);
} else {
endTime = null;
}
if (endTime) endTime = endTime.getTime();
if (operation === 'between') {
if (endTime) {
if (startTime > endTime && daily) return !(time >= endTime && time < startTime);
else return time >= startTime && time < endTime;
} else {
adapter.log.warn('missing or unrecognized endTime expression: ' + endTime);
return false;
}
} else if (operation === 'not between') {
if (endTime) {
if (startTime > endTime && daily) return time >= endTime && time < startTime;
else return !(time >= startTime && time < endTime);
} else {
adapter.log.warn('missing or unrecognized endTime expression: ' + endTime);
return false;
}
} else if (operation === '>') {
return time > startTime;
} else if (operation === '>=') {
return time >= startTime;
} else if (operation === '<') {
return time < startTime;
} else if (operation === '<=') {
return time <= startTime;
} else if (operation === '==') {
return time === startTime;
} else if (operation === '<>') {
return time !== startTime;
} else {
adapter.log.warn('Invalid operator: ' + operation);
return false;
}
},
onStop: function (cb, timeout) {
if (sandbox.verbose) sandbox.log('onStop(timeout=' + timeout + ')', 'info');
script.onStopCb = cb;
script.onStopTimeout = timeout || 1000;
},
formatValue: function (value, decimals, format) {
if (!format && objects['system.config']) {
format = objects['system.config'].common.isFloatComma ? '.,' : ',.';
}
return adapter.formatValue(value, decimals, format);
},
formatDate: function (date, format, language) {
if (!format) {
format = objects['system.config'] ? (objects['system.config'].common.dateFormat || 'DD.MM.YYYY') : 'DD.MM.YYYY';
}
if (format.match(/[WНOО]+/)) {
let text = adapter.formatDate(date, format);
if (!language || !consts.dayOfWeeksFull[language]) language = objects['system.config'].common.language;
const d = date.getDay();
text = text.replace('WW', consts.dayOfWeeksFull[language][d]);
text = text.replace('НН', consts.dayOfWeeksFull[language][d]);
text = text.replace('W', consts.dayOfWeeksShort[language][d]);
text = text.replace('Н', consts.dayOfWeeksShort[language][d]);
text = text.replace('W', consts.dayOfWeeksShort[language][d]);
text = text.replace('Н', consts.dayOfWeeksShort[language][d]);
const m = date.getMonth();
text = text.replace('OOO', consts.monthFullGen[language][m]);
text = text.replace('ООО', consts.monthFullGen[language][m]);
text = text.replace('OO', consts.monthFull[language][m]);
text = text.replace('ОО', consts.monthFull[language][m]);
text = text.replace('O', consts.monthShort[language][m]);
text = text.replace('О', consts.monthShort[language][m]);
text = text.replace('O', consts.monthShort[language][m]);
text = text.replace('О', consts.monthShort[language][m]);
return text;
} else {
return adapter.formatDate(date, format);
}
},
getDateObject: function (date) {
if (typeof date === 'object') return date;
if (typeof date !== 'string') return new Date(date);
if (date.match(/^\d?\d$/)) {
const _now = new Date();
date = _now.getFullYear() + '-' + (_now.getMonth() + 1) + '-' + _now.getDate() + ' ' + date + ':00';
} else {
// 20:00, 2:00, 20:00:00, 2:00:00
if (date.match(/^\d?\d:\d\d(:\d\d)?$/)) {
const now = new Date();
date = now.getFullYear() + '-' + (now.getMonth() + 1) + '-' + now.getDate() + ' ' + date;
}
}
return new Date(date);
},
writeFile: function (_adapter, fileName, data, callback) {
if (typeof data === 'function' || !data) {
callback = data;
data = fileName;
fileName = _adapter;
_adapter = null;
}
if (debug) {
sandbox.log('readFile(adapter=' + _adapter + ', fileName=' + fileName + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
if (typeof callback === 'function') {
setTimeout(function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, 0);
}
} else {
if (sandbox.verbose) sandbox.log('readFile(adapter=' + _adapter + ', fileName=' + fileName + ')', 'info');
adapter.writeFile(_adapter, fileName, data, callback);
}
},
readFile: function (_adapter, fileName, callback) {
if (typeof fileName === 'function') {
callback = fileName;
fileName = _adapter;
_adapter = null;
}
if (sandbox.verbose) sandbox.log('readFile(adapter=' + _adapter + ', fileName=' + fileName + ')', 'info');
adapter.readFile(_adapter, fileName, callback);
},
unlink: function (_adapter, fileName, callback) {
if (typeof fileName === 'function') {
callback = fileName;
fileName = _adapter;
_adapter = null;
}
if (sandbox.verbose) sandbox.log('unlink(adapter=' + _adapter + ', fileName=' + fileName + ')', 'info');
if (debug) {
sandbox.log('unlink(adapter=' + _adapter + ', fileName=' + fileName + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
if (typeof callback === 'function') {
setTimeout(function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, 0);
}
} else {
if (sandbox.verbose) sandbox.log('unlink(adapter=' + _adapter + ', fileName=' + fileName + ')', 'info');
adapter.unlink(_adapter, fileName, callback);
}
},
delFile: function (_adapter, fileName, callback) {
return sandbox.unlink(_adapter, fileName, callback);
},
getHistory: function (instance, options, callback) {
if (typeof instance === 'object') {
callback = options;
options = instance;
instance = null;
}
if (typeof callback !== 'function') {
adapter.log.error('No callback found!');
return;
}
if (typeof options !== 'object') {
adapter.log.error('No options found!');
return;
}
if (!options.id) {
adapter.log.error('No ID found!');
return;
}
const timeoutMs = parseInt(options.timeout, 10) || 20000;
if (!instance) {
instance = objects['system.config'] ? objects['system.config'].common.defaultHistory : null;
}
if (sandbox.verbose) sandbox.log('getHistory(instance=' + instance + ', options=' + JSON.stringify(options) + ')', 'debug');
if (!instance) {
adapter.log.error('No default history instance found!');
try {
callback.call(sandbox, 'No default history instance found!');
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
return;
}
if (instance.match(/^system\.adapter\./)) instance = instance.substring('system.adapter.'.length);
if (!objects['system.adapter.' + instance]) {
adapter.log.error('Instance "' + instance + '" not found!');
try {
callback.call(sandbox, 'Instance "' + instance + '" not found!');
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
return;
}
let timeout = setTimeout(function () {
timeout = null;
if (sandbox.verbose) sandbox.log('getHistory => timeout', 'debug');
if (typeof callback === 'function') {
try {
callback.call(sandbox, 'Timeout', null, options, instance);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
callback = null;
}
}, timeoutMs);
adapter.sendTo(instance, 'getHistory', {id: options.id, options: options}, function (result) {
if (timeout) clearTimeout(timeout);
if (sandbox.verbose && result.error) sandbox.log('getHistory => ' + result.error, 'error');
if (sandbox.verbose && result.result) sandbox.log('getHistory => ' + result.result.length + ' items', 'debug');
if (typeof callback === 'function') {
try {
callback.call(sandbox, result.error, result.result, options, instance);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
callback = null;
}
});
},
runScript: function (scriptName, callback) {
scriptName = scriptName || name;
if (!scriptName.match(/^script\.js\./)) scriptName = 'script.js.' + scriptName;
// start other script
if (!objects[scriptName] || !objects[scriptName].common) {
sandbox.log('Cannot start "' + scriptName + '", because not found', 'error');
return false;
} else {
if (debug) {
sandbox.log('runScript(scriptName=' + scriptName + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
} else {
if (objects[scriptName].common.enabled) {
objects[scriptName].common.enabled = false;
adapter.extendForeignObject(scriptName, {common: {enabled: false}}, function (/* err, obj */) {
adapter.extendForeignObject(scriptName, {common: {enabled: true}}, function (err) {
if (callback === 'function') callback(err);
});
scriptName = null;
});
} else {
adapter.extendForeignObject(scriptName, {common: {enabled: true}}, function (err) {
if (callback === 'function') callback(err);
});
}
}
return true;
}
},
startScript: function (scriptName, ignoreIfStarted, callback) {
if (typeof ignoreIfStarted === 'function') {
callback = ignoreIfStarted;
ignoreIfStarted = false;
}
scriptName = scriptName || name;
if (!scriptName.match(/^script\.js\./)) scriptName = 'script.js.' + scriptName;
// start other script
if (!objects[scriptName] || !objects[scriptName].common) {
sandbox.log('Cannot start "' + scriptName + '", because not found', 'error');
return false;
} else {
console.log('STARTING!');
if (debug) {
sandbox.log('startScript(scriptName=' + scriptName + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
} else {
if (objects[scriptName].common.enabled) {
if (!ignoreIfStarted) {
objects[scriptName].common.enabled = false;
adapter.extendForeignObject(scriptName, {common: {enabled: false}}, function (err) {
adapter.extendForeignObject(scriptName, {common: {enabled: true}}, function (err) {
if (callback === 'function') callback(err, true);
});
scriptName = null;
});
} else if (callback === 'function') {
callback(null, false);
}
} else {
adapter.extendForeignObject(scriptName, {common: {enabled: true}}, function (err) {
if (callback === 'function') callback(err, true);
});
}
}
return true;
}
},
stopScript: function (scriptName, callback) {
scriptName = scriptName || name;
if (!scriptName.match(/^script\.js\./)) scriptName = 'script.js.' + scriptName;
// stop other script
if (!objects[scriptName] || !objects[scriptName].common) {
sandbox.log('Cannot stop "' + scriptName + '", because not found', 'error');
return false;
} else {
if (debug) {
sandbox.log('stopScript(scriptName=' + scriptName + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
} else {
if (objects[scriptName].common.enabled) {
objects[scriptName].common.enabled = false;
adapter.extendForeignObject(scriptName, {common: {enabled: false}}, function (err) {
if (callback === 'function') callback(err, true);
scriptName = null;
});
} else if (callback === 'function') {
callback(null, false);
}
}
return true;
}
},
isScriptActive: function (scriptName) {
if (!scriptName.match(/^script\.js\./)) scriptName = 'script.js.' + scriptName;
if (!objects[scriptName] || !objects[scriptName].common) {
sandbox.log('Script does not exist', 'error');
return false;
} else {
return objects[scriptName].common.enabled;
}
},
toInt: function (val) {
if (val === true || val === 'true') val = 1;
if (val === false || val === 'false') val = 0;
val = parseInt(val) || 0;
return val;
},
toFloat: function (val) {
if (val === true || val === 'true') val = 1;
if (val === false || val === 'false') val = 0;
val = parseFloat(val) || 0;
return val;
},
toBoolean: function (val) {
if (val === '1' || val === 'true') val = true;
if (val === '0' || val === 'false') val = false;
return !!val;
},
getAttr: function (obj, path) {
if (typeof path === 'string') {
path = path.split('.');
}
if (typeof obj === 'string') {
try {
obj = JSON.parse(obj);
} catch (e) {
sandbox.log('Cannot parse "' + obj.substring(0, 30) + '"' + e, 'error');
return null;
}
}
const attr = path.shift();
try {
obj = obj[attr];
} catch (e) {
sandbox.log(`Cannot get ${attr} of ${JSON.stringify(obj)}`, 'error');
return null;
}
if (!path.length) {
return obj;
} else {
const type = typeof obj;
if (obj === null || obj === undefined || type === 'boolean' || type === 'number') {
return null;
} else {
return sandbox.getAttr(obj, path);
}
}
},
console: {
log: function (msg) {
sandbox.log(msg, 'info');
},
error: function (msg) {
sandbox.log(msg, 'error');
},
warn: function (msg) {
sandbox.log(msg, 'warn');
},
debug: function (msg) {
sandbox.log(msg, 'debug');
}
}
};
if (adapter.config.enableSetObject) {
sandbox.setObject = function (id, obj, callback) {
if (debug) {
sandbox.log('setObject(id=' + id + ', obj=' + JSON.stringify(obj) + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
if (typeof callback === 'function') {
setTimeout(function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, 0);
}
} else {
if (sandbox.verbose) sandbox.log('setObject(id=' + id + ', obj=' + JSON.stringify(obj) + ')', 'info');
adapter.setForeignObject(id, obj, callback);
}
};
sandbox.extendObject = function (id, obj, callback) {
if (debug) {
sandbox.log('extendObject(id=' + id + ', obj=' + JSON.stringify(obj) + ') - ' + words._('was not executed, while debug mode is active'), 'warn');
if (typeof callback === 'function') {
setTimeout(function () {
try {
callback.call(sandbox);
} catch (e) {
errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
}
}, 0);
}
} else {
if (sandbox.verbose) sandbox.log('extendObject(id=' + id + ', obj=' + JSON.stringify(obj) + ')', 'info');
adapter.extendForeignObject(id, obj, callback);
}
};
}
// Make all predefined properties and methods readonly so scripts cannot overwrite them
for (const prop in sandbox) {
if (sandbox.hasOwnProperty(prop)) {
Object.defineProperty(sandbox, prop, {
configurable: false,
writable: false
});
}
}
return sandbox;
}
module.exports = sandBox;
Reference in New Issue Copy Permalink