feat: enhance UtmIncident resource with auditing support and improved alert validation

mjabascal10 · mjabascal10 · commit d0566024af3e · 2025-10-14T14:25:25.000-05:00
diff --git a/backend/src/main/java/com/park/utmstack/service/incident/UtmIncidentService.java b/backend/src/main/java/com/park/utmstack/service/incident/UtmIncidentService.java
@@ -17,6 +17,7 @@
 import com.park.utmstack.service.dto.incident.NewIncidentDTO;
 import com.park.utmstack.service.dto.incident.RelatedIncidentAlertsDTO;
 import com.park.utmstack.service.incident.util.ResolveIncidentStatus;
+import com.park.utmstack.util.exceptions.IncidentAlertConflictException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.data.domain.Page;
@@ -27,10 +28,7 @@
 import org.springframework.util.CollectionUtils;
 
 import javax.validation.Valid;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -76,7 +74,6 @@ public UtmIncidentService(UtmIncidentRepository utmIncidentRepository,
      */
     public UtmIncident save(UtmIncident utmIncident) {
         final String ctx = ".save";
-        log.debug("Request to save UtmIncident : {}", utmIncident);
         try {
             return utmIncidentRepository.save(utmIncident);
         } catch (Exception e) {
@@ -140,6 +137,8 @@ public UtmIncident changeStatus(UtmIncident utmIncident) {
     public UtmIncident createIncident(NewIncidentDTO newIncidentDTO) {
         final String ctx = CLASSNAME + ".createIncident";
         try {
+            validateAlertsNotAlreadyLinked(newIncidentDTO.getAlertList(), ctx);
+
             UtmIncident utmIncident = new UtmIncident();
             utmIncident.setIncidentName(newIncidentDTO.getIncidentName());
             utmIncident.setIncidentDescription(newIncidentDTO.getIncidentDescription());
@@ -177,10 +176,25 @@ public UtmIncident addAlertsIncident(@Valid AddToIncidentDTO addToIncidentDTO) {
         final String ctx = CLASSNAME + ".addAlertsIncident";
         try {
             log.debug("Request to add alert to UtmIncident : {}", addToIncidentDTO);
+
+            List<RelatedIncidentAlertsDTO> alertIds = addToIncidentDTO.getAlertList();
+
+            String alertsIds = alertIds.stream().map(RelatedIncidentAlertsDTO::getAlertId).collect(Collectors.joining(","));
+            Map<String, Object> extra = Map.of(
+                    "alertIds", alertsIds,
+                    "source", "service"
+            );
+            String attemptMsg = String.format("Attempt to add %d alerts to incident %d", addToIncidentDTO.getAlertList().size(), addToIncidentDTO.getIncidentId());
+            eventService.createEvent(attemptMsg, ApplicationEventType.INCIDENT_ALERT_ADD_ATTEMPT, extra);
+
+            validateAlertsNotAlreadyLinked(addToIncidentDTO.getAlertList(), ctx);
             UtmIncident utmIncident = utmIncidentRepository.findById(addToIncidentDTO.getIncidentId()).orElseThrow(() -> new RuntimeException(ctx + ": Incident not found"));
             saveRelatedAlerts(addToIncidentDTO.getAlertList(), utmIncident.getId());
             String historyMessage = String.format("New %d alerts added to incident", addToIncidentDTO.getAlertList().size());
             utmIncidentHistoryService.createHistory(IncidentHistoryActionEnum.INCIDENT_ALERT_ADD, utmIncident.getId(), "New alerts added to incident", historyMessage);
+
+            eventService.createEvent(historyMessage, ApplicationEventType.INCIDENT_ALERTS_ADDED, extra);
+
             return utmIncident;
         } catch (Exception e) {
             String msg = ctx + ": " + e.getMessage();
@@ -284,4 +298,20 @@ private void sendIncidentsEmail(List<String> alertIds, UtmIncident utmIncident)
             eventService.createEvent(msg, ApplicationEventType.ERROR);
         }
     }
+
+    private void validateAlertsNotAlreadyLinked(List<RelatedIncidentAlertsDTO> alertList, String ctx) {
+
+        List<String> alertIds = alertList.stream()
+                .map(RelatedIncidentAlertsDTO::getAlertId)
+                .collect(Collectors.toList());
+
+        List<String> alertsFound = utmIncidentAlertService.existsAnyAlert(alertIds);
+
+        if (!alertsFound.isEmpty()) {
+            String alertIdsList = String.join(", ", alertIds);
+            String msg = "Some alerts are already linked to another incident. Alert IDs: " + alertIdsList + ". Check the related incidents for more details.";
+
+            throw new IncidentAlertConflictException(ctx + ": " + msg);
+        }
+    }
 }
diff --git a/backend/src/main/java/com/park/utmstack/web/rest/incident/UtmIncidentResource.java b/backend/src/main/java/com/park/utmstack/web/rest/incident/UtmIncidentResource.java
@@ -2,60 +2,44 @@
 
 import com.park.utmstack.domain.application_events.enums.ApplicationEventType;
 import com.park.utmstack.domain.incident.UtmIncident;
-import com.park.utmstack.service.application_events.ApplicationEventService;
 import com.park.utmstack.service.dto.incident.*;
-import com.park.utmstack.service.incident.UtmIncidentAlertService;
 import com.park.utmstack.service.incident.UtmIncidentQueryService;
 import com.park.utmstack.service.incident.UtmIncidentService;
-import com.park.utmstack.util.UtilResponse;
+import com.park.utmstack.util.exceptions.NoAlertsProvidedException;
 import com.park.utmstack.web.rest.errors.BadRequestAlertException;
 import com.park.utmstack.web.rest.util.HeaderUtil;
 import com.park.utmstack.web.rest.util.PaginationUtil;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.*;
-import tech.jhipster.web.util.ResponseUtil;
+import com.park.utmstack.aop.logging.AuditEvent;
 
 import javax.validation.Valid;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.List;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
 /**
  * REST controller for managing UtmIncident.
  */
 @RestController
+@RequiredArgsConstructor
+@Slf4j
 @RequestMapping("/api")
 public class UtmIncidentResource {
-    private final String CLASS_NAME = "UtmIncidentResource";
-    private final Logger log = LoggerFactory.getLogger(UtmIncidentResource.class);
 
     private static final String ENTITY_NAME = "utmIncident";
 
     private final UtmIncidentService utmIncidentService;
 
-    private final UtmIncidentAlertService utmIncidentAlertService;
-
     private final UtmIncidentQueryService utmIncidentQueryService;
-    private final ApplicationEventService applicationEventService;
-
-    public UtmIncidentResource(UtmIncidentService utmIncidentService,
-                               UtmIncidentAlertService utmIncidentAlertService,
-                               UtmIncidentQueryService utmIncidentQueryService,
-                               ApplicationEventService applicationEventService) {
-        this.utmIncidentService = utmIncidentService;
-        this.utmIncidentAlertService = utmIncidentAlertService;
-        this.utmIncidentQueryService = utmIncidentQueryService;
-        this.applicationEventService = applicationEventService;
-    }
+
 
     /**
      * Creates a new incident based on the provided details.
@@ -75,38 +59,21 @@ public UtmIncidentResource(UtmIncidentService utmIncidentService,
      * @throws IllegalArgumentException if the input data is invalid.
      */
     @PostMapping("/utm-incidents")
+    @AuditEvent(
+        attemptType = ApplicationEventType.INCIDENT_CREATION_ATTEMPT,
+        attemptMessage = "Attempt to create a new incident initiated",
+        successType = ApplicationEventType.INCIDENT_CREATION_SUCCESS,
+        successMessage = "Incident created successfully"
+    )
     public ResponseEntity<UtmIncident> createUtmIncident(@Valid @RequestBody NewIncidentDTO newIncidentDTO) {
         final String ctx = ".createUtmIncident";
-        try {
-            if (CollectionUtils.isEmpty(newIncidentDTO.getAlertList())) {
-                String msg = ctx + ": A new incident has to have at least one alert related";
-                log.error(msg);
-                applicationEventService.createEvent(msg, ApplicationEventType.ERROR);
-                return UtilResponse.buildErrorResponse(HttpStatus.BAD_REQUEST, msg);
-            }
-
-            List<String> alertIds = newIncidentDTO.getAlertList().stream()
-                    .map(RelatedIncidentAlertsDTO::getAlertId)
-                    .collect(Collectors.toList());
-
-            List<String> alertsFound = utmIncidentAlertService.existsAnyAlert(alertIds);
-
-            if (!alertsFound.isEmpty()) {
-                String alertIdsList = String.join(", ", alertIds);
-                String msg = "Some alerts are already linked to another incident. Alert IDs: " + alertIdsList + ". Check the related incidents for more details.";
-                log.error(msg);
-                applicationEventService.createEvent(ctx + ": " + msg , ApplicationEventType.ERROR);
-                return UtilResponse.buildErrorResponse(HttpStatus.CONFLICT, utmIncidentAlertService.formatAlertMessage(alertsFound));
-            }
-
-
-            return ResponseEntity.ok(utmIncidentService.createIncident(newIncidentDTO));
-        } catch (Exception e) {
-            String msg = ctx + ": " + e.getMessage();
-            log.error(msg);
-            applicationEventService.createEvent(msg, ApplicationEventType.ERROR);
-            return UtilResponse.buildErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR, msg);
+
+        if (CollectionUtils.isEmpty(newIncidentDTO.getAlertList())) {
+            String msg = ctx + ": A new incident has to have at least one alert related";
+            throw new NoAlertsProvidedException(ctx + ": " + msg);
         }
+
+        return ResponseEntity.ok(utmIncidentService.createIncident(newIncidentDTO));
     }
 
     /**
@@ -124,36 +91,22 @@ public ResponseEntity<UtmIncident> createUtmIncident(@Valid @RequestBody NewInci
      * @throws URISyntaxException if the Location URI syntax is incorrect
      */
     @PostMapping("/utm-incidents/add-alerts")
+    @AuditEvent(
+        attemptType = ApplicationEventType.INCIDENT_ALERT_ADD_ATTEMPT,
+        attemptMessage = "Attempt to add alerts to incident initiated",
+        successType = ApplicationEventType.INCIDENT_ALERT_ADD_SUCCESS,
+        successMessage = "Alerts added to incident successfully"
+    )
     public ResponseEntity<UtmIncident> addAlertsToUtmIncident(@Valid @RequestBody AddToIncidentDTO addToIncidentDTO) throws URISyntaxException {
-        final String ctx = ".addAlertsToUtmIncident";
-        try {
-            log.debug("REST request to save UtmIncident : {}", addToIncidentDTO);
-            if (CollectionUtils.isEmpty(addToIncidentDTO.getAlertList())) {
-                throw new BadRequestAlertException("Add utmIncident cannot already have an empty related alerts", ENTITY_NAME, "alertList");
-            }
-            List<String> alertIds = addToIncidentDTO.getAlertList().stream()
-                    .map(RelatedIncidentAlertsDTO::getAlertId)
-                    .collect(Collectors.toList());
-
-            List<String> alertsFound = utmIncidentAlertService.existsAnyAlert(alertIds);
-
-            if (!alertsFound.isEmpty()) {
-                String alertIdsList = String.join(", ", alertIds);
-                String msg = "Some alerts are already linked to another incident. Alert IDs: " + alertIdsList + ". Check the related incidents for more details.";
-                log.error(msg);
-                applicationEventService.createEvent(ctx + ": " + msg , ApplicationEventType.ERROR);
-                return UtilResponse.buildErrorResponse(HttpStatus.CONFLICT, utmIncidentAlertService.formatAlertMessage(alertsFound));
-            }
-            UtmIncident result = utmIncidentService.addAlertsIncident(addToIncidentDTO);
-            return ResponseEntity.created(new URI("/api/utm-incidents/add-alerts" + result.getId()))
+
+        if (CollectionUtils.isEmpty(addToIncidentDTO.getAlertList())) {
+            throw new NoAlertsProvidedException("Add utmIncident cannot already have an empty related alerts");
+        }
+
+        UtmIncident result = utmIncidentService.addAlertsIncident(addToIncidentDTO);
+           return ResponseEntity.created(new URI("/api/utm-incidents/add-alerts" + result.getId()))
                 .headers(HeaderUtil.createEntityCreationAlert(ENTITY_NAME, result.getId().toString()))
                 .body(result);
-        } catch (Exception e) {
-            String msg = ctx + ": " + e.getMessage();
-            log.error(msg);
-            applicationEventService.createEvent(msg, ApplicationEventType.ERROR);
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).headers(HeaderUtil.createFailureAlert(CLASS_NAME, null, msg)).body(null);
-        }
     }
 
     /**
@@ -166,23 +119,22 @@ public ResponseEntity<UtmIncident> addAlertsToUtmIncident(@Valid @RequestBody Ad
      * @throws URISyntaxException if the Location URI syntax is incorrect
      */
     @PutMapping("/utm-incidents/change-status")
-    public ResponseEntity<UtmIncident> updateUtmIncident(@Valid @RequestBody UtmIncident utmIncident) throws URISyntaxException {
-        final String ctx = ".updateUtmIncident";
-        try {
-            log.debug("REST request to update UtmIncident : {}", utmIncident);
-            if (utmIncident.getId() == null) {
-                throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
-            }
-            UtmIncident result = utmIncidentService.changeStatus(utmIncident);
-            return ResponseEntity.ok()
+    @AuditEvent(
+        attemptType = ApplicationEventType.INCIDENT_UPDATE_ATTEMPT,
+        attemptMessage = "Attempt to update incident status initiated",
+        successType = ApplicationEventType.INCIDENT_UPDATE_SUCCESS,
+        successMessage = "Incident status updated successfully"
+    )
+    public ResponseEntity<UtmIncident> updateUtmIncident(@Valid @RequestBody UtmIncident utmIncident) {
+
+        if (utmIncident.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        UtmIncident result = utmIncidentService.changeStatus(utmIncident);
+
+        return ResponseEntity.ok()
                 .headers(HeaderUtil.createEntityUpdateAlert(ENTITY_NAME, utmIncident.getId().toString()))
                 .body(result);
-        } catch (Exception e) {
-            String msg = ctx + ": " + e.getMessage();
-            log.error(msg);
-            applicationEventService.createEvent(msg, ApplicationEventType.ERROR);
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).headers(HeaderUtil.createFailureAlert(CLASS_NAME, null, msg)).body(null);
-        }
     }
 
     /**
@@ -194,18 +146,10 @@ public ResponseEntity<UtmIncident> updateUtmIncident(@Valid @RequestBody UtmInci
      */
     @GetMapping("/utm-incidents")
     public ResponseEntity<List<UtmIncident>> getAllUtmIncidents(UtmIncidentCriteria criteria, Pageable pageable) {
-        final String ctx = ".getAllUtmIncidents";
-        try {
-            log.debug("REST request to get UtmIncidents by criteria: {}", criteria);
-            Page<UtmIncident> page = utmIncidentQueryService.findByCriteria(criteria, pageable);
-            HttpHeaders headers = PaginationUtil.generatePaginationHttpHeaders(page, "/api/utm-incidents");
-            return ResponseEntity.ok().headers(headers).body(page.getContent());
-        } catch (Exception e) {
-            String msg = ctx + ": " + e.getMessage();
-            log.error(msg);
-            applicationEventService.createEvent(msg, ApplicationEventType.ERROR);
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).headers(HeaderUtil.createFailureAlert(CLASS_NAME, null, msg)).body(null);
-        }
+
+        Page<UtmIncident> page = utmIncidentQueryService.findByCriteria(criteria, pageable);
+        HttpHeaders headers = PaginationUtil.generatePaginationHttpHeaders(page, "/api/utm-incidents");
+        return ResponseEntity.ok().headers(headers).body(page.getContent());
     }
 
     /**
@@ -215,15 +159,7 @@ public ResponseEntity<List<UtmIncident>> getAllUtmIncidents(UtmIncidentCriteria
      */
     @GetMapping("/utm-incidents/users-assigned")
     public ResponseEntity<List<IncidentUserAssignedDTO>> getAllUserAssigned() {
-        final String ctx = ".getAllUserAssigned";
-        try {
-            return ResponseEntity.ok().body(utmIncidentQueryService.getAllUsersAssigned());
-        } catch (Exception e) {
-            String msg = ctx + ": " + e.getMessage();
-            log.error(msg);
-            applicationEventService.createEvent(msg, ApplicationEventType.ERROR);
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).headers(HeaderUtil.createFailureAlert(CLASS_NAME, null, msg)).body(null);
-        }
+        return ResponseEntity.ok().body(utmIncidentQueryService.getAllUsersAssigned());
     }
 
     /**
@@ -234,16 +170,9 @@ public ResponseEntity<List<IncidentUserAssignedDTO>> getAllUserAssigned() {
      */
     @GetMapping("/utm-incidents/{id}")
     public ResponseEntity<UtmIncident> getUtmIncident(@PathVariable Long id) {
-        final String ctx = ".getUtmIncident";
-        try {
-            log.debug("REST request to get UtmIncident : {}", id);
-            Optional<UtmIncident> utmIncident = utmIncidentService.findOne(id);
-            return ResponseUtil.wrapOrNotFound(utmIncident);
-        } catch (Exception e) {
-            String msg = ctx + ": " + e.getMessage();
-            log.error(msg);
-            applicationEventService.createEvent(msg, ApplicationEventType.ERROR);
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).headers(HeaderUtil.createFailureAlert(CLASS_NAME, null, msg)).body(null);
-        }
+
+        Optional<UtmIncident> utmIncident = utmIncidentService.findOne(id);
+        return tech.jhipster.web.util.ResponseUtil.wrapOrNotFound(utmIncident);
+
     }
 }
