Implemented Email and Hash Service

2026-08-20 16:14:35 +02:00
parent 7415a53ee2
commit 8fb4aac0c1
13 changed files with 452 additions and 0 deletions
@@ -0,0 +1,3 @@
+namespace PostFundManagement.Domain.Abstractions;
+
+public interface IService;
@@ -0,0 +1,10 @@
+namespace PostFundManagement.Domain.Configuration.Hash;
+
+public sealed class HasherSettings
+{
+    public string? Salt { get; set; }
+
+    public int MinHashLength { get; set; }
+
+    public string? PayfastPassphrase { get; set; }
+}
@@ -1,5 +1,17 @@
 namespace PostFundManagement.Domain;

+public enum EmailStatuses : int
+{
+    GeneralError = 0,
+    AuthenticationError = 1,
+    ProtocolError = 2,
+    Connected = 3,
+    Disconnected = 4,
+    TooManyConnections = 5,
+    ConnectionAborted = 6,
+    Success = 7
+}
+
 public enum NotificationStatus : int
 {
    Pending = 1,
@@ -0,0 +1,12 @@
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+
+namespace PostFundManagement.Domain.Extensions;
+
+public static class EmailTelemetry
+{
+    public static readonly ActivitySource Source = new("LiteCharms.EmailService");
+    public static readonly Meter Meter = new("LiteCharms.EmailService");
+    public static readonly Counter<long> EmailsSent = Meter.CreateCounter<long>("emails_sent_total", "count", "Total successful emails sent");
+    public static readonly Counter<long> EmailsFailed = Meter.CreateCounter<long>("emails_failed_total", "count", "Total failed email attempts");
+}
@@ -0,0 +1,23 @@
+using PostFundManagement.Domain.Configuration.Hash;
+using PostFundManagement.Domain.Services;
+
+namespace PostFundManagement.Domain.Extensions;
+
+public static class Hash
+{
+    public const string HasherConfigSectionName = "HasherSettings";
+
+    public static IServiceCollection AddHashServices(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.Configure<HasherSettings>(configuration.GetSection(HasherConfigSectionName));
+
+        var settings = configuration.GetSection(HasherConfigSectionName).Get<HasherSettings>();
+
+        services.AddSingleton<IHashids>(_ =>
+            new Hashids(settings!.Salt, minHashLength: settings.MinHashLength));
+
+        services.AddSingleton<HashService>();
+
+        return services;
+    }    
+}
@@ -0,0 +1,8 @@
+namespace PostFundManagement.Domain.Models.Email;
+
+public sealed class Attachment
+{
+    public string? Name { get; set; }
+
+    public Stream? FileStream { get; set; }
+}
@@ -0,0 +1,26 @@
+namespace PostFundManagement.Domain.Models.Email;
+
+public sealed class Body : IDisposable
+{
+    public string? Message { get; set; }
+
+    public ReadOnlyCollection<Attachment>? Attachments { get; set; }
+
+    public BodyProperties Properties { get; set; } = new();
+
+    public void Dispose()
+    {
+        if (Attachments is null) return;
+
+        foreach (var attachment in Attachments!)
+        {
+            if (attachment is not null)
+            {
+                attachment.FileStream!.Close();
+                attachment.FileStream!.Dispose();
+            }
+        }
+
+        GC.SuppressFinalize(this);
+    }
+}
@@ -0,0 +1,8 @@
+namespace PostFundManagement.Domain.Models.Email;
+
+public sealed class BodyProperties
+{
+    public bool IsHtml { get; set; }
+
+    public bool HasAttachments { get; set; }
+}
@@ -0,0 +1,19 @@
+namespace PostFundManagement.Domain.Models.Email;
+
+public sealed class Message : IDisposable
+{
+    public Party? Sender { get; set; }
+
+    public Party? Recipient { get; set; }
+
+    public string? Subject { get; set; }
+
+    public Body? Body { get; set; }
+
+    public void Dispose()
+    {
+        Body?.Dispose();
+
+        GC.SuppressFinalize(this);
+    }
+}
@@ -0,0 +1,8 @@
+namespace PostFundManagement.Domain.Models.Email;
+
+public sealed class Party
+{
+    public string? Name { get; set; }
+
+    public string? Address { get; set; }
+}
@@ -0,0 +1,20 @@
+namespace PostFundManagement.Domain.Models.Email;
+
+public sealed class Response
+{
+    public int Code { get; set; }
+
+    public string? Error { get; set; }
+
+    public EmailStatuses Status { get; set; }
+
+    private Response(EmailStatuses status, int code = 0, string? error = null)
+    {
+        Status = status;
+        Code = code;
+        Error = error;
+    }
+
+    public static Response Create(EmailStatuses status, int code = 0, string? error = null) =>
+        new(status, code, error);
+}
@@ -0,0 +1,214 @@
+using System.Diagnostics;
+using PostFundManagement.Domain.Configuration.Email;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Models.Email;
+using static PostFundManagement.Domain.Extensions.EmailTelemetry;
+
+namespace PostFundManagement.Domain.Services;
+
+public sealed class EmailService(IOptions<SmtpSettings> options) : IDisposable
+{
+    private readonly SmtpSettings settings = options.Value;
+
+    private readonly SmtpClient client = new();
+
+    private readonly int sendMaxCount = 10;
+
+    private int sendCount = 0;
+
+    public EmailStatuses Status { get; private set; } = EmailStatuses.Disconnected;
+
+    public async ValueTask<Result<Response>> SendEmailAsync(Message message, CancellationToken cancellationToken = default)
+    {
+        using var activity = EmailTelemetry.Source.StartActivity("Email Send");
+
+        activity?.SetTag("email.recipient", message.Recipient?.Address);
+
+        try
+        {
+            if (Status != EmailStatuses.Connected)
+            {
+                activity?.SetStatus(ActivityStatusCode.Error, "Disconnected");
+
+                return Result.Fail<Response>("Smtp service is disconnected.");
+            }
+
+            var email = ConstructEmail(message, cancellationToken);
+
+            var response = await client.SendAsync(email, cancellationToken);
+
+            bool emailSent = response.Contains("OK", StringComparison.InvariantCultureIgnoreCase);
+
+            message.Dispose();
+
+            Interlocked.Increment(ref sendCount);
+
+            if (sendCount % sendMaxCount == 0)
+            {
+                using var delayActivity = EmailTelemetry.Source.StartActivity("Rate Limit Pause");
+
+                sendCount = 0;
+
+                await Task.Delay(1000, cancellationToken);
+            }
+
+            if (emailSent)
+            {
+                EmailTelemetry.EmailsSent.Add(1, new TagList { { "host", settings.Host } });
+
+                return Result.Ok(Response.Create(EmailStatuses.Success));
+            }
+
+            await DisconnectAsync(cancellationToken);
+
+            var failCheckResult = HandleNegativeResponse(response);
+
+            if (failCheckResult.IsFailed) return failCheckResult;
+
+            Status = EmailStatuses.Disconnected;
+
+            return Result.Fail<Response>("General error, disconnected");
+        }
+        catch (Exception ex)
+        {
+            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
+            activity?.AddException(ex);
+
+            EmailTelemetry.EmailsFailed.Add(1, new TagList { { "exception", ex.GetType().Name } });
+
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    private static MimeMessage ConstructEmail(Message message, CancellationToken cancellationToken)
+    {
+        var email = new MimeMessage();
+        email.From.Add(new MailboxAddress(message.Sender!.Name, message.Sender.Address!));
+        email.To.Add(new MailboxAddress(message.Recipient!.Name, message.Recipient!.Address!));
+        email.Subject = message.Subject!;
+
+        var bodyBuilder = new BodyBuilder();
+
+        if (message.Body!.Properties.HasAttachments)
+            foreach (var attachment in message.Body?.Attachments!)
+                bodyBuilder.Attachments.Add(attachment.Name!, attachment.FileStream!, cancellationToken);
+
+        if (!message.Body.Properties.IsHtml) bodyBuilder.TextBody = message.Body.Message;
+        if (message.Body.Properties.IsHtml) bodyBuilder.HtmlBody = message.Body.Message;
+
+        email.Body = bodyBuilder.ToMessageBody();
+
+        return email;
+    }
+
+    private Result<Response> HandleNegativeResponse(string response)
+    {
+        if (response.Contains("421", StringComparison.Ordinal))
+        {
+            Status = EmailStatuses.TooManyConnections;
+
+            return Result.Fail<Response>(response);
+        }
+
+        if (response.Contains("451", StringComparison.Ordinal))
+        {
+            Status = EmailStatuses.ConnectionAborted;
+
+            return Result.Fail<Response>(response);
+        }
+
+        EmailTelemetry.EmailsFailed.Add(1, new TagList { { "error_message", response } });
+
+        return Result.Fail<Response>(response);
+    }
+
+    public async ValueTask<Result<Response>> ConnectAsync(CancellationToken cancellationToken = default)
+    {
+        using var activity = EmailTelemetry.Source.StartActivity("Email Connect");
+        activity?.SetTag("email.smtp.connect", settings.Host);
+
+        try
+        {
+            if (Status is EmailStatuses.Connected) return Result.Ok(Response.Create(Status));
+
+            await client.ConnectAsync(settings.Host!, settings.Port, settings.UseSsl, cancellationToken);
+            await client.AuthenticateAsync(settings.Credentials!.Username!, settings.Credentials.Password!, cancellationToken);
+
+            Status = EmailStatuses.Connected;
+
+            activity?.SetStatus(ActivityStatusCode.Ok, "Connected");
+
+            return Result.Ok(Response.Create(Status));
+        }
+        catch (MailKit.ProtocolException ex)
+        {
+            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
+            activity?.AddException(ex);
+
+            EmailTelemetry.EmailsFailed.Add(1, new TagList { { "exception", ex.GetType().Name } });
+
+            Status = EmailStatuses.ProtocolError;
+
+            return Result.Fail<Response>(new Error(ex.Message).CausedBy(ex));
+        }
+        catch (Exception ex) when (ex is MailKit.Security.SslHandshakeException || ex is MailKit.Security.AuthenticationException)
+        {
+            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
+            activity?.AddException(ex);
+
+            EmailTelemetry.EmailsFailed.Add(1, new TagList { { "exception", ex.GetType().Name } });
+
+            Status = EmailStatuses.AuthenticationError;
+
+            return Result.Fail<Response>(new Error(ex.Message).CausedBy(ex));
+        }
+        catch (Exception ex)
+        {
+            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
+            activity?.AddException(ex);
+
+            EmailTelemetry.EmailsFailed.Add(1, new TagList { { "exception", ex.GetType().Name } });
+
+            Status = EmailStatuses.GeneralError;
+
+            return Result.Fail<Response>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> DisconnectAsync(CancellationToken cancellationToken = default)
+    {
+        using var activity = EmailTelemetry.Source.StartActivity("Email Disconnect");
+        activity?.SetTag("email.smtp.disconnect", settings.Host);
+
+        try
+        {
+            if (Status is EmailStatuses.Disconnected) return Result.Ok();
+
+            await client.DisconnectAsync(true, cancellationToken);
+
+            activity?.SetStatus(ActivityStatusCode.Ok, "Disconnected");
+
+            Status = EmailStatuses.Disconnected;
+
+            return Result.Ok();
+        }
+        catch (Exception ex)
+        {
+            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
+            activity?.AddException(ex);
+
+            EmailTelemetry.EmailsFailed.Add(1, new TagList { { "exception", ex.GetType().Name } });
+
+            Status = EmailStatuses.GeneralError;
+
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public void Dispose()
+    {
+        client.Dispose();
+
+        GC.SuppressFinalize(this);
+    }
+}
@@ -0,0 +1,89 @@
+using PostFundManagement.Domain.Abstractions;
+
+namespace PostFundManagement.Domain.Services;
+
+public sealed partial class HashService(IHashids hasher) : IService
+{
+    [GeneratedRegex(@"\A\b[0-9a-fA-F]+\b\Z", RegexOptions.None, matchTimeoutMilliseconds: 100)]
+    private static partial Regex HexHashRegex { get; }
+
+    [GeneratedRegex(@"\A[0-9a-fA-F]{32}\Z", RegexOptions.None, matchTimeoutMilliseconds: 100)]
+    private static partial Regex Md5Regex { get; }
+
+    [GeneratedRegex(@"\A[0-9a-fA-F]{64}\Z", RegexOptions.None, matchTimeoutMilliseconds: 100)]
+    private static partial Regex Sha256Regex { get; }
+
+    public static bool IsMd5Hash(string? value) =>
+        !string.IsNullOrWhiteSpace(value) && Md5Regex.IsMatch(value);
+
+    public static bool IsSha256Hash(string? value) =>
+        !string.IsNullOrWhiteSpace(value) && Sha256Regex.IsMatch(value);
+
+    public static string? StringToSha256Hash(string? input) =>
+        string.IsNullOrEmpty(input) ? null : Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(input)));
+
+    public static string? StreamToSha256Hash(Stream stream) =>
+        stream is null ? null : Convert.ToHexString(SHA256.HashData(stream));
+
+    public static string? BytesToSha256Hash(byte[] bytes) =>
+        bytes is null ? null : Convert.ToHexString(SHA256.HashData(bytes));
+
+    public static Result<string> ToMd5Hash(string input)
+    {
+        if (string.IsNullOrEmpty(input))
+            return Result.Fail<string>("Input content cannot be null or empty for MD5 processing.");
+
+        byte[] bytes = MD5.HashData(Encoding.UTF8.GetBytes(input));
+        return Result.Ok(Convert.ToHexString(bytes).ToLowerInvariant());
+    }
+
+    public Result<string> HashEncodeHex(string input) => string.IsNullOrWhiteSpace(input) || !HexHashRegex.IsMatch(input)
+            ? Result.Fail<string>("Input must be a valid hexadecimal string.")
+            : Result.Ok(hasher.EncodeHex(input));
+
+    public Result<string> HashEncodeIntId(int id) => id < 0
+        ? Result.Fail<string>("Id cannot be negative.")
+        : Result.Ok(hasher.Encode(id));
+
+    public Result<string> HashEncodeLongId(long id) => id < 0
+        ? Result.Fail<string>("Id cannot be negative.")
+        : Result.Ok(hasher.EncodeLong(id));
+
+    public Result<int> DecodeIntIdHash(string hash)
+    {
+        if (string.IsNullOrWhiteSpace(hash)) return Result.Fail<int>("Invalid token layout.");
+
+        int[] decoded = hasher.Decode(hash);
+
+        return decoded.Length == 1 ? Result.Ok(decoded[0]) : Result.Fail<int>("Invalid or modified Int hash token.");
+    }
+
+    public Result<long> DecodeLongIdHash(string hash)
+    {
+        if (string.IsNullOrWhiteSpace(hash)) return Result.Fail<long>("Invalid token layout.");
+
+        long[] decoded = hasher.DecodeLong(hash);
+
+        return decoded.Length == 1 ? Result.Ok(decoded[0]) : Result.Fail<long>("Invalid or modified Long hash token.");
+    }
+
+    public Result<string> DecodeHexHash(string hex)
+    {
+        try
+        {
+            string decoded = hasher.DecodeHex(hex);
+
+            return string.IsNullOrEmpty(decoded)
+                ? Result.Fail<string>("Invalid or corrupted hex hash.")
+                : Result.Ok(decoded);
+        }
+        catch (FormatException fex)
+        {
+            return Result.Fail<string>(new Error("Invalid hash structure.").CausedBy(fex));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<string>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}