Alert Rule : Delete with id

Author: VincentD06

src/main/java/com/airbus_cyber_security/graylog/wizard/alert/rest/AlertRuleResource.java

@@ -105,6 +105,7 @@ public class AlertRuleResource extends RestResource implements PluginRestResourc
     private static final Logger LOG = LoggerFactory.getLogger(AlertRuleResource.class);
 
     private static final String ENCODING = "UTF-8";
+    private static final String ID = "id";
     private static final String TITLE = "title";
 
     private static final String DEFAULT_SORT_FIELD = "title";
@@ -305,8 +306,9 @@ private String checkImportPolicyAndGetTitle(String title, UserContext userContex
                 alertTitle = newAlertTitle;
             } else if (importPolicy != null && importPolicy.equals(ImportPolicyType.REPLACE)) {
                 try {
-                    this.delete(alertTitle, userContext);
-                } catch (MongoException | UnsupportedEncodingException e) {
+                    AlertRule alert = this.alertRuleService.load(alertTitle);
+                    this.delete(alert.id(), userContext);
+                } catch (MongoException | UnsupportedEncodingException | NotFoundException e) {
                     LOG.error("Failed to replace alert rule");
                     throw new BadRequestException("Failed to replace alert rule.");
                 }
@@ -531,7 +533,7 @@ private void deleteAlertPattern(AlertPattern alertPattern) {
     }
 
     @DELETE
-    @Path("/{title}")
+    @Path("/{id}")
     @RequiresAuthentication
     @RequiresPermissions(AlertRuleRestPermissions.WIZARD_ALERTS_RULES_DELETE)
     @ApiOperation(value = "Delete a alert")
@@ -540,25 +542,25 @@ private void deleteAlertPattern(AlertPattern alertPattern) {
             @ApiResponse(code = 400, message = "Invalid ObjectId.")
     })
     @AuditEvent(type = AlertWizardAuditEventTypes.WIZARD_ALERTS_RULES_DELETE)
-    public void delete(@ApiParam(name = TITLE, required = true)
-                       @PathParam(TITLE) String title,
+    public void delete(@ApiParam(name = ID, required = true)
+                       @PathParam(ID) String id,
                        @Context UserContext userContext
     ) throws MongoException, UnsupportedEncodingException {
-        String alertTitle = java.net.URLDecoder.decode(title, ENCODING);
+        Optional<AlertRule> alertRuleOptional = this.alertRuleService.get(id);
 
-        try {
-            AlertRule alertRule = this.alertRuleService.load(alertTitle);
+        if (alertRuleOptional.isPresent()) {
+            AlertRule alertRule = alertRuleOptional.get();
 
             deleteAlertPattern(alertRule.pattern());
             if (alertRule.getNotificationID() != null && !alertRule.getNotificationID().isEmpty()) {
                 // TODO move this down into AlertRuleUtilsService and remove the use for eventNotificationsResource
                 this.eventNotificationsResource.delete(alertRule.getNotificationID(), userContext);
             }
-        } catch (NotFoundException e) {
-            LOG.error("Cannot find alert " + alertTitle, e);
-        }
 
-        this.alertRuleService.destroy(alertTitle);
+            this.alertRuleService.delete(id);
+        } else {
+            LOG.error("Cannot find alert {}", id);
+        }
     }
 
     @POST

src/web/wizard/actions/AlertRuleActions.jsx

@@ -22,7 +22,7 @@ const AlertRuleActions = Reflux.createActions({
     get: {asyncResult: true},
     create: {asyncResult: true},
     clone: {asyncResult: true},
-    deleteByName: {asyncResult: true},
+    delete: {asyncResult: true},
     update: {asyncResult: true},
     searchPaginated: { asyncResult: true },
 });

src/web/wizard/components/rules/AlertRulesContainer.jsx

@@ -17,22 +17,22 @@
 
 import React from 'react';
 import { useState, useCallback } from 'react';
+import { useIntl, FormattedMessage } from 'react-intl';
+import { useQueryClient } from '@tanstack/react-query';
+import { toDateObject } from 'util/DateTime';
+import StreamsStore from 'stores/streams/StreamsStore';
 import { PaginatedEntityTable, Timestamp } from 'components/common';
+import ButtonToEventDefinition from 'wizard/components/buttons/ButtonToEventDefinition';
+import ButtonToNotification from 'wizard/components/buttons/ButtonToNotification';
+import ButtonToSearch from 'wizard/components/buttons/ButtonToSearch';
+import ButtonToUpdateRule from 'wizard/components/buttons/ButtonToUpdateRule';
+import EventDefinitionResources from 'wizard/resources/EventDefinitionResource';
 import AlertRuleActions from 'wizard/actions/AlertRuleActions';
-import { useQueryClient } from '@tanstack/react-query';
-import { keyFn, fetchAlertRules, KEY_PREFIX } from './hooks/useAlertRules';
-import { useIntl, FormattedMessage } from 'react-intl';
+import AlertValidation from 'wizard/logic/AlertValidation';
+import { keyFn, fetchAlertRules } from './hooks/useAlertRules';
 import AlertRuleBulkActions from './AlertRuleBulkActions';
-import { toDateObject } from 'util/DateTime';
 import AlertRuleText from './AlertRuleText';
-import ButtonToEventDefinition from '../buttons/ButtonToEventDefinition';
-import ButtonToNotification from '../buttons/ButtonToNotification';
 import AlertRuleCloneForm from './AlertRuleCloneForm';
-import EventDefinitionResources from '../../resources/EventDefinitionResource';
-import StreamsStore from 'stores/streams/StreamsStore';
-import ButtonToSearch from '../buttons/ButtonToSearch';
-import AlertValidation from '../../logic/AlertValidation';
-import ButtonToUpdateRule from '../buttons/ButtonToUpdateRule';
 import {DEFAULT_LAYOUT} from "./Constants";
 
 function _convertAlertToElement(alert) {
@@ -84,7 +84,7 @@ const AlertRulesContainer = ({ fieldOrder }) => {
     const intl = useIntl();
     const queryClient = useQueryClient();
 
-    const _loadAlertRules = () => queryClient.invalidateQueries(KEY_PREFIX);
+    const _loadAlertRules = () => queryClient.invalidateQueries(keyFn());
     const fieldsTitle = [
         {key: 'title', label: intl.formatMessage({id: 'wizard.title', defaultMessage: 'Title'}), config: 'title', sortable: true},
         {key: 'priority', label: intl.formatMessage({id: 'wizard.priority', defaultMessage: 'Priority'}), config: 'Priority', sortable: true},
@@ -169,7 +169,6 @@ const AlertRulesContainer = ({ fieldOrder }) => {
                               disableAlertRulesFunction={disableAlertRules}
                               enableAlertRulesFunction={enableAlertRules} />
     );
-    const onSortChange = useCallback(() => {}, []);
     const renderAlertRuleActions = useCallback((alert) => {
         const element = _convertAlertToElement(alert);
 
@@ -182,22 +181,21 @@ const AlertRulesContainer = ({ fieldOrder }) => {
         </div>);
     }, []);
 
-    const deleteAlertRules = (alertRulesTitles) => {
-        const promises = alertRulesTitles.map(name => AlertRuleActions.deleteByName(name));
+    const deleteAlertRules = (alertRulesIds) => {
+        const promises = alertRulesIds.map(id => AlertRuleActions.delete(id));
         Promise.all(promises).then(() => _loadAlertRules());
     }
 
-    const disableAlertRules = (alertRulesTitles) => {
-        console.log(alertRulesTitles);
-        const tempElements = alertRulesTitles.map(name => elements.find(x => x.id === name));
+    const disableAlertRules = (alertRulesIds) => {
+        const tempElements = alertRulesIds.map(name => elements.find(x => x.id === name));
 
         for(const elt of tempElements) {
             _onPause(elt.title, elt.condition, elt.streamId, elt.secondEventDefinition, elt.streamId2);
         }
     }
 
-    const enableAlertRules = (alertRulesTitles) => {
-        const tempElements = alertRulesTitles.map(name => elements.find(x => x.id === name));
+    const enableAlertRules = (alertRulesIds) => {
+        const tempElements = alertRulesIds.map(name => elements.find(x => x.id === name));
 
         for(const elt of tempElements) {
             _onResume(elt.condition, elt.streamId, elt.secondEventDefinition, elt.streamId2);

src/web/wizard/stores/AlertRuleStore.js

@@ -199,8 +199,8 @@ const AlertRuleStore = Reflux.createStore({
         AlertRuleActions.update.promise(promise);
     },
 
-    deleteByName(alertName) {
-        const url = URLUtils.qualifyUrl(SOURCE_URL + '/' + encodeURIComponent(alertName));
+    delete(id) {
+        const url = URLUtils.qualifyUrl(SOURCE_URL + '/' + encodeURIComponent(id));
         const method = 'DELETE';
 
         const promise = fetch(method, url)
@@ -211,7 +211,7 @@ const AlertRuleStore = Reflux.createStore({
                 UserNotification.error(`Deleting alert rule failed with status: ${error.message}`,
                     'Could not delete alert rule');
             });
-        AlertRuleActions.deleteByName.promise(promise);
+        AlertRuleActions.delete.promise(promise);
     },
 });