Add realtime output of telemetry data in conditionals and add support…

… for historical conditional telemetry queries to allow for plotting

src/plugins/condition/ConditionManager.js

@@ -24,6 +24,7 @@ import { EventEmitter } from 'eventemitter3';
 import { v4 as uuid } from 'uuid';
 
 import Condition from './Condition.js';
+import HistoricalTelemetryProvider from './historicalTelemetryProvider.js';
 import { getLatestTimestamp } from './utils/time.js';
 
 export default class ConditionManager extends EventEmitter {
@@ -46,6 +47,8 @@ export default class ConditionManager extends EventEmitter {
       applied: false
     };
     this.initialize();
+    this.telemetryBuffer = [];
+    this.isProcessing = false;
   }
 
   subscribeToTelemetry(telemetryObject) {
@@ -320,6 +323,17 @@ export default class ConditionManager extends EventEmitter {
     return currentCondition;
   }
 
+  getHistoricalData() {
+    const historicalTelemetry = new HistoricalTelemetryProvider(
+      this.openmct,
+      this.telemetryObjects,
+      this.compositionLoad,
+      this.conditions,
+      this.conditionSetDomainObject
+    );
+    return historicalTelemetry.getHistoricalData();
+  }
+
   getCurrentConditionLAD(conditionResults) {
     const conditionCollection = this.conditionSetDomainObject.configuration.conditionCollection;
     let currentCondition = conditionCollection[conditionCollection.length - 1];
@@ -375,8 +389,26 @@ export default class ConditionManager extends EventEmitter {
     }
 
     const currentCondition = this.getCurrentConditionLAD(conditionResults);
+    let output = currentCondition?.configuration?.output;
+    if (output === 'telemetry value') {
+      const { outputTelemetry, outputMetadata } = currentCondition.configuration;
+      const outputTelemetryObject = await this.openmct.objects.get(outputTelemetry);
+      const telemetryOptions = {
+        size: 1,
+        strategy: 'latest',
+        timeContext: this.openmct.time.getContextForView([])
+      };
+      const latestData = await this.openmct.telemetry.request(
+        outputTelemetryObject,
+        telemetryOptions
+      );
+      if (latestData?.[0]?.[outputMetadata]) {
+        output = latestData?.[0]?.[outputMetadata];
+      }
+    }
+
     const currentOutput = {
-      output: currentCondition.configuration.output,
+      output: output,
       id: this.conditionSetDomainObject.identifier,
       conditionId: currentCondition.id,
       ...latestTimestamp
@@ -394,6 +426,18 @@ export default class ConditionManager extends EventEmitter {
       }
     }
 
+    const conditionTelemetries = [];
+    const conditions = this.conditionSetDomainObject.configuration.conditionCollection;
+    conditions.forEach((condition) => {
+      if (condition?.configuration?.outputTelemetry) {
+        conditionTelemetries.push(condition?.configuration?.outputTelemetry);
+      }
+    });
+
+    if (conditionTelemetries.includes(id)) {
+      return true;
+    }
+
     return false;
   }
 
@@ -415,7 +459,7 @@ export default class ConditionManager extends EventEmitter {
     timestamp[timeSystemKey] = currentTimestamp;
     if (this.shouldEvaluateNewTelemetry(currentTimestamp)) {
       this.updateConditionResults(normalizedDatum);
-      this.updateCurrentCondition(timestamp);
+      this.updateCurrentCondition(timestamp, endpoint, datum);
     }
   }
 
@@ -428,14 +472,12 @@ export default class ConditionManager extends EventEmitter {
     });
   }
 
-  updateCurrentCondition(timestamp) {
-    const currentCondition = this.getCurrentCondition();
-
+  emitConditionSetResult(currentCondition, timestamp, outputValue) {
     this.emit(
       'conditionSetResultUpdated',
       Object.assign(
         {
-          output: currentCondition.configuration.output,
+          output: outputValue,
           id: this.conditionSetDomainObject.identifier,
           conditionId: currentCondition.id
         },
@@ -444,6 +486,60 @@ export default class ConditionManager extends EventEmitter {
     );
   }
 
+  updateCurrentCondition(timestamp, telemetryObject, telemetryData) {
+    this.telemetryBuffer.push({ timestamp, telemetryObject, telemetryData });
+
+    if (!this.isProcessing) {
+      this.processBuffer();
+    }
+  }
+
+  async processBuffer() {
+    this.isProcessing = true;
+
+    while (this.telemetryBuffer.length > 0) {
+      const { timestamp, telemetryObject, telemetryData } = this.telemetryBuffer.shift();
+      await this.processCondition(timestamp, telemetryObject, telemetryData);
+    }
+
+    this.isProcessing = false;
+  }
+
+  async processCondition(timestamp, telemetryObject, telemetryData) {
+    const currentCondition = this.getCurrentCondition();
+    let telemetryValue = currentCondition.configuration.output;
+    if (currentCondition?.configuration?.outputTelemetry) {
+      const selectedOutputIdentifier = currentCondition?.configuration?.outputTelemetry;
+      const outputMetadata = currentCondition?.configuration?.outputMetadata;
+      const telemetryKeystring = this.openmct.objects.makeKeyString(telemetryObject.identifier);
+
+      if (selectedOutputIdentifier === telemetryKeystring) {
+        telemetryValue = telemetryData[outputMetadata];
+      } else {
+        const outputTelemetryObject = await this.openmct.objects.get(selectedOutputIdentifier);
+        const telemetryOptions = {
+          size: 1,
+          strategy: 'latest',
+          start: timestamp?.utc - 1000,
+          end: timestamp?.utc + 1000
+        };
+        const outputTelemetryData = await this.openmct.telemetry.request(
+          outputTelemetryObject,
+          telemetryOptions
+        );
+        const outputTelemetryValue =
+          outputTelemetryData?.length > 0 ? outputTelemetryData.slice(-1)[0] : null;
+        if (outputTelemetryData.length && outputTelemetryValue?.[outputMetadata]) {
+          telemetryValue = outputTelemetryValue?.[outputMetadata];
+        } else {
+          telemetryValue = undefined;
+        }
+      }
+    }
+
+    this.emitConditionSetResult(currentCondition, timestamp, telemetryValue);
+  }
+
   getTestData(metadatum) {
     let data = undefined;
     if (this.testData.applied) {

src/plugins/condition/ConditionSetTelemetryProvider.js

@@ -42,8 +42,9 @@ export default class ConditionSetTelemetryProvider {
 
   async request(domainObject, options) {
     let conditionManager = this.getConditionManager(domainObject);
+    const formattedHistoricalData = await conditionManager.getHistoricalData();
     let latestOutput = await conditionManager.requestLADConditionSetOutput(options);
-    return latestOutput;
+    return [...formattedHistoricalData, ...latestOutput];
   }
 
   subscribe(domainObject, callback) {

src/plugins/condition/components/ConditionCollection.vue

@@ -235,10 +235,11 @@ export default {
 
       return arr;
     },
-    addTelemetryObject(domainObject) {
+    async addTelemetryObject(domainObject) {
       const keyString = this.openmct.objects.makeKeyString(domainObject.identifier);
+      const telemetryPath = await this.getFullTelemetryPath(domainObject);
 
-      this.telemetryObjs.push(domainObject);
+      this.telemetryObjs.push({ ...domainObject, path: telemetryPath });
       this.$emit('telemetry-updated', this.telemetryObjs);
 
       this.subscribeToStaleness(domainObject, (stalenessResponse) => {
@@ -248,6 +249,19 @@ export default {
         });
       });
     },
+    async getFullTelemetryPath(telemetry) {
+      const keyString = this.openmct.objects.makeKeyString(telemetry.identifier);
+      const originalPathObjects = await this.openmct.objects.getOriginalPath(keyString, []);
+
+      const telemetryPath = originalPathObjects.reverse().map((pathObject) => {
+        if (pathObject.type !== 'root') {
+          return pathObject.name;
+        }
+        return undefined;
+      });
+
+      return telemetryPath.join('/');
+    },
     removeTelemetryObject(identifier) {
       const keyString = this.openmct.objects.makeKeyString(identifier);
       const index = this.telemetryObjs.findIndex((obj) => {

src/plugins/condition/components/ConditionItem.vue

@@ -99,22 +99,55 @@
               @change="setOutputValue"
             >
               <option v-for="option in outputOptions" :key="option" :value="option">
-                {{ initCap(option) }}
+                {{ option }}
               </option>
             </select>
           </span>
           <span class="c-cdef__control">
             <input
-              v-if="selectedOutputSelection === outputOptions[2]"
+              v-if="selectedOutputSelection === outputOptions[3]"
               v-model="condition.configuration.output"
               aria-label="Condition Output String"
               class="t-condition-name-input"
               type="text"
               @change="persist"
             />
           </span>
+          <span v-if="selectedOutputSelection === 'telemetry value'" class="c-cdef__control">
+            <select
+              v-model="condition.configuration.outputTelemetry"
+              aria-label="Output Telemetry Selection"
+              @change="persist"
+            >
+              <option value="">- Select Telemetry -</option>
+              <option
+                v-for="telemetryOption in telemetry"
+                :key="openmct.objects.makeKeyString(telemetryOption.identifier)"
+                :value="openmct.objects.makeKeyString(telemetryOption.identifier)"
+              >
+                {{ telemetryOption.path }}
+              </option>
+            </select>
+          </span>
+          <span v-if="condition.configuration.outputTelemetry" class="c-cdef__control">
+            <select
+              v-model="condition.configuration.outputMetadata"
+              aria-label="Output Telemetry Metadata Selection"
+              @change="persist"
+            >
+              <option value="">- Select Field -</option>
+              <option
+                v-for="(option, index) in telemetryMetadataOptions[
+                  condition.configuration.outputTelemetry
+                ]"
+                :key="index"
+                :value="option.key"
+              >
+                {{ option.name }}
+              </option>
+            </select>
+          </span>
         </span>
-
         <div v-if="!condition.isDefault" class="c-cdef__match-and-criteria">
           <span class="c-cdef__separator c-row-separator"></span>
           <span class="c-cdef__label">Match</span>
@@ -181,7 +214,12 @@
         <span class="c-condition__name">
           {{ condition.configuration.name }}
         </span>
-        <span class="c-condition__output"> Output: {{ condition.configuration.output }} </span>
+        <span class="c-condition__output">
+          Output:
+          {{
+            condition.configuration.output === undefined ? 'none' : condition.configuration.output
+          }}
+        </span>
       </div>
       <div class="c-condition__summary">
         <ConditionDescription :show-label="false" :condition="condition" />
@@ -250,10 +288,11 @@ export default {
       expanded: true,
       trigger: 'all',
       selectedOutputSelection: '',
-      outputOptions: ['false', 'true', 'string'],
+      outputOptions: ['none', 'false', 'true', 'string', 'telemetry value'],
       criterionIndex: 0,
       draggingOver: false,
-      isDefault: this.condition.isDefault
+      isDefault: this.condition.isDefault,
+      telemetryMetadataOptions: {}
     };
   },
   computed: {
@@ -287,26 +326,51 @@ export default {
       return false;
     }
   },
+  watch: {
+    condition: {
+      handler() {
+        if (this.condition.configuration.output !== 'telemetry value') {
+          this.condition.configuration.outputTelemetry = null;
+          this.condition.configuration.outputMetadata = null;
+        }
+      },
+      deep: true
+    },
+    isEditing(newValue, oldValue) {
+      if (newValue === true) {
+        this.initializeMetadata();
+      }
+    }
+  },
   unmounted() {
     this.destroy();
   },
   mounted() {
     this.setOutputSelection();
+    this.initializeMetadata();
   },
   methods: {
     setOutputSelection() {
       let conditionOutput = this.condition.configuration.output;
       if (conditionOutput) {
-        if (conditionOutput !== 'false' && conditionOutput !== 'true') {
+        if (
+          conditionOutput !== 'false' &&
+          conditionOutput !== 'true' &&
+          conditionOutput !== 'telemetry value'
+        ) {
           this.selectedOutputSelection = 'string';
         } else {
           this.selectedOutputSelection = conditionOutput;
         }
+      } else if (conditionOutput === undefined) {
+        this.selectedOutputSelection = 'none';
       }
     },
     setOutputValue() {
       if (this.selectedOutputSelection === 'string') {
         this.condition.configuration.output = '';
+      } else if (this.selectedOutputSelection === 'none') {
+        this.condition.configuration.output = undefined;
       } else {
         this.condition.configuration.output = this.selectedOutputSelection;
       }
@@ -401,6 +465,24 @@ export default {
     },
     initCap(str) {
       return str.charAt(0).toUpperCase() + str.slice(1);
+    },
+    initializeMetadata() {
+      this.telemetry.forEach((telemetryObject) => {
+        const id = this.openmct.objects.makeKeyString(telemetryObject.identifier);
+        let telemetryMetadata = this.openmct.telemetry.getMetadata(telemetryObject);
+        if (telemetryMetadata) {
+          this.telemetryMetadataOptions[id] = telemetryMetadata.values().slice();
+        } else {
+          this.telemetryMetadataOptions[id] = [];
+        }
+      });
+    },
+    getId(identifier) {
+      if (identifier) {
+        return this.openmct.objects.makeKeyString(identifier);
+      }
+
+      return [];
     }
   }
 };

src/plugins/condition/components/CriterionItem.vue

@@ -40,7 +40,7 @@
             :key="telemetryOption.identifier.key"
             :value="telemetryOption.identifier"
           >
-            {{ telemetryOption.name }}
+            {{ telemetryOption.path }}
           </option>
         </select>
       </span>