NotificationService.java

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

  3. import com.github.benmanes.caffeine.cache.Cache;
  4. import com.github.benmanes.caffeine.cache.Caffeine;
  5. import lombok.RequiredArgsConstructor;
  6. import lombok.extern.slf4j.Slf4j;
  7. import no.nav.data.common.auditing.domain.AuditVersionRepository;
  8. import no.nav.data.common.exceptions.NotFoundException;
  9. import no.nav.data.common.exceptions.ValidationException;
  10. import no.nav.data.common.mail.EmailService;
  11. import no.nav.data.common.mail.MailTask;
  12. import no.nav.data.common.security.SecurityUtils;
  13. import no.nav.data.common.storage.StorageService;
  14. import no.nav.data.common.utils.MetricUtils;
  15. import no.nav.data.team.contact.domain.ContactAddress;
  16. import no.nav.data.team.contact.domain.ContactMessage;
  17. import no.nav.data.team.integration.slack.SlackClient;
  18. import no.nav.data.team.notify.domain.GenericNotificationTask.InactiveMembers;
  19. import no.nav.data.team.notify.domain.Notification;
  20. import no.nav.data.team.notify.domain.Notification.NotificationChannel;
  21. import no.nav.data.team.notify.domain.Notification.NotificationTime;
  22. import no.nav.data.team.notify.domain.Notification.NotificationType;
  23. import no.nav.data.team.notify.domain.NotificationTask;
  24. import no.nav.data.team.notify.dto.Changelog;
  25. import no.nav.data.team.notify.dto.MailModels.UpdateModel;
  26. import no.nav.data.team.notify.dto.NotificationDto;
  27. import no.nav.data.team.resource.NomClient;
  28. import no.nav.data.team.resource.domain.Resource;
  29. import no.nav.data.team.shared.Lang;
  30. import no.nav.data.team.shared.domain.Membered;
  31. import no.nav.data.team.team.domain.Team;
  32. import no.nav.data.team.team.domain.TeamRole;
  33. import org.apache.commons.lang3.NotImplementedException;
  34. import org.apache.commons.lang3.StringUtils;
  35. import org.springframework.stereotype.Service;
  36. import org.springframework.util.CollectionUtils;

  38. import java.time.Duration;
  39. import java.time.LocalDateTime;
  40. import java.time.Month;
  41. import java.util.List;
  42. import java.util.Objects;
  43. import java.util.UUID;
  44. import java.util.function.Function;
  45. import java.util.stream.Collectors;

  47. import static no.nav.data.common.utils.StreamUtils.convert;
  48. import static no.nav.data.common.utils.StreamUtils.safeStream;
  49. import static no.nav.data.common.utils.StreamUtils.tryFind;
  50. import static no.nav.data.team.contact.domain.Channel.EPOST;

  52. @Slf4j
  53. @Service
  54. @RequiredArgsConstructor
  55. public class NotificationService {

  57.     private final StorageService storage;
  58.     private final NomClient nomClient;
  59.     private final EmailService emailService;
  60.     private final TemplateService templateService;
  61.     private final SlackClient slackClient;
  62.     private final NotificationSlackMessageConverter notificationSlackMessageConverter;

  64.     private final AuditVersionRepository auditVersionRepository;
  65.     private final NotificationMessageGenerator messageGenerator;
  66.     private final AuditDiffService auditDiffService;
  67.     private final Cache<String, Changelog> changelogCache = MetricUtils.register("changelogCache",
  68.             Caffeine.newBuilder()
  69.                     .expireAfterWrite(Duration.ofMinutes(15))
  70.                     .maximumSize(500)
  71.                     .recordStats().build());

  73.     // changes before this date have non-backwards compatible formats
  74.     private static final LocalDateTime earliestChangelog = LocalDateTime.of(2020, Month.APRIL, 24, 0, 0);

  76.     public Notification save(NotificationDto dto) {
  77.         dto.validate();
  78.         SecurityUtils.assertIsUserOrAdmin(dto.getIdent(), "Cannot edit other users notifications");

  80.         if (nomClient.getByNavIdent(dto.getIdent()).isEmpty()) {
  81.             throw new ValidationException("Couldn't find user " + dto.getIdent());
  82.         }

  84.         return storage.save(new Notification(dto));
  85.     }

  87.     public Notification delete(UUID id) {
  88.         var notification = storage.get(id, Notification.class);
  89.         SecurityUtils.assertIsUserOrAdmin(notification.getIdent(), "Cannot delete other users notifications");
  90.         return storage.delete(id, Notification.class);
  91.     }

  93.     public void notifyTask(NotificationTask task) {
  94.         log.info("Sending notification for task {}", task);
  95.         var email = getEmailForIdent(task.getIdent());

  97.         var message = messageGenerator.updateSummary(task);
  98.         if (message.isEmpty()) {
  99.             log.info("Skipping task, end message is empty taskId {}", task.getId());
  100.             return;
  101.         }
  102.         if (task.getChannel() == NotificationChannel.EMAIL) {
  103.             sendUpdateMail(email, message.getModel(), message.getSubject());
  104.         } else if (task.getChannel() == NotificationChannel.SLACK) {
  105.             var blocks = notificationSlackMessageConverter.convertTeamUpdateModel(message.getModel());
  106.             try {
  107.                 slackClient.sendMessageToUser(email, message.getSubject(), blocks);
  108.             } catch (NotFoundException e) {
  109.                 sendUpdateMail(email, message.getModel(), message.getSubject() + " - Erstatning for slack melding. Klarte ikke finne din slack bruker.");
  110.             }
  111.         }
  112.     }

  114.     private void sendUpdateMail(String email, UpdateModel model, String subject) {
  115.         String body = templateService.teamUpdate(model);

  117.         emailService.sendMail(MailTask.builder().to(email).subject(subject).body(body).build());
  118.     }

  120.     public void nudge(Membered object) {
  121.         sendMessage(object, recipients -> messageGenerator.nudgeTime(object, recipients.role()));
  122.     }

  124.     public void inactive(InactiveMembers task) {
  125.         Membered object = storage.get(task.getId(), task.getType());
  126.         sendMessage(object, recipients -> messageGenerator.inactive(object, recipients.role(), task.getIdentsInactive()));
  127.     }

  129.     private void sendMessage(Membered membered, Function<Recipients, ContactMessage> messageGenerator) {
  130.         try {
  131.             var recipients = getRecipients(membered);
  132.             if (recipients.isEmpty()) {
  133.                 log.info("No recipients found for contact to {}: {}", membered.type(), membered.getName());
  134.                 return;
  135.             }
  136.             var contactMessage = messageGenerator.apply(recipients);
  137.             // TODO consider schedule slack messages async (like email) to guard against slack downtime
  138.             for (var recipient : recipients.addresses) {
  139.                 switch (recipient.getType()) {
  140.                     case EPOST -> emailService.scheduleMail(MailTask.builder().to(recipient.getAddress()).subject(contactMessage.getTitle()).body(contactMessage.toHtml()).build());
  141.                     case SLACK -> slackClient.sendMessageToChannel(recipient.getAddress(), contactMessage.getTitle(), contactMessage.toSlack());
  142.                     case SLACK_USER -> slackClient.sendMessageToUserId(recipient.getAddress(), contactMessage.getTitle(), contactMessage.toSlack());
  143.                     default -> throw new NotImplementedException("%s is not an implemented varsel type".formatted(recipient.getType()));
  144.                 }
  145.             }
  146.         } catch (Exception e) {
  147.             log.error("Failed to send message to %s %s".formatted(membered.type(), membered.getName()), e);
  148.             throw e;
  149.         }
  150.     }

  152.     private Recipients getRecipients(Membered object) {
  153.         if (object instanceof Team team) {
  154.             if (!CollectionUtils.isEmpty(team.getContactAddresses())) {
  155.                 return new Recipients("Kontaktadresse", team.getContactAddresses());
  156.             } else if (!StringUtils.isBlank(team.getContactPersonIdent())) {
  157.                 return new Recipients("Kontaktperson", List.of(new ContactAddress(getEmailForIdent(team.getContactPersonIdent()), EPOST)));
  158.             }
  159.         }
  160.         var role = TeamRole.LEAD;
  161.         List<String> emails = getEmails(object, role);
  162.         if (emails.isEmpty()) {
  163.             role = TeamRole.PRODUCT_OWNER;
  164.             emails = getEmails(object, role);
  165.         }
  166.         return new Recipients(Lang.roleName(role), convert(emails, e -> new ContactAddress(e, EPOST)));
  167.     }

  169.     private List<String> getEmails(Membered object, TeamRole role) {
  170.         return safeStream(object.getMembers())
  171.                 .filter(m -> m.getRoles().contains(role))
  172.                 .map(l -> {
  173.                     try {
  174.                         return getEmailForIdent(l.getNavIdent());
  175.                     } catch (MailNotFoundException e) {
  176.                         log.warn("email not found", e);
  177.                         return null;
  178.                     }
  179.                 })
  180.                 .filter(Objects::nonNull)
  181.                 .collect(Collectors.toList());
  182.     }

  184.     private String getEmailForIdent(String ident) {
  185.         return nomClient.getByNavIdent(ident)
  186.                 .map(Resource::getEmail)
  187.                 .orElseThrow(() -> new MailNotFoundException("Can't find email for " + ident));
  188.     }

  190.     public String changelogMail(NotificationType type, UUID targetId, LocalDateTime start, LocalDateTime end) {
  191.         var model = changelog(type, targetId, start, end);
  192.         if (model == null) {
  193.             return "empty";
  194.         }
  195.         log.info("new {} removes {} updates {}", model.getCreated(), model.getDeleted(), model.getUpdated());
  196.         return templateService.teamUpdate(model);
  197.     }

  199.     public Changelog changelogJson(NotificationType type, UUID targetId, LocalDateTime start, LocalDateTime end) {
  200.         return changelogCache.get("" + type + targetId + start + end, k -> Changelog.from(changelog(type, targetId, start, end)));
  201.     }

  203.     private UpdateModel changelog(NotificationType type, UUID targetId, LocalDateTime start, LocalDateTime end) {
  204.         var notifications = List.of(Notification.builder()
  205.                 .channels(List.of(NotificationChannel.EMAIL))
  206.                 .target(targetId)
  207.                 .type(type)
  208.                 .ident("MANUAL")
  209.                 .time(NotificationTime.ALL)
  210.                 .build());
  211.         start = start.isBefore(earliestChangelog) ? earliestChangelog : start;
  212.         var audits = auditVersionRepository.findByTimeBetween(start, end);
  213.         var tasks = auditDiffService.createTask(audits, notifications);
  214.         var task = tryFind(tasks, t -> t.getChannel() == NotificationChannel.EMAIL);
  215.         if (task.isEmpty() || task.get().getTargets().isEmpty()) {
  216.             return null;
  217.         }
  218.         return messageGenerator.updateSummary(task.get()).getModel();
  219.     }

  221.     record Recipients(String role, List<ContactAddress> addresses) {

  223.         boolean isEmpty() {
  224.             return addresses.isEmpty();
  225.         }

  227.     }
  228. }
Created with JaCoCo 0.8.12.202403310830