fab-approval-worker-service/FabApprovalWorkerService/Workers/ApprovalNotificationWorker.cs

using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;

using Infineon.Monitoring.MonA;

using Quartz;

using System.Net.Mail;
using System.Text;

namespace FabApprovalWorkerService.Workers;

public class ApprovalNotificationWorker : IJob {
    private readonly ILogger<ApprovalNotificationWorker> _logger;
    private readonly IApprovalService _approvalService;
    private readonly IECNService _ecnService;
    private readonly ICorrectiveActionService _caService;
    private readonly IMRBService _mrbService;
    private readonly IPCRBService _pcrbService;
    private readonly ISmtpService _smtpService;
    private readonly IMonInClient _monInClient;
    private readonly IUserService _userService;
    private readonly string _oldFabApprovalBaseUrl;
    private readonly string _newFabApprovalBaseUrl;

    public ApprovalNotificationWorker(ILogger<ApprovalNotificationWorker> logger,
                                      IApprovalService approvalService,
                                      IECNService ecnService,
                                      ICorrectiveActionService caService,
                                      IMRBService mrbService,
                                      IPCRBService pcrbService,
                                      ISmtpService smtpService,
                                      IMonInClient monInClient,
                                      IUserService userService) {
        _logger = logger ?? throw new ArgumentNullException("ILogger not injected");
        _approvalService = approvalService ?? throw new ArgumentNullException("IApprovalService not injected");
        _ecnService = ecnService ?? throw new ArgumentNullException("IECNService not injected");
        _caService = caService ?? throw new ArgumentNullException("ICorrectiveActionService not injected");
        _mrbService = mrbService ?? throw new ArgumentNullException("IMRBService not injected");
        _pcrbService = pcrbService ?? throw new ArgumentNullException("IPCRBService not injected");
        _smtpService = smtpService ?? throw new ArgumentNullException("ISmtpService not injected");
        _monInClient = monInClient ?? throw new ArgumentNullException("IMonInClient not injected");
        _userService = userService ?? throw new ArgumentNullException("IUserService not injected");
        _oldFabApprovalBaseUrl = Environment.GetEnvironmentVariable("OldFabApprovalUrl") ??
            throw new ArgumentNullException("OldFabApprovalUrl environment variable not found");
        _newFabApprovalBaseUrl = Environment.GetEnvironmentVariable("NewFabApprovalBaseUrl") ??
            throw new ArgumentNullException("NewFabApprovalBaseUrl environment variable not found");
    }

    public async Task Execute(IJobExecutionContext context) {
        DateTime start = DateTime.Now;
        bool isInternalError = false;
        StringBuilder errorMessage = new();
        string metricName = "ApprovalNotificationWorker";

        try {
            _logger.LogInformation("Attempting to notify approvers of outstanding approvals");

            IEnumerable<Approval> approvals = await _approvalService.GetActiveApprovalsWithNotificationOlderThanFiveDays();

            HashSet<string> issueAndUserIds = new();

            foreach (Approval approval in approvals) {
                bool isEcn = false;
                bool isCa = false;
                bool isMrb = false;
                bool isPcrb = false;

                string approvalType = string.Empty;

                string title = string.Empty;

                string url = string.Empty;

                if (await _ecnService.ECNNumberIsActive(approval.IssueID)) {
                    isEcn = true;
                    approvalType = "ECN";

                    ECN ecn = await _ecnService.GetEcnByNumber(approval.IssueID);
                    title = ecn.Title;

                    url = $"{_oldFabApprovalBaseUrl}/ECN/Edit?IssueID={approval.IssueID}";
                } else if (await _caService.CANumberIsActive(approval.IssueID)) {
                    isCa = true;
                    approvalType = "Corrective Action";

                    CorrectiveAction ca = await _caService.GetCorrectiveActionById(approval.IssueID);
                    title = ca.CATitle;

                    url = $"{_oldFabApprovalBaseUrl}/CorrectiveAction/Edit?IssueID={approval.IssueID}";
                } else if (await _mrbService.MRBNumberIsActive(approval.IssueID)) {
                    isMrb = true;
                    approvalType = "MRB";

                    MRB mrb = await _mrbService.GetMRBById(approval.IssueID);
                    title = mrb.Title;

                    url = $"{_newFabApprovalBaseUrl}/redirect?redirectPath=mrb/{approval.IssueID}";
                } else if (await _pcrbService.PCRBNumberIsActive(approval.IssueID)) {
                    isPcrb = true;
                    approvalType = "PCRB";

                    PCRB pcrb = await _pcrbService.GetPCRBByPlanNumber(approval.IssueID);
                    title = pcrb.Title;

                    url = $"{_newFabApprovalBaseUrl}/redirect?redirectPath=pcrb/{approval.IssueID}";
                }

                /*if (approval.AssignedDate < DateTimeOffset.Now.AddDays(-150)) {
                    approval.CompletedDate = DateTime.Now;
                    approval.ItemStatus = 1;

                    await _approvalService.UpdateApproval(approval);
                }*/

                if (issueAndUserIds.Contains($"{approval.IssueID}{approval.UserID}")) {
                    approval.NotifyDate = DateTime.Now;
                    await _approvalService.UpdateApproval(approval);
                } else if ((isEcn || isCa || isMrb || isPcrb) && 
                    !string.IsNullOrWhiteSpace(title) && 
                    !string.IsNullOrWhiteSpace(url) &&
                    !issueAndUserIds.Contains($"{approval.IssueID}{approval.UserID}")) {

                    User user = await _userService.GetUserById(approval.UserID);

                    IEnumerable<MailAddress> recipients = new List<MailAddress>() {
                        new MailAddress(user.Email)
                    };

                    IEnumerable<MailAddress> ccRecipients = new List<MailAddress>();

                    StringBuilder bodyBuilder = new();
                    bodyBuilder.Append($"*** Please DO NOT reply to this email ***");
                    bodyBuilder.Append("<br/><br/>This is a reminder that you have an approval waiting for you to review.");
                    bodyBuilder.Append("<br/><br/>Please log on to the Mesa Approval website to view the assignment and act accordingly. ");
                    bodyBuilder.Append($"<br/><br/>Document Type: {approvalType}");
                    bodyBuilder.Append($"<br/>Title: {title}");
                    bodyBuilder.Append($"<br/></br><a href='{url}'>{url}</a>");
                    bodyBuilder.Append($"<br/><br/>If you have any questions or trouble logging on please contact a site administrator.");
                    bodyBuilder.Append($"<br/><br/>Thank you!");

                    string subject = $"{approvalType} Approval Reminder: {title}";

                    await _smtpService.SendEmail(recipients, ccRecipients, subject, bodyBuilder.ToString());

                    approval.NotifyDate = DateTime.Now;
                    await _approvalService.UpdateApproval(approval);

                    issueAndUserIds.Add($"{approval.IssueID}{approval.UserID}");
                }
            }
        } catch (Exception ex) {
            StringBuilder errMsgBuilder = new();
            errMsgBuilder.Append("An exception occurred when attempting to create follow up approvals for ");
            errMsgBuilder.Append($"CAs needing it in five days. Exception: {ex.Message}");
            _logger.LogError(errMsgBuilder.ToString());
            isInternalError = true;
        } finally {
            DateTime end = DateTime.Now;
            double latencyInMS = (end - start).TotalMilliseconds;
            _monInClient.PostMetric(metricName + "Latency", latencyInMS);

            if (isInternalError) {
                _monInClient.PostStatus(metricName, State.Critical);
            } else {
                _monInClient.PostStatus(metricName, State.Ok);
            }
        }
    }
}