Refactor QueriesReducer and action creators for improved readability and consistency

Author: walrus51

applications/virtual-fly-brain/frontend/src/reducers/QueriesReducer.js

@@ -19,80 +19,75 @@ const QueriesReducer = (state = initialStateQueriesReducer, response) => {
       let updatedQueries = [...state.queries];
       response.payload.query.active = true;
       if (Array.isArray(response.payload.query.queries)) {
-\        let findQuery = updatedQueries?.find(
-  (i) => i.short_form === response.payload.short_form
-);
-
-if (findQuery === undefined) {
-  // Create a NEW query entry with ALL queries at once
-  const queriesObject = {};
-  response.payload.query.queries.forEach((query) => {
-    query.active = true;
-    queriesObject[query["query"]] = query;
-  });
-
-  const newQuery = {
-    short_form: response.payload.short_form,
-    name: response.payload.query.name,
-    queries: queriesObject,
-  };
-  updatedQueries.push(newQuery);
-} else {
-  // Query entry exists, add/update individual queries
-  response.payload.query.queries.forEach((query) => {
-    query.active = true;
-    findQuery.queries[query["query"]] = query;
-  });
-}
+        let findQuery = updatedQueries?.find(
+          (i) => i.short_form === response.payload.short_form
+        );
+        if (findQuery === undefined) {
+          const queriesObject = {};
+          response.payload.query.queries.forEach((query) => {
+            query.active = true;
+            queriesObject[query["query"]] = query;
+          });
+          const newQuery = {
+            short_form: response.payload.short_form,
+            name: response.payload.query.name,
+            queries: queriesObject,
+          };
+          updatedQueries.push(newQuery);
+        } else {
+          response.payload.query.queries.forEach((query) => {
+            query.active = true;
+            findQuery.queries[query["query"]] = query;
+          });
+        }
       } else {
-  let findQuery = updatedQueries?.find(
-    (i) => i.short_form === response.payload.short_form
-  );
-  if (findQuery === undefined) {
-    const newQuery = {
-      short_form: response.payload.short_form,
-      name: response.payload.query.name,
-      queries: { [response.payload.type]: response.payload.query },
-    };
-    updatedQueries.push(newQuery);
-  } else {
-    findQuery.type = response.payload.type;
-    findQuery.queries[response.payload.type] = response.payload.query;
-  }
-}
-
-return Object.assign({}, state, {
-  queries: updatedQueries,
-  isLoading: false,
-});
+        let findQuery = updatedQueries?.find(
+          (i) => i.short_form === response.payload.short_form
+        );
+        if (findQuery === undefined) {
+          const newQuery = {
+            short_form: response.payload.short_form,
+            name: response.payload.query.name,
+            queries: { [response.payload.type]: response.payload.query },
+          };
+          updatedQueries.push(newQuery);
+        } else {
+          findQuery.type = response.payload.type;
+          findQuery.queries[response.payload.type] = response.payload.query;
+        }
+      }
+      return Object.assign({}, state, {
+        queries: updatedQueries,
+        isLoading: false,
+      });
     }
     case getQueriesTypes.UPDATE_QUERIES:
-return Object.assign({}, state, {
-  queries: response.payload,
-});
+      return Object.assign({}, state, {
+        queries: response.payload,
+      });
     case getQueriesTypes.DELETE_QUERY:
-return Object.assign({}, state, {
-  queries: state.queries?.filter(
-    (i) => i.short_form !== response.payload.id
-  ),
-  isLoading: false,
-  error: false,
-  errorMessage: undefined,
-});
+      return Object.assign({}, state, {
+        queries: state.queries?.filter(
+          (i) => i.short_form !== response.payload.id
+        ),
+        isLoading: false,
+        error: false,
+        errorMessage: undefined,
+      });
     case getQueriesTypes.GET_QUERIES_FAILURE:
-return Object.assign({}, state, {
-  error: true,
-  errorMessage: response.payload.error,
-  errorID: response.payload.id,
-});
+      return Object.assign({}, state, {
+        error: true,
+        errorMessage: response.payload.error,
+        errorID: response.payload.id,
+      });
     case getGlobalTypes.RESET_ERRORS: {
-  return Object.assign({}, state, {
-    error: false,
-    errorMessage: undefined,
-  });
-}
+      return Object.assign({}, state, {
+        error: false,
+        errorMessage: undefined,
+      });
+    }
     default:
-return state;
+      return state;
   }
 };
 

applications/virtual-fly-brain/frontend/src/reducers/actions/queries.js

@@ -5,9 +5,9 @@ import { getQueriesTypes } from './types/getQueriesTypes';
 const getQueriesSuccess = (query, short_form, type) => ({
   type: getQueriesTypes.GET_QUERIES_SUCCESS,
   payload: {
-    query : query,
-    short_form : short_form,
-    type : type
+    query: query,
+    short_form: short_form,
+    type: type
   }
 });
 
@@ -31,35 +31,35 @@ const _getQueriesStarted = () => ({
 });
 
 
-export const getQueriesFailure = ( error, id) => ({
+export const getQueriesFailure = (error, id) => ({
   type: getQueriesTypes.GET_QUERIES_FAILURE,
   payload: {
-    error : error,
-    id : id
+    error: error,
+    id: id
   }
 });
 
 export const getQueries = async (short_form, type) => {
 
   store.dispatch(_getQueriesStarted())
-  
+
   const state = store.getState();
   const allLoadedInstances = state.instances.allLoadedInstances;
-  
+
   let response;
   try {
-    // When type is provided - EXECUTE the specific query
+    // When type is provided - execute the specific query
     if (type) {
       response = await get_query_results(short_form, type);
       store.dispatch(getQueriesSuccess(response, short_form, type))
-    } 
-    // When type is NOT provided - LOAD available queries list
+    }
+    // When type is not provided - load available queries list
     else {
       // Check if instance already loaded (CACHE CHECK)
       const existingInstance = allLoadedInstances?.find(
         i => i.metadata?.Id === short_form
       );
-      
+
       let queriesData;
       if (existingInstance?.metadata?.Queries) {
         // Use cached instance data - no network call needed!
@@ -71,13 +71,13 @@ export const getQueries = async (short_form, type) => {
         // Instance not loaded, fetch queries from backend using get_queries
         queriesData = await get_queries(short_form);
       }
-      
+
       // Format response to match what reducer expects
       response = {
         queries: queriesData.queries, // Array of all available queries
         name: queriesData.name
       };
-      
+
       store.dispatch(getQueriesSuccess(response, short_form, undefined))
     }
   } catch (error) {