AuditDiffService.java

  1. package no.nav.data.team.notify;

  3. import lombok.Value;
  4. import lombok.extern.slf4j.Slf4j;
  5. import no.nav.data.common.auditing.domain.Action;
  6. import no.nav.data.common.auditing.domain.AuditVersionRepository;
  7. import no.nav.data.common.auditing.dto.AuditMetadata;
  8. import no.nav.data.team.notify.domain.Notification;
  9. import no.nav.data.team.notify.domain.Notification.NotificationChannel;
  10. import no.nav.data.team.notify.domain.Notification.NotificationType;
  11. import no.nav.data.team.notify.domain.NotificationTask;
  12. import no.nav.data.team.notify.domain.NotificationTask.AuditTarget;
  13. import no.nav.data.team.notify.domain.TeamAuditMetadata;
  14. import org.springframework.stereotype.Service;

  16. import java.util.ArrayList;
  17. import java.util.HashMap;
  18. import java.util.HashSet;
  19. import java.util.List;
  20. import java.util.Map;
  21. import java.util.Map.Entry;
  22. import java.util.Set;
  23. import java.util.UUID;
  24. import java.util.stream.Stream;

  26. import static java.util.stream.Collectors.groupingBy;
  27. import static java.util.stream.Collectors.toList;
  28. import static no.nav.data.common.utils.StreamUtils.convert;
  29. import static no.nav.data.common.utils.StreamUtils.filter;
  30. import static no.nav.data.common.utils.StreamUtils.find;
  31. import static no.nav.data.common.utils.StreamUtils.tryFind;
  32. import static no.nav.data.common.utils.StreamUtils.union;

  34. @Slf4j
  35. @Service
  36. public class AuditDiffService {

  38.     private final AuditVersionRepository auditVersionRepository;

  40.     public AuditDiffService(AuditVersionRepository auditVersionRepository) {
  41.         this.auditVersionRepository = auditVersionRepository;
  42.     }

  44.     public List<NotificationTask> createTask(List<AuditMetadata> audits, List<Notification> notifications) {
  45.         var allTasks = new ArrayList<NotificationTask>();
  46.         if (audits.isEmpty()) {
  47.             return allTasks;
  48.         }

  50.         var lastAudit = audits.get(audits.size() - 1);
  51.         var auditsStart = audits.get(0).getTime();
  52.         var auditsEnd = lastAudit.getTime();
  53.         log.info("Notification {} audits", audits.size());

  55.         var teamsPrev = auditVersionRepository.getTeamMetadataBefore(auditsStart);
  56.         var teamsCurr = auditVersionRepository.getTeamMetadataBetween(auditsStart, auditsEnd);
  57.         notifications = expandProductAreaNotifications(notifications, teamsPrev, teamsCurr);
  58.         var auditsByTargetId = audits.stream().collect(groupingBy(AuditMetadata::getTableId));
  59.         notifications.removeIf(n -> {
  60.                     boolean notAllEventNotification = n.getType() != NotificationType.ALL_EVENTS;
  61.                     boolean noAuditsForNotification = !auditsByTargetId.containsKey(n.getTarget());
  62.                     boolean noDependentAuditsForNotification = auditsByTargetId.keySet().stream().noneMatch(n::isDependentOn);
  63.                     return notAllEventNotification && noAuditsForNotification && noDependentAuditsForNotification;
  64.                 }
  65.         );
  66.         notifications.forEach(n -> {
  67.             if (n.getTarget() != null && !auditsByTargetId.containsKey(n.getTarget())) {
  68.                 log.info("Adding empty audits for target {}", n.getTarget());
  69.                 auditsByTargetId.put(n.getTarget(), List.of());
  70.             }
  71.         });

  73.         var notificationsByIdent = notifications.stream().collect(groupingBy(Notification::getIdent));
  74.         log.info("Notification for {}", notificationsByIdent.keySet());
  75.         for (Entry<String, List<Notification>> entry : notificationsByIdent.entrySet()) {
  76.             String ident = entry.getKey();
  77.             List<Notification> notificationsForIdent = entry.getValue();
  78.             var notificationTargetAudits = unpackAndGroupTargets(notificationsForIdent, auditsByTargetId);
  79.             var tasksForIdent = createTasks(ident, notificationTargetAudits);
  80.             allTasks.addAll(filter(tasksForIdent, t -> !t.getTargets().isEmpty()));
  81.         }
  82.         return allTasks;
  83.     }

  85.     private List<Notification> expandProductAreaNotifications(List<Notification> notifications, List<TeamAuditMetadata> teamsPrev, List<TeamAuditMetadata> teamsCurr) {
  86.         var allNotifications = new ArrayList<>(notifications);
  87.         for (Notification notification : notifications) {
  88.             if (notification.getType() == NotificationType.PA) {
  89.                 var paTeamsPrev = filter(teamsPrev, t -> notification.getTarget().equals(t.getProductAreaId()));
  90.                 var paTeamsCurr = filter(teamsCurr, t -> notification.getTarget().equals(t.getProductAreaId()));
  91.                 var allTeams = union(paTeamsPrev, paTeamsCurr).stream().map(TeamAuditMetadata::getTableId).distinct().collect(toList());
  92.                 // Adding teams from product area to notifications, setting their level as Product area, to enforce correct channel overrides later
  93.                 allNotifications.addAll(convert(allTeams, teamId -> Notification.builder()
  94.                         .type(NotificationType.PA)
  95.                         .time(notification.getTime())
  96.                         .ident(notification.getIdent())
  97.                         .channels(notification.getChannels())
  98.                         .target(teamId)
  99.                         .build()));
  100.                 notification.setDependentTargets(allTeams);
  101.                 log.info("Notification PA {} DependentTargets {}", notification.getTarget(), allTeams);
  102.             }
  103.         }
  104.         return allNotifications;
  105.     }

  107.     private List<NotificationTargetAudits> unpackAndGroupTargets(List<Notification> notifications, Map<UUID, List<AuditMetadata>> auditsByTargetId) {
  108.         var allEventAudits = new ArrayList<NotificationTargetAudits>();
  109.         // unpack ALL_EVENTS
  110.         tryFind(notifications, n -> n.getType() == NotificationType.ALL_EVENTS)
  111.                 .ifPresent(n -> allEventAudits.addAll(convert(auditsByTargetId.entrySet(), e -> new NotificationTargetAudits(n, e.getKey(), e.getValue()))));

  113.         var targetAudits = notifications.stream()
  114.                 .filter(n -> n.getType() != NotificationType.ALL_EVENTS)
  115.                 .map(n -> new NotificationTargetAudits(n, n.getTarget(), auditsByTargetId.get(n.getTarget())))
  116.                 .collect(toList());
  117.         return union(allEventAudits, targetAudits);
  118.     }

  120.     private List<NotificationTask> createTasks(String ident, List<NotificationTargetAudits> targetAudits) {
  121.         // All times are equal down here
  122.         var time = targetAudits.get(0).getNotification().getTime();

  124.         // Calculate which type is the most specific for each target.
  125.         // ie. if a a user has a team marked as a different channel than it's product area, we will use the teams channel settings for that target, same goes for ALL_EVENTS.
  126.         Map<UUID, NotificationType> targetTypes = new HashMap<>();
  127.         targetAudits.forEach(ta -> targetTypes.compute(ta.getTargetId(), (uuid, existingType) -> NotificationType.min(ta.getNotification().getType(), existingType)));

  129.         var classifications = Stream.of(NotificationChannel.values()).map(TargetClassification::new).collect(toList());

  131.         targetAudits.forEach(ta -> {
  132.             Notification notification = ta.getNotification();
  133.             UUID targetId = ta.getTargetId();

  135.             var notificationTypeForTarget = targetTypes.get(targetId);
  136.             var silent = notificationTypeForTarget != notification.getType();

  138.             filter(classifications, c -> c.matches(notification.getChannels()))
  139.                     .forEach(c -> c.add(new Target(targetId, ta.getAudits(), silent)));
  140.         });

  142.         return classifications.stream()
  143.                 .filter(c -> c.getTargets().stream().anyMatch(t -> !t.isSilent()))
  144.                 .map(classification ->
  145.                         NotificationTask.builder()
  146.                                 .ident(ident)
  147.                                 .time(time)
  148.                                 .channel(classification.getChannel())
  149.                                 .targets(convertAuditTargets(ident, classification.getTargets()))
  150.                                 .build()
  151.                 )
  152.                 .collect(toList());
  153.     }

  155.     private List<AuditTarget> convertAuditTargets(String ident, List<Target> targets) {
  156.         return convert(targets, target -> {
  157.             var targetId = target.getTarget();
  158.             var audits = target.getAudits();
  159.             AuditMetadata oldestAudit;
  160.             UUID prev;
  161.             UUID curr;
  162.             if (audits.isEmpty()) {
  163.                 // If the target in question has not actually changed, ie. a team added/removed in a product area
  164.                 oldestAudit = auditVersionRepository.lastAuditForObject(targetId);
  165.                 prev = oldestAudit.getId();
  166.                 curr = oldestAudit.getId();
  167.             } else {
  168.                 oldestAudit = audits.get(0);
  169.                 var newestAudit = audits.get(audits.size() - 1);
  170.                 prev = getPreviousFor(oldestAudit);
  171.                 curr = newestAudit.getAction() == Action.DELETE ? null : newestAudit.getId();
  172.             }
  173.             if (prev == null && curr == null) {
  174.                 log.info("Create and delete target {}, ignoring", targetId);
  175.                 return null;
  176.             }
  177.             var tableName = oldestAudit.getTableName();
  178.             log.info("Notification to {} target {}: {} from {} to {}", ident, tableName, targetId, prev, curr);
  179.             return AuditTarget.builder()
  180.                     .targetId(targetId)
  181.                     .type(tableName)
  182.                     .prevAuditId(prev)
  183.                     .currAuditId(curr)
  184.                     .silent(target.isSilent())
  185.                     .build();
  186.         });
  187.     }

  189.     private UUID getPreviousFor(AuditMetadata oldestAudit) {
  190.         if (oldestAudit.getAction() == Action.CREATE) {
  191.             return null;
  192.         }
  193.         return UUID.fromString(auditVersionRepository.getPreviousAuditIdFor(oldestAudit.getId()));
  194.     }

  196.     @Value
  197.     static class NotificationTargetAudits {

  199.         Notification notification;
  200.         UUID targetId;
  201.         List<AuditMetadata> audits;
  202.     }

  204.     @Value
  205.     static class TargetClassification {

  207.         NotificationChannel channel;
  208.         List<Target> targets = new ArrayList<>();
  209.         Set<UUID> targetsAdded = new HashSet<>();

  211.         TargetClassification(NotificationChannel channel) {
  212.             this.channel = channel;
  213.         }

  215.         boolean isAdded(UUID targetId) {
  216.             return targetsAdded.contains(targetId);
  217.         }

  219.         void add(Target target) {
  220.             if (isAdded(target.getTarget())) {
  221.                 if (!target.isSilent()) {
  222.                     var existingTarget = find(targets, t -> t.getTarget().equals(target.getTarget()));
  223.                     if (existingTarget.isSilent()) {
  224.                         targets.remove(existingTarget);
  225.                         targets.add(target);
  226.                     }
  227.                 }
  228.             } else {
  229.                 targetsAdded.add(target.getTarget());
  230.                 targets.add(target);
  231.             }
  232.         }

  234.         boolean matches(List<NotificationChannel> channels) {
  235.             return channels.contains(channel);
  236.         }
  237.     }

  239.     @Value
  240.     static class Target {

  242.         UUID target;
  243.         List<AuditMetadata> audits;
  244.         boolean silent;
  245.     }
  246. }
Created with JaCoCo 0.8.12.202403310830