Line chart merge fix

Author: naiduajaykumar

src/actions/__tests__/authActions.js.test.js

@@ -13,7 +13,7 @@ import {
   setCurrentUser, // Import setCurrentUser action
   setHeaderData, // Import setHeaderData action
 } from '../authActions'; // Import actions from authActions
-import { SET_CURRENT_USER, SET_HEADER_DATA } from '../../constants/auth'; // Import constants
+import { SET_CURRENT_USER, SET_HEADER_DATA, STOP_FORCE_LOGOUT } from '../../constants/auth'; // Import constants
 
 
 const middlewares = [thunk]; // Define middlewares
@@ -35,7 +35,10 @@ describe('authActions', () => {
     httpService.post.mockResolvedValue({ data: { token } }); // Mock the httpService post method
     jwtDecode.mockReturnValue(decodedToken); // Mock the jwtDecode function
 
-    const expectedActions = [{ type: SET_CURRENT_USER, payload: decodedToken }]; // Define expected actions
+    const expectedActions = [
+      { type: STOP_FORCE_LOGOUT }, // Ensure any existing timers are cleared
+      { type: SET_CURRENT_USER, payload: decodedToken },
+    ]; // Define expected actions
 
     await store.dispatch(loginUser(credentials)); // Dispatch the loginUser action
     expect(store.getActions()).toEqual(expectedActions); // Assert the actions
@@ -68,7 +71,10 @@ describe('authActions', () => {
 
   it('creates SET_CURRENT_USER with null when logoutUser is called', () => {
     const store = mockStore({}); // Create a mock store
-    const expectedActions = [{ type: SET_CURRENT_USER, payload: null }]; // Define expected actions
+    const expectedActions = [
+      { type: STOP_FORCE_LOGOUT }, // Clear any active force-logout timer
+      { type: SET_CURRENT_USER, payload: null },
+    ]; // Define expected actions
 
     store.dispatch(logoutUser()); // Dispatch the logoutUser action
     expect(store.getActions()).toEqual(expectedActions); // Assert the actions

src/actions/authActions.js

@@ -8,6 +8,7 @@ import {
   SET_CURRENT_USER,
   SET_HEADER_DATA,
   START_FORCE_LOGOUT,
+  STOP_FORCE_LOGOUT,
 } from '../constants/auth';
 
 const { tokenKey } = config;
@@ -22,6 +23,21 @@ export const setHeaderData = data => ({
   payload: data,
 });
 
+/**
+ * Stops any active force logout timer and clears related state
+ */
+export const stopForceLogout = () => (dispatch, getState) => {
+  const { auth } = getState();
+  if (auth?.timerId) {
+    try {
+      clearTimeout(auth.timerId);
+    } catch (e) {
+      // Timer already cleared or invalid
+    }
+  }
+  dispatch({ type: STOP_FORCE_LOGOUT });
+};
+
 export const loginUser = credentials => dispatch => {
   return httpService
     .post(ENDPOINTS.LOGIN, credentials)
@@ -33,6 +49,8 @@ export const loginUser = credentials => dispatch => {
       localStorage.setItem(tokenKey, res.data.token);
       httpService.setjwt(res.data.token);
       const decoded = jwtDecode(res.data.token);
+      // Ensure any existing timers from a previous session are cleared
+      dispatch(stopForceLogout());
       dispatch(setCurrentUser(decoded));
       return { success: true };
     })
@@ -98,6 +116,8 @@ export const getHeaderData = userId => {
 };
 
 export const logoutUser = () => dispatch => {
+  // Clear any active force-logout timer before logging out
+  dispatch(stopForceLogout());
   localStorage.removeItem(tokenKey);
   httpService.setjwt(false);
   dispatch(setCurrentUser(null));
@@ -134,6 +154,9 @@ export const startForceLogout = (delayMs = 20000) => (dispatch, getState) => {
       // eslint-disable-next-line no-console
       console.error('Error acknowledging permissions during force logout:', error);
     } finally {
+      // Set flag to indicate user was force logged out due to permission changes
+      // This helps distinguish "force logged out" vs "first login after permission change"
+      sessionStorage.setItem('wasForceLoggedOut', 'true');
       dispatch(logoutUser());
     }
   }, delayMs);

src/components/Auth/PermissionWatcher.jsx

@@ -2,7 +2,7 @@ import { useEffect, useState } from 'react';
 import { useSelector, useDispatch } from 'react-redux';
 import axios from 'axios';
 import { ENDPOINTS } from '~/utils/URL';
-import { startForceLogout } from '../../actions/authActions';
+import { startForceLogout, stopForceLogout } from '../../actions/authActions';
 import { useCountdown } from '../../hooks/useCountdown';
 import PopUpBar from '../PopUpBar/PopUpBar';
 import { getUserProfile } from '../../actions/userProfile';
@@ -11,31 +11,108 @@ function PermissionWatcher() {
   const dispatch = useDispatch();
   const { isAuthenticated, forceLogoutAt } = useSelector(state => state.auth || {});
   const userProfile = useSelector(state => state.userProfile);
-  const isAcknowledged = userProfile?.permissions?.isAcknowledged !== false;
+  const isAcknowledged = userProfile?.permissions?.isAcknowledged;
   const [isAckLoading, setIsAckLoading] = useState(false);
-  // Get seconds remaining until force logout
   const secondsRemaining = useCountdown(forceLogoutAt);
+  const [wasForceLoggedOut, setWasForceLoggedOut] = useState(false);
+  const [flagReady, setFlagReady] = useState(false);
+  const [initialAcknowledgedState, setInitialAcknowledgedState] = useState(null);
+  const [isInitialLogin, setIsInitialLogin] = useState(false);
 
-  // Start the force logout countdown when conditions are met
   useEffect(() => {
-    if (isAuthenticated && !isAcknowledged && !forceLogoutAt) {
-      // eslint-disable-next-line no-console
-      console.log('Starting force logout countdown due to unacknowledged permission changes');
-      dispatch(startForceLogout(20000)); // 20 seconds countdown
+    if (isAuthenticated) {
+      try {
+        const flag = sessionStorage.getItem('wasForceLoggedOut');
+        setWasForceLoggedOut(flag === 'true');
+        sessionStorage.removeItem('wasForceLoggedOut');
+      } catch {}
+      setIsInitialLogin(true);
+      setInitialAcknowledgedState(null);
+    } else {
+      setIsInitialLogin(false);
+      setInitialAcknowledgedState(null);
+      setWasForceLoggedOut(false);
     }
-  }, [isAuthenticated, isAcknowledged, forceLogoutAt, dispatch]);
-  // Handle acknowledgment of permission changes
+    setFlagReady(true);
+  }, [isAuthenticated]);
+
+  useEffect(() => {
+    if (!isAuthenticated || !flagReady) return;
+    if (!userProfile) return;
+    if (!isInitialLogin) return;
+
+    if (initialAcknowledgedState === null) {
+      const safestate = isAcknowledged === undefined ? true : isAcknowledged;
+      setInitialAcknowledgedState(safestate);
+      return;
+    }
+
+    const loggedInWithUnacknowledgedPermissions =
+      isAcknowledged === false && !forceLogoutAt && !wasForceLoggedOut;
+
+    if (loggedInWithUnacknowledgedPermissions) {
+      setIsInitialLogin(false);
+      return;
+    }
+
+    const loggedInAfterForceLogout =
+      isAcknowledged === false && !forceLogoutAt && wasForceLoggedOut;
+
+    if (loggedInAfterForceLogout) {
+      setIsInitialLogin(false);
+      return;
+    }
+
+    if (isAcknowledged !== false) {
+      setIsInitialLogin(false);
+    }
+  }, [
+    isAuthenticated,
+    flagReady,
+    isAcknowledged,
+    forceLogoutAt,
+    wasForceLoggedOut,
+    dispatch,
+    isInitialLogin,
+    initialAcknowledgedState,
+    userProfile,
+  ]);
+
+  useEffect(() => {
+    if (!isAuthenticated || !flagReady) return;
+    if (!userProfile) return;
+    if (isInitialLogin) return;
+
+    const permissionsChangedMidSession =
+      isAcknowledged === false && !forceLogoutAt && initialAcknowledgedState !== false;
+
+    if (permissionsChangedMidSession) {
+      dispatch(startForceLogout(20000));
+      return;
+    }
+
+    if (isAcknowledged === true && forceLogoutAt) {
+      dispatch(stopForceLogout());
+      setInitialAcknowledgedState(true);
+    }
+  }, [
+    isAuthenticated,
+    flagReady,
+    isAcknowledged,
+    forceLogoutAt,
+    dispatch,
+    isInitialLogin,
+    initialAcknowledgedState,
+    userProfile,
+  ]);
+
   const handleAcknowledge = async () => {
     try {
       setIsAckLoading(true);
-
       if (!userProfile || !userProfile._id) {
-        // eslint-disable-next-line no-console
-        //console.error('User profile not available');
         setIsAckLoading(false);
         return;
       }
-
       const { firstName: name, lastName, personalLinks, adminLinks, _id } = userProfile;
 
       axios
@@ -44,40 +121,34 @@ function PermissionWatcher() {
           lastName,
           personalLinks,
           adminLinks,
-
           isAcknowledged: true,
         })
         .then(() => {
           setIsAckLoading(false);
+          setInitialAcknowledgedState(true);
+          setIsInitialLogin(false);
           dispatch(getUserProfile(_id));
         })
         .catch(error => {
-          // eslint-disable-next-line no-console
-          // console.error('Error updating user profile:', error);
           setIsAckLoading(false);
         });
     } catch (error) {
-      // eslint-disable-next-line no-console
-      // console.error('Error acknowledging permission changes:', error);
       setIsAckLoading(false);
     }
   };
 
-  // Only render the popup when a force logout is in progress
-  if (!forceLogoutAt) {
-    return null;
-  }
-  return (
-    !isAcknowledged && (
+  if (forceLogoutAt && isAcknowledged === false) {
+    return (
       <PopUpBar
-        message={`Permissions changed—logging out in ${secondsRemaining}s. Timer will be stopped; please restart after login.`}
+        message={`Permissions changed—logging out in ${secondsRemaining}s unless acknowledged.`}
         onClickClose={handleAcknowledge}
-        textColor="red"
         isLoading={isAckLoading}
-        button={false}
+        button
       />
-    )
-  );
+    );
+  }
+
+  return null;
 }
 
 export default PermissionWatcher;