Cleanup and add missing files

.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',

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,53 @@
+// src/plugins/condition/ConditionInspectorView.js
+
+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

@@ -324,14 +324,16 @@
   }
 
   getHistoricalData() {
+    if (!this.conditionSetDomainObject.configuration.shouldFetchHistorical) {
+      return [];
+    }
     const historicalTelemetry = new HistoricalTelemetryProvider(
       this.openmct,
       this.telemetryObjects,
-      this.compositionLoad,
       this.conditions,
       this.conditionSetDomainObject
     );
     return historicalTelemetry.getHistoricalData();
   }
 
   getCurrentConditionLAD(conditionResults) {
@@ -389,21 +391,21 @@
     }
 
     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];
       }
     }
 
@@ -426,16 +428,16 @@
       }
     }
 
     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;
@@ -509,30 +511,30 @@
     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;
         }
       }
     }

src/plugins/condition/components/ConditionInspectorConfigView.vue

@@ -0,0 +1,62 @@
+<template>
+  <div class="c-inspect-properties">
+    <h2>Configuration</h2>
+    <section>
+      <div class="c-form-row">
+        <label for="historical-toggle">Enable Historical: </label>
+        <ToggleSwitch
+          id="historical-toggle"
+          class="c-toggle-switch"
+          :checked="historicalEnabled"
+          name="condition-historical-toggle"
+          @change="onToggleChange"
+        />
+      </div>
+    </section>
+  </div>
+</template>
+
+<script>
+import ToggleSwitch from '../../../ui/components/ToggleSwitch.vue';
+
+export default {
+  components: {
+    ToggleSwitch
+  },
+  inject: ['openmct', 'domainObject'],
+  data() {
+    return {
+      historicalEnabled: false
+    };
+  },
+  mounted() {
+    this.historicalEnabled = this.domainObject.configuration.shouldFetchHistorical;
+  },
+  methods: {
+    onToggleChange() {
+      this.historicalEnabled = !this.historicalEnabled;
+      this.openmct.objects.mutate(
+        this.domainObject,
+        'configuration.shouldFetchHistorical',
+        this.historicalEnabled
+      );
+    }
+  }
+};
+</script>
+
+<style scoped>
+.c-inspect-properties {
+  padding: 10px;
+}
+
+.c-form-row {
+  display: flex;
+  align-items: center;
+  margin-bottom: 10px;
+}
+
+label {
+  margin-right: 10px;
+}
+</style>

src/plugins/condition/historicalTelemetryProvider.js

@@ -1,107 +1,106 @@
 export default class HistoricalTelemetryProvider {
-  constructor(openmct, telemetryObjects, compositionLoad, conditions, conditionSetDomainObject) {
+  constructor(openmct, telemetryObjects, conditions, conditionSetDomainObject) {
     this.openmct = openmct;
     this.telemetryObjects = telemetryObjects;
-    this.compositionLoad = compositionLoad;
     this.bounds = { start: null, end: null };
     this.telemetryList = [];
     this.conditions = conditions;
     this.conditionSetDomainObject = conditionSetDomainObject;
     this.historicalTelemetryPoolMap = new Map();
     this.historicalTelemetryDateMap = new Map();
     this.index = 0;
   }
 
   setTimeBounds(bounds) {
     this.bounds = bounds;
   }
 
   refreshAllHistoricalTelemetries() {
     const refreshPromises = [];
     for (const [, value] of Object.entries(this.telemetryObjects)) {
       refreshPromises.push(this.refreshHistoricalTelemetry(value));
     }
     return Promise.all(refreshPromises);
   }
 
   async refreshHistoricalTelemetry(domainObject, identifier) {
     console.log('refreshHistoricalTelemetry');
     if (!domainObject && identifier) {
       domainObject = await this.openmct.objects.get(identifier);
     }
     const id = this.openmct.objects.makeKeyString(domainObject.identifier);
     const telemetryOptions = { ...this.bounds };
     const historicalTelemetry = await this.openmct.telemetry.request(
       domainObject,
       telemetryOptions
     );
     this.historicalTelemetryPoolMap.set(id, { domainObject, historicalTelemetry });
     return { domainObject, historicalTelemetry };
   }
 
   evaluateTrueCondition(historicalDateMap, timestamp, condition, conditionCollectionMap) {
     const telemetryData = historicalDateMap.get(timestamp);
     const conditionConfiguration = conditionCollectionMap.get(condition.id)?.configuration;
     const { outputTelemetry, outputMetadata } = conditionConfiguration;
     let output = {};
     if (outputTelemetry) {
       const outputTelemetryID = this.openmct.objects.makeKeyString(outputTelemetry);
       const outputTelemetryData = telemetryData.get(outputTelemetryID);
       output.telemetry = outputTelemetryData;
       output.value = outputTelemetryData[outputMetadata];
       output.condition = condition;
     } else if (conditionConfiguration?.output) {
       output.telemetry = null;
       output.value = conditionConfiguration?.output;
       output.condition = condition;
     }
     return output;
   }
 
   async getAllTelemetries(conditionCollection) {
     const conditionCollectionMap = new Map();
     const inputTelemetries = [];
     const outputTelemetries = [];
     const historicalTelemetryPoolPromises = [];
 
     conditionCollection.forEach((condition, index) => {
       console.log('-------------------------');
       console.log(condition);
       const { id } = condition;
       const { criteria, output, outputTelemetry, outputMetadata } = condition.configuration;
       const inputTelemetry = criteria?.[0]?.telemetry;
       console.log(id);
       console.log(criteria);
       console.log(output);
       console.log(outputMetadata);
       console.log('inputTelemetry', inputTelemetry);
       console.log('outputTelemetry', outputTelemetry);
       conditionCollectionMap.set(condition?.id, condition);
       if (inputTelemetry) {
         const inputTelemetryId = this.openmct.objects.makeKeyString(inputTelemetry);
         if (![...inputTelemetries, ...outputTelemetries].includes(inputTelemetryId)) {
           historicalTelemetryPoolPromises.push(
             this.refreshHistoricalTelemetry(null, inputTelemetry)
           );
         }
         inputTelemetries.push(inputTelemetryId);
       } else {
         inputTelemetries.push(null);
       }
       if (outputTelemetry) {
         if (![...inputTelemetries, ...outputTelemetries].includes(outputTelemetry)) {
           historicalTelemetryPoolPromises.push(
             this.refreshHistoricalTelemetry(null, outputTelemetry)
           );
         }
         outputTelemetries.push(outputTelemetry);
       } else {
         outputTelemetries.push(null);
       }
     });
 
     const historicalTelemetriesPool = await Promise.all(historicalTelemetryPoolPromises);
     return {
       historicalTelemetriesPool,
       inputTelemetries,
       outputTelemetries,
@@ -110,165 +109,179 @@
   }
 
   sortTelemetriesByDate(historicalTelemetriesPool) {
     const historicalTelemetryDateMap = new Map();
     historicalTelemetriesPool.forEach((historicalTelemetryList) => {
       const { historicalTelemetry, domainObject } = historicalTelemetryList;
       const { identifier } = domainObject;
       const telemetryIdentifier = this.openmct.objects.makeKeyString(identifier);
       historicalTelemetry.forEach((historicalTelemetryItem) => {
         if (!historicalTelemetryDateMap.get(historicalTelemetryItem.utc)) {
           const telemetryMap = new Map();
           telemetryMap.set(telemetryIdentifier, historicalTelemetryItem);
           historicalTelemetryDateMap.set(historicalTelemetryItem.utc, telemetryMap);
         } else {
           const telemetryMap = historicalTelemetryDateMap.get(historicalTelemetryItem.utc);
           telemetryMap.set(telemetryIdentifier, historicalTelemetryItem);
           historicalTelemetryDateMap.set(historicalTelemetryItem.utc, telemetryMap);
         }
       });
     });
     return historicalTelemetryDateMap;
   }
 
+  async sortTelemetriesInWorker(historicalTelemetriesPool) {
+    const sortedTelemetries = await this.startWorker('sortTelemetries', {
+      historicalTelemetriesPool
+    });
+    return sortedTelemetries;
+  }
+
+  async startWorker(type, data) {
+    // eslint-disable-next-line no-undef
+    const workerUrl = `${this.openmct.getAssetPath()}${__OPENMCT_ROOT_RELATIVE__}historicalTelemetryWorker.js`;
+    const worker = new Worker(workerUrl);
+
+    try {
+      const result = await this.getDataFromWorker(worker, type, data);
+      return result;
+    } catch (error) {
+      console.error('Error in condition manager getHistoricalData:', error);
+      throw error;
+    } finally {
+      worker.terminate();
+    }
+  }
+
+  getDataFromWorker(worker, type, data) {
+    return new Promise((resolve, reject) => {
+      worker.onmessage = (e) => {
+        if (e.data.type === 'result') {
+          resolve(e.data.data);
+        } else if (e.data.type === 'error') {
+          reject(new Error(e.data.error));
+        }
+      };
+
+      worker.onerror = (error) => {
+        reject(error);
+      };
+
+      worker.postMessage({
+        type,
+        data
+      });
+    });
+  }
+
   evaluateConditionsByDate(historicalTelemetryDateMap, conditionCollectionMap) {
     const outputTelemetryDateMap = new Map();
     historicalTelemetryDateMap.forEach((historicalTelemetryMap, timestamp) => {
       let isConditionValid = false;
       const evaluatedConditions = [];
       this.conditions.forEach((condition) => {
         if (isConditionValid) {
           return;
         }
         const { id } = condition;
         const conditionMetadata = { condition };
         const conditionCriteria = condition.criteria[0];
         let result;
         if (conditionCriteria?.telemetry) {
           const conditionInputTelemetryId = this.openmct.objects.makeKeyString(
             conditionCriteria.telemetry
           );
           const inputTelemetry = historicalTelemetryMap.get(conditionInputTelemetryId);
           conditionMetadata.inputTelemetry = inputTelemetry;
           result = conditionCriteria.computeResult({
             id,
             ...inputTelemetry
           });
         } else if (!conditionCriteria) {
           const conditionDetails = conditionCollectionMap.get(id);
           const { isDefault } = conditionDetails;
           const conditionConfiguration = conditionDetails?.configuration;
           const { outputTelemetry, outputMetadata, output } = conditionConfiguration;
           if (isDefault) {
             const conditionOutput = {
               telemetry: null,
               value: output,
               condition
             };
             outputTelemetryDateMap.set(timestamp, conditionOutput);
           }
         }
         conditionMetadata.result = result;
         evaluatedConditions.push(conditionMetadata);
         if (result === true) {
           isConditionValid = true;
           const conditionOutput = this.evaluateTrueCondition(
             historicalTelemetryDateMap,
             timestamp,
             condition,
             conditionCollectionMap
           );
-          console.log(conditionOutput.value);
           outputTelemetryDateMap.set(timestamp, conditionOutput);
         }
       });
     });
     return outputTelemetryDateMap;
   }
 
   async getHistoricalInputsByDate() {
-    console.log('getHistoricalInputsByDate');
-    console.log(this.conditions);
     const conditionCollection = this.conditionSetDomainObject.configuration.conditionCollection;
 
     const {
       historicalTelemetriesPool,
       inputTelemetries,
       outputTelemetries,
       conditionCollectionMap
     } = await this.getAllTelemetries(conditionCollection);
 
-    const historicalTelemetryDateMap = this.sortTelemetriesByDate(historicalTelemetriesPool);
+    const historicalTelemetryDateMap =
+      await this.sortTelemetriesInWorker(historicalTelemetriesPool);
     const outputTelemetryDateMap = this.evaluateConditionsByDate(
       historicalTelemetryDateMap,
       conditionCollectionMap
     );
 
     console.log('*️⃣*️⃣*️⃣*️⃣*️⃣*️⃣*️⃣*️⃣*️⃣*️⃣*️⃣*️⃣*️⃣*️⃣');
     console.log(historicalTelemetriesPool);
     console.log(this.historicalTelemetryPoolMap);
     console.log(inputTelemetries);
     console.log(outputTelemetries);
     console.log(historicalTelemetryDateMap);
     console.log(outputTelemetryDateMap);
 
     return outputTelemetryDateMap;
   }
 
   addItemToHistoricalTelemetryMap(telemetryMap, item, type, index) {
     if (type === 'input') {
       telemetryMap.set();
     }
   }
 
   async getHistoricalData() {
     console.log('getHistoricalData');
-    await this.compositionLoad;
     this.setTimeBounds(this.openmct.time.getBounds());
     const outputTelemetryMap = await this.getHistoricalInputsByDate();
     const formattedOutputTelemetry = this.formatOutputData(outputTelemetryMap);
-    // const firstObjectKey = this.historicalTelemetryPoolMap.keys().next().value;
-    // const firstObjectValue = this.historicalTelemetryPoolMap.values().next().value;
-    // const formattedHistoricalData = this.formatHistoricalData(firstObjectKey, firstObjectValue);
     console.log(formattedOutputTelemetry);
-    // console.log(formattedHistoricalData);
     return formattedOutputTelemetry;
   }
 
   formatOutputData(outputTelemetryMap) {
     const outputTelemetryList = [];
     const domainObject = this.conditionSetDomainObject;
     outputTelemetryMap.forEach((outputMetadata, timestamp) => {
       const { condition, telemetry, value } = outputMetadata;
       outputTelemetryList.push({
         conditionId: condition.id,
         id: domainObject.identifier,
         output: value,
         utc: timestamp
       });
     });
     return outputTelemetryList;
   }
-
-  simpleTelemetryList(outputTelemetryMap) {
-    const outputTelemetryList = [];
-    outputTelemetryMap.forEach((outputMetadata, timestamp) => {
-      const { value } = outputMetadata;
-      outputTelemetryList.push(value);
-    });
-    return outputTelemetryList;
-  }
-
-  formatHistoricalData(historicalDataKey, telemetryDetails) {
-    const formattedData = [];
-    const { domainObject, historicalTelemetry } = telemetryDetails;
-    historicalTelemetry.forEach((value) => {
-      formattedData.push({
-        id: domainObject.identifier,
-        output: value.sin,
-        conditionId: historicalDataKey,
-        utc: value.utc
-      });
-    });
-    return formattedData;
-  }
 }

src/plugins/condition/historicalTelemetryWorker.js

@@ -0,0 +1,33 @@
+import { makeKeyString } from '../../api/objects/object-utils.js';
+
+function sortTelemetriesByDate(historicalTelemetriesPool) {
+  const historicalTelemetryDateMap = new Map();
+  historicalTelemetriesPool.forEach((historicalTelemetryList) => {
+    const { historicalTelemetry, domainObject } = historicalTelemetryList;
+    const { identifier } = domainObject;
+    const telemetryIdentifier = makeKeyString(identifier);
+    historicalTelemetry.forEach((historicalTelemetryItem) => {
+      if (!historicalTelemetryDateMap.get(historicalTelemetryItem.utc)) {
+        const telemetryMap = new Map();
+        telemetryMap.set(telemetryIdentifier, historicalTelemetryItem);
+        historicalTelemetryDateMap.set(historicalTelemetryItem.utc, telemetryMap);
+      } else {
+        const telemetryMap = historicalTelemetryDateMap.get(historicalTelemetryItem.utc);
+        telemetryMap.set(telemetryIdentifier, historicalTelemetryItem);
+        historicalTelemetryDateMap.set(historicalTelemetryItem.utc, telemetryMap);
+      }
+    });
+  });
+  return historicalTelemetryDateMap;
+}
+
+self.onmessage = function (e) {
+  const { type, data } = e.data;
+
+  if (type === 'sortTelemetries') {
+    const sortedTelemetries = sortTelemetriesByDate(data.historicalTelemetriesPool);
+    self.postMessage({ type: 'result', data: sortedTelemetries });
+  } else {
+    self.postMessage({ type: 'error', error: 'Unknown message type' });
+  }
+};

src/plugins/condition/plugin.js

@@ -21,6 +21,7 @@
  *****************************************************************************/
 import { v4 as uuid } from 'uuid';
 
+import ConditionInspectorViewProvider from './ConditionInspectorViewProvider.js';
 import ConditionSetCompositionPolicy from './ConditionSetCompositionPolicy.js';
 import ConditionSetMetadataProvider from './ConditionSetMetadataProvider.js';
 import ConditionSetTelemetryProvider from './ConditionSetTelemetryProvider.js';
@@ -37,6 +38,7 @@ export default function ConditionPlugin() {
       cssClass: 'icon-conditional',
       initialize: function (domainObject) {
         domainObject.configuration = {
+          shouldFetchHistorical: false,
           conditionTestData: [],
           conditionCollection: [
             {
@@ -61,5 +63,6 @@ export default function ConditionPlugin() {
     openmct.telemetry.addProvider(new ConditionSetMetadataProvider(openmct));
     openmct.telemetry.addProvider(new ConditionSetTelemetryProvider(openmct));
     openmct.objectViews.addProvider(new ConditionSetViewProvider(openmct));
+    openmct.inspectorViews.addProvider(new ConditionInspectorViewProvider(openmct));
   };
 }