Feature/historical conditions

.webpack/webpack.common.mjs

@@ -50,7 +50,8 @@ const config = {
     inMemorySearchWorker: './src/api/objects/InMemorySearchWorker.js',
     espressoTheme: './src/plugins/themes/espresso-theme.scss',
     snowTheme: './src/plugins/themes/snow-theme.scss',
-    darkmatterTheme: './src/plugins/themes/darkmatter-theme.scss'
+    darkmatterTheme: './src/plugins/themes/darkmatter-theme.scss',
+    historicalTelemetryWorker: './src/plugins/condition/historicalTelemetryWorker.js',
   },
   output: {
     globalObject: 'this',

e2e/appActions.js

@@ -127,6 +127,22 @@ async function createDomainObjectWithDefaults(
   };
 }
 
+/**
+ * Retrieves the properties of an OpenMCT domain object by its identifier.
+ *
+ * @param {import('@playwright/test').Page} page - The Playwright page object.
+ * @param {string | identifier - The identifier or UUID of the domain object.
+ * @returns {Promise<Object>} An object containing the properties of the domain object.
+ */
+async function getDomainObject(page, identifier) {
+  const domainObject = await page.evaluate(async (objIdentifier) => {
+    const object = await window.openmct.objects.get(objIdentifier);
+    return object;
+  }, identifier);
+
+  return domainObject;
+}
+
 /**
  * Generate a notification with the given options.
  * @param {import('@playwright/test').Page} page
@@ -716,6 +732,7 @@ export {
   createStableStateTelemetry,
   expandEntireTree,
   getCanvasPixels,
+  getDomainObject,
   linkParameterToObject,
   navigateToObjectWithFixedTimeBounds,
   navigateToObjectWithRealTime,

e2e/tests/functional/plugins/conditionSet/conditionSet.e2e.spec.js

@@ -29,7 +29,8 @@ import { fileURLToPath } from 'url';
 
 import {
   createDomainObjectWithDefaults,
-  createExampleTelemetryObject
+  createExampleTelemetryObject,
+  getDomainObject
 } from '../../../../appActions.js';
 import { expect, test } from '../../../../pluginFixtures.js';
 
@@ -468,6 +469,34 @@ test.describe('Basic Condition Set Use', () => {
       description: 'https://github.com/nasa/openmct/issues/7484'
     });
   });
+
+  test('should toggle shouldFetchHistorical property in inspector', async ({ page }) => {
+    await page.goto(conditionSet.url);
+    await page.getByLabel('Edit Object').click();
+    await page.getByRole('tab', { name: 'Config' }).click();
+    let toggleSwitch = page.getByLabel('condition-historical-toggle');
+    const initialState = await toggleSwitch.isChecked();
+    expect(initialState).toBe(false);
+
+    await toggleSwitch.click();
+    let toggledState = await toggleSwitch.isChecked();
+    expect(toggledState).toBe(true);
+    await page.click('button[title="Save"]');
+    await page.getByRole('listitem', { name: 'Save and Finish Editing' }).click();
+    let conditionSetObject = await getDomainObject(page, conditionSet.uuid);
+    expect(conditionSetObject.configuration.shouldFetchHistorical).toBe(true);
+
+    await page.getByLabel('Edit Object').click();
+    await page.getByRole('tab', { name: 'Config' }).click();
+    toggleSwitch = page.getByLabel('condition-historical-toggle');
+    await toggleSwitch.click();
+    toggledState = await toggleSwitch.isChecked();
+    expect(toggledState).toBe(false);
+    await page.click('button[title="Save"]');
+    await page.getByRole('listitem', { name: 'Save and Finish Editing' }).click();
+    conditionSetObject = await getDomainObject(page, conditionSet.uuid);
+    expect(conditionSetObject.configuration.shouldFetchHistorical).toBe(false);
+  });
 });
 
 test.describe('Condition Set Composition', () => {

karma.conf.cjs

@@ -66,6 +66,10 @@ module.exports = async (config) => {
       {
         pattern: 'dist/generatorWorker.js*',
         included: false
+      },
+      {
+        pattern: 'dist/historicalTelemetryWorker.js*',
+        included: false
       }
     ],
     port: 9876,

src/plugins/condition/ConditionInspectorViewProvider.js

@@ -0,0 +1,73 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2024, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+import mount from 'utils/mount';
+
+import ConditionConfigView from './components/ConditionInspectorConfigView.vue';
+
+export default function ConditionInspectorView(openmct) {
+  return {
+    key: 'condition-config',
+    name: 'Config',
+    canView: function (selection) {
+      return selection.length > 0 && selection[0][0].context.item.type === 'conditionSet';
+    },
+    view: function (selection) {
+      let _destroy = null;
+      const domainObject = selection[0][0].context.item;
+
+      return {
+        show: function (element) {
+          const { destroy } = mount(
+            {
+              el: element,
+              components: {
+                ConditionConfigView: ConditionConfigView
+              },
+              provide: {
+                openmct,
+                domainObject
+              },
+              template: '<condition-config-view></condition-config-view>'
+            },
+            {
+              app: openmct.app,
+              element
+            }
+          );
+          _destroy = destroy;
+        },
+        showTab: function (isEditing) {
+          return isEditing;
+        },
+        priority: function () {
+          return 1;
+        },
+        destroy: function () {
+          if (_destroy) {
+            _destroy();
+          }
+        }
+      };
+    }
+  };
+}

src/plugins/condition/ConditionManager.js

@@ -24,6 +24,8 @@ import { EventEmitter } from 'eventemitter3';
 import { v4 as uuid } from 'uuid';
 
 import Condition from './Condition.js';
+import HistoricalTelemetryProvider from './HistoricalTelemetryProvider.js';
+import { TELEMETRY_VALUE } from './utils/constants.js';
 import { getLatestTimestamp } from './utils/time.js';
 
 export default class ConditionManager extends EventEmitter {
@@ -52,6 +54,8 @@ export default class ConditionManager extends EventEmitter {
       applied: false
     };
     this.initialize();
+    this.telemetryBuffer = [];
+    this.isProcessing = false;
   }
 
   subscribeToTelemetry(telemetryObject) {
@@ -310,6 +314,39 @@ export default class ConditionManager extends EventEmitter {
     this.persistConditions();
   }
 
+  getCurrentCondition() {
+    const conditionCollection = this.conditionSetDomainObject.configuration.conditionCollection;
+    let currentCondition = conditionCollection[conditionCollection.length - 1];
+
+    for (let i = 0; i < conditionCollection.length - 1; i++) {
+      const condition = this.findConditionById(conditionCollection[i].id);
+      if (condition.result) {
+        //first condition to be true wins
+        currentCondition = conditionCollection[i];
+        break;
+      }
+    }
+
+    return currentCondition;
+  }
+
+  getHistoricalData(options) {
+    if (!this.conditionSetDomainObject.configuration.shouldFetchHistorical) {
+      return [];
+    }
+    let historicalTelemetry = new HistoricalTelemetryProvider(
+      this.openmct,
+      this.telemetryObjects,
+      this.conditions,
+      this.conditionSetDomainObject,
+      options
+    );
+    const historicalData = historicalTelemetry.getHistoricalData();
+    historicalTelemetry = null;
+
+    return historicalData;
+  }
+
   getCurrentConditionLAD(conditionResults) {
     const conditionCollection = this.conditionSetDomainObject.configuration.conditionCollection;
     let currentCondition = conditionCollection[conditionCollection.length - 1];
@@ -365,14 +402,36 @@ 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];
+      }
+    }
+
+    let result = currentCondition?.isDefault ? false : conditionResults[currentCondition.id];
     const currentOutput = {
-      output: currentCondition.configuration.output,
-      id: this.conditionSetDomainObject.identifier,
       conditionId: currentCondition.id,
-      ...latestTimestamp
+      id: this.conditionSetDomainObject.identifier,
+      output: output,
+      ...latestTimestamp,
+      result,
+      isDefault: currentCondition?.isDefault
     };
 
-    return [currentOutput];
+    return output !== undefined ? [currentOutput] : [];
   }
 
   isTelemetryUsed(endpoint) {
@@ -407,8 +466,8 @@ export default class ConditionManager extends EventEmitter {
     this.#latestDataTable.set(normalizedDatum.id, normalizedDatum);
 
     if (this.shouldEvaluateNewTelemetry(currentTimestamp)) {
-      const matchingCondition = this.updateConditionResults(normalizedDatum.id);
-      this.updateCurrentCondition(timestamp, matchingCondition);
+      this.updateConditionResults(normalizedDatum);
+      this.updateCurrentCondition(timestamp, endpoint, datum);
     }
   }
 
@@ -423,23 +482,80 @@ export default class ConditionManager extends EventEmitter {
     return matchingCondition;
   }
 
-  updateCurrentCondition(timestamp, matchingCondition) {
-    const conditionCollection = this.conditionSetDomainObject.configuration.conditionCollection;
-    const defaultCondition = conditionCollection[conditionCollection.length - 1];
+  emitConditionSetResult(currentCondition, timestamp, outputValue, result, isDefault) {
+    this.emit('conditionSetResultUpdated', {
+      conditionId: currentCondition.id,
+      id: this.conditionSetDomainObject.identifier,
+      output: outputValue,
+      ...timestamp,
+      result,
+      isDefault
+    });
+  }
 
-    const currentCondition = matchingCondition || defaultCondition;
+  updateCurrentCondition(timestamp, telemetryObject, telemetryData) {
+    this.telemetryBuffer.push({ timestamp, telemetryObject, telemetryData });
 
-    this.emit(
-      'conditionSetResultUpdated',
-      Object.assign(
-        {
-          output: currentCondition.configuration.output,
-          id: this.conditionSetDomainObject.identifier,
-          conditionId: currentCondition.id
-        },
-        timestamp
-      )
-    );
+    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();
+    const conditionDetails = this.conditions.filter(
+      (condition) => condition.id === currentCondition.id
+    )?.[0];
+    const conditionResult = currentCondition?.isDefault ? false : conditionDetails?.result;
+    let telemetryValue = currentCondition.configuration.output;
+
+    if (telemetryValue !== undefined && 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,
+        conditionResult,
+        currentCondition?.isDefault
+      );
+    }
   }
 
   getTestData(metadatum, identifier) {