iobroker.javascript 6.2.0 → 7.0.0

package/lib/sandbox.js

@@ -283,7 +283,7 @@ function sandBox(script, name, verbose, debug, context) {
      * @returns {Promise<void>}
      */
     async function ensureObjectStructure(id) {
-        //adapter.log.debug(`ensure Logic called for "${id}": ${verifiedObjects[id]}`);
+        // adapter.log.debug(`ensure Logic called for "${id}": ${verifiedObjects[id]}`);
         if (!validIdForAutomaticFolderCreation(id)) {
             return;
         }
@@ -300,7 +300,7 @@ function sandBox(script, name, verbose, debug, context) {
 
         context.folderCreationVerifiedObjects[id] = true;
         for (const part of idArr) {
-            idToCheck += '.' + part;
+            idToCheck += `.${part}`;
             //adapter.log.debug(`    check "${idToCheck}": ${verifiedObjects[idToCheck]}`);
             if (context.folderCreationVerifiedObjects[idToCheck] === true || objects[idToCheck]) {
                 continue;
@@ -318,11 +318,11 @@ function sandBox(script, name, verbose, debug, context) {
                     await adapter.setForeignObjectAsync(idToCheck, {
                         type: 'folder',
                         common: {
-                            name: part
+                            name: part,
                         },
                         native: {
-                            autocreated: 'by automatic ensure logic'
-                        }
+                            autocreated: 'by automatic ensure logic',
+                        },
                     });
                 } catch (err) {
                     adapter.log.info(`Could not automatically create folder object ${idToCheck}: ${err.message}`);
@@ -416,7 +416,7 @@ function sandBox(script, name, verbose, debug, context) {
                         try {
                             callback.call(sandbox, `Could not stringify value for type ${actualCommonType} and id ${id}: ${err.message}`);
                         } catch (e) {
-                            errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
+                            errorInCallback(e); // adapter.log.error('Error in callback: ' + e)
                         }
                     }
                 }
@@ -469,7 +469,7 @@ function sandBox(script, name, verbose, debug, context) {
                     context.interimStateValues[id] = state;
                 }
                 setStateFunc(id, state, err => {
-                    err && sandbox.log('setForeignState: ' + err, 'error');
+                    err && sandbox.log(`setForeignState: ${err}`, 'error');
                     // If adapter holds all states
                     if (err && !adapter.config.subscribe) {
                         delete context.interimStateValues[id];
@@ -480,7 +480,7 @@ function sandBox(script, name, verbose, debug, context) {
                             try {
                                 callback.call(sandbox);
                             } catch (e) {
-                                errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
+                                errorInCallback(e); // adapter.log.error('Error in callback: ' + e)
                             }
                         });
                     }
@@ -493,7 +493,7 @@ function sandBox(script, name, verbose, debug, context) {
                     try {
                         callback.call(sandbox, `State "${id}" not found`);
                     } catch (e) {
-                        errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
+                        errorInCallback(e); // adapter.log.error('Error in callback: ' + e)
                     }
                 });
             }
@@ -1027,6 +1027,7 @@ function sandBox(script, name, verbose, debug, context) {
                 return this;
             };
             result.setBinaryState = function (state, isAck, callback) {
+                sandbox.log(`$.setBinaryState(id=${this[0]}) is deprecated. Please use Files instead!`, 'info');
                 if (typeof isAck === 'function') {
                     callback = isAck;
                     isAck = undefined;
@@ -1037,6 +1038,7 @@ function sandBox(script, name, verbose, debug, context) {
                 return this;
             };
             result.setBinaryStateAsync = async function (state, isAck) {
+                sandbox.log(`$.setBinaryStateAsync(id=${this[0]}) is deprecated. Please use Files instead!`, 'info');
                 if (isAck === true || isAck === false || isAck === 'true' || isAck === 'false') {
                     if (isObject(state)) {
                         state.ack = isAck;
@@ -1935,17 +1937,17 @@ function sandBox(script, name, verbose, debug, context) {
                             return context.convertBackStringifiedValues(id, context.interimStateValues[id]);
                         }
                         return context.convertBackStringifiedValues(id, states[id]);
-                    } else if (states[adapter.namespace + '.' + id]) {
-                        sandbox.verbose && sandbox.log(`getState(id=${id}, timerId=${timers[id]}) => ${states[adapter.namespace + '.' + id]}`, 'info');
-                        if (context.interimStateValues[adapter.namespace + '.' + id] !== undefined) {
-                            return context.convertBackStringifiedValues(id, context.interimStateValues[adapter.namespace + '.' + id]);
+                    } else if (states[`${adapter.namespace}.${id}`]) {
+                        sandbox.verbose && sandbox.log(`getState(id=${id}, timerId=${timers[id]}) => ${states[`${adapter.namespace}.${id}`]}`, 'info');
+                        if (context.interimStateValues[`${adapter.namespace}.${id}`] !== undefined) {
+                            return context.convertBackStringifiedValues(id, context.interimStateValues[`${adapter.namespace}.${id}`]);
                         }
-                        return context.convertBackStringifiedValues(id, states[adapter.namespace + '.' + id]);
+                        return context.convertBackStringifiedValues(id, states[`${adapter.namespace}.${id}`]);
                     }
 
                     sandbox.verbose && sandbox.log(`getState(id=${id}, timerId=${timers[id]}) => not found`, 'info');
 
-                    context.logWithLineInfo && context.logWithLineInfo.warn(`getState "${id}" not found (3)${states[id] !== undefined ? ' states[id]=' + states[id] : ''}`);     ///xxx
+                    context.logWithLineInfo && context.logWithLineInfo.warn(`getState "${id}" not found (3)${states[id] !== undefined ? ` states[id]=${states[id]}` : ''}`);     ///xxx
                     return {val: null, notExist: true};
                 }
             }
@@ -1964,8 +1966,15 @@ function sandBox(script, name, verbose, debug, context) {
         },
         existsState: function (id, callback) {
             if (typeof callback === 'function') {
-                adapter.getForeignObject(id, (err, obj) =>
-                    callback(err, obj && obj.type === 'state' && !!states[id]));
+                adapter.getForeignObject(id, (err, obj) => {
+                    if (adapter.config.subscribe) {
+                        adapter.getForeignState(id, (err, state) => {
+                            callback(err, obj && obj.type === 'state' && !!state);
+                        });
+                    } else {
+                        callback(err, obj && obj.type === 'state' && !!states[id]);
+                    }
+                });
             } else {
                 return !!states[id];
             }
@@ -2144,7 +2153,7 @@ function sandBox(script, name, verbose, debug, context) {
             }
 
             if (!name.startsWith('alias.0.')) {
-                name = 'alias.0.' + name;
+                name = `alias.0.${name}`;
             }
 
             common = common || {};
@@ -2231,7 +2240,7 @@ function sandBox(script, name, verbose, debug, context) {
 
             return sandbox.createState(name, undefined, forceCreation, common, native, callback);
         },
-        createState: function (name, initValue, forceCreation, common, native, callback) {
+        createState: async function (name, initValue, forceCreation, common, native, callback) {
             if (typeof native === 'function') {
                 callback = native;
                 native   = {};
@@ -2358,7 +2367,7 @@ function sandBox(script, name, verbose, debug, context) {
                                     try {
                                         callback.call(sandbox, err);
                                     } catch (e) {
-                                        errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
+                                        errorInCallback(e); // adapter.log.error('Error in callback: ' + e)
                                     }
                                 }
                                 return;
@@ -2382,7 +2391,7 @@ function sandBox(script, name, verbose, debug, context) {
 
             sandbox.verbose && sandbox.log(`createState(name=${name}, initValue=${initValue}, forceCreation=${forceCreation}, common=${JSON.stringify(common)}, native=${JSON.stringify(native)}, isAlias=${isAlias})`, 'debug');
 
-            let id = adapter.namespace + '.' + name;
+            let id = `${adapter.namespace}.${name}`;
             if (name.match(/^javascript\.\d+\./) || name.startsWith('0_userdata.0.') || isAlias) {
                 id = name;
             }
@@ -2391,79 +2400,212 @@ function sandBox(script, name, verbose, debug, context) {
             } else if (id.match(/^javascript\.\d+\.scriptProblem/)) {
                 sandbox.log(`Own states (${id}) should not be created in javascript.X.scriptProblem.*! Please move the states to 0_userdata.0.*`, 'info');
             }
-            adapter.getForeignObject(id,  async (err, obj) => {
-                if (obj && obj._id && validIdForAutomaticFolderCreation(obj._id) && obj.type === 'folder' && obj.native && obj.native.autocreated === 'by automatic ensure logic') {
-                    // ignore default created object because we now have a more defined one
-                    obj = null;
+
+            // User can create aliases by two ways:
+            // - id is starting with "alias.0." and common.alias.id is set, so the state defined in common.alias.id will be created automatically if not exists
+            // - id is not starting with "alias.0.", but common.alias is set, so the state defined in common.alias will be created automatically if not exists
+            if (!isAlias && common.alias) {
+                // check and create if not exists the alias
+                let alias = common.alias;
+                delete common.alias;
+                if (typeof alias === 'string') {
+                    alias = {
+                        id: alias,
+                    };
+                } else if (typeof alias === 'boolean') {
+                    const parts = id.split('.');
+                    parts[0] = 'alias';
+                    parts[1] = '0';
+
+                    alias = {
+                        id: parts.join('.'),
+                    };
+                }
+
+                if (!alias.id.startsWith('alias.0.')) {
+                    alias.id = `alias.0.${alias.id}`;
                 }
 
-                if (err || !obj || forceCreation) {
-                    // create new one
-                    const newObj = {
-                        common,
-                        native,
-                        type: 'state'
+                let aObj;
+                try {
+                    aObj = await adapter.getForeignObjectAsync(alias.id);
+                } catch (e) {
+                    // ignore
+                }
+                if (!aObj) {
+                    try {
+                        await adapter.setForeignObjectAsync(alias.id, {
+                            type: 'state',
+                            common: {
+                                name: `Alias to ${id}`,
+                                role: 'state',
+                                type: common.type,
+                                read: common.read,
+                                write: common.write,
+                                unit: common.unit,
+                                alias: {
+                                    id,
+                                    read: alias.read,
+                                    write: alias.write,
+                                },
+                            },
+                            native: {},
+                        });
+                    } catch (e) {
+                        adapter.log.error(`Cannot create alias "${alias.id}": ${e}`);
+                    }
+                }
+            } else if (isAlias && common.alias) {
+                if (typeof common.alias === 'string') {
+                    common.alias = {
+                        id: common.alias,
                     };
-                    adapter.setForeignObject(id, newObj, async (err) => {
-                        if (err) {
-                            adapter.log.warn(`Cannot set object "${id}": ${err}`);
-                            if (typeof callback === 'function') {
-                                try {
-                                    callback.call(sandbox, err);
-                                } catch (e) {
-                                    errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
-                                }
-                            }
-                            return;
+                }
+                const readId = typeof common.alias.id === 'string' ? common.alias.id : common.alias.id.read;
+                let writeId = typeof common.alias.id === 'string' ? common.alias.id : common.alias.id.write;
+                if (writeId === readId) {
+                    writeId = undefined;
+                }
+                // try to create the linked states
+                let aObj;
+                try {
+                    aObj = await adapter.getForeignObjectAsync(readId);
+                } catch (e) {
+                    // ignore
+                }
+                if (!aObj) {
+                    try {
+                        await adapter.setForeignObjectAsync(readId, {
+                            type: 'state',
+                            common: {
+                                name: `State for ${id}`,
+                                role: 'state',
+                                type: common.type,
+                                read: common.read,
+                                write: common.write,
+                                unit: common.unit,
+                            },
+                            native: {},
+                        });
+                    } catch (e) {
+                        adapter.log.error(`Cannot create alias "${readId}": ${e}`);
+                    }
+                }
+                if (writeId && common.write !== false) {
+                    try {
+                        aObj = await adapter.getForeignObjectAsync(writeId);
+                    } catch (e) {
+                        // ignore
+                    }
+                    if (!aObj) {
+                        try {
+                            await adapter.setForeignObjectAsync(writeId, {
+                                type: 'state',
+                                common: {
+                                    name: `Write state for ${id}`,
+                                    role: 'state',
+                                    type: common.type,
+                                    read: common.read,
+                                    write: common.write,
+                                    unit: common.unit,
+                                },
+                                native: {},
+                            });
+                        } catch (e) {
+                            adapter.log.error(`Cannot create alias "${writeId}": ${e}`);
                         }
+                    }
+                }
+            }
 
-                        // Update meta objects
-                        context.updateObjectContext(id, newObj);
+            let obj;
+            try {
+                obj = await adapter.getForeignObjectAsync(id);
+            } catch (err) {
+                // ignore
+            }
 
-                        if (!isAlias && initValue !== undefined) {
-                            if (isObject(initValue) && initValue.ack !== undefined) {
-                                setStateHelper(sandbox, false, id, initValue, callback);
-                            } else {
-                                setStateHelper(sandbox, false, id, initValue, true, callback);
-                            }
-                        } else if (!isAlias && !forceCreation) {
-                            setStateHelper(sandbox, false, id, null, callback);
-                        } else if (isAlias) {
-                            adapter.getForeignState(id, (err, state) => {
-                                console.log('getState ' + id + ' => ' + JSON.stringify(state));
-                                states[id] = state;
-                                if (typeof callback === 'function') {
-                                    try {
-                                        callback.call(sandbox, null, id);
-                                    } catch (e) {
-                                        errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
-                                    }
-                                }
-                            });
-                        } else if (typeof callback === 'function') {
-                            try {
-                                callback.call(sandbox, null, id);
-                            } catch (e) {
-                                errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
-                            }
+            if (obj &&
+                obj._id &&
+                validIdForAutomaticFolderCreation(obj._id) &&
+                obj.type === 'folder' &&
+                obj.native &&
+                obj.native.autocreated === 'by automatic ensure logic'
+            ) {
+                // ignore default created object because we now have a more defined one
+                obj = null;
+            }
+
+            if (!obj || forceCreation) {
+                // create new one
+                const newObj = {
+                    common,
+                    native,
+                    type: 'state',
+                };
+                try {
+                    await adapter.setForeignObjectAsync(id, newObj);
+                } catch (err) {
+                    adapter.log.warn(`Cannot set object "${id}": ${err}`);
+                    if (typeof callback === 'function') {
+                        try {
+                            callback.call(sandbox, err);
+                        } catch (e) {
+                            errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
                         }
-                        await ensureObjectStructure(id);
-                    });
-                } else {
-                    if (!adapter.config.subscribe && !states[id] && states[adapter.namespace + '.' + id] === undefined) {
-                        states[id] = {val: null, ack: true};
                     }
-                    // state yet exists
+                    return;
+                }
+
+                // Update meta objects
+                context.updateObjectContext(id, newObj);
+
+                if (!isAlias && initValue !== undefined) {
+                    if (isObject(initValue) && initValue.ack !== undefined) {
+                        setStateHelper(sandbox, false, id, initValue, callback);
+                    } else {
+                        setStateHelper(sandbox, false, id, initValue, true, callback);
+                    }
+                } else if (!isAlias && !forceCreation) {
+                    setStateHelper(sandbox, false, id, null, callback);
+                } else if (isAlias) {
+                    try {
+                        const state = await adapter.getForeignStateAsync(id);
+                        console.log(`getState ${id} => ${JSON.stringify(state)}`);
+                        states[id] = state;
+                    } catch (err) {
+                        // ignore
+                    }
                     if (typeof callback === 'function') {
                         try {
                             callback.call(sandbox, null, id);
                         } catch (e) {
-                            errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
+                            errorInCallback(e); // adapter.log.error('Error in callback: ' + e)
                         }
                     }
-                    await ensureObjectStructure(id);
+                } else if (typeof callback === 'function') {
+                    try {
+                        callback.call(sandbox, null, id);
+                    } catch (e) {
+                        errorInCallback(e); // adapter.log.error('Error in callback: ' + e)
+                    }
                 }
-            });
+                await ensureObjectStructure(id);
+            } else {
+                // state yet exists
+                if (!adapter.config.subscribe && !states[id] && states[`${adapter.namespace}.${id}`] === undefined) {
+                    states[id] = {val: null, ack: true};
+                }
+                if (typeof callback === 'function') {
+                    try {
+                        callback.call(sandbox, null, id);
+                    } catch (e) {
+                        errorInCallback(e); //adapter.log.error('Error in callback: ' + e)
+                    }
+                }
+
+                await ensureObjectStructure(id);
+            }
         },
         deleteState: function (id, callback) {
             // todo: check rights
@@ -2494,11 +2636,11 @@ function sandBox(script, name, verbose, debug, context) {
                     });
 
                 });
-            } else if (objects[adapter.namespace + '.' + id]) {
-                delete objects[adapter.namespace + '.' + id];
+            } else if (objects[`${adapter.namespace}.${id}`]) {
+                delete objects[`${adapter.namespace}.${id}`];
                 found = true;
-                if (states[adapter.namespace + '.' + id]) {
-                    delete states[adapter.namespace + '.' + id];
+                if (states[`${adapter.namespace}.${id}`]) {
+                    delete states[`${adapter.namespace}.${id}`];
                 }
 
                 adapter.delObject(id, function (err) {

package/main.js

@@ -143,10 +143,61 @@ function provideDeclarationsForGlobalScript(scriptID, declarations) {
     });
 }
 
+// taken from here: https://stackoverflow.com/questions/11887934/how-to-check-if-dst-daylight-saving-time-is-in-effect-and-if-so-the-offset
+function dstOffsetAtDate(dateInput) {
+    const fullYear = dateInput.getFullYear() | 0;
+    // "Leap Years are any year that can be exactly divided by 4 (2012, 2016, etc)
+    //   except if it can be exactly divided by 100, then it isn't (2100, 2200, etc)
+    //    except if it can be exactly divided by 400, then it is (2000, 2400)"
+    // (https://www.mathsisfun.com/leap-years.html).
+    const isLeapYear = ((fullYear & 3) | (fullYear/100 & 3)) === 0 ? 1 : 0;
+    // (fullYear & 3) = (fullYear % 4), but faster
+    //Alternative:var isLeapYear=(new Date(currentYear,1,29,12)).getDate()===29?1:0
+    const fullMonth = dateInput.getMonth() | 0;
+    return (
+        // 1. We know what the time since the Epoch really is
+        (+dateInput) // same as the dateInput.getTime() method
+        // 2. We know what the time since the Epoch at the start of the year is
+        - (+new Date(fullYear, 0)) // day defaults to 1 if not explicitly zeroed
+        // 3. Now, subtract what we would expect the time to be if daylight savings
+        //      did not exist. This yields the time-offset due to daylight savings.
+        - ((
+            ((
+                // Calculate the day of the year in the Gregorian calendar
+                // The code below works based upon the facts of signed right shifts
+                //    • (x) >> n: shifts n and fills in the n highest bits with 0s
+                //    • (-x) >> n: shifts n and fills in the n highest bits with 1s
+                // (This assumes that x is a positive integer)
+                -1 + // first day in the year is day 1
+                (31 & ((-fullMonth) >> 4)) + // January // (-11)>>4 = -1
+                ((28 + isLeapYear) & ((1 - fullMonth) >> 4)) + // February
+                (31 & ((2 - fullMonth) >> 4)) + // March
+                (30 & ((3 - fullMonth) >> 4)) + // April
+                (31 & ((4 - fullMonth) >> 4)) + // May
+                (30 & ((5 - fullMonth) >> 4)) + // June
+                (31 & ((6 - fullMonth) >> 4)) + // July
+                (31 & ((7 - fullMonth) >> 4)) + // August
+                (30 & ((8 - fullMonth) >> 4)) + // September
+                (31 & ((9 - fullMonth) >> 4)) + // October
+                (30 & ((10 - fullMonth) >> 4)) + // November
+                // There are no months past December: the year rolls into the next.
+                // Thus, fullMonth is 0-based, so it will never be 12 in Javascript
+
+                (dateInput.getDate() | 0) // get day of the month
+
+            ) & 0xffff) * 24 * 60 // 24 hours in a day, 60 minutes in an hour
+            + (dateInput.getHours() & 0xff) * 60 // 60 minutes in an hour
+            + (dateInput.getMinutes() & 0xff)
+        )|0) * 60 * 1000 // 60 seconds in a minute * 1000 milliseconds in a second
+        - (dateInput.getSeconds() & 0xff) * 1000 // 1000 milliseconds in a second
+        - dateInput.getMilliseconds()
+    );
+}
+
 function loadTypeScriptDeclarations() {
     // try to load the typings on disk for all 3rd party modules
     const packages = [
-        'node', // this provides auto completion for most builtins
+        'node', // this provides auto-completion for most builtins
         'request', // preloaded by the adapter
     ];
     // Also include user-selected libraries (but only those that are also installed)
@@ -1276,12 +1327,12 @@ function timeSchedule(adapter, context) {
         }
     }
     if (context.timeSettings.leadingZeros && hours < 10) {
-        hours = '0' + hours;
+        hours = `0${hours}`;
     }
     if (minutes < 10) {
-        minutes = '0' + minutes;
+        minutes = `0${minutes}`;
     }
-    adapter.setState('variables.dayTime', hours + ':' + minutes, true);
+    adapter.setState('variables.dayTime', `${hours}:${minutes}`, true);
     now.setMinutes(now.getMinutes() + 1);
     now.setSeconds(0);
     now.setMilliseconds(0);
@@ -1321,23 +1372,32 @@ function dayTimeSchedules(adapter, context) {
         sunsetTimeout = 3600000;
     }
 
-    let isDay;
-    if (sunriseTimeout < 5000) {
-        isDay = true;
-    } else if (sunsetTimeout < 5000) {
-        isDay = false;
-    } else {
-        // check if in between
-        isDay = nowDate.getTime() > (todaySunrise.getTime() - 60000) && nowDate <= todaySunset;
-    }
-
     adapter.getState('variables.isDayTime', (err, state) => {
+        let isDay;
+        if (sunriseTimeout < 5000) {
+            isDay = true;
+        } else if (sunsetTimeout < 5000) {
+            isDay = false;
+        } else {
+            // check if in between
+            isDay = nowDate.getTime() > (todaySunrise.getTime() - 60000) && nowDate <= todaySunset;
+        }
+
         const val = state ? !!state.val : false;
         if (val !== isDay) {
             adapter.setState('variables.isDayTime', isDay, true);
         }
     });
 
+    adapter.getState('variables.isDaylightSaving', (err, state) => {
+        const isDayLightSaving = dstOffsetAtDate(nowDate) !== 0;
+
+        const val = state ? !!state.val : false;
+        if (val !== isDayLightSaving) {
+            adapter.setState('variables.isDaylightSaving', isDayLightSaving, true);
+        }
+    });
+
     let nextTimeout = sunriseTimeout;
     if (sunriseTimeout > sunsetTimeout) {
         nextTimeout = sunsetTimeout;
@@ -2332,7 +2392,7 @@ function patchFont() {
         // ignore
     }
     if (!stat || stat.size !== 62324) {
-        const buffer = Buffer.from(JSON.parse(nodeFS.readFileSync(__dirname + '/admin-config/vsFont/codicon.json')));
+        const buffer = Buffer.from(JSON.parse(nodeFS.readFileSync(`${__dirname}/admin-config/vsFont/codicon.json`)));
 
         return require('jszip').loadAsync(buffer)
             .then(zip => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.javascript",
-  "version": "6.2.0",
+  "version": "7.0.0",
   "description": "Rules Engine for ioBroker",
   "author": "bluefox <dogafox@gmail.com>",
   "contributors": [