@machinemetrics/io-adapter-lib 2.32.0 → 2.32.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [2.32.2]
+- Add support to reclassify conditions to NORMAL
+
+## [2.32.1]
+- Added opcua-conditions block to opcua config
+- Fixed message overrides in conditions
+
 ## [2.32.0]
 - Repackaged for public NPM publishing on @machinemetrics/io-adapter-lib
 

package/lib/config/adapterConfig.js

@@ -350,6 +350,9 @@ class AdapterConfig {
         if (item['reclassify-fault']) {
           source.reclassifyFault = allowDenyList.parseWildcardKeyList(item['reclassify-fault'], `conditions.${key}.reclassify-fault-codes`);
         }
+        if (item['reclassify-normal']) {
+          source.reclassifyNormal = allowDenyList.parseWildcardKeyList(item['reclassify-normal'], `conditions.${key}.reclassify-normal-codes`);
+        }
 
         if (item.overrides) {
           if (!_.isArray(item.overrides)) {
@@ -379,7 +382,7 @@ class AdapterConfig {
               defn.message = override['override-message'];
               defn.messagePath = `conditions.${key}.overrides.${index}.override-message`;
               defn.messageIsStatic = this.expressionService.isStaticExpression(defn.messagePath);
-              defn.messageResolver = this.expressionResolver(defn.code, defn.messagePath);
+              defn.messageResolver = this.expressionResolver(defn.message, defn.messagePath);
               defn.messageResolverTriggers = this.expressionService.expressionTriggers(defn.messagePath);
               this.conditionsByExpression[defn.messagePath] = key;
             }

package/lib/config/device/opcuaConfig.js

@@ -19,13 +19,11 @@ class OpcuaConfig {
   }
 
   getIdentifiers(config = {}) {
-    if (_.isEmpty(config.tags)) {
-      // No tags, this should be a softer warning
-      return [];
-    }
+    const keyset = Object.keys(config.tags || {});
 
-    const keyset = Object.keys(config.tags);
-    if (config['opcua-condition-key']) {
+    if (config['opcua-conditions']?.key) {
+      keyset.push(config['opcua-conditions'].key);
+    } else if (config['opcua-condition-key']) {
       keyset.push(config['opcua-condition-key']);
     }
 
@@ -55,7 +53,17 @@ class OpcuaConfig {
     this.userPrivateKeyPath = config['user-private-key-path'];
 
     this.tags = this.loadTags(config.tags);
+
+    // opcua-condition-key deprecated in favor of opcua-conditions
     this.conditionKey = config['opcua-condition-key'];
+    this.opcuaConditions = this.loadConditions(config['opcua-conditions']);
+
+    // For backwards compatibility
+    if (this.conditionKey && !this.opcuaConditions?.key) {
+      this.opcuaConditions = { key: this.conditionKey };
+    } else if (this.opcuaConditions?.key) {
+      this.conditionKey = this.opcuaConditions.key;
+    }
 
     this.securityMode = this.checkSecurityMode(config['security-mode']);
     this.securityPolicy = this.checkSecurityPolicy(config['security-policy']);
@@ -106,6 +114,45 @@ class OpcuaConfig {
     }).keyBy('name').value();
   }
 
+  loadConditions(conditions) {
+    if (!conditions) {
+      return {};
+    }
+
+    try {
+      if (!conditions.key) {
+        throw new ConfigError('key is required').atAttribute('key');
+      }
+
+      const result = {
+        key: conditions.key,
+      };
+
+      if (_.has(conditions, 'fault-threshold')) {
+        const faultThreshold = conditions['fault-threshold'];
+        if (!_.isNumber(faultThreshold)) {
+          throw new ConfigError('fault-threshold must be a number').atAttribute('fault-threshold');
+        }
+        result.faultThreshold = faultThreshold;
+      }
+
+      if (_.has(conditions, 'warning-threshold')) {
+        const warningThreshold = conditions['warning-threshold'];
+        if (!_.isNumber(warningThreshold)) {
+          throw new ConfigError('warning-threshold must be a number').atAttribute('warning-threshold');
+        }
+        result.warningThreshold = warningThreshold;
+      }
+
+      return result;
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        error.atSection('opcua-conditions');
+      }
+      throw error;
+    }
+  }
+
   checkTagPath(defn) {
     const path = defn.path;
     if (!path) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@machinemetrics/io-adapter-lib",
-  "version": "2.32.0",
+  "version": "2.32.2",
   "description": "Configuration and engine implementation for MachineMetrics AdapterScripts and adapters",
   "main": "index.js",
   "license": "UNLICENSED",

package/test/.eslintrc.json

@@ -4,7 +4,8 @@
   },
   "rules": {
     "import/no-extraneous-dependencies": [ "off" ],
-    "prefer-arrow-callback": "off"
+    "prefer-arrow-callback": "off",
+    "no-unused-expressions": "off"
   },
   "env": {
     "mocha": true

package/test/conditions.test.js

@@ -72,6 +72,37 @@ describe('data items', async function () {
     validateCondition(captured[10], 'cond1', 'FAULT', 5000, 'A2', 'Code A2');
     validateCondition(captured[11], 'cond2', 'FAULT', 6000, 'B33', 'Code B33');
   });
+
+  it('loads reclassification config', async function () {
+    expect(config.adapter.passthroughConditions).to.exist;
+    expect(config.adapter.passthroughConditions.system).to.exist;
+    expect(config.adapter.passthroughConditions.system.length).to.eq(1);
+
+    const source = config.adapter.passthroughConditions.system[0];
+    expect(source.name).to.eq('cond4');
+    expect(source.reclassifyFault).to.exist;
+    expect(source.reclassifyWarning).to.exist;
+    expect(source.reclassifyNormal).to.exist;
+  });
+
+  it('reclassifies codes based on patterns', async function () {
+    const source = config.adapter.passthroughConditions.system[0];
+
+    // Test FAULT reclassification
+    expect(source.reclassifyFault[0].test('HIGH_TEMP')).to.eq(true);
+    expect(source.reclassifyFault[0].test('HIGH_PRESSURE')).to.eq(true);
+    expect(source.reclassifyFault[0].test('MEDIUM_TEMP')).to.eq(false);
+
+    // Test WARNING reclassification
+    expect(source.reclassifyWarning[0].test('MEDIUM_TEMP')).to.eq(true);
+    expect(source.reclassifyWarning[0].test('MEDIUM_PRESSURE')).to.eq(true);
+    expect(source.reclassifyWarning[0].test('LOW_TEMP')).to.eq(false);
+
+    // Test NORMAL reclassification
+    expect(source.reclassifyNormal[0].test('LOW_TEMP')).to.eq(true);
+    expect(source.reclassifyNormal[0].test('LOW_PRESSURE')).to.eq(true);
+    expect(source.reclassifyNormal[0].test('HIGH_TEMP')).to.eq(false);
+  });
 });
 
 function validateCondition(entry, key, value, time, code, message) {

package/test/config/opcua.test.js

@@ -7,9 +7,12 @@ const testUtils = require('../util/testUtils');
 describe('OPC-UA config tests', function () {
   let config;
   let defaultConfig;
+  let conditionsConfig;
+
   before(async () => {
     defaultConfig = await testUtils.loadConfig('device/opcua-default.yml');
     config = await testUtils.loadConfig('device/opcua-std.yml');
+    conditionsConfig = await testUtils.loadConfig('device/opcua-conditions.yml');
   });
 
   it('loads minimal config with defaults', async function () {
@@ -24,6 +27,7 @@ describe('OPC-UA config tests', function () {
     expect(defaultConfig.device.userCertificatePath).to.eq(undefined);
     expect(defaultConfig.device.userPrivateKeyPath).to.eq(undefined);
     expect(defaultConfig.device.conditionKey).to.eq(undefined);
+    expect(defaultConfig.device.opcuaConditions).to.deep.eq({});
   });
 
   it('reads tags', async function () {
@@ -31,7 +35,7 @@ describe('OPC-UA config tests', function () {
   });
 
   it('loaded expression service', async function () {
-    const deviceNames = ['fan-speed', 'pump-speed', 'some-date', 'pressure'];
+    const deviceNames = ['fan-speed', 'pump-speed', 'some-date', 'pressure', 'system'];
     const allNames = [...deviceNames, 'device-connected'];
     expect(config.expressionService.definedNames()).to.deep.eq(allNames);
     expect(config.expressionService.definedNames('device')).to.deep.eq(deviceNames);
@@ -40,6 +44,11 @@ describe('OPC-UA config tests', function () {
     expect(config.expressionService.referencedNames('device')).to.deep.eq(['fan-speed', 'pump-speed']);
   });
 
+  it('migrates deprecated opcua-condition-key to opcua-conditions', async function () {
+    expect(config.device.conditionKey).to.eq('system');
+    expect(config.device.opcuaConditions).to.deep.eq({ key: 'system' });
+  });
+
   it('catches bad tag definition (bad path syntax)', async function () {
     try {
       await testUtils.loadConfig('device/opcua-bad-tag.yml');
@@ -94,4 +103,13 @@ describe('OPC-UA config tests', function () {
     testPath('10853');
     testPath('nsu=http://test.org/UA/Data/;i=10853');
   });
+
+  it('loads opcua-conditions with all properties', async function () {
+    expect(conditionsConfig.device.opcuaConditions).to.deep.eq({
+      key: 'system',
+      faultThreshold: 100,
+      warningThreshold: 50,
+    });
+    expect(conditionsConfig.device.conditionKey).to.eq('system');
+  });
 });

package/test/configFiles/conditions.yml

@@ -5,6 +5,8 @@ declare-keys:
   - key2
   - key3
   - key4
+  - system:
+      type: condition
 variables:
   keymod:
     - source: key2
@@ -35,3 +37,11 @@ conditions:
         override-message: ${this} coolant=${key1}
       - override-code: Y
         override-message: Z
+  cond4:
+    source: system
+    reclassify-fault:
+      - HIGH*
+    reclassify-warning:
+      - MEDIUM*
+    reclassify-normal:
+      - LOW*

package/test/configFiles/device/opcua-conditions.yml

@@ -0,0 +1,7 @@
+version: 2
+device: opc-ua
+endpoint: opc.tcp://localhost:4840
+opcua-conditions:
+  key: system
+  fault-threshold: 100
+  warning-threshold: 50

package/test/configFiles/device/opcua-std.yml

@@ -1,6 +1,7 @@
 version: 2
 device: opc-ua
 endpoint: opc.tcp://opcuademo.sterfive.com:26543
+opcua-condition-key: system
 mtconnect-port: 8001
 tags:
   fan-speed: