Add all and any options for telemetry

src/plugins/condition/Condition.js

@@ -25,6 +25,7 @@ import uuid from 'uuid';
 import TelemetryCriterion from "./criterion/TelemetryCriterion";
 import { TRIGGER } from "./utils/constants";
 import {computeCondition} from "./utils/evaluator";
+import AllTelemetryCriterion from "@/plugins/condition/criterion/AllTelemetryCriterion";
 
 /*
 * conditionConfiguration = {
@@ -124,8 +125,13 @@ export default class ConditionClass extends EventEmitter {
      *  adds criterion to the condition.
      */
     addCriterion(criterionConfiguration) {
+        let criterion;
         let criterionConfigurationWithId = this.generateCriterion(criterionConfiguration || null);
-        let criterion = new TelemetryCriterion(criterionConfigurationWithId, this.openmct);
+        if (criterionConfiguration.telemetry && (criterionConfiguration.telemetry === 'any' || criterionConfiguration.telemetry === 'all')) {
+            criterion = new AllTelemetryCriterion(criterionConfigurationWithId, this.openmct);
+        } else {
+            criterion = new TelemetryCriterion(criterionConfigurationWithId, this.openmct);
+        }
         criterion.on('criterionUpdated', (obj) => this.handleCriterionUpdated(obj));
         criterion.on('criterionResultUpdated', (obj) => this.handleCriterionResult(obj));
         if (!this.criteria) {

src/plugins/condition/components/Criterion.vue

@@ -9,6 +9,8 @@
                     @change="updateMetadataOptions"
             >
                 <option value="">- Select Telemetry -</option>
+                <option value="all">All Telemetry</option>
+                <option value="any">Any Telemetry</option>
                 <option v-for="telemetryOption in telemetry"
                         :key="telemetryOption.identifier.key"
                         :value="telemetryOption.identifier"
@@ -109,7 +111,7 @@ export default {
     data() {
         return {
             telemetryMetadata: {},
-            telemetryMetadataOptions: {},
+            telemetryMetadataOptions: [],
             operations: OPERATIONS,
             inputCount: 0,
             rowLabel: '',
@@ -132,7 +134,11 @@ export default {
             return (this.index !== 0 ? operator : '') + 'when';
         },
         filteredOps: function () {
+            if (this.operationFormat === 'all') {
+                return this.operations;
+            } else {
                 return [...this.operations.filter(op => op.appliesTo.indexOf(this.operationFormat) !== -1)];
+            }
         },
         setInputType: function () {
             let type = '';
@@ -154,8 +160,11 @@ export default {
     },
     methods: {
         checkTelemetry() {
-            if(this.criterion.telemetry &&
+            if(this.criterion.telemetry) {
-                !this.telemetry.find((telemetryObj) => this.openmct.objects.areIdsEqual(this.criterion.telemetry, telemetryObj.identifier))) {
+                if (this.criterion.telemetry === 'any' && this.criterion.telemetry === 'all') {
+                    this.updateMetadataOptions();
+                } else {
+                    if (!this.telemetry.find((telemetryObj) => this.openmct.objects.areIdsEqual(this.criterion.telemetry, telemetryObj.identifier))) {
                         //telemetry being used was removed. So reset this criterion.
                         this.criterion.telemetry = '';
                         this.criterion.metadata = '';
@@ -163,9 +172,14 @@ export default {
                         this.criterion.operation = '';
                         this.persist();
                     }
+                }
+            }
         },
         getOperationFormat() {
             this.enumerations = [];
+            if (this.criterion.telemetry && (this.criterion.telemetry === 'any' || this.criterion.telemetry === 'all')) {
+                this.operationFormat = 'all';
+            } else {
                 this.telemetryMetadata.valueMetadatas.forEach((value, index) => {
                     if (value.key === this.criterion.metadata) {
                         let valueMetadata = this.telemetryMetadataOptions[index];
@@ -183,25 +197,39 @@ export default {
                         }
                     }
                 });
+            }
         },
         updateMetadataOptions(ev) {
             if (ev) {
-                this.clearDependentFields(ev.target)
+                this.clearDependentFields(ev.target);
+                this.updateOperations(ev);
             }
             if (this.criterion.telemetry) {
+                if (this.criterion.telemetry === 'any' || this.criterion.telemetry === 'all') {
+                    let telemetryPromises = this.telemetry.map((telemetryObject) => this.openmct.objects.get(telemetryObject.identifier));
+                    Promise.all(telemetryPromises).then(telemetryObjects => {
+                        this.telemetryMetadataOptions = [];
+                        telemetryObjects.forEach(telemetryObject => {
+                            let telemetryMetadata = this.openmct.telemetry.getMetadata(telemetryObject);
+                            this.telemetryMetadataOptions = this.telemetryMetadataOptions.concat(telemetryMetadata.values());
+                            this.updateOperations();
+                            this.updateOperationInputVisibility();
+                        });
+                    });
+                } else {
                     this.openmct.objects.get(this.criterion.telemetry).then((telemetryObject) => {
                         this.telemetryMetadata = this.openmct.telemetry.getMetadata(telemetryObject);
                         this.telemetryMetadataOptions = this.telemetryMetadata.values();
-                    this.updateOperations(ev);
+                        this.updateOperations();
                         this.updateOperationInputVisibility();
-                    this.$emit('setTelemetryName', telemetryObject.name)
                     });
+                }
             } else {
                 this.criterion.metadata = '';
             }
         },
         updateOperations(ev) {
-            if (ev.target === this.$ref.telemetrySelect) {
+            if (ev && (ev.target === this.$refs.telemetrySelect)) {
                 this.clearDependentFields(ev.target);
                 this.persist();
             }
@@ -221,10 +249,10 @@ export default {
             }
         },
         clearDependentFields(el) {
-            if (el === this.$ref.telemetrySelect) {
+            if (el === this.$refs.telemetrySelect) {
                 this.criterion.metadata = '';
                 this.criterion.operation = '';
-            } else if (el === this.$ref.metadataSelect) {
+            } else if (el === this.$refs.metadataSelect) {
                 this.criterion.operation = '';
             }
             this.criterion.input = [];

src/plugins/condition/criterion/AllTelemetryCriterion.js

@@ -50,10 +50,18 @@ export default class TelemetryCriterion extends EventEmitter {
         this.telemetryDataCache = {};
     }
 
-    formatData(data, telemetryObjects) {
+    updateTelemetry(telemetryObjects) {
-        this.telemetryDataCache[data.id] = this.computeResult(data);
+        this.telemetryObjects = telemetryObjects;
+    }
 
-        telemetryObjects.forEach((telemetryObject) => {
+    formatData(data, telemetryObjects) {
+        if (data) {
+            this.telemetryDataCache[data.id] = this.computeResult(data);
+        }
+
+        let keys = Object.keys(telemetryObjects);
+        keys.forEach((key) => {
+            let telemetryObject = telemetryObjects[key];
             const id = this.openmct.objects.makeKeyString(telemetryObject.identifier);
             if (this.telemetryDataCache[id] === undefined) {
                 this.telemetryDataCache[id] = false;
@@ -70,7 +78,6 @@ export default class TelemetryCriterion extends EventEmitter {
                 datum[timeSystem.key] = data[timeSystem.key]
             });
         }
-
         return datum;
     }
 
@@ -137,25 +144,21 @@ export default class TelemetryCriterion extends EventEmitter {
 
         return Promise.all(telemetryRequests)
             .then(telemetryRequestsResults => {
-                telemetryRequestsResults.forEach(results => {
+                telemetryRequestsResults.forEach((results, index) => {
                     const latestDatum = results.length ? results[results.length - 1] : {};
+                    if (index === telemetryRequestsResults.length-1) {
+                        //when the last result is computed, we return the result
                         return {
                             id: this.id,
                             data: this.formatData(latestDatum, options.telemetryObjects)
                         };
+                    } else {
+                        if (latestDatum) {
+                            this.telemetryDataCache[latestDatum.id] = this.computeResult(latestDatum);
+                        }
+                    }
                 });
             });
-
-        // return this.telemetryAPI.request(
-        //     this.telemetryObject,
-        //     options
-        // ).then(results => {
-        //     const latestDatum = results.length ? results[results.length - 1] : {};
-        //     return {
-        //         id: this.id,
-        //         data: this.formatData(latestDatum)
-        //     };
-        // });
     }
 
     destroy() {