From 94f700ffbbd470b5353d00de6d7bb1747b2d62e0 Mon Sep 17 00:00:00 2001
From: David Tsay <3614296+davetsay@users.noreply.github.com>
Date: Thu, 21 Nov 2024 14:29:53 -0800
Subject: [PATCH] Fix local storage filtering overriding historical session
 filtering set by url (#235)

Co-authored-by: Jamie V. <jamie.j.vigliotta@nasa.gov>
---
 src/historical/HistoricalProvider.js          | 10 ++---
 src/historical/HistoricalProviderSpec.js      |  2 +-
 .../indicator/historicalSessionIndicator.vue  | 34 ++++++++--------
 .../historicalSessionSelector.vue             | 26 ++++++-------
 .../session/SessionLocalStorageHandler.js     | 35 +++++++++--------
 src/services/session/SessionService.js        | 39 ++++++++-----------
 src/services/session/SessionURLHandler.js     | 37 +++++++++---------
 .../test/service/SessionServiceSpec.js        |  8 ++--
 src/venues/VenueService.js                    |  4 +-
 9 files changed, 95 insertions(+), 100 deletions(-)

diff --git a/src/historical/HistoricalProvider.js b/src/historical/HistoricalProvider.js
index 195e60b..ae378cc 100644
--- a/src/historical/HistoricalProvider.js
+++ b/src/historical/HistoricalProvider.js
@@ -517,11 +517,11 @@ define([
         }
 
         const sessions = this.getSessionService();
-        const session = sessions.getHistoricalSession();
+        const sessionFilter = sessions.getHistoricalSessionFilter();
 
-        if (session) {
-            params.filter.session_id = '(' + session.numbers.join(',') + ')';
-            params.filter.session_host = session.host;
+        if (sessionFilter) {
+            params.filter.session_id = `(${sessionFilter.numbers.join(',')})`;
+            params.filter.session_host = sessionFilter.host;
         } else if (window.openmctMCWSConfig?.sessions?.historicalSessionFilter?.disable !== true && window.openmctMCWSConfig?.sessions?.historicalSessionFilter?.denyUnfilteredQueries === true) {
             const notificationMessage = 'Filtering by historical sessions is required for historical queries.';
 
@@ -531,7 +531,7 @@ define([
         }
 
         if (this.isUnsupportedDomain(provider, options)) {
-            const message = !session
+            const message = !sessionFilter
                 ? `This view requires a session or supported time system for historical requests.`
                 : `This view does not support ${options.domain}. Historical data might not match the time system.`;
 
diff --git a/src/historical/HistoricalProviderSpec.js b/src/historical/HistoricalProviderSpec.js
index 06b895b..9d30ff0 100644
--- a/src/historical/HistoricalProviderSpec.js
+++ b/src/historical/HistoricalProviderSpec.js
@@ -31,7 +31,7 @@ describe('Historical Provider', function () {
         });
 
         mockSessionService = jasmine.createSpyObj('SessionService', [
-          'getHistoricalSession'
+          'getHistoricalSessionFilter'
         ]);
         spyOn(HistoricalProvider.prototype, 'getSessionService').and.returnValue(mockSessionService);
 
diff --git a/src/multipleHistoricalSessions/indicator/historicalSessionIndicator.vue b/src/multipleHistoricalSessions/indicator/historicalSessionIndicator.vue
index 8b23314..ec98d86 100644
--- a/src/multipleHistoricalSessions/indicator/historicalSessionIndicator.vue
+++ b/src/multipleHistoricalSessions/indicator/historicalSessionIndicator.vue
@@ -3,12 +3,12 @@
 
         <div class="c-indicator icon-session"
             :class="{
-                's-status-on': activeSessions.numbers,
+                's-status-on': sessionFilter.numbers,
                 's-status-available': availableSessions.length
             }">
 
             <span 
-                v-if="historicalSessionDisabled" 
+                v-if="historicalSessionFilterDisabled" 
                 class="c-indicator__label"
             >
                 <span class="angular-w">
@@ -24,7 +24,7 @@
 
                 <template v-if="availableSessions.length">
 
-                    <span v-if="activeSessions.numbers"
+                    <span v-if="sessionFilter.numbers"
                         class="angular-w">
                         {{filteredByMessageString}}
                         <button @click="openSessionSelector">
@@ -57,7 +57,7 @@
 
         <historical-session-selector
             v-if="showSessionSelector"
-            :activeSessions="activeSessions"
+            :sessionFilter="sessionFilter"
             @update-available-sessions="setAvailableSessions"
             @close-session-selector="closeSessionSelector"
         />
@@ -83,30 +83,30 @@ export default {
         filteredByMessageString() {
             let sessionOrSessions;
 
-            if (this.activeSessions.numbers.length === 1) {
+            if (this.sessionFilter.numbers.length === 1) {
                 sessionOrSessions = 'session'
             } else {
                 sessionOrSessions = 'sessions'
             }
-            return `Historical queries filtered by ${this.activeSessions.numbers.length} ${sessionOrSessions}`;
+            return `Historical queries filtered by ${this.sessionFilter.numbers.length} ${sessionOrSessions}`;
         }
     },
     data() {
         return {
-            activeSessions: {},
+            sessionFilter: {},
             numFilteredSessions: 8,
             availableSessions: [],
             showSessionSelector: false,
             isRequestingSessions: false,
-            historicalSessionDisabled: false
+            historicalSessionFilterDisabled: false
         }
     },
     methods: {
-        onActiveSessionChange(sessions) {
+        setHistoricalSessionFilter(sessions) {
             if (sessions) {
-                this.activeSessions = sessions;
+                this.sessionFilter = sessions;
             } else {
-                this.activeSessions = {};
+                this.sessionFilter = {};
             }
         },  
         setAvailableSessions(sessions) {
@@ -120,7 +120,7 @@ export default {
             this.showSessionSelector = false;
         },
         clearAllSessions() {
-            this.sessionService.setHistoricalSession();
+            this.sessionService.setHistoricalSessionFilter();
         },
         checkForHistoricalSessions() {
             this.isRequestingSessions = true;
@@ -129,17 +129,17 @@ export default {
     },
     mounted() {
         this.sessionService = SessionService();
-        this.historicalSessionDisabled = this.sessionService.historicalSessionFilterConfig.disable;
+        this.historicalSessionFilterDisabled = this.sessionService.historicalSessionFilterConfig.disable;
 
         window.setTimeout(this.checkForHistoricalSessions, 2000);
 
-        this.unsubscribeSessionListener = this.sessionService.listenForHistoricalChange(this.onActiveSessionChange);
+        this.unsubscribeSessionListener = this.sessionService.listenForHistoricalChange(this.setHistoricalSessionFilter);
 
-        let activeSessions = this.sessionService.getHistoricalSession();
-        this.onActiveSessionChange(activeSessions);
+        const sessionFilter = this.sessionService.getHistoricalSessionFilter();
+        this.setHistoricalSessionFilter(sessionFilter);
     },
     beforeUnmount() {
-        this.table.extendsDestroy();    
+        this.table.extendsDestroy();
         this.unsubscribeSessionListener();
     }
 }
diff --git a/src/multipleHistoricalSessions/sessionSelector/historicalSessionSelector.vue b/src/multipleHistoricalSessions/sessionSelector/historicalSessionSelector.vue
index 1114318..2b09d4c 100644
--- a/src/multipleHistoricalSessions/sessionSelector/historicalSessionSelector.vue
+++ b/src/multipleHistoricalSessions/sessionSelector/historicalSessionSelector.vue
@@ -47,12 +47,12 @@
             <div class="c-overlay__button-bar">
                 <a class="c-button c-button--major"
                     :class="{disabled: !selectedSessions.length}"
-                    @click="applyHistoricalSessions">
+                    @click="applyHistoricalSessionFilter">
                     Filter By Selected Sessions
                 </a>
                 <a class="c-button"
-                    :class="{disabled: !activeSessions}"
-                    @click="clearHistoricalSessions">
+                    :class="{disabled: !sessionFilter}"
+                    @click="clearHistoricalSessionFilter">
                     Clear Filtering
                 </a>
                 <a class="c-button"
@@ -149,7 +149,7 @@ import { nextTick } from 'vue';
 
 export default {
     inject: ['openmct', 'table'],
-    props: ['activeSessions'],
+    props: ['sessionFilter'],
     components: {
         TelemetryTable
     },
@@ -188,10 +188,10 @@ export default {
             });
         },
         setMarkedSessions() {
-            if(this.activeSessions.numbers && this.activeSessions.host) {
+            if(this.sessionFilter.numbers && this.sessionFilter.host) {
                 this.availableSessions.forEach(session => {
-                    if (this.activeSessions.numbers.some((sessionNumber => sessionNumber == session.number))
-                        && this.activeSessions.host === session.host) {
+                    if (this.sessionFilter.numbers.some((sessionNumber => sessionNumber === session.number))
+                        && this.sessionFilter.host === session.host) {
 
                         session.marked = true;
                     }
@@ -207,8 +207,8 @@ export default {
             this.setMarkedSessions();
             this.hosts = this.getUniq('host', this.availableSessions)
             
-            if (this.activeSessions.host) {
-                primaryHost = this.activeSessions.host
+            if (this.sessionFilter.host) {
+                primaryHost = this.sessionFilter.host
             } else {
                 primaryHost = this.hosts[0];
             }
@@ -221,11 +221,11 @@ export default {
         updateSelectedSessions(sessions) {
             this.selectedSessions = sessions;
         },
-        clearHistoricalSessions() {
-            this.sessionService.setHistoricalSession();
+        clearHistoricalSessionFilter() {
+            this.sessionService.setHistoricalSessionFilter();
             this.closeOverlay();
         },
-        applyHistoricalSessions() {
+        applyHistoricalSessionFilter() {
             let selectedSessions  = this.selectedSessions.map(row => row.datum),
                 host = this.selectedHost,
                 startTime,
@@ -253,7 +253,7 @@ export default {
                 numbers: selectedSessions.map(s => s.number)
             }
 
-            this.sessionService.setHistoricalSession(sessionObject);
+            this.sessionService.setHistoricalSessionFilter(sessionObject);
             this.closeOverlay();
         },
         closeOverlay() {
diff --git a/src/services/session/SessionLocalStorageHandler.js b/src/services/session/SessionLocalStorageHandler.js
index f8de4ea..c477c7b 100644
--- a/src/services/session/SessionLocalStorageHandler.js
+++ b/src/services/session/SessionLocalStorageHandler.js
@@ -48,7 +48,7 @@ define([
 
         sessionService.listen(this.storeRealtimeSession.bind(this));
         sessionService.listenForHistoricalChange(
-            this.storeHistoricalSession.bind(this)
+            this.storeHistoricalSessionFilter.bind(this)
         );
         this.initializeFromStorage();
     }
@@ -58,25 +58,26 @@ define([
      * from localStorage (if it exists)
      */
     SessionLocalStorageHandler.prototype.initializeFromStorage = function () {
-        if (this.sessionService.hasActiveTopicOrSession()) {
-            return;
-        }
+        if (!this.sessionService.hasActiveTopicOrSession()) {
+          const realtimeSession = localStorage.getItem(REALTIME_SESSION_KEY);
 
-        var realtimeSession = localStorage.getItem(REALTIME_SESSION_KEY);
-        if (realtimeSession) {
-            this.sessionService.setActiveTopicOrSession(JSON.parse(realtimeSession));
+          if (realtimeSession) {
+              this.sessionService.setActiveTopicOrSession(JSON.parse(realtimeSession));
+          }
         }
 
-        var historicalSessionJSON = localStorage.getItem(HISTORICAL_SESSION_KEY);
+        if (!this.sessionService.hasHistoricalSessionFilter()) {
+          const sessionFilterJSON = localStorage.getItem(HISTORICAL_SESSION_KEY);
 
-        if (historicalSessionJSON) {
-            var historicalSession = JSON.parse(historicalSessionJSON);
+          if (sessionFilterJSON) {
+            const sessionFilter = JSON.parse(sessionFilterJSON);
 
-            if (!historicalSession.numbers) {
-                historicalSession.numbers = [historicalSession.number];
+            if (!sessionFilter.numbers) {
+                sessionFilter.numbers = [sessionFilter.number];
             }
 
-            this.sessionService.setHistoricalSession(historicalSession);
+            this.sessionService.setHistoricalSessionFilter(sessionFilter);
+          }
         }
     };
 
@@ -92,11 +93,11 @@ define([
     };
 
     /**
-     * store the historical session in localStorage.
+     * store the historical session filter in localStorage.
      */
-    SessionLocalStorageHandler.prototype.storeHistoricalSession = function (historicalSession) {
-        if (historicalSession) {
-            localStorage.setItem(HISTORICAL_SESSION_KEY, JSON.stringify(historicalSession));
+    SessionLocalStorageHandler.prototype.storeHistoricalSessionFilter = function (sessionFilter) {
+        if (sessionFilter) {
+            localStorage.setItem(HISTORICAL_SESSION_KEY, JSON.stringify(sessionFilter));
         } else {
             localStorage.removeItem(HISTORICAL_SESSION_KEY);
         }
diff --git a/src/services/session/SessionService.js b/src/services/session/SessionService.js
index 6833ebf..868a5ae 100644
--- a/src/services/session/SessionService.js
+++ b/src/services/session/SessionService.js
@@ -50,7 +50,7 @@ class SessionService {
             historical: []
         };
         this.activeModel = undefined;
-        this.historicalSession = undefined;
+        this.historicalSessionFilter = undefined;
         this.sessionConfig = openmctMCWSConfig.sessions;
         this.realtimeSessionConfig = this.sessionConfig.realtimeSession;
         this.historicalSessionFilterConfig = this.sessionConfig.historicalSessionFilter;
@@ -61,9 +61,9 @@ class SessionService {
         openmct.on('start', () => {
             new SessionURLHandler(this, openmct);
             new SessionLocalStorageHander(this);
-        });
 
-        this.pollForActiveSession();
+            this.pollForActiveSession();
+        });
     }
 
     /**
@@ -332,18 +332,25 @@ class SessionService {
         return historicalSessions;
     };
 
-    getHistoricalSession() {
-        return this.historicalSession;
+    getHistoricalSessionFilter() {
+        return this.historicalSessionFilter;
     };
 
-    setHistoricalSession(model) {
+    /**
+     * @returns boolean true if a historical session filtering is active, otherwise false.
+     */
+    hasHistoricalSessionFilter() {
+        return Boolean(this.historicalSessionFilter);
+    };
+
+    setHistoricalSessionFilter(model) {
         if (this.historicalSessionFilterConfig.disable) {
             this.notificationService.alert('Historical Session Filtering has been disabled in config');
 
             return;
         }
 
-        this.historicalSession = model;
+        this.historicalSessionFilter = model;
         this.subscriptions.historical.forEach((listener) => {
             try {
                 listener(model);
@@ -353,7 +360,7 @@ class SessionService {
             }
         });
 
-        this.notifyUserOfHistoricalSessionChange(model);
+        this.notifyUserOfHistoricalSessionFilterChange(model);
         
         //clear plots and tables before requery
         this.openmct.objectViews.emit('clearData');
@@ -388,7 +395,7 @@ class SessionService {
         }
     };
 
-    notifyUserOfHistoricalSessionChange(model) {
+    notifyUserOfHistoricalSessionFilterChange(model) {
         let notificationString = 'Historical queries not restricted by session.';
 
         if (model) {
@@ -398,20 +405,6 @@ class SessionService {
         this.notificationService.info(notificationString);
     };
 
-    isActiveHistoricalSession(model) {
-        if ((!this.historicalSession || !model) && this.activeModel !== model) {
-            
-            return false;
-        }
-
-        if (this.historicalSession.topic === model.topic && this.historicalSession.number === model.number) {
-
-            return true;
-        }
-
-        return false;
-    };
-
     sessionOrTopic(model) {
         return model.number ? 'session' : 'topic';
     };
diff --git a/src/services/session/SessionURLHandler.js b/src/services/session/SessionURLHandler.js
index 9004f0e..2307dd3 100644
--- a/src/services/session/SessionURLHandler.js
+++ b/src/services/session/SessionURLHandler.js
@@ -10,7 +10,7 @@ export default class SessionURLHandler {
             this.updateURLFromRealtimeSession.bind(this)
         );
         sessionService.listenForHistoricalChange(
-            this.updateURLFromHistoricalSession.bind(this)
+            this.updateURLFromHistoricalSessionFilter.bind(this)
         );
 
         this.didSessionParamsChange = this.didSessionParamsChange.bind(this);
@@ -33,20 +33,21 @@ export default class SessionURLHandler {
     };
 
     updateSession() {
-        var params = this.getParams();
+        const params = this.getParams();
 
         if (!this.didSessionParamsChange(params)) {
             return;
         }
 
         if (params.historical.numbers && params.historical.host) {
-            var historicalSession = this.sessionService.getHistoricalSession();
-            if (!historicalSession ||
-                historicalSession.numbers.join(',') !== params.historical.numbers ||
-                historicalSession.host !== params.historical.host) {
+            const historicalSessionFilter = this.sessionService.getHistoricalSessionFilter();
+
+            if (!historicalSessionFilter ||
+                historicalSessionFilter.numbers.join(',') !== params.historical.numbers ||
+                historicalSessionFilter.host !== params.historical.host) {
                 
                 params.historical.numbers = params.historical.numbers.split(',');
-                this.sessionService.setHistoricalSession(params.historical);
+                this.sessionService.setHistoricalSessionFilter(params.historical);
             }
         }
         
@@ -66,15 +67,15 @@ export default class SessionURLHandler {
     };
     
     updateAfterNavigation() {
-        var params = this.getParams();
-        var historicalSession = this.sessionService.getHistoricalSession();
-        var realtimeSession = this.sessionService.getActiveTopicOrSession();
+        const params = this.getParams();
+        const historicalSessionFilter = this.sessionService.getHistoricalSessionFilter();
+        const realtimeSession = this.sessionService.getActiveTopicOrSession();
 
-        if (historicalSession && (
-                historicalSession.numbers.join(',') !== params.historical.numbers ||
-                historicalSession.host !== params.historical.host
+        if (historicalSessionFilter && (
+                historicalSessionFilter.numbers.join(',') !== params.historical.numbers ||
+                historicalSessionFilter.host !== params.historical.host
             )) {
-            this.updateURLFromHistoricalSession(historicalSession);
+            this.updateURLFromHistoricalSessionFilter(historicalSessionFilter);
         }
         if (realtimeSession && (
                 realtimeSession.topic !== params.realtime.topic ||
@@ -107,10 +108,10 @@ export default class SessionURLHandler {
     
     };
     
-    updateURLFromHistoricalSession(historicalSession) {
-        if (historicalSession) {
-            this.openmct.router.setSearchParam('v_hsi', historicalSession.numbers.join(','));
-            this.openmct.router.setSearchParam('v_hsh', historicalSession.host);
+    updateURLFromHistoricalSessionFilter(sessionFilter) {
+        if (sessionFilter) {
+            this.openmct.router.setSearchParam('v_hsi', sessionFilter.numbers.join(','));
+            this.openmct.router.setSearchParam('v_hsh', sessionFilter.host);
         } else {
             this.openmct.router.deleteSearchParam('v_hsi');
             this.openmct.router.deleteSearchParam('v_hsh');
diff --git a/src/services/session/test/service/SessionServiceSpec.js b/src/services/session/test/service/SessionServiceSpec.js
index 643598a..365d1ea 100644
--- a/src/services/session/test/service/SessionServiceSpec.js
+++ b/src/services/session/test/service/SessionServiceSpec.js
@@ -101,7 +101,7 @@ describe('SessionService', () => {
         spyOn(sessionService, 'listen').and.callThrough();
         spyOn(sessionService, 'listenForHistoricalChange').and.callThrough();
         spyOn(sessionService, 'getDatasets').and.returnValue(datasetCache.datasets);
-        sessionService.notifyUserOfHistoricalSessionChange = jasmine.createSpy('notifyUserOfHistoricalSessionChange');
+        sessionService.notifyUserOfHistoricalSessionFilterChange = jasmine.createSpy('notifyUserOfHistoricalSessionFilterChange');
     });
 
     afterEach(() => {
@@ -131,7 +131,7 @@ describe('SessionService', () => {
         sessionService.listenForHistoricalChange(callback);
         expect(sessionService.listenForHistoricalChange).toHaveBeenCalledWith(callback);
 
-        sessionService.setHistoricalSession(model);
+        sessionService.setHistoricalSessionFilter(model);
         expect(callback).toHaveBeenCalledWith(model);
     });
 
@@ -234,12 +234,12 @@ describe('SessionService', () => {
                 misc: 'other stuff'                };
 
             sessionService.listenForHistoricalChange(callback);
-            sessionService.setHistoricalSession(model);
+            sessionService.setHistoricalSessionFilter(model);
         });
 
         it('notifies topic with active session', () => {
             expect(callback).toHaveBeenCalledWith(model);
-            expect(sessionService.notifyUserOfHistoricalSessionChange).toHaveBeenCalledWith(model);
+            expect(sessionService.notifyUserOfHistoricalSessionFilterChange).toHaveBeenCalledWith(model);
         });
     });
 
diff --git a/src/venues/VenueService.js b/src/venues/VenueService.js
index f650f11..bb0d9ae 100644
--- a/src/venues/VenueService.js
+++ b/src/venues/VenueService.js
@@ -129,11 +129,11 @@ class VenueService {
 
         if (config.session.number) {
             config.session.numbers = [config.session.number];
-            sessions.setHistoricalSession(config.session);
+            sessions.setHistoricalSessionFilter(config.session);
         } else if (config.session.sessions?.[0]) {
             let session = config.session.sessions[0];
             session.numbers = [session.number];
-            sessions.setHistoricalSession(session);
+            sessions.setHistoricalSessionFilter(session);
         }
 
         if (config.isActive) {