frodovdr/node-red
1
0
Fork 0
mirror of https://github.com/node-red/node-red.git synced 2025-03-01 10:36:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove promises from Change node

Browse Source
This commit is contained in:
Nick O'Leary
2018-12-21 14:36:45 +00:00
parent 5fa4d227b8
commit d5ef428edd
1 changed files with 184 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

354
packages/node_modules/@node-red/nodes/core/logic/15-change.js vendored
View File

@@ -98,7 +98,7 @@ module.exports = function(RED) {
} }
} }
function getToValue(msg,rule) { function getToValue(msg,rule,done) {
var value = rule.to; var value = rule.to;
if (rule.tot === 'json') { if (rule.tot === 'json') {
value = JSON.parse(rule.to); value = JSON.parse(rule.to);
@@ -107,222 +107,236 @@ module.exports = function(RED) {
} }
if (rule.tot === "msg") { if (rule.tot === "msg") {
value = RED.util.getMessageProperty(msg,rule.to); value = RED.util.getMessageProperty(msg,rule.to);
} else if ((rule.tot === 'flow') || } else if ((rule.tot === 'flow') || (rule.tot === 'global')) {
(rule.tot === 'global')) { RED.util.evaluateNodeProperty(rule.to, rule.tot, node, msg, (err,value) => {
return new Promise((resolve,reject) => { if (err) {
RED.util.evaluateNodeProperty(rule.to, rule.tot, node, msg, (err,value) => { done(undefined,undefined);
if (err) { } else {
resolve(undefined); done(undefined,value);
} else { }
resolve(value);
}
});
}); });
return
} else if (rule.tot === 'date') { } else if (rule.tot === 'date') {
value = Date.now(); value = Date.now();
} else if (rule.tot === 'jsonata') { } else if (rule.tot === 'jsonata') {
return new Promise((resolve,reject) => { RED.util.evaluateJSONataExpression(rule.to,msg, (err, value) => {
RED.util.evaluateJSONataExpression(rule.to,msg, (err, value) => { if (err) {
if (err) { done(RED._("change.errors.invalid-expr",{error:err.message}))
reject(RED._("change.errors.invalid-expr",{error:err.message})) } else {
} else { done(undefined, value);
resolve(value); }
}
});
}); });
return;
} }
return Promise.resolve(value); done(undefined,value);
} }
function getFromValue(msg,rule) {
function getFromValueType(fromValue, done) {
var fromType;
var fromRE;
if (typeof fromValue === 'number' || fromValue instanceof Number) {
fromType = 'num';
} else if (typeof fromValue === 'boolean') {
fromType = 'bool'
} else if (fromValue instanceof RegExp) {
fromType = 're';
fromRE = fromValue;
} else if (typeof fromValue === 'string') {
fromType = 'str';
fromRE = fromValue.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
try {
fromRE = new RegExp(fromRE, "g");
} catch (e) {
done(new Error(RED._("change.errors.invalid-from",{error:e.message})));
}
} else {
done(new Error(RED._("change.errors.invalid-from",{error:"unsupported type: "+(typeof fromValue)})));
}
done(undefined,{
fromType,
fromValue,
fromRE
});
}
function getFromValue(msg,rule, done) {
var fromValue; var fromValue;
var fromType; var fromType;
var fromRE; var fromRE;
if (rule.t === 'change') { if (rule.t === 'change') {
if (rule.fromt === 'msg' || rule.fromt === 'flow' || rule.fromt === 'global') { if (rule.fromt === 'msg' || rule.fromt === 'flow' || rule.fromt === 'global') {
return new Promise((resolve,reject) => { if (rule.fromt === "msg") {
if (rule.fromt === "msg") { return getFromValueType(RED.util.getMessageProperty(msg,rule.from),done);
resolve(RED.util.getMessageProperty(msg,rule.from)); } else if (rule.fromt === 'flow' || rule.fromt === 'global') {
} else if (rule.fromt === 'flow' || rule.fromt === 'global') { var contextKey = RED.util.parseContextStore(rule.from);
var contextKey = RED.util.parseContextStore(rule.from); node.context()[rule.fromt].get(contextKey.key, contextKey.store, (err,fromValue) => {
node.context()[rule.fromt].get(contextKey.key, contextKey.store, (err,fromValue) => { if (err) {
if (err) { done(err)
reject(err); } else {
} else { getFromValueType(fromValue,done);
resolve(fromValue);
}
});
}
}).then(fromValue => {
if (typeof fromValue === 'number' || fromValue instanceof Number) {
fromType = 'num';
} else if (typeof fromValue === 'boolean') {
fromType = 'bool'
} else if (fromValue instanceof RegExp) {
fromType = 're';
fromRE = fromValue;
} else if (typeof fromValue === 'string') {
fromType = 'str';
fromRE = fromValue.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
try {
fromRE = new RegExp(fromRE, "g");
} catch (e) {
throw new Error(RED._("change.errors.invalid-from",{error:e.message}));
} }
} else { });
throw new Error(RED._("change.errors.invalid-from",{error:"unsupported type: "+(typeof fromValue)})); return;
} }
return {
fromType,
fromValue,
fromRE
}
});
} else { } else {
fromType = rule.fromt; fromType = rule.fromt;
fromValue = rule.from; fromValue = rule.from;
fromRE = rule.fromRE; fromRE = rule.fromRE;
} }
} }
return Promise.resolve({ done(undefined, {
fromType, fromType,
fromValue, fromValue,
fromRE fromRE
}); });
} }
function applyRule(msg,rule) { function applyRule(msg,rule,done) {
var property = rule.p; var property = rule.p;
var current; var current;
var fromValue; var fromValue;
var fromType; var fromType;
var fromRE; var fromRE;
try {
return getToValue(msg,rule).then(value => { try {
return getFromValue(msg,rule).then(fromParts => { getToValue(msg,rule,(err,value) => {
fromValue = fromParts.fromValue; if (err) {
fromType = fromParts.fromType; node.error(err, msg);
fromRE = fromParts.fromRE; return done(undefined,null);
if (rule.pt === 'msg') { } else {
try { getFromValue(msg,rule,(err,fromParts) => {
if (rule.t === 'delete') { if (err) {
RED.util.setMessageProperty(msg,property,undefined); node.error(err, msg);
} else if (rule.t === 'set') { return done(undefined,null);
RED.util.setMessageProperty(msg,property,value); } else {
} else if (rule.t === 'change') { fromValue = fromParts.fromValue;
current = RED.util.getMessageProperty(msg,property); fromType = fromParts.fromType;
if (typeof current === 'string') { fromRE = fromParts.fromRE;
if ((fromType === 'num' || fromType === 'bool' || fromType === 'str') && current === fromValue) { if (rule.pt === 'msg') {
// str representation of exact from number/boolean try {
// only replace if they match exactly if (rule.t === 'delete') {
RED.util.setMessageProperty(msg,property,undefined);
} else if (rule.t === 'set') {
RED.util.setMessageProperty(msg,property,value); RED.util.setMessageProperty(msg,property,value);
} else { } else if (rule.t === 'change') {
current = current.replace(fromRE,value); current = RED.util.getMessageProperty(msg,property);
RED.util.setMessageProperty(msg,property,current); if (typeof current === 'string') {
if ((fromType === 'num' || fromType === 'bool' || fromType === 'str') && current === fromValue) {
// str representation of exact from number/boolean
// only replace if they match exactly
RED.util.setMessageProperty(msg,property,value);
} else {
current = current.replace(fromRE,value);
RED.util.setMessageProperty(msg,property,current);
}
} else if ((typeof current === 'number' || current instanceof Number) && fromType === 'num') {
if (current == Number(fromValue)) {
RED.util.setMessageProperty(msg,property,value);
}
} else if (typeof current === 'boolean' && fromType === 'bool') {
if (current.toString() === fromValue) {
RED.util.setMessageProperty(msg,property,value);
}
}
} }
} else if ((typeof current === 'number' || current instanceof Number) && fromType === 'num') { } catch(err) {}
if (current == Number(fromValue)) { return done(undefined,msg);
RED.util.setMessageProperty(msg,property,value); } else if (rule.pt === 'flow' || rule.pt === 'global') {
} var contextKey = RED.util.parseContextStore(property);
} else if (typeof current === 'boolean' && fromType === 'bool') { var target = node.context()[rule.pt];
if (current.toString() === fromValue) { var callback = err => {
RED.util.setMessageProperty(msg,property,value);
}
}
}
} catch(err) {}
return msg;
} else if (rule.pt === 'flow' || rule.pt === 'global') {
var contextKey = RED.util.parseContextStore(property);
return new Promise((resolve,reject) => {
var target = node.context()[rule.pt];
var callback = err => {
if (err) {
reject(err);
} else {
resolve(msg);
}
}
if (rule.t === 'delete') {
target.set(contextKey.key,undefined,contextKey.store,callback);
} else if (rule.t === 'set') {
target.set(contextKey.key,value,contextKey.store,callback);
} else if (rule.t === 'change') {
target.get(contextKey.key,contextKey.store,(err,current) => {
if (err) { if (err) {
reject(err); node.error(err, msg);
return; return done(undefined,null);
} else {
done(undefined,msg);
} }
if (typeof current === 'string') { }
if ((fromType === 'num' || fromType === 'bool' || fromType === 'str') && current === fromValue) { if (rule.t === 'delete') {
// str representation of exact from number/boolean target.set(contextKey.key,undefined,contextKey.store,callback);
// only replace if they match exactly } else if (rule.t === 'set') {
target.set(contextKey.key,value,contextKey.store,callback); target.set(contextKey.key,value,contextKey.store,callback);
} else { } else if (rule.t === 'change') {
current = current.replace(fromRE,value); target.get(contextKey.key,contextKey.store,(err,current) => {
target.set(contextKey.key,current,contextKey.store,callback); if (err) {
node.error(err, msg);
return done(undefined,null);
} }
} else if ((typeof current === 'number' || current instanceof Number) && fromType === 'num') { if (typeof current === 'string') {
if (current == Number(fromValue)) { if ((fromType === 'num' || fromType === 'bool' || fromType === 'str') && current === fromValue) {
target.set(contextKey.key,value,contextKey.store,callback); // str representation of exact from number/boolean
// only replace if they match exactly
target.set(contextKey.key,value,contextKey.store,callback);
} else {
current = current.replace(fromRE,value);
target.set(contextKey.key,current,contextKey.store,callback);
}
} else if ((typeof current === 'number' || current instanceof Number) && fromType === 'num') {
if (current == Number(fromValue)) {
target.set(contextKey.key,value,contextKey.store,callback);
}
} else if (typeof current === 'boolean' && fromType === 'bool') {
if (current.toString() === fromValue) {
target.set(contextKey.key,value,contextKey.store,callback);
}
} }
} else if (typeof current === 'boolean' && fromType === 'bool') { });
if (current.toString() === fromValue) { }
target.set(contextKey.key,value,contextKey.store,callback);
}
}
});
} }
}); }
} })
}); }
}).catch(err => {
node.error(err, msg);
return null;
}); });
} catch(err) { } catch(err) {
return Promise.resolve(msg); // This is an okay error
done(undefined,msg);
} }
} }
function applyRules(msg, currentRule) { function completeApplyingRules(msg,currentRule,done) {
if (!msg) {
return done();
} else if (currentRule === node.rules.length - 1) {
return done(undefined, msg);
} else {
applyRules(msg, currentRule+1,done);
}
}
function applyRules(msg, currentRule, done) {
if (currentRule >= node.rules.length) { if (currentRule >= node.rules.length) {
return Promise.resolve(msg); return done(undefined,msg);
} }
var r = node.rules[currentRule]; var r = node.rules[currentRule];
var rulePromise; var rulePromise;
if (r.t === "move") { if (r.t === "move") {
if ((r.tot !== r.pt) || (r.p.indexOf(r.to) !== -1)) { if ((r.tot !== r.pt) || (r.p.indexOf(r.to) !== -1)) {
rulePromise = applyRule(msg,{t:"set", p:r.to, pt:r.tot, to:r.p, tot:r.pt}).then( applyRule(msg,{t:"set", p:r.to, pt:r.tot, to:r.p, tot:r.pt},(err,msg) => {
msg => applyRule(msg,{t:"delete", p:r.p, pt:r.pt}) applyRule(msg,{t:"delete", p:r.p, pt:r.pt}, (err,msg) => {
); completeApplyingRules(msg,currentRule,done);
} })
else { // 2 step move if we are moving from a child });
rulePromise = applyRule(msg,{t:"set", p:"_temp_move", pt:r.tot, to:r.p, tot:r.pt}).then( } else { // 2 step move if we are moving from a child
msg => applyRule(msg,{t:"delete", p:r.p, pt:r.pt}) applyRule(msg,{t:"set", p:"_temp_move", pt:r.tot, to:r.p, tot:r.pt},(err,msg)=> {
).then( applyRule(msg,{t:"delete", p:r.p, pt:r.pt},(err,msg)=> {
msg => applyRule(msg,{t:"set", p:r.to, pt:r.tot, to:"_temp_move", tot:r.pt}) applyRule(msg,{t:"set", p:r.to, pt:r.tot, to:"_temp_move", tot:r.pt},(err,msg)=> {
).then( applyRule(msg,{t:"delete", p:"_temp_move", pt:r.pt},(err,msg)=> {
msg => applyRule(msg,{t:"delete", p:"_temp_move", pt:r.pt}) completeApplyingRules(msg,currentRule,done);
) });
});
});
});
} }
} else { } else {
rulePromise = applyRule(msg,r); applyRule(msg,r,(err,msg)=> { completeApplyingRules(msg,currentRule,done); });
} }
return rulePromise.then(
msg => {
if (!msg) {
return
} else if (currentRule === node.rules.length - 1) {
return msg;
} else {
return applyRules(msg, currentRule+1);
}
}
);
} }
if (valid) { if (valid) {
this.on('input', function(msg) { this.on('input', function(msg) {
applyRules(msg, 0) applyRules(msg, 0, (err,msg) => {
.then( msg => { if (msg) { node.send(msg) }} ) if (err) {
.catch( err => node.error(err, msg)) node.error(err,msg);
} else if (msg) {
node.send(msg);
}
})
}); });
} }
} }