Enhance telemetry tables to allow in place updates for data

src/api/telemetry/TelemetryMetadataManager.js

@@ -134,6 +134,14 @@ define(['lodash'], function (_) {
     );
   };
 
+  TelemetryMetadataManager.prototype.getUseToUpdateInPlaceValue = function () {
+    return this.valueMetadatas.find(this.isInPlaceUpdateValue);
+  };
+
+  TelemetryMetadataManager.prototype.isInPlaceUpdateValue = function (metadatum) {
+    return metadatum.useToUpdateInPlace === true;
+  };
+
   TelemetryMetadataManager.prototype.getDefaultDisplayValue = function () {
     let valueMetadata = this.valuesForHints(['range'])[0];
 

src/plugins/telemetryTable/TelemetryTable.js

@@ -215,8 +215,13 @@ define([
           return;
         }
 
+        const metadataValue = this.openmct.telemetry
+          .getMetadata(this.telemetryObjects[keyString].telemetryObject)
+          .getUseToUpdateInPlaceValue();
+
         let telemetryRows = telemetry.map(
-          (datum) => new TelemetryTableRow(datum, columnMap, keyString, limitEvaluator)
+          (datum) =>
+            new TelemetryTableRow(datum, columnMap, keyString, limitEvaluator, metadataValue?.key)
         );
 
         if (this.paused) {
@@ -268,8 +273,14 @@ define([
       Object.keys(this.telemetryCollections).forEach((keyString) => {
         let { columnMap, limitEvaluator } = this.telemetryObjects[keyString];
 
+        const metadataValue = this.openmct.telemetry
+          .getMetadata(this.telemetryObjects[keyString].telemetryObject)
+          .getUseToUpdateInPlaceValue();
+
         this.telemetryCollections[keyString].getAll().forEach((datum) => {
-          allRows.push(new TelemetryTableRow(datum, columnMap, keyString, limitEvaluator));
+          allRows.push(
+            new TelemetryTableRow(datum, columnMap, keyString, limitEvaluator, metadataValue?.key)
+          );
         });
       });
 
@@ -321,11 +332,12 @@ define([
     }
 
     addColumnsForObject(telemetryObject) {
-      let metadataValues = this.openmct.telemetry.getMetadata(telemetryObject).values();
+      const metadata = this.openmct.telemetry.getMetadata(telemetryObject);
+      let metadataValues = metadata.values();
 
       this.addNameColumn(telemetryObject, metadataValues);
       metadataValues.forEach((metadatum) => {
-        if (metadatum.key === 'name') {
+        if (metadatum.key === 'name' || metadata.isInPlaceUpdateValue(metadatum)) {
           return;
         }
 

src/plugins/telemetryTable/TelemetryTableRow.js

@@ -22,13 +22,14 @@
 
 define([], function () {
   class TelemetryTableRow {
-    constructor(datum, columns, objectKeyString, limitEvaluator) {
+    constructor(datum, columns, objectKeyString, limitEvaluator, inPlaceUpdateKey) {
       this.columns = columns;
 
       this.datum = createNormalizedDatum(datum, columns);
       this.fullDatum = datum;
       this.limitEvaluator = limitEvaluator;
       this.objectKeyString = objectKeyString;
+      this.inPlaceUpdateKey = inPlaceUpdateKey;
     }
 
     getFormattedDatum(headers) {
@@ -88,6 +89,15 @@ define([], function () {
     getContextMenuActions() {
       return ['viewDatumAction', 'viewHistoricalData'];
     }
+
+    updateWithDatum(updatesToDatum) {
+      const normalizedUpdatesToDatum = createNormalizedDatum(updatesToDatum, this.columns);
+      this.datum = {
+        ...this.datum,
+        ...normalizedUpdatesToDatum
+      };
+      this.fullDatum = this.datum;
+    }
   }
 
   /**
@@ -101,7 +111,10 @@ define([], function () {
     const normalizedDatum = JSON.parse(JSON.stringify(datum));
 
     Object.values(columns).forEach((column) => {
-      normalizedDatum[column.getKey()] = column.getRawValue(datum);
+      const rawValue = column.getRawValue(datum);
+      if (rawValue !== undefined) {
+        normalizedDatum[column.getKey()] = rawValue;
+      }
     });
 
     return normalizedDatum;

src/plugins/telemetryTable/collections/TableRowCollection.js

@@ -85,28 +85,49 @@ define(['lodash', 'EventEmitter'], function (_, EventEmitter) {
     }
 
     sortAndMergeRows(rows) {
-      const sortedRowsToAdd = this.sortCollection(rows);
+      const sortedRows = this.sortCollection(rows);
 
       if (this.rows.length === 0) {
-        this.rows = sortedRowsToAdd;
+        this.rows = sortedRows;
 
         return;
       }
 
-      const firstIncomingRow = sortedRowsToAdd[0];
-      const lastIncomingRow = sortedRowsToAdd[sortedRowsToAdd.length - 1];
+      const firstIncomingRow = sortedRows[0];
+      const lastIncomingRow = sortedRows[sortedRows.length - 1];
       const firstExistingRow = this.rows[0];
       const lastExistingRow = this.rows[this.rows.length - 1];
 
       if (this.firstRowInSortOrder(lastIncomingRow, firstExistingRow) === lastIncomingRow) {
-        this.rows = [...sortedRowsToAdd, ...this.rows];
+        this.insertOrUpdateRows(sortedRows, true);
       } else if (this.firstRowInSortOrder(lastExistingRow, firstIncomingRow) === lastExistingRow) {
-        this.rows = [...this.rows, ...sortedRowsToAdd];
+        this.insertOrUpdateRows(sortedRows, false);
       } else {
-        this.mergeSortedRows(sortedRowsToAdd);
+        this.mergeSortedRows(sortedRows);
       }
     }
 
+    getInPlaceUpdateIndex(row) {
+      const inPlaceUpdateKey = row.inPlaceUpdateKey;
+      if (!inPlaceUpdateKey) {
+        return false;
+      }
+
+      const foundIndex = this.rows.findIndex(
+        (existingRow) =>
+          existingRow.datum[inPlaceUpdateKey] &&
+          existingRow.datum[inPlaceUpdateKey] === row.datum[inPlaceUpdateKey]
+      );
+
+      return foundIndex;
+    }
+
+    updateRowInPlace(row, index) {
+      const foundRow = this.rows[index];
+      foundRow.updateWithDatum(row.datum);
+      this.rows[index] = foundRow;
+    }
+
     sortCollection(rows) {
       const sortedRows = _.orderBy(
         rows,
@@ -117,6 +138,21 @@ define(['lodash', 'EventEmitter'], function (_, EventEmitter) {
       return sortedRows;
     }
 
+    insertOrUpdateRows(rowsToAdd, addToBeginning) {
+      rowsToAdd.forEach((row) => {
+        const index = this.getInPlaceUpdateIndex(row);
+        if (index > -1) {
+          this.updateRowInPlace(row, index);
+        } else {
+          if (addToBeginning) {
+            this.rows.unshift(row);
+          } else {
+            this.rows.push(row);
+          }
+        }
+      });
+    }
+
     mergeSortedRows(rows) {
       const mergedRows = [];
       let i = 0;
@@ -126,12 +162,17 @@ define(['lodash', 'EventEmitter'], function (_, EventEmitter) {
         const existingRow = this.rows[i];
         const incomingRow = rows[j];
 
-        if (this.firstRowInSortOrder(existingRow, incomingRow) === existingRow) {
-          mergedRows.push(existingRow);
-          i++;
+        const index = this.getInPlaceUpdateIndex(incomingRow);
+        if (index > -1) {
+          this.updateRowInPlace(incomingRow, index);
         } else {
-          mergedRows.push(incomingRow);
-          j++;
+          if (this.firstRowInSortOrder(existingRow, incomingRow) === existingRow) {
+            mergedRows.push(existingRow);
+            i++;
+          } else {
+            mergedRows.push(incomingRow);
+            j++;
+          }
         }
       }