Register User

Author: bird_egop

BusinessLogic/BusinessException.cs

@@ -0,0 +1,8 @@
+namespace BusinessLogic;
+
+public class BusinessException : Exception
+{
+    public BusinessException(string message) : base(message)
+    {
+    }
+}

BusinessLogic/BusinessLogic.csproj

@@ -17,7 +17,7 @@
     </ItemGroup>
 
     <ItemGroup>
-      <Folder Include="Mediatr" />
+      <ProjectReference Include="..\DataAccess\DataAccess.csproj" />
     </ItemGroup>
 
 </Project>

BusinessLogic/Mediatr/RegisterUser.cs

@@ -0,0 +1,56 @@
+using DataAccess.Models;
+using DataAccess.RepositoryNew;
+using FluentValidation;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace BusinessLogic.Mediatr;
+
+public static class RegisterUser
+{
+    public record Command(string Email, string Password) : IRequest<Unit>;
+
+    public class CommandValidator : AbstractValidator<Command>
+    {
+        public CommandValidator()
+        {
+            RuleFor(x => x.Email)
+                .NotEmpty()
+                .EmailAddress();
+
+            RuleFor(x => x.Password)
+                .NotEmpty()
+                .Length(8, 50);
+        }
+    }
+
+    public class Handler : IRequestHandler<Command, Unit>
+    {
+        private readonly IRepository<AppUser> _repository;
+
+        public Handler(IRepository<AppUser> repository)
+        {
+            _repository = repository;
+        }
+
+        public async Task<Unit> Handle(Command request, CancellationToken cancellationToken)
+        {
+            if (await _repository.GetAll()
+                    .AnyAsync(x => x.Email == request.Email, cancellationToken))
+            {
+                throw new BusinessException("Email уже занят");
+            }
+
+            var appUser = new AppUser()
+            {
+                Email = request.Email,
+                Password = request.Password,
+                Username = ""
+            };
+
+            await _repository.Add(appUser, cancellationToken);
+            
+            return Unit.Value;
+        }
+    }
+}

BusinessLogic/ValidationBehavior.cs

@@ -0,0 +1,31 @@
+using FluentValidation;
+using MediatR;
+
+namespace BusinessLogic;
+
+//all validators must ne inherited from abstract  AbstractValidator<TValidator>
+
+public class ValidationBehavior <TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse> 
+    where TRequest : IRequest<TResponse>
+{
+    private readonly IEnumerable<IValidator<TRequest>> _validators;
+
+    public ValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
+    {
+        _validators = validators;
+    }
+    
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+    {
+        if (_validators.Any())
+        {
+            var context = new ValidationContext<TRequest>(request);
+            var validationResults = await Task.WhenAll(_validators.Select(v => v.ValidateAsync(context, cancellation: cancellationToken)));
+            var failures = validationResults.SelectMany(r => r.Errors).Where(f => f != null).ToList();
+            if (failures.Count != 0)
+                throw new ValidationException(failures);
+        }
+
+        return await next();
+    }
+}

ProjectManager/Controllers/AuthController.cs

@@ -0,0 +1,28 @@
+using BusinessLogic.Mediatr;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ProjectManager.Controllers;
+
+[Route("[controller]/[action]")]
+[ProducesResponseType(typeof(ErrorDto), 400)]
+[Produces("application/json")]
+[ResponseCache(NoStore = true, Duration = 0)]
+public class AuthController : Controller
+{
+    private readonly IMediator _mediator;
+
+    public AuthController(IMediator mediator)
+    {
+        _mediator = mediator;
+    }
+
+    [HttpPost]
+    [ProducesResponseType(200)]
+    public async Task<ActionResult> Register([FromBody] RegisterUser.Command command, CancellationToken cancellationToken)
+    {
+        await _mediator.Send(command, cancellationToken);
+
+        return Ok();
+    }
+}

ProjectManager/Middlewares/ExceptionCatcherMiddleware.cs

@@ -1,4 +1,5 @@
 using System.Net;
+using FluentValidation;
 
 namespace ProjectManager.Middlewares;
 
@@ -17,6 +18,11 @@ public async Task InvokeAsync(HttpContext context, ILogger<ExceptionCatcherMiddl
         {
             await _next(context);
         }
+        catch (ValidationException ex)
+        {
+            context.Response.StatusCode = (int) HttpStatusCode.BadRequest;
+            await context.Response.WriteAsJsonAsync(new ErrorDto(string.Join("\n", ex.Errors.Select(x => x.ErrorMessage))));
+        }
         catch (Exception ex)
         {
             logger.LogCritical(ex, "Unhandled Exception");

ProjectManager/ProjectManager.csproj

@@ -7,10 +7,6 @@
         <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
     </PropertyGroup>
 
-    <ItemGroup>
-        <Folder Include="Controllers" />
-    </ItemGroup>
-
     <ItemGroup>
         <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="6.0.9" />
         <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.13" />