Tast/ssad 93/create email microservice

Streetcode/Streetcode.BLL/DTO/Email/EmailDTO.cs

@@ -1,14 +1,18 @@
-using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations;
 
 namespace Streetcode.BLL.DTO.Email
 {
     public class EmailDTO
     {
+        public EmailDTO()
+        {
+        }
+
         [MaxLength(80)]
         public string From { get; set; }
 
         [Required]
         [StringLength(500, MinimumLength = 1)]
         public string Content { get; set; }
     }
-}
+}

Streetcode/Streetcode.Email.BLL/Configs/EmailConfiguration.cs

@@ -0,0 +1,14 @@
+namespace Streetcode.Email.BLL.Configs
+{
+    public class EmailConfiguration
+    {
+        public const string SectionName = "EmailConfiguration";
+
+        public string FromAddress { get; set; }
+        public string AdminAddress { get; set; }
+        public string SmtpServer { get; set; }
+        public int Port { get; set; }
+        public string SmtpUser { get; set; }
+        public string SmtpPassword { get; set; }
+    }
+}

Streetcode/Streetcode.Email.BLL/DTO/EmailDTO.cs

@@ -0,0 +1,11 @@
+namespace Streetcode.Email.BLL.DTO
+{
+    public class EmailDTO
+    {
+        public EmailDTO()
+        {
+        }
+        public string From { get; set; }
+        public string Content { get; set; }
+    }
+}

Streetcode/Streetcode.Email.BLL/Exceptions/ValidationException.cs

@@ -0,0 +1,29 @@
+using FluentValidation.Results;
+
+namespace Streetcode.Email.BLL.Exceptions
+{
+    public class ValidationException : Exception
+    {
+        public ValidationException() : base("One or more validation failures have occurred.")
+        {
+            Errors = new Dictionary<string, string[]>();
+        }
+
+        public ValidationException(IEnumerable<ValidationFailure> failures) : this()
+        {
+            Errors = failures
+                .GroupBy(e => e.PropertyName, e => e.ErrorMessage)
+                .ToDictionary(failureGroup => failureGroup.Key, failureGroup => failureGroup.ToArray());
+        }
+
+        public ValidationException(string propertyName, string errorMessage) : this()
+        {
+            Errors = new Dictionary<string, string[]>
+        {
+            { propertyName, new[] { errorMessage } }
+        };
+        }
+
+        public IDictionary<string, string[]> Errors { get; }
+    }
+}

Streetcode/Streetcode.Email.BLL/Interfaces/IEmailService.cs

@@ -0,0 +1,9 @@
+using Streetcode.Email.BLL.DTO;
+
+namespace Streetcode.Email.BLL.Interfaces
+{
+    public interface IEmailService
+    {
+        Task SendEmailAsync(EmailDTO email);
+    }
+}

Streetcode/Streetcode.Email.BLL/Mapping/EmailProfile.cs

@@ -0,0 +1,14 @@
+using AutoMapper;
+using Streetcode.Email.BLL.DTO;
+using EmailEntity = Streetcode.Email.DAL.Entities.Email;
+
+namespace Streetcode.Email.BLL.Mapping
+{
+    public class EmailProfile : Profile
+    {
+        public EmailProfile()
+        {
+            CreateMap<EmailEntity, EmailDTO>().ReverseMap();
+        }
+    }
+}

Streetcode/Streetcode.Email.BLL/MediatR/Behavior/ValidatorBehavior.cs

@@ -0,0 +1,33 @@
+using FluentValidation;
+using MediatR;
+
+namespace Streetcode.Email.BLL.MediatR.Behavior
+{
+    public class ValidatorBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+        where TRequest : IRequest<TResponse>
+    {
+        private readonly IEnumerable<IValidator<TRequest>> _validators;
+
+        public ValidatorBehavior(IEnumerable<IValidator<TRequest>> validators)
+        {
+            _validators = validators;
+        }
+
+        public Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+        {
+            var context = new ValidationContext<TRequest>(request);
+            var failures = _validators
+                .Select(v => v.Validate(context))
+                .SelectMany(result => result.Errors)
+                .Where(f => f != null)
+                .ToList();
+
+            if (failures.Count != 0)
+            {
+                throw new Exceptions.ValidationException(failures);
+            }
+
+            return next();
+        }
+    }
+}

Streetcode/Streetcode.Email.BLL/MediatR/Email/EmailDTOValidator.cs

@@ -0,0 +1,20 @@
+using FluentValidation;
+using Streetcode.Email.BLL.DTO;
+
+namespace Streetcode.Email.BLL.MediatR.Email
+{
+    public class EmailDTOValidator : AbstractValidator<EmailDTO>
+    {
+        public EmailDTOValidator()
+        { 
+            RuleFor(x => x.From)
+                .NotEmpty()
+                .EmailAddress();
+
+            RuleFor(x => x.Content)
+                .NotEmpty()
+                .MinimumLength(5)
+                .MaximumLength(1000);
+        }
+    }
+}

Streetcode/Streetcode.Email.BLL/MediatR/Email/SendEmailCommand.cs

@@ -0,0 +1,8 @@
+using FluentResults;
+using MediatR;
+using Streetcode.Email.BLL.DTO;
+
+namespace Streetcode.Email.BLL.MediatR.Email
+{
+    public record SendEmailCommand(EmailDTO email) : IRequest<Result<Unit>>;
+}

Streetcode/Streetcode.Email.BLL/MediatR/Email/SendEmailCommandValidator.cs

@@ -0,0 +1,16 @@
+using FluentValidation;
+using Streetcode.Resources;
+
+namespace Streetcode.Email.BLL.MediatR.Email
+{
+    public class SendEmailCommandValidator : AbstractValidator<SendEmailCommand>
+    {
+        public SendEmailCommandValidator()
+        {
+            RuleFor(x => x.email)
+                .NotNull()
+                .WithMessage(Messages.Error_CommandDataRequired)
+                .SetValidator(new EmailDTOValidator());
+        }
+    }
+}

Streetcode/Streetcode.Email.BLL/MediatR/Email/SendEmailHandler.cs

@@ -0,0 +1,52 @@
+using AutoMapper;
+using FluentResults;
+using Hangfire;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using Streetcode.Email.BLL.DTO;
+using Streetcode.Email.BLL.Interfaces;
+using Streetcode.Email.DAL.Persistence;
+using Streetcode.Resources;
+using EmailEntity = Streetcode.Email.DAL.Entities.Email;
+
+namespace Streetcode.Email.BLL.MediatR.Email
+{
+    public class SendEmailHandler : IRequestHandler<SendEmailCommand, Result<Unit>>
+    {
+        private readonly EmailDbContext _context;
+        private readonly IMapper _mapper;
+        private readonly ILogger<SendEmailHandler> _logger;
+        private readonly IBackgroundJobClient _backgroundJob;
+
+        public SendEmailHandler(EmailDbContext context, IMapper mapper, ILogger<SendEmailHandler> logger, IBackgroundJobClient backgroundJob)
+        {
+            _context = context;
+            _mapper = mapper;
+            _logger = logger;
+            _backgroundJob = backgroundJob;
+        }
+
+        public async Task<Result<Unit>> Handle(SendEmailCommand request, CancellationToken cancellationToken)
+        {
+            var EmailEntity = _mapper.Map<EmailEntity>(request.email);
+
+            _context.Emails.Add(EmailEntity);
+
+            var rowsAffected = await _context.SaveChangesAsync(cancellationToken);
+
+            if (rowsAffected <= 0)
+            {
+                var errorMsg = Messages.Error_FailedToCreateEntity;
+                _logger.LogError(errorMsg);
+                return Result.Fail(errorMsg);
+            }
+
+            _backgroundJob.Enqueue<IEmailService>(emailService =>
+                emailService.SendEmailAsync(request.email));
+
+            _logger.LogInformation("Email saved to DB and email task enqueued for {Email}", request.email.From);
+
+            return Result.Ok(Unit.Value);
+        }
+    }
+}