From 6c819b01cee5a36ea650dec98ce5757aa447190d Mon Sep 17 00:00:00 2001
From: Max Cao <macao@redhat.com>
Date: Tue, 15 Nov 2022 15:12:30 -0500
Subject: [PATCH] filters, but Score filter doesn't work

---
 .../AutomatedAnalysisCard.tsx                 | 124 +++++----
 .../AutomatedAnalysisFilters.tsx              | 240 ++++++++++++++++++
 .../Filters/AutomatedAnalysisNameFilter.tsx   |  89 +++++++
 .../Filters/AutomatedAnalysisScoreFilter.tsx  |  74 ++++++
 .../Filters/AutomatedAnalysisTopicFilter.tsx  |  83 ++++++
 .../Redux/AutomatedAnalysisFilterActions.tsx  | 119 +++++++++
 .../Redux/AutomatedAnalysisFilterReducer.tsx  | 176 +++++++++++++
 src/app/Shared/Redux/ReduxStore.tsx           |   3 +
 src/app/Shared/Services/Api.service.tsx       |   8 +
 src/app/utils/LocalStorage.ts                 |   1 +
 .../Recordings/ActiveRecordingsTable.test.tsx |   3 +
 .../ArchivedRecordingsTable.test.tsx          |   3 +
 src/test/Recordings/RecordingFilters.test.tsx |   3 +
 13 files changed, 871 insertions(+), 55 deletions(-)
 create mode 100644 src/app/Dashboard/AutomatedAnalysis/AutomatedAnalysisFilters.tsx
 create mode 100644 src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisNameFilter.tsx
 create mode 100644 src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisScoreFilter.tsx
 create mode 100644 src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisTopicFilter.tsx
 create mode 100644 src/app/Shared/Redux/AutomatedAnalysisFilterActions.tsx
 create mode 100644 src/app/Shared/Redux/AutomatedAnalysisFilterReducer.tsx

diff --git a/src/app/Dashboard/AutomatedAnalysis/AutomatedAnalysisCard.tsx b/src/app/Dashboard/AutomatedAnalysis/AutomatedAnalysisCard.tsx
index fe32d0834c..21acc30d7d 100644
--- a/src/app/Dashboard/AutomatedAnalysis/AutomatedAnalysisCard.tsx
+++ b/src/app/Dashboard/AutomatedAnalysis/AutomatedAnalysisCard.tsx
@@ -36,7 +36,6 @@
  * SOFTWARE.
  */
 import * as React from 'react';
-import { BreadcrumbTrail } from '@app/BreadcrumbPage/BreadcrumbPage';
 import { ServiceContext } from '@app/Shared/Services/Services';
 import {
   Button,
@@ -47,23 +46,14 @@ import {
   CardHeader,
   CardTitle,
   Checkbox,
-  Dropdown,
   Grid,
   GridItem,
-  HelperText,
-  HelperTextItem,
-  KebabToggle,
-  Label,
   LabelGroup,
-  LabelProps,
-  Select,
-  SelectOption,
-  Spinner,
-  Stack,
-  StackItem,
   Text,
   TextContent,
   TextVariants,
+  Toolbar,
+  ToolbarContent,
   Tooltip,
 } from '@patternfly/react-core';
 import { useSubscriptions } from '@app/utils/useSubscriptions';
@@ -77,6 +67,11 @@ import {
   ArchivedRecording,
   defaultAutomatedAnalysis,
 } from '@app/Shared/Services/Api.service';
+import { AutomatedAnalysisFilters, AutomatedAnalysisFiltersCategories, emptyAutomatedAnalysisFilters, filterAutomatedAnalysis } from './AutomatedAnalysisFilters';
+import { useDispatch, useSelector } from 'react-redux';
+import { RootState, StateDispatch } from '@app/Shared/Redux/ReduxStore';
+import { TargetAutomatedAnalysisFilters } from '@app/Shared/Redux/AutomatedAnalysisFilterReducer';
+import { automatedAnalysisAddFilterIntent, automatedAnalysisAddTargetIntent, automatedAnalysisDeleteAllFiltersIntent, automatedAnalysisDeleteCategoryFiltersIntent, automatedAnalysisDeleteFilterIntent } from '@app/Shared/Redux/AutomatedAnalysisFilterActions';
 
 interface AutomatedAnalysisCardProps {
   pageTitle: string;
@@ -85,16 +80,16 @@ interface AutomatedAnalysisCardProps {
 export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCardProps> = (props) => {
   const context = React.useContext(ServiceContext);
   const addSubscription = useSubscriptions();
+  const dispatch = useDispatch<StateDispatch>();
 
+  const [targetConnectURL, setTargetConnectURL] = React.useState('');
   const [categorizedEvaluation, setCategorizedEvaluation] = React.useState<[string, RuleEvaluation[]][]>(
     [] as [string, RuleEvaluation[]][]
   );
-  const [criticalCategorizedEvaluation, setCriticalCategorizedEvaluation] = React.useState<
+  const [filteredCategorizedEvaluation, setFilteredCategorizedEvaluation] = React.useState<
     [string, RuleEvaluation[]][]
   >([] as [string, RuleEvaluation[]][]);
   const [isExpanded, setIsExpanded] = React.useState<boolean>(true);
-  const [isKebabOpen, setIsKebabOpen] = React.useState<boolean>(false);
-  const [isChecked, setIsChecked] = React.useState<boolean>(false);
   const [isError, setIsError] = React.useState<boolean>(false);
   const [errorMessage, setErrorMessage] = React.useState<string>('');
   const [isLoading, setIsLoading] = React.useState<boolean>(false);
@@ -109,6 +104,14 @@ export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCar
   const HOUR_MILLIS = 60 * MINUTE_MILLIS;
   const DAY_MILLIS = 24 * HOUR_MILLIS;
 
+  const targetAutomatedAnalysisFilters = useSelector((state: RootState) => {
+    const filters = state.automatedAnalysisFilters.list.filter(
+      (targetFilter: TargetAutomatedAnalysisFilters) => targetFilter.target === targetConnectURL
+    );
+    return filters.length > 0 ? filters[0].filters : emptyAutomatedAnalysisFilters;
+
+  }) as AutomatedAnalysisFiltersCategories;
+
   const categorizeEvaluation = React.useCallback(
     (arr: [string, RuleEvaluation][]) => {
       const map = new Map<string, RuleEvaluation[]>();
@@ -231,6 +234,8 @@ export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCar
     addSubscription(
       context.target.target().subscribe((target) => {
         handleLoading();
+        setTargetConnectURL(target.connectUrl);
+        dispatch(automatedAnalysisAddTargetIntent(target.connectUrl));
         context.api.createSnapshotV2().pipe(first()).subscribe({
           next: (snapshot) => {
               context.reports
@@ -260,9 +265,11 @@ export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCar
     );
   }, [
     addSubscription,
+    dispatch,
     context.api,
     context.target,
     context.reports,
+    automatedAnalysisAddTargetIntent,
     categorizeEvaluation,
     handleEmptyRecordings,
     handleLoading,
@@ -299,23 +306,13 @@ export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCar
     }
   }, [errorMessage, startProfilingRecording, takeSnapshot]);
 
-  const showCriticalScores = React.useCallback(() => {
-    const criticalScores = categorizedEvaluation.map(([topic, evaluations]) => {
-      return [topic, evaluations.filter((evaluation) => evaluation.score >= ORANGE_SCORE_THRESHOLD)] as [
-        string,
-        RuleEvaluation[]
-      ];
-    });
-    setCriticalCategorizedEvaluation(criticalScores);
-  }, [categorizedEvaluation, setCriticalCategorizedEvaluation]);
-
   React.useEffect(() => {
     addSubscription(
       context.target.authFailure().subscribe(() => {
         handleStateErrors("Authentication failure");        
       })
     );
-  }, [addSubscription, context.target.authFailure, handleStateErrors]);
+  }, [addSubscription, context.target, handleStateErrors]);
 
   React.useEffect(() => {
     takeSnapshot();
@@ -353,16 +350,8 @@ export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCar
   }, [setReportStalenessTimer, setReportStalenessTimerUnits, reportTime, reportStalenessTimer, usingArchivedReport, usingCachedReport]);
 
   React.useEffect(() => {
-    if (isChecked) {
-      showCriticalScores();
-    } else {
-      setCriticalCategorizedEvaluation(categorizedEvaluation);
-    }
-  }, [isChecked, categorizedEvaluation, showCriticalScores, setCriticalCategorizedEvaluation]);
-
-  const onClick = (checked: boolean) => {
-    setIsChecked(checked);
-  };
+    setFilteredCategorizedEvaluation(filterAutomatedAnalysis(categorizedEvaluation, targetAutomatedAnalysisFilters));
+  }, [categorizedEvaluation, targetAutomatedAnalysisFilters, filterAutomatedAnalysis, setFilteredCategorizedEvaluation]);
 
   const onExpand = (event: React.MouseEvent, id: string) => {
     setIsExpanded(!isExpanded);
@@ -371,7 +360,7 @@ export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCar
   const filteredCategorizedLabels = React.useMemo(() => {
     return (
       <Grid>
-        {criticalCategorizedEvaluation
+        {filteredCategorizedEvaluation
           .filter(([_, evaluations]) => evaluations.length > 0)
           .map(([topic, evaluations]) => {
             return (
@@ -386,7 +375,7 @@ export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCar
           })}
       </Grid>
     );
-  }, [criticalCategorizedEvaluation]);
+  }, [filteredCategorizedEvaluation]);
 
   const clearCachedReports = React.useCallback(() => {
     addSubscription(
@@ -406,6 +395,25 @@ export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCar
     handleStateErrors(NO_RECORDINGS_MESSAGE);
   }, [addSubscription, context.target, context.reports]);
 
+  const updateFilters = React.useCallback(
+    (target, { filterValue, filterKey, deleted = false, deleteOptions }) => {
+      if (deleted) {
+        if (deleteOptions && deleteOptions.all) {
+          dispatch(automatedAnalysisDeleteCategoryFiltersIntent(target, filterKey));
+        } else {
+          dispatch(automatedAnalysisDeleteFilterIntent(target, filterKey, filterValue));
+        }
+      } else {
+        dispatch(automatedAnalysisAddFilterIntent(target, filterKey, filterValue));
+      }
+    },
+    [dispatch, automatedAnalysisDeleteCategoryFiltersIntent, automatedAnalysisDeleteFilterIntent, automatedAnalysisAddFilterIntent]
+  );
+
+  const handleClearFilters = React.useCallback(() => {
+    dispatch(automatedAnalysisDeleteAllFiltersIntent(targetConnectURL));
+  }, [dispatch, automatedAnalysisDeleteAllFiltersIntent, targetConnectURL]);
+
   const reportStalenessText = React.useMemo(() => {
     if (isLoading || !(usingArchivedReport || usingCachedReport)) {
       return '';
@@ -463,23 +471,29 @@ export const AutomatedAnalysisCard: React.FunctionComponent<AutomatedAnalysisCar
       >
         <CardTitle component="h4">Automated Analysis</CardTitle>
         <CardActions>
-          <Checkbox
-            id="automated-analysis-check"
-            label={'Show critical scores'}
-            isDisabled={isError}
-            aria-label="automated-analysis show-critical-scores"
-            name="automated-analysis-critical-scores"
-            isChecked={isChecked}
-            onChange={onClick}
-          />
-          <Button
-            isSmall
-            isAriaDisabled={isLoading}
-            aria-label="Refresh automated analysis"
-            onClick={takeSnapshot}
-            variant="control"
-            icon={<Spinner2Icon />}
-          />
+          <Toolbar
+            id="automated-analysis-toolbar"
+            aria-label="automated-analysis-toolbar"
+            clearAllFilters={handleClearFilters}
+          >
+            <ToolbarContent>
+              <AutomatedAnalysisFilters 
+                  target={targetConnectURL}
+                  evaluations={categorizedEvaluation} 
+                  filters={targetAutomatedAnalysisFilters} 
+                  updateFilters={updateFilters}
+              />
+              <Button
+                isSmall
+                isAriaDisabled={isLoading}
+                aria-label="Refresh automated analysis"
+                onClick={takeSnapshot}
+                variant="control"
+                icon={<Spinner2Icon />}
+              />
+            </ToolbarContent>
+          </Toolbar>
+
         </CardActions>
       </CardHeader>
       <CardExpandableContent>
diff --git a/src/app/Dashboard/AutomatedAnalysis/AutomatedAnalysisFilters.tsx b/src/app/Dashboard/AutomatedAnalysis/AutomatedAnalysisFilters.tsx
new file mode 100644
index 0000000000..79a3eab772
--- /dev/null
+++ b/src/app/Dashboard/AutomatedAnalysis/AutomatedAnalysisFilters.tsx
@@ -0,0 +1,240 @@
+/*
+ * Copyright The Cryostat Authors
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or data
+ * (collectively the "Software"), free of charge and under any and all copyright
+ * rights in the Software, and any and all patent rights owned or freely
+ * licensable by each licensor hereunder covering either (i) the unmodified
+ * Software as contributed to or provided by such licensor, or (ii) the Larger
+ * Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software (each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ * The above copyright notice and either this complete permission notice or at
+ * a minimum a reference to the UPL must be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import {
+    Dropdown,
+    DropdownItem,
+    DropdownPosition,
+    DropdownToggle,
+    InputGroup,
+    ToolbarFilter,
+    ToolbarGroup,
+    ToolbarItem,
+    ToolbarToggleGroup,
+  } from '@patternfly/react-core';
+  import { FilterIcon } from '@patternfly/react-icons';
+  import React from 'react';
+  import { useDispatch, useSelector } from 'react-redux';
+
+import { AutomatedAnalysisNameFilter } from './Filters/AutomatedAnalysisNameFilter';
+import { UpdateFilterOptions } from '@app/Shared/Redux/RecordingFilterReducer';
+import { RootState, StateDispatch } from '@app/Shared/Redux/ReduxStore';
+import { automatedAnalysisUpdateCategoryIntent } from '@app/Shared/Redux/AutomatedAnalysisFilterActions';
+import { RuleEvaluation } from '@app/Shared/Services/Report.service';
+import { AutomatedAnalysisTopicFilter } from './Filters/AutomatedAnalysisTopicFilter';
+import { AutomatedAnalysisScoreFilter } from './Filters/AutomatedAnalysisScoreFilter';
+  
+  export interface AutomatedAnalysisFiltersCategories {
+    Name: string[];
+    Topic: string[];
+    Score: number[];
+  }
+  
+  export const emptyAutomatedAnalysisFilters = {
+    Name: [],
+    Topic: [],
+    Score: [],
+  } as AutomatedAnalysisFiltersCategories;
+  
+  export const allowedAutomatedAnalysisFilters = Object.keys(emptyAutomatedAnalysisFilters);
+  
+  export interface AutomatedAnalysisFiltersProps {
+    target: string;
+    evaluations: [string, RuleEvaluation[]][];
+    filters: AutomatedAnalysisFiltersCategories;
+    updateFilters: (target: string, updateFilterOptions: UpdateFilterOptions) => void;
+  }
+  
+  export const AutomatedAnalysisFilters: React.FunctionComponent<AutomatedAnalysisFiltersProps> = (props) => {
+    const dispatch = useDispatch<StateDispatch>();
+  
+    const currentCategory = useSelector((state: RootState) => {
+      const targetAutomatedAnalysisFilters = state.automatedAnalysisFilters.list.filter(
+        (targetFilter) => targetFilter.target === props.target
+      );
+      if (!targetAutomatedAnalysisFilters.length) return 'Name'; // Target is not yet loaded
+      return targetAutomatedAnalysisFilters[0].selectedCategory;
+    });
+  
+    const [isCategoryDropdownOpen, setIsCategoryDropdownOpen] = React.useState(false);
+  
+    const onCategoryToggle = React.useCallback(() => {
+      setIsCategoryDropdownOpen((opened) => !opened);
+    }, [setIsCategoryDropdownOpen]);
+  
+    const onCategorySelect = React.useCallback(
+      (category) => {
+        setIsCategoryDropdownOpen(false);
+        dispatch(automatedAnalysisUpdateCategoryIntent(props.target, category));
+      },
+      [dispatch, automatedAnalysisUpdateCategoryIntent, setIsCategoryDropdownOpen, props.target]
+    );
+  
+    const onDelete = React.useCallback(
+      (category, value) => props.updateFilters(props.target, { filterKey: category, filterValue: value, deleted: true }),
+      [props.updateFilters, props.target]
+    );
+  
+    const onDeleteGroup = React.useCallback(
+      (category) =>
+        props.updateFilters(props.target, { filterKey: category, deleted: true, deleteOptions: { all: true } }),
+      [props.updateFilters, props.target]
+    );
+  
+    const onNameInput = React.useCallback(
+      (inputName) => props.updateFilters(props.target, { filterKey: currentCategory!, filterValue: inputName }),
+      [props.updateFilters, currentCategory, props.target]
+    );
+  
+    const onTopicInput = React.useCallback((inputTopic) => {
+      props.updateFilters(props.target, { filterKey: currentCategory!, filterValue: inputTopic })
+    },[props.updateFilters, currentCategory, props.target]);
+
+    const onScoreSelectToggle = React.useCallback(
+      (searchState) => {
+        const deleted = props.filters.Score && props.filters.Score.includes(searchState);
+        props.updateFilters(props.target, { filterKey: currentCategory!, filterValue: searchState, deleted: deleted });
+      },
+      [props.updateFilters, currentCategory, props.target]
+    );
+
+    const categoryDropdown = React.useMemo(() => {
+      return (
+        <Dropdown
+          aria-label={'Category Dropdown'}
+          position={DropdownPosition.left}
+          toggle={
+            <DropdownToggle aria-label={currentCategory} onToggle={onCategoryToggle}>
+              <FilterIcon /> {currentCategory}
+            </DropdownToggle>
+          }
+          isOpen={isCategoryDropdownOpen}
+          dropdownItems={(allowedAutomatedAnalysisFilters).map(
+            (cat) => (
+              <DropdownItem aria-label={cat} key={cat} onClick={() => onCategorySelect(cat)}>
+                {cat}
+              </DropdownItem>
+            )
+          )}
+        />
+      );
+    }, [
+      allowedAutomatedAnalysisFilters,
+      isCategoryDropdownOpen,
+      currentCategory,
+      onCategoryToggle,
+      onCategorySelect,
+    ]);
+  
+    const filterDropdownItems = React.useMemo(
+      () => [
+        <AutomatedAnalysisNameFilter evaluations={props.evaluations} filteredNames={props.filters.Name} onSubmit={onNameInput}/>,
+        <AutomatedAnalysisTopicFilter evaluations={props.evaluations} filteredTopics={props.filters.Topic} onSubmit={onTopicInput}></AutomatedAnalysisTopicFilter>,
+        <AutomatedAnalysisScoreFilter filteredScores={props.filters.Score} onSelectToggle={onScoreSelectToggle}></AutomatedAnalysisScoreFilter>
+      ],
+      [
+        props.evaluations,
+        props.filters.Name,
+        props.filters.Topic,
+        props.filters.Score,
+        onNameInput,
+        onTopicInput,
+        onScoreSelectToggle,
+      ]
+    );
+  
+    return (
+      <ToolbarToggleGroup toggleIcon={<FilterIcon />} breakpoint="xl">
+        <ToolbarGroup variant="filter-group">
+          <ToolbarItem>
+            <InputGroup>
+              {categoryDropdown}
+              {Object.keys(props.filters).map((filterKey, i) => (
+                <ToolbarFilter
+                  key={filterKey}
+                  chips={props.filters[filterKey]}
+                  deleteChip={onDelete}
+                  deleteChipGroup={onDeleteGroup}
+                  categoryName={filterKey}
+                  showToolbarItem={filterKey === currentCategory}
+                >
+                  {filterDropdownItems[i]}
+                </ToolbarFilter>
+              ))}
+            </InputGroup>
+          </ToolbarItem>
+        </ToolbarGroup>
+      </ToolbarToggleGroup>
+    );
+  };
+  
+  export const filterAutomatedAnalysis = (topicEvalTuple: [string, RuleEvaluation[]][], filters: AutomatedAnalysisFiltersCategories) => {
+    if (!topicEvalTuple || !topicEvalTuple.length) {
+      return topicEvalTuple;
+    }
+    
+    let filtered = topicEvalTuple;
+    console.log(filters);
+  
+    if (!!filters.Name.length) {
+      filtered = filtered.map(([topic, evaluations]) => {
+        return [topic, evaluations.filter((evaluation) => filters.Name.includes(evaluation.name))] as [
+          string,
+          RuleEvaluation[]
+        ];
+      })
+    }
+    if (filters.Score != null && !!filters.Score.length) {
+      filtered = filtered.map(([topic, evaluations]) => {
+        return [topic, evaluations.filter((evaluation) => Math.max(...filters.Score) > evaluation.score)] as [
+          string,
+          RuleEvaluation[]
+        ];
+      })    
+    }
+    if (filters.Topic != null && !!filters.Topic.length) {
+      filtered = filtered.map(([topic, evaluations]) => {
+        return [topic, evaluations.filter((evaluation) => filters.Topic.includes(topic))] as [
+          string,
+          RuleEvaluation[]
+        ];
+      })    
+    }
+
+    return filtered;
+  };
+  
\ No newline at end of file
diff --git a/src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisNameFilter.tsx b/src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisNameFilter.tsx
new file mode 100644
index 0000000000..cef0e8a427
--- /dev/null
+++ b/src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisNameFilter.tsx
@@ -0,0 +1,89 @@
+/*
+ * Copyright The Cryostat Authors
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or data
+ * (collectively the "Software"), free of charge and under any and all copyright
+ * rights in the Software, and any and all patent rights owned or freely
+ * licensable by each licensor hereunder covering either (i) the unmodified
+ * Software as contributed to or provided by such licensor, or (ii) the Larger
+ * Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software (each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ * The above copyright notice and either this complete permission notice or at
+ * a minimum a reference to the UPL must be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import React from 'react';
+import { Select, SelectOption, SelectVariant } from '@patternfly/react-core';
+import { RuleEvaluation } from '@app/Shared/Services/Report.service';
+
+export interface AutomatedAnalysisNameFilterProps {
+  evaluations: [string, RuleEvaluation[]][];
+  filteredNames: string[];
+  onSubmit: (inputName: string) => void;
+}
+
+export const AutomatedAnalysisNameFilter: React.FunctionComponent<AutomatedAnalysisNameFilterProps> = (props) => {
+  const [isExpanded, setIsExpanded] = React.useState(false);
+
+  const onSelect = React.useCallback(
+    (_, selection, isPlaceholder) => {
+      if (!isPlaceholder) {
+        setIsExpanded(false);
+        props.onSubmit(selection);
+      }
+    },
+    [props.onSubmit, setIsExpanded]
+  );
+
+  const nameOptions = React.useMemo(() => {
+    const flatEvalMap: string[] = [] as string[];
+    for (let topic of props.evaluations.map((r) => r[1])) {
+      for (let rule of topic) {
+        flatEvalMap.push(rule.name);
+      }
+    }
+    return flatEvalMap
+      .filter((n) => !props.filteredNames.includes(n))
+      .sort()
+      .map((option, index) => <SelectOption key={index} value={option} />);
+  }, [props.evaluations, props.filteredNames]);
+
+  return (
+    <Select
+      variant={SelectVariant.typeahead}
+      onToggle={setIsExpanded}
+      onSelect={onSelect}
+      isOpen={isExpanded}
+      typeAheadAriaLabel="Filter by name..."
+      placeholderText="Filter by name..."
+      aria-label="Filter by name"
+      maxHeight="16em"
+    >
+      {nameOptions}
+    </Select>
+  );
+};
diff --git a/src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisScoreFilter.tsx b/src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisScoreFilter.tsx
new file mode 100644
index 0000000000..010f26d5fd
--- /dev/null
+++ b/src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisScoreFilter.tsx
@@ -0,0 +1,74 @@
+/*
+ * Copyright The Cryostat Authors
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or data
+ * (collectively the "Software"), free of charge and under any and all copyright
+ * rights in the Software, and any and all patent rights owned or freely
+ * licensable by each licensor hereunder covering either (i) the unmodified
+ * Software as contributed to or provided by such licensor, or (ii) the Larger
+ * Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software (each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ * The above copyright notice and either this complete permission notice or at
+ * a minimum a reference to the UPL must be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import React from 'react';
+import { Button, Select, SelectOption, SelectVariant } from '@patternfly/react-core';
+import { AutomatedAnalysisScoreState } from '@app/Shared/Services/Api.service';
+
+export interface AutomatedAnalysisScoreFilterProps {
+  filteredScores: AutomatedAnalysisScoreState[] | undefined;
+  onSelectToggle: (state: any) => void;
+}
+
+export const AutomatedAnalysisScoreFilter: React.FunctionComponent<AutomatedAnalysisScoreFilterProps> = (props) => {
+  const [isOpen, setIsOpen] = React.useState(false);
+
+  const onSelect = React.useCallback(
+    (_, selection) => {
+      setIsOpen(false);
+      props.onSelectToggle(selection);
+    },
+    [setIsOpen, props.onSelectToggle]
+  );
+
+  return (
+    <Select
+      variant={SelectVariant.checkbox}
+      onToggle={setIsOpen}
+      onSelect={onSelect}
+      selections={props.filteredScores}
+      isOpen={isOpen}
+      aria-label="Filter by score"
+      placeholderText="Filter by score"
+    >
+      {Object.values(AutomatedAnalysisScoreState).map((rs) => (
+        <SelectOption aria-label={`${rs} State`} key={rs} value={rs} />
+      ))}
+    </Select>
+  );
+};
diff --git a/src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisTopicFilter.tsx b/src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisTopicFilter.tsx
new file mode 100644
index 0000000000..bc7ca3a9e2
--- /dev/null
+++ b/src/app/Dashboard/AutomatedAnalysis/Filters/AutomatedAnalysisTopicFilter.tsx
@@ -0,0 +1,83 @@
+/*
+ * Copyright The Cryostat Authors
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or data
+ * (collectively the "Software"), free of charge and under any and all copyright
+ * rights in the Software, and any and all patent rights owned or freely
+ * licensable by each licensor hereunder covering either (i) the unmodified
+ * Software as contributed to or provided by such licensor, or (ii) the Larger
+ * Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software (each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ * The above copyright notice and either this complete permission notice or at
+ * a minimum a reference to the UPL must be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import React from 'react';
+import { Select, SelectOption, SelectVariant } from '@patternfly/react-core';
+import { RuleEvaluation } from '@app/Shared/Services/Report.service';
+
+export interface AutomatedAnalysisTopicFilterProps {
+  evaluations: [string, RuleEvaluation[]][];
+  filteredTopics: string[];
+  onSubmit: (inputName: string) => void;
+}
+
+export const AutomatedAnalysisTopicFilter: React.FunctionComponent<AutomatedAnalysisTopicFilterProps> = (props) => {
+  const [isExpanded, setIsExpanded] = React.useState(false);
+
+  const onSelect = React.useCallback(
+    (_, selection, isPlaceholder) => {
+      if (!isPlaceholder) {
+        setIsExpanded(false);
+        props.onSubmit(selection);
+      }
+    },
+    [props.onSubmit, setIsExpanded]
+  );
+
+  const topicOptions = React.useMemo(() => {
+    return props.evaluations
+      .map((r) => r[0])
+      .filter((n) => !props.filteredTopics.includes(n))
+      .map((option, index) => <SelectOption key={index} value={option} />);
+  }, [props.evaluations, props.filteredTopics]);
+
+  return (
+    <Select
+      variant={SelectVariant.typeahead}
+      onToggle={setIsExpanded}
+      onSelect={onSelect}
+      isOpen={isExpanded}
+      typeAheadAriaLabel="Filter by topic..."
+      placeholderText="Filter by topic..."
+      aria-label="Filter by topic"
+      maxHeight="16em"
+    >
+      {topicOptions}
+    </Select>
+  );
+};
diff --git a/src/app/Shared/Redux/AutomatedAnalysisFilterActions.tsx b/src/app/Shared/Redux/AutomatedAnalysisFilterActions.tsx
new file mode 100644
index 0000000000..62e87e11c5
--- /dev/null
+++ b/src/app/Shared/Redux/AutomatedAnalysisFilterActions.tsx
@@ -0,0 +1,119 @@
+/*
+ * Copyright The Cryostat Authors
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or data
+ * (collectively the "Software"), free of charge and under any and all copyright
+ * rights in the Software, and any and all patent rights owned or freely
+ * licensable by each licensor hereunder covering either (i) the unmodified
+ * Software as contributed to or provided by such licensor, or (ii) the Larger
+ * Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software (each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ * The above copyright notice and either this complete permission notice or at
+ * a minimum a reference to the UPL must be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { createAction } from '@reduxjs/toolkit';
+
+// Common action string format: "resource(s)/action"
+export enum AutomatedAnalysisFilterAction {
+  FILTER_ADD = 'automated-analysis-filter/add',
+  FILTER_DELETE = 'automated-analysis-filter/delete',
+  FILTER_DELETE_ALL = 'automated-analysis-filter/delete_all', // Delete all filters in all categories
+  CATEGORY_FILTERS_DELETE = 'automated-analysis-filters/delete', // Delete all filters of the same category
+  CATEGORY_UPDATE = 'automated-analysis-category/update',
+  TARGET_ADD = 'automated-analysis-target/add',
+  TARGET_DELETE = 'automated-analysis-target/delete',
+}
+
+export interface AutomatedAnalysisFilterActionPayload {
+  target: string;
+  category?: string;
+  filter?: any;
+}
+
+export const automatedAnalysisAddFilterIntent = createAction(
+  AutomatedAnalysisFilterAction.FILTER_ADD,
+  (target: string, category: string, filter: any) => ({
+    payload: {
+      target: target,
+      category: category,
+      filter: filter,
+    } as AutomatedAnalysisFilterActionPayload,
+  })
+);
+
+export const automatedAnalysisDeleteFilterIntent = createAction(
+  AutomatedAnalysisFilterAction.FILTER_DELETE,
+  (target: string, category: string, filter: any) => ({
+    payload: {
+      target: target,
+      category: category,
+      filter: filter,
+    } as AutomatedAnalysisFilterActionPayload,
+  })
+);
+
+export const automatedAnalysisDeleteCategoryFiltersIntent = createAction(
+  AutomatedAnalysisFilterAction.CATEGORY_FILTERS_DELETE,
+  (target: string, category: string) => ({
+    payload: {
+      target: target,
+      category: category,
+    } as AutomatedAnalysisFilterActionPayload,
+  })
+);
+
+export const automatedAnalysisDeleteAllFiltersIntent = createAction(
+  AutomatedAnalysisFilterAction.FILTER_DELETE_ALL,
+  (target: string) => ({
+    payload: {
+      target: target,
+    } as AutomatedAnalysisFilterActionPayload,
+  })
+);
+
+export const automatedAnalysisUpdateCategoryIntent = createAction(
+  AutomatedAnalysisFilterAction.CATEGORY_UPDATE,
+  (target: string, category: string) => ({
+    payload: {
+      target: target,
+      category: category,
+    } as AutomatedAnalysisFilterActionPayload,
+  })
+);
+
+export const automatedAnalysisAddTargetIntent = createAction(AutomatedAnalysisFilterAction.TARGET_ADD, (target: string) => ({
+  payload: {
+    target: target,
+  } as AutomatedAnalysisFilterActionPayload,
+}));
+
+export const automatedAnalysisDeleteTargetIntent = createAction(AutomatedAnalysisFilterAction.TARGET_DELETE, (target: string) => ({
+  payload: {
+    target: target,
+  } as AutomatedAnalysisFilterActionPayload,
+}));
diff --git a/src/app/Shared/Redux/AutomatedAnalysisFilterReducer.tsx b/src/app/Shared/Redux/AutomatedAnalysisFilterReducer.tsx
new file mode 100644
index 0000000000..edf48521c9
--- /dev/null
+++ b/src/app/Shared/Redux/AutomatedAnalysisFilterReducer.tsx
@@ -0,0 +1,176 @@
+/*
+ * Copyright The Cryostat Authors
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or data
+ * (collectively the "Software"), free of charge and under any and all copyright
+ * rights in the Software, and any and all patent rights owned or freely
+ * licensable by each licensor hereunder covering either (i) the unmodified
+ * Software as contributed to or provided by such licensor, or (ii) the Larger
+ * Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software (each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ * The above copyright notice and either this complete permission notice or at
+ * a minimum a reference to the UPL must be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { AutomatedAnalysisFiltersCategories, emptyAutomatedAnalysisFilters } from '@app/Dashboard/AutomatedAnalysis/AutomatedAnalysisFilters';
+  import { getFromLocalStorage } from '@app/utils/LocalStorage';
+  import { createReducer } from '@reduxjs/toolkit';
+  import { WritableDraft } from 'immer/dist/internal';
+import { automatedAnalysisAddFilterIntent, automatedAnalysisAddTargetIntent, automatedAnalysisDeleteAllFiltersIntent, automatedAnalysisDeleteCategoryFiltersIntent, automatedAnalysisDeleteFilterIntent, automatedAnalysisDeleteTargetIntent, automatedAnalysisUpdateCategoryIntent } from './AutomatedAnalysisFilterActions';
+import { UpdateFilterOptions } from './RecordingFilterReducer';
+
+  export interface TargetAutomatedAnalysisFilters {
+    target: string; // connectURL
+    selectedCategory?: string;
+    filters: AutomatedAnalysisFiltersCategories;
+};
+  
+  export const createOrUpdateAutomatedAnalysisFilter = (
+    old: AutomatedAnalysisFiltersCategories,
+    { filterValue, filterKey, deleted = false, deleteOptions }: UpdateFilterOptions
+  ): AutomatedAnalysisFiltersCategories => {
+    let newFilterValues: any[];
+    if (!old[filterKey]) {
+      newFilterValues = [];
+    } else {
+      const oldFilterValues = old[filterKey] as any[];
+      if (deleted) {
+        if (deleteOptions && deleteOptions.all) {
+          newFilterValues = [];
+        } else {
+          newFilterValues = oldFilterValues.filter((val) => val !== filterValue);
+        }
+      } else {
+        newFilterValues = Array.from(new Set([...oldFilterValues, filterValue]));
+      }
+    }
+  
+    const newFilters = { ...old };
+    newFilters[filterKey] = newFilterValues;
+    return newFilters;
+  };
+  
+  export const getAutomatedAnalysisFilter = (
+    state: WritableDraft<{ list: TargetAutomatedAnalysisFilters[] }>,
+    target: string
+  ): TargetAutomatedAnalysisFilters => {
+    const targetFilter = state.list.filter((targetFilters) => targetFilters.target === target);
+    return targetFilter.length > 0 ? targetFilter[0] : createEmptyAutomatedAnalysisFilters(target);
+  };
+  
+  export const createEmptyAutomatedAnalysisFilters = (target: string) =>
+  ({
+    target: target,
+    selectedCategory: 'Name',
+    filters: emptyAutomatedAnalysisFilters,
+  } as TargetAutomatedAnalysisFilters);
+
+export const deleteAllAutomatedAnalysisFilters = (automatedAnalysisFilter: TargetAutomatedAnalysisFilters) => {
+  return {
+    ...automatedAnalysisFilter,
+      selectedCategory: automatedAnalysisFilter.selectedCategory,
+      filters: emptyAutomatedAnalysisFilters,
+  };
+};
+  
+  // Initial states are loaded from local storage if there are any
+  const initialState = {
+    list: getFromLocalStorage('AUTOMATED_ANALYSIS_FILTERS', []) as TargetAutomatedAnalysisFilters[],
+  };
+  
+  export const automatedAnalysisFilterReducer = createReducer(initialState, (builder) => {
+    builder
+      .addCase(automatedAnalysisAddFilterIntent, (state, { payload }) => {
+        const oldAutomatedAnalysisFilter = getAutomatedAnalysisFilter(state, payload.target);
+  
+        let newAutomatedAnalysisFilter: TargetAutomatedAnalysisFilters = {
+            ...oldAutomatedAnalysisFilter,
+              selectedCategory: payload.category,
+              filters: createOrUpdateAutomatedAnalysisFilter(oldAutomatedAnalysisFilter.filters, {
+                filterKey: payload.category!,
+                filterValue: payload.filter,
+              }),
+          };
+        state.list = state.list.filter((targetFilters) => targetFilters.target !== newAutomatedAnalysisFilter.target);
+        state.list.push(newAutomatedAnalysisFilter);
+      })
+      .addCase(automatedAnalysisDeleteFilterIntent, (state, { payload }) => {
+        const oldAutomatedAnalysisFilter = getAutomatedAnalysisFilter(state, payload.target);
+  
+        let newAutomatedAnalysisFilter: TargetAutomatedAnalysisFilters = {
+            ...oldAutomatedAnalysisFilter,
+              selectedCategory: payload.category,
+              filters: createOrUpdateAutomatedAnalysisFilter(oldAutomatedAnalysisFilter.filters, {
+                filterKey: payload.category!,
+                filterValue: payload.filter,
+                deleted: true,
+              }),
+          };
+
+        state.list = state.list.filter((targetFilters) => targetFilters.target !== newAutomatedAnalysisFilter.target);
+        state.list.push(newAutomatedAnalysisFilter);
+      })
+      .addCase(automatedAnalysisDeleteCategoryFiltersIntent, (state, { payload }) => {
+        const oldAutomatedAnalysisFilter = getAutomatedAnalysisFilter(state, payload.target);
+  
+        let newAutomatedAnalysisFilter: TargetAutomatedAnalysisFilters = {
+            ...oldAutomatedAnalysisFilter,
+              selectedCategory: payload.category,
+              filters: createOrUpdateAutomatedAnalysisFilter(oldAutomatedAnalysisFilter.filters, {
+                filterKey: payload.category!,
+                deleted: true,
+                deleteOptions: { all: true },
+              }),
+          };
+        state.list = state.list.filter((targetFilters) => targetFilters.target !== newAutomatedAnalysisFilter.target);
+        state.list.push(newAutomatedAnalysisFilter);
+      })
+      .addCase(automatedAnalysisDeleteAllFiltersIntent, (state, { payload }) => {
+        const oldAutomatedAnalysisFilter = getAutomatedAnalysisFilter(state, payload.target);
+        const newAutomatedAnalysisFilter = deleteAllAutomatedAnalysisFilters(oldAutomatedAnalysisFilter);
+        state.list = state.list.filter((targetFilters) => targetFilters.target !== newAutomatedAnalysisFilter.target);
+        state.list.push(newAutomatedAnalysisFilter);
+      })
+      .addCase(automatedAnalysisUpdateCategoryIntent, (state, { payload }) => {
+        const oldAutomatedAnalysisFilter = getAutomatedAnalysisFilter(state, payload.target);
+        const newAutomatedAnalysisFilter = { ...oldAutomatedAnalysisFilter };
+
+        newAutomatedAnalysisFilter.selectedCategory = payload.category;
+        
+        state.list = state.list.filter((targetFilters) => targetFilters.target !== newAutomatedAnalysisFilter.target);
+        state.list.push(newAutomatedAnalysisFilter);
+      })
+      .addCase(automatedAnalysisAddTargetIntent, (state, { payload }) => {
+        const AutomatedAnalysisFilter = getAutomatedAnalysisFilter(state, payload.target);
+        state.list = state.list.filter((targetFilters) => targetFilters.target !== payload.target);
+        state.list.push(AutomatedAnalysisFilter);
+      })
+      .addCase(automatedAnalysisDeleteTargetIntent, (state, { payload }) => {
+        state.list = state.list.filter((targetFilters) => targetFilters.target !== payload.target);
+      });
+  });
+  
\ No newline at end of file
diff --git a/src/app/Shared/Redux/ReduxStore.tsx b/src/app/Shared/Redux/ReduxStore.tsx
index cd964f3176..b0608f67be 100644
--- a/src/app/Shared/Redux/ReduxStore.tsx
+++ b/src/app/Shared/Redux/ReduxStore.tsx
@@ -39,9 +39,11 @@
 import { saveToLocalStorage } from '@app/utils/LocalStorage';
 import { combineReducers, configureStore, PreloadedState } from '@reduxjs/toolkit';
 import { recordingFilterReducer as recordingFiltersReducer } from './RecordingFilterReducer';
+import { automatedAnalysisFilterReducer as automatedAnalysisFiltersReducer } from './AutomatedAnalysisFilterReducer';
 
 export const rootReducer = combineReducers({
   recordingFilters: recordingFiltersReducer,
+  automatedAnalysisFilters: automatedAnalysisFiltersReducer,
 });
 
 export const setupStore = (preloadedState?: PreloadedState<RootState>) =>
@@ -60,3 +62,4 @@ export type Store = ReturnType<typeof setupStore>;
 // Add a subscription to save filter states to local storage
 // if states change.
 store.subscribe(() => saveToLocalStorage('TARGET_RECORDING_FILTERS', store.getState().recordingFilters.list));
+store.subscribe(() => saveToLocalStorage('AUTOMATED_ANALYSIS_FILTERS', store.getState().automatedAnalysisFilters.list));
diff --git a/src/app/Shared/Services/Api.service.tsx b/src/app/Shared/Services/Api.service.tsx
index 30b39123d8..ee84e719b5 100644
--- a/src/app/Shared/Services/Api.service.tsx
+++ b/src/app/Shared/Services/Api.service.tsx
@@ -46,6 +46,7 @@ import { Rule } from '@app/Rules/Rules';
 import { NotificationCategory } from './NotificationChannel.service';
 import _ from 'lodash';
 import { createBlobURL } from '@app/utils/utils';
+import { ORANGE_SCORE_THRESHOLD, RED_SCORE_THRESHOLD } from './Report.service';
 
 type ApiVersion = 'v1' | 'v2' | 'v2.1' | 'v2.2' | 'beta';
 
@@ -1041,6 +1042,13 @@ export interface ActiveRecording extends Omit<ArchivedRecording, 'size' | 'archi
   maxAge: number;
 }
 
+export enum AutomatedAnalysisScoreState {
+  NA = -1,
+  OK = ORANGE_SCORE_THRESHOLD,
+  WARNING = RED_SCORE_THRESHOLD,
+  CRITICAL = 100,
+}
+
 export enum RecordingState {
   STOPPED = 'STOPPED',
   STARTING = 'STARTING',
diff --git a/src/app/utils/LocalStorage.ts b/src/app/utils/LocalStorage.ts
index e9d8d815ec..d3a77461f0 100644
--- a/src/app/utils/LocalStorage.ts
+++ b/src/app/utils/LocalStorage.ts
@@ -37,6 +37,7 @@
  */
 
 export enum LocalStorageKey {
+  AUTOMATED_ANALYSIS_FILTERS,
   TARGET_RECORDING_FILTERS,
   JMX_CREDENTIAL_LOCATION,
   JMX_CREDENTIALS,
diff --git a/src/test/Recordings/ActiveRecordingsTable.test.tsx b/src/test/Recordings/ActiveRecordingsTable.test.tsx
index 5560620169..bf6a2fb7fd 100644
--- a/src/test/Recordings/ActiveRecordingsTable.test.tsx
+++ b/src/test/Recordings/ActiveRecordingsTable.test.tsx
@@ -194,6 +194,9 @@ describe('<ActiveRecordingsTable />', () => {
           } as TargetRecordingFilters,
         ],
       },
+      automatedAnalysisFilters: {
+        list: []
+      }
     };
   });
 
diff --git a/src/test/Recordings/ArchivedRecordingsTable.test.tsx b/src/test/Recordings/ArchivedRecordingsTable.test.tsx
index daafb17cf7..0602cac34d 100644
--- a/src/test/Recordings/ArchivedRecordingsTable.test.tsx
+++ b/src/test/Recordings/ArchivedRecordingsTable.test.tsx
@@ -189,6 +189,9 @@ describe('<ArchivedRecordingsTable />', () => {
           } as TargetRecordingFilters,
         ],
       },
+      automatedAnalysisFilters: {
+        list: []
+      }
     };
   });
 
diff --git a/src/test/Recordings/RecordingFilters.test.tsx b/src/test/Recordings/RecordingFilters.test.tsx
index 3e934d437e..ac3507e899 100644
--- a/src/test/Recordings/RecordingFilters.test.tsx
+++ b/src/test/Recordings/RecordingFilters.test.tsx
@@ -138,6 +138,9 @@ describe('<RecordingFilters />', () => {
           } as TargetRecordingFilters,
         ],
       },
+      automatedAnalysisFilters: {
+        list: []
+      }
     };
   });