@machinemetrics/io-adapter-lib 2.32.0

package/lib/config/transformConfigUtil.js

@@ -0,0 +1,296 @@
+'use strict';
+
+const _ = require('lodash');
+const Transform = require('../transform');
+const ConfigError = require('./configError');
+
+class TransformConfigUtil {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    this.transformMap = Object.values(Transform).reduce((trmap, transform) => {
+      trmap[transform.op] = transform;
+      transform.opAliases.forEach((alias) => {
+        trmap[alias] = transform;
+      });
+      return trmap;
+    }, {});
+  }
+
+  loadTransformList(variable, sectionPath, enforceSource = true) {
+    const transformDefn = _.isArray(variable) ? variable : variable.transform;
+    if (_.isEmpty(transformDefn) || !_.isArray(transformDefn)) {
+      const message = 'Variable must defined as a list of operations';
+      throw new ConfigError(message).atPath(sectionPath);
+    }
+
+    const transform = _.map(transformDefn, (transform, index) => {
+      const basePath = `${sectionPath}.${index}`;
+      const transformConfig = this.parseTransformConfig(transform, basePath);
+
+      if (!transformConfig.func) {
+        const message = 'Malformed operation';
+        throw new ConfigError(message).atPath(sectionPath);
+      }
+
+      if (!this.transformMap[transformConfig.func]) {
+        const message = `Unsupported operation '${transformConfig.func}'`;
+        throw new ConfigError(message).atPath(sectionPath);
+      }
+
+      if (enforceSource) {
+        if (index === 0 && !_.includes(['source', 'expression', 'state'], transformConfig.func)) {
+          const message = `First line in variable must be 'source' operation, but found '${transformConfig.func}'`;
+          throw new ConfigError(message).atPath(sectionPath);
+        }
+      }
+
+      try {
+        this.transformMap[transformConfig.func].parseConfig(this, transformConfig);
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          error.atSection(sectionPath);
+        }
+        throw error;
+      }
+
+      return transformConfig;
+    });
+
+    return { transform };
+  }
+
+  parseTransformConfig(transform, basePath) {
+    let tobj = {};
+    if (_.isString(transform)) {
+      tobj = {
+        func: transform,
+        args: [],
+        path: `${basePath}.${transform}`,
+      };
+    } else if (_.isObject(transform)) {
+      const func = _.first(_.keys(transform));
+      let args = [];
+
+      const primary = transform[func];
+      if (_.isEmpty(primary) && transform.length > 1) {
+        args = _.rest(transform);
+      } else if (_.isObject(primary)) {
+        args = primary;
+      } else if (!_.isUndefined(primary)) {
+        args = {};
+        args[func] = primary;
+      }
+
+      tobj = {
+        func,
+        args,
+        path: `${basePath}.${func}`,
+      };
+    }
+
+    return tobj;
+  }
+
+  getExpressionsFromVariables(variables) {
+    return _(variables).map((defn, varName) => {
+      return _.map(defn, (transformContainer, index) => {
+        return _.map(transformContainer, (body, attribute) => {
+          if (this.transformMap[attribute]) {
+            return this.transformMap[attribute].getExpressions(this, body, { varName, index, attribute });
+          }
+          return [];
+        });
+      });
+    }).flattenDeep().compact().value();
+  }
+
+  getExpressions(body, { varName, index, attribute, field }, includeDefault = false) {
+    const parts = [];
+
+    let expression = '';
+    if (_.isUndefined(body)) {
+      expression = '';
+    } else if (_.isObject(body) && field) {
+      expression = (body[field] ?? '').toString();
+    } else if (!field || includeDefault) {
+      expression = body.toString();
+    }
+
+    if (!expression) {
+      return parts;
+    }
+
+    if (field) {
+      parts.push({
+        path: `variables.${varName}.${index}.${attribute}.${field}`,
+        expression,
+      });
+    }
+
+    if (!field || includeDefault) {
+      parts.push({
+        path: `variables.${varName}.${index}.${attribute}`,
+        expression,
+      });
+    }
+
+    parts.push({
+      path: `variables.${varName}`,
+      expression,
+    });
+
+    return parts;
+  }
+
+  getStringExpressionsFromVariables(variables) {
+    return _(variables).map((defn, varName) => {
+      return _.map(defn, (transformContainer, index) => {
+        return _.map(transformContainer, (body, attribute) => {
+          if (this.transformMap[attribute]) {
+            return this.transformMap[attribute].getStringExpressions(this, body, { varName, index, attribute });
+          }
+          return [];
+        });
+      });
+    }).flattenDeep().compact().value();
+  }
+
+  getStringExpressions(body, value, { varName, index, attribute, field }, withThis = true) {
+    if (!_.isObject(body) || _.isUndefined(body[field])) {
+      return [];
+    }
+
+    return [{
+      path: `variables.${varName}.${index}.${attribute}.${field}`,
+      string: value,
+      withThis,
+    }, {
+      path: `variables.${varName}`,
+      string: value,
+      withThis: true,
+    }];
+  }
+
+  decomposePattern(pattern, validFlags = 'imus') {
+    let flags = '';
+    const match = pattern.match(/^\/(.+)\/([a-z]*)$/sm);
+    if (match) {
+      pattern = match[1];
+      flags = (match[2] ?? '').replace(new RegExp(`[^${validFlags}]`, 'g'), '');
+    } else {
+      const match2 = pattern.match(/^\/(.+)\/$/sm);
+      if (match2) {
+        pattern = match[0];
+      }
+    }
+    return { pattern, flags };
+  }
+
+  testPattern(pattern, flags, attribute) {
+    try {
+      const regPattern = new RegExp(pattern, flags);
+      if (!regPattern) {
+        throw new ConfigError(`Invalid regular expression: ${pattern}`).atAttribute(attribute);
+      }
+    } catch (err) {
+      throw new ConfigError(err.message).atAttribute(attribute);
+    }
+  }
+
+  parseBool(value) {
+    if (_.isString(value)) {
+      value = value.toLowerCase();
+      return value === 'true';
+    }
+
+    return !!_.toInteger(value);
+  }
+
+  requireObjectParams(args, attribute, {
+    optional = true,
+    exclusive = false,
+    availableAttributes = [],
+    defaultAttribute = null
+  }) {
+    if (defaultAttribute && _.isObject(args) && _.isUndefined(args[defaultAttribute])) {
+      args[defaultAttribute] = args[attribute];
+    }
+
+    let attrCount = 0;
+    if (_.isObject(args)) {
+      attrCount = Object.keys(args).reduce((count, key) => {
+        return count + availableAttributes.includes(key) ? 1 : 0;
+      }, 0);
+    }
+
+    if (!optional && attrCount === 0) {
+      throw new ConfigError(`Expected one of the following attributes: [${availableAttributes.join(', ')}]`).atAttribute(attribute);
+    }
+    if (exclusive && attrCount > 1) {
+      throw new ConfigError(`Expected exactly one of the following attributes: [${availableAttributes.join(', ')}]`).atAttribute(attribute);
+    }
+
+    if (_.isArray(args) && args.length > 0) {
+      const filtered = _.filter(args, a => _.isObject(a) && !_.isArray(a));
+      if (filtered.length === args.length) {
+        const keys = _.keys(_.merge({ }, ...args));
+        throw new ConfigError(`Unexpected list. The attributes [${keys.join(', ')}] should not be prefixed with a dash (-).`).atAttribute(attribute);
+      } else {
+        throw new ConfigError('Unexpected list').atAttribute(attribute);
+      }
+    }
+  }
+
+  getArgOrShorthand(defn, value) {
+    if (!_.isUndefined(defn.args[value])) {
+      return { value: defn.args[value], usingShorthand: false };
+    }
+    return { value: defn.args[defn.func], usingShorthand: true };
+  }
+
+  requireNumeric(value, field, attribute) {
+    if (!_.isNumber(value)) {
+      throw new ConfigError(`${field} must have a numeric value`).atAttribute(attribute);
+    }
+  }
+
+  requirePositive(value, field, attribute) {
+    if (!_.isNumber(value)) {
+      throw new ConfigError(`${field} must have a numeric value`).atAttribute(attribute);
+    }
+    if (value <= 0) {
+      throw new ConfigError(`${field} must be greater than 0`).atAttribute(attribute);
+    }
+  }
+
+  requireZeroPositive(value, field, attribute) {
+    if (!_.isNumber(value)) {
+      throw new ConfigError(`${field} must have a numeric value`).atAttribute(attribute);
+    }
+    if (value < 0) {
+      throw new ConfigError(`${field} must be 0 or greater`).atAttribute(attribute);
+    }
+  }
+
+  requireValueIn(value, validSet, field, attribute) {
+    if (!validSet.includes(value)) {
+      throw new ConfigError(`${field} must be on of [${validSet.join(', ')}]`).atAttribute(attribute);
+    }
+  }
+
+  compileExpression(expression, attribute, scope = { this: 0 }) {
+    try {
+      return this.expressionService.compileExpression(expression, scope);
+    } catch (err) {
+      this.throwConfigError(err, attribute);
+      return null;
+    }
+  }
+
+  throwConfigError(error, attribute) {
+    throw new ConfigError(error).atAttribute(attribute);
+  }
+}
+
+module.exports = TransformConfigUtil;

package/lib/engine/dataOutput.js

@@ -0,0 +1,357 @@
+'use strict';
+
+const _ = require('lodash');
+const EventEmitter = require('eventemitter3');
+
+class DataOutput extends EventEmitter {
+  constructor(engine, config, options = {}) {
+    super();
+
+    this.logDir = options.logDir || '.';
+    this.logger = options.logger || {
+      error: () => {},
+      warn: () => {},
+      info: () => {},
+    };
+
+    this.engine = engine;
+    this.config = config;
+
+    this.adapterConfig = config.adapter;
+    this.dataItems = this.adapterConfig.dataItems;
+    this.conditions = this.adapterConfig.conditions;
+
+    this.inputState = { ...this.config.expressionService.defaultValues };
+    this.inputUnavail = _.mapValues(this.inputState, () => true);
+    this.currentConditionCodesByPath = {}; // code path based, related to calculated codes
+    this.currentConditionCodes = {};
+    this.updateSet = {};
+  }
+
+  initiailize() {
+    const now = Date.now();
+    this.processSampleDataItems(this.dataItems, now);
+    this.procesConditionDataItems(this.conditions, now);
+  }
+
+  setUnavailable() {
+    this.inputUnavail = _.mapValues(this.inputUnavail, () => true);
+  }
+
+  handleUpdate(inputName, value, time) {
+    this.inputState[inputName] = value;
+    this.inputUnavail[inputName] = false;
+
+    const dataItemNames = this.adapterConfig.triggeredDataItems(inputName);
+    const dataItems = _.map(dataItemNames, name => this.dataItems[name]);
+    this.processSampleDataItems(dataItems, time * 1000);
+
+    if (this.lastUpdateTime !== time) {
+      this.handleScanSync();
+      this.lastUpdateTime = time;
+    }
+    this.updateSet[inputName] = 1;
+  }
+
+  handleItemUnavailable(inputName, time) {
+    this.inputState[inputName] = null;
+    this.inputUnavail[inputName] = true;
+
+    const dataItemNames = this.adapterConfig.triggeredDataItems(inputName);
+    _.each(dataItemNames, (name) => {
+      this.emit('data_unavailable', name, time * 1000);
+    });
+
+    if (this.lastUpdateTime !== time) {
+      this.handleScanSync();
+      this.lastUpdateTime = time;
+    }
+    this.updateSet[inputName] = 1;
+  }
+
+  handleScanSync() {
+    if (this.lastUpdateTime > 0) {
+      const conditionNames = _(this.updateSet).keys().map((inputName) => {
+        return this.adapterConfig.triggeredConditions(inputName);
+      }).flatten().uniq().value();
+
+      const conditions = _.map(conditionNames, name => this.conditions[name]);
+      this.procesConditionDataItems(conditions, this.lastUpdateTime * 1000);
+    }
+
+    this.updateSet = {};
+  }
+
+  matchRule(ruleSet, key) {
+    return _.reduce(ruleSet, (result, rule) => {
+      return result || rule.test(key);
+    }, false);
+  }
+
+  handleMtconnectSample(name, value, time) {
+    this.emit('data', name, value ?? 'UNAVAILABLE', time);
+  }
+
+  handleMtconnectCondition(name, fields, time) {
+    if (!_.isObject(fields)) {
+      return;
+    }
+
+    if (this.adapterConfig.passthroughConditions[name]) {
+      _.each(this.adapterConfig.passthroughConditions[name], (source) => {
+        if (fields.code) {
+          if (source.allowCodes && !this.matchRule(source.allowCodes, fields.code)) {
+            return;
+          }
+          if (source.denyCodes && this.matchRule(source.denyCodes, fields.code)) {
+            return;
+          }
+        }
+
+        this.trackCurrentCondition(name, fields.code);
+        this.emit('data', source.name, fields.level || 'NORMAL', time, {
+          type: 'condition',
+          nativeCode: fields.code,
+          severity: fields.severity ?? null,
+          qualifier: fields.qualifier ?? null,
+          message: fields.message,
+        });
+      });
+    }
+
+    if (!_.includes(_.map(this.adapterConfig.passthroughConditions[name], 'name'), name)) {
+      this.trackCurrentCondition(name, fields.code);
+      this.emit('data', name, fields.level || 'NORMAL', time, {
+        type: 'condition',
+        nativeCode: fields.code,
+        severity: fields.severity ?? null,
+        qualifier: fields.qualifier ?? null,
+        message: fields.message,
+      });
+    }
+  }
+
+  handleMtconnectMessage(name, fields, time) {
+    if (_.isObject(fields)) {
+      this.emit('data', name, fields.message ?? 'UNAVAILABLE', time, {
+        type: 'message',
+        nativeCode: fields.code ?? null,
+      });
+    } else {
+      this.emit('data', name, fields ?? 'UNAVAILABLE', time, {
+        type: 'message',
+        nativeCode: null,
+      });
+    }
+  }
+
+  nullTriggers(triggers) {
+    return _.reduce(triggers, (ac, name) => {
+      return ac || this.inputUnavail[name] || this.inputState[name] === null;
+    }, false);
+  }
+
+  processSampleDataItems(dataItems, time) {
+    _.each(dataItems, (item) => {
+      if (item.rule) {
+        if (this.nullTriggers(item.rule.triggers)) {
+          this.emit('data_unavailable', item.name, time);
+        } else {
+          let result;
+          if (item.rule.rawExpression && _.has(this.inputState, item.rule.rawExpression)) {
+            result = _.get(this.inputState, item.rule.rawExpression);
+          } else {
+            result = item.rule.expression.evaluate(this.inputState);
+          }
+
+          // True floating-value numeric results get precision-adjusted
+          if (_.isFinite(result) && !_.isInteger(result)) {
+            const floatResult = Number(result);
+            if (!Number.isNaN(floatResult)) {
+              if (Math.abs(floatResult) < 1) {
+                result = floatResult.toPrecision(3);
+              } else {
+                result = Number(floatResult.toFixed(3));
+              }
+            }
+          }
+
+          if (_.isUndefined(result) || _.isNull(result)) {
+            result = 'UNAVAILABLE';
+          }
+          this.emit('data', item.name, result, time);
+        }
+      } else if (item.stateRules) {
+        const result = _.reduce(item.stateRules, (res, rule) => {
+          if (this.nullTriggers(rule.triggers)) {
+            return res || 'UNAVAILABLE';
+          }
+          return res || (rule.expression.evaluate(this.inputState) ? rule.value : res);
+        }, undefined);
+
+        if (_.isUndefined(result) || _.isNull(result) || result === 'UNAVAILABLE') {
+          this.emit('data_unavailable', item.name, time);
+        } else {
+          this.emit('data', item.name, result, time);
+        }
+      }
+    });
+  }
+
+  // Conditions are processed after a "scansync" event, which typically happens after a scan loop in a device
+  // or other appropriate breathing point in data acquisition.  This is to ensure that all data related to
+  // codes and messages, which are calculated independently, have converged into a consistent state.
+
+  procesConditionDataItems(conditions, time) {
+    _.each(conditions, (condition) => {
+      if (condition.arraySource) {
+        const active = this.getConditionCodesFromArraySource(condition.arraySource);
+        if (active === null) {
+          this.emit('data_unavailable', condition.name, time);
+        } else {
+          this.updateActiveConditions(condition, condition.name, 'FAULT', time, active);
+        }
+      }
+
+      _.each(condition.codes, (code) => {
+        const result = _.reduce(code.stateRules, (res, rule) => {
+          if (this.nullTriggers(rule.triggers)) {
+            return res || 'UNAVAILABLE';
+          }
+          return res || (rule.expression.evaluate(this.inputState) ? rule.value : res);
+        }, undefined);
+
+        if (_.isUndefined(result) || _.isNull(result) || result === 'UNAVAILABLE') {
+          this.emit('data_unavailable', condition.name, time, {
+            type: 'condition',
+            nativeCode: code.code,
+          });
+        } else {
+          const nativeCode = code.codeResolver(this.engine);
+          const condByPath = this.currentConditionCodesByPath[code.codePath];
+          if (condByPath && condByPath !== nativeCode) {
+            this.clearCurrentCondition(condition.name, this.currentConditionCodesByPath[code.codePath]);
+            this.emit('data', condition.name, 'NORMAL', time, {
+              type: 'condition',
+              nativeCode: this.currentConditionCodesByPath[code.codePath],
+              message: '',
+            });
+          }
+
+          if (_.isNull(nativeCode)) {
+            delete this.currentConditionCodesByPath[code.codePath];
+            return; // Cancel code
+          }
+          this.currentConditionCodesByPath[code.codePath] = nativeCode;
+
+          let message = code.messageResolver(this.engine);
+          if (_.isNull(message)) {
+            message = 'UNAVAILABLE';
+          }
+
+          // TODO: cancel previous code state / track result of computed code
+          this.trackCurrentCondition(condition.name, nativeCode);
+          this.emit('data', condition.name, result || 'NORMAL', time, {
+            type: 'condition',
+            nativeCode,
+            message,
+          });
+        }
+      });
+    });
+  }
+
+  getConditionCodesFromArraySource(arraySource) {
+    if (this.inputUnavail[arraySource.codeList] || this.inputUnavail[arraySource.messageList]) {
+      return null;
+    }
+
+    let codeList = this.inputState[arraySource.codeList];
+    if (!_.isArray(codeList)) {
+      codeList = [codeList];
+    }
+    let messageList = this.inputState[arraySource.messageList];
+    if (!_.isArray(messageList)) {
+      messageList = [messageList];
+    }
+
+    let levelList = _.map(codeList, () => 'FAULT');
+    if (arraySource.levelList) {
+      levelList = this.inputState[arraySource.levelList];
+      if (!_.isArray(levelList)) {
+        levelList = [levelList];
+      }
+    }
+
+    return _(_.zip(codeList, messageList, levelList)).map(([code, message, level]) => {
+      if (_.isObject(code)) {
+        code = _.get(code, 'code');
+      }
+      if (_.isObject(message)) {
+        message = _.get(message, 'message');
+      }
+      if (_.isObject(level)) {
+        level = _.get(level, 'level');
+      }
+      if (_.isUndefined(code) || _.isUndefined(message)) {
+        return null;
+      }
+
+      if (_.isUndefined(level)) {
+        level = 'FAULT';
+      }
+
+      return { code, message, level };
+    }).compact().value();
+  }
+
+  updateActiveConditions(condition, key, level, time, codeMessageList) {
+    const activeCodes = _.map(codeMessageList, 'code');
+    const currentCodes = this.currentConditionCodes[key] || [];
+
+    _.each(currentCodes, (code) => {
+      if (!_.isEmpty(code) && !_.includes(activeCodes, code)) {
+        this.clearCurrentCondition(key, code);
+        this.emit('data', key, 'NORMAL', time, {
+          type: 'condition',
+          nativeCode: code,
+          message: '',
+        });
+      }
+    });
+
+    _.each(codeMessageList, ({ code, message, localLevel }) => {
+      if (condition.allowCodes && !this.matchRule(condition.allowCodes, code)) {
+        return;
+      }
+      if (condition.denyCodes && this.matchRule(condition.denyCodes, code)) {
+        return;
+      }
+
+      this.trackCurrentCondition(key, code);
+      this.emit('data', key, localLevel ?? level, time, {
+        type: 'condition',
+        nativeCode: code,
+        message: String(message),
+      });
+    });
+  }
+
+  trackCurrentCondition(key, code) {
+    if (!this.currentConditionCodes[key]) {
+      this.currentConditionCodes[key] = [];
+    }
+    if (!_.includes(this.currentConditionCodes, code)) {
+      this.currentConditionCodes[key].push(code);
+    }
+  }
+
+  clearCurrentCondition(key, code) {
+    if (!this.currentConditionCodes[key]) {
+      return;
+    }
+    _.pull(this.currentConditionCodes[key], code);
+  }
+}
+
+module.exports = DataOutput;