Refactoring of email messaging infrastructure (#6505)

Author: xavierdecoster

src/NuGetGallery.Core/Authentication/CredentialTypeInfo.cs

@@ -0,0 +1,19 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace NuGetGallery.Authentication
+{
+    public class CredentialTypeInfo
+    {
+        public CredentialTypeInfo(string type, bool isApiKey, string description)
+        {
+            Type = type;
+            IsApiKey = isApiKey;
+            Description = description;
+        }
+
+        public string Type { get; }
+        public bool IsApiKey { get; }
+        public string Description { get; }
+    }
+}

src/NuGetGallery.Core/Infrastructure/mail/ConfirmationEmailBuilder.cs

@@ -0,0 +1,32 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Net.Mail;
+
+namespace NuGetGallery.Infrastructure.Mail
+{
+    public abstract class ConfirmationEmailBuilder : MarkdownEmailBuilder
+    {
+        protected readonly IMessageServiceConfiguration Configuration;
+        protected readonly string RawConfirmationUrl;
+        protected readonly bool IsOrganization;
+
+        protected ConfirmationEmailBuilder(
+            IMessageServiceConfiguration configuration,
+            User user,
+            string confirmationUrl)
+        {
+            Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
+            User = user ?? throw new ArgumentNullException(nameof(user));
+            IsOrganization = user is Organization;
+            RawConfirmationUrl = confirmationUrl ?? throw new ArgumentNullException(nameof(confirmationUrl));
+            ConfirmationUrl = EscapeLinkForMarkdown(confirmationUrl);
+        }
+
+        public override MailAddress Sender => Configuration.GalleryNoReplyAddress;
+
+        public User User { get; }
+        public string ConfirmationUrl { get; }
+    }
+}

src/NuGetGallery.Core/Infrastructure/mail/CoreMarkdownMessageService.cs

@@ -0,0 +1,143 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.Linq;
+using System.Net.Mail;
+using System.Threading.Tasks;
+using AnglicanGeek.MarkdownMailer;
+
+namespace NuGetGallery.Infrastructure.Mail
+{
+    public class CoreMarkdownMessageService : IMessageService
+    {
+        private static readonly ReadOnlyCollection<TimeSpan> RetryDelays = Array.AsReadOnly(new[] {
+            TimeSpan.FromSeconds(0.1),
+            TimeSpan.FromSeconds(1),
+            TimeSpan.FromSeconds(10)
+        });
+
+        public CoreMarkdownMessageService(
+            IMailSender mailSender,
+            IMessageServiceConfiguration configuration)
+        {
+            MailSender = mailSender ?? throw new ArgumentNullException(nameof(mailSender));
+            Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
+        }
+
+        public IMailSender MailSender { get; protected set; }
+        public IMessageServiceConfiguration Configuration { get; protected set; }
+
+        public async Task SendMessageAsync(IEmailBuilder emailBuilder, bool copySender = false, bool discloseSenderAddress = false)
+        {
+            if (emailBuilder == null)
+            {
+                throw new ArgumentNullException(nameof(emailBuilder));
+            }
+
+            using (var email = CreateMailMessage(emailBuilder))
+            {
+                await SendMessageInternalAsync(email, copySender, discloseSenderAddress);
+            }
+        }
+
+        protected virtual async Task SendMessageInternalAsync(MailMessage mailMessage, bool copySender = false, bool discloseSenderAddress = false)
+        {
+            if (!mailMessage.To.Any())
+            {
+                return;
+            }
+
+            var attempt = 0;
+            var success = false;
+            while (!success)
+            {
+                try
+                {
+                    await AttemptSendMessageAsync(mailMessage, attempt + 1);
+                    success = true;
+                }
+                catch (SmtpException)
+                {
+                    if (attempt < RetryDelays.Count)
+                    {
+                        await Task.Delay(RetryDelays[attempt]);
+                        attempt++;
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+
+            if (copySender && !discloseSenderAddress)
+            {
+                await SendMessageToSenderAsync(mailMessage);
+            }
+        }
+
+        protected virtual Task AttemptSendMessageAsync(MailMessage mailMessage, int attemptNumber)
+        {
+            // AnglicanGeek.MarkdownMailer doesn't have an async overload
+            MailSender.Send(mailMessage);
+            return Task.CompletedTask;
+        }
+
+        protected static MailMessage CreateMailMessage(IEmailBuilder emailBuilder)
+        {
+            if (emailBuilder == null)
+            {
+                throw new ArgumentNullException(nameof(emailBuilder));
+            }
+
+            var mailMessage = new MailMessage();
+            mailMessage.From = emailBuilder.Sender;
+            mailMessage.Subject = emailBuilder.GetSubject();
+            mailMessage.Body = emailBuilder.GetBody(EmailFormat.Markdown);
+
+            var recipients = emailBuilder.GetRecipients();
+            foreach (var toAddress in recipients.To)
+            {
+                mailMessage.To.Add(toAddress);
+            }
+
+            foreach (var ccAddress in recipients.CC)
+            {
+                mailMessage.CC.Add(ccAddress);
+            }
+
+            foreach (var bccAddress in recipients.Bcc)
+            {
+                mailMessage.Bcc.Add(bccAddress);
+            }
+
+            foreach (var replyToAddress in recipients.ReplyTo)
+            {
+                mailMessage.ReplyToList.Add(replyToAddress);
+            }
+
+            return mailMessage;
+        }
+
+        private async Task SendMessageToSenderAsync(MailMessage mailMessage)
+        {
+            using (var senderCopy = new MailMessage(
+                Configuration.GalleryOwner,
+                mailMessage.ReplyToList.First()))
+            {
+                senderCopy.Subject = mailMessage.Subject + " [Sender Copy]";
+                senderCopy.Body = string.Format(
+                        CultureInfo.CurrentCulture,
+                        "You sent the following message via {0}: {1}{1}{2}",
+                        Configuration.GalleryOwner.DisplayName,
+                        Environment.NewLine,
+                        mailMessage.Body);
+                senderCopy.ReplyToList.Add(mailMessage.ReplyToList.First());
+                await SendMessageInternalAsync(senderCopy);
+            }
+        }
+    }
+}

src/NuGetGallery.Core/Infrastructure/mail/EmailBuilder.cs

@@ -0,0 +1,53 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Net.Mail;
+using System.Web;
+
+namespace NuGetGallery.Infrastructure.Mail
+{
+    /// <summary>
+    /// Abstract base class for building email messages.
+    /// </summary>
+    public abstract class EmailBuilder : IEmailBuilder
+    {
+        public abstract MailAddress Sender { get; }
+
+        public string GetBody(EmailFormat format)
+        {
+            switch (format)
+            {
+                case EmailFormat.PlainText:
+                    return GetPlainTextBody();
+                case EmailFormat.Markdown:
+                    return GetMarkdownBody();
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(format));
+            }
+        }
+
+        public abstract IEmailRecipients GetRecipients();
+
+        public abstract string GetSubject();
+
+        protected abstract string GetPlainTextBody();
+        protected abstract string GetMarkdownBody();
+
+        /// <summary>
+        /// Markdown sees the underscore as italics indicator, so underscores are stripped in the message.
+        /// This prevents cut and pasting of the address or the use of text only email readers.
+        /// </summary>
+        /// <param name="encodedUrl">The encoded Url</param>
+        /// <returns>Returns a Markdown-friendly url by escaping underscore characters.</returns>
+        protected string EscapeLinkForMarkdown(string encodedUrl)
+        {
+            if (encodedUrl == null)
+            {
+                throw new ArgumentNullException(nameof(encodedUrl));
+            }
+
+            return HttpUtility.UrlDecode(encodedUrl).Replace("_", "\\_");
+        }
+    }
+}

src/NuGetGallery.Core/Infrastructure/mail/EmailFormat.cs

@@ -0,0 +1,23 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace NuGetGallery.Infrastructure.Mail
+{
+    /// <summary>
+    /// Defines the formatting to be used by <see cref="EmailBuilder"/> for creating email messages.
+    /// </summary>
+    public enum EmailFormat
+    {
+        /// <summary>
+        /// Indicates that <see cref="EmailBuilder"/> will create plain-text email messages, without markup. 
+        /// Used as a fallback by email clients that don't support other formats.
+        /// </summary>
+        PlainText,
+
+        /// <summary>
+        /// Indicates that <see cref="EmailBuilder"/> will create email messages using Markdown formatting,
+        /// which will be rendered as HTML by email clients.
+        /// </summary>
+        Markdown
+    }
+}

src/NuGetGallery.Core/Infrastructure/mail/EmailRecipients.cs

@@ -0,0 +1,71 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Mail;
+
+namespace NuGetGallery.Infrastructure.Mail
+{
+    public class EmailRecipients : IEmailRecipients
+    {
+        public EmailRecipients(
+            IReadOnlyList<MailAddress> to,
+            IReadOnlyList<MailAddress> cc = null,
+            IReadOnlyList<MailAddress> bcc = null,
+            IReadOnlyList<MailAddress> replyTo = null)
+        {
+            To = to ?? throw new ArgumentNullException(nameof(to));
+            CC = cc ?? new List<MailAddress>();
+            Bcc = bcc ?? new List<MailAddress>();
+            ReplyTo = replyTo ?? new List<MailAddress>();
+        }
+
+        public static IEmailRecipients None = new EmailRecipients(to: Array.Empty<MailAddress>());
+
+        public IReadOnlyList<MailAddress> To { get; }
+
+        public IReadOnlyList<MailAddress> CC { get; }
+
+        public IReadOnlyList<MailAddress> Bcc { get; }
+
+        public IReadOnlyList<MailAddress> ReplyTo { get; }
+
+        public static IReadOnlyList<MailAddress> GetAllOwners(PackageRegistration packageRegistration, bool requireEmailAllowed)
+        {
+            if (packageRegistration == null)
+            {
+                throw new ArgumentNullException(nameof(packageRegistration));
+            }
+
+            var recipients = new List<MailAddress>();
+            var owners = requireEmailAllowed 
+                ? packageRegistration.Owners.Where(o => o.EmailAllowed) 
+                : packageRegistration.Owners;
+
+            foreach (var owner in owners)
+            {
+                recipients.Add(owner.ToMailAddress());
+            }
+
+            return recipients;
+        }
+
+        public static IReadOnlyList<MailAddress> GetOwnersSubscribedToPackagePushedNotification(PackageRegistration packageRegistration)
+        {
+            if (packageRegistration == null)
+            {
+                throw new ArgumentNullException(nameof(packageRegistration));
+            }
+
+            var recipients = new List<MailAddress>();
+            foreach (var owner in packageRegistration.Owners.Where(o => o.NotifyPackagePushed))
+            {
+                recipients.Add(owner.ToMailAddress());
+            }
+
+            return recipients;
+        }
+    }
+}

src/NuGetGallery.Core/Infrastructure/mail/IEmailBuilder.cs

@@ -0,0 +1,34 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Net.Mail;
+
+namespace NuGetGallery.Infrastructure.Mail
+{
+    /// <summary>
+    /// Represents an email message builder.
+    /// </summary>
+    public interface IEmailBuilder
+    {
+        /// <summary>
+        /// The sender of the email message.
+        /// </summary>
+        MailAddress Sender { get; }
+
+        /// <summary>
+        /// Retrieve the email message body in the requested <paramref name="format"/>.
+        /// </summary>
+        /// <param name="format">The requested markup format for the email body.</param>
+        string GetBody(EmailFormat format);
+
+        /// <summary>
+        /// Gets the email message subject.
+        /// </summary>
+        string GetSubject();
+
+        /// <summary>
+        /// Gets the email recipients.
+        /// </summary>
+        IEmailRecipients GetRecipients();
+    }
+}