initial commit

ConfigBackEnd/Behaviours/AuthorizationBehaviour.cs

@@ -0,0 +1,68 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using Indotalent.ConfigBackEnd.Attributes;
+using Indotalent.ConfigBackEnd.Exceptions;
+using Indotalent.ConfigBackEnd.Interfaces;
+using MediatR;
+using System.Reflection;
+
+public class AuthorizationBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly ICurrentUserService _currentUserService;
+
+    public AuthorizationBehaviour(ICurrentUserService currentUserService)
+    {
+        _currentUserService = currentUserService;
+    }
+
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+    {
+        var authorizeAttributes = request.GetType().GetCustomAttributes<AuthorizeAttribute>();
+
+        if (authorizeAttributes.Any())
+        {
+            if (_currentUserService.UserId == null)
+            {
+                throw new UnauthorizedAccessException();
+            }
+
+            var authorizeAttributesWithRoles = authorizeAttributes.Where(a => !string.IsNullOrWhiteSpace(a.Role));
+
+            if (authorizeAttributesWithRoles.Any())
+            {
+                var authorized = false;
+                foreach (var role in authorizeAttributesWithRoles.Select(a => a.Role))
+                {
+                    var isInRole = await _currentUserService.IsInRoleAsync(role.Trim());
+                    if (isInRole)
+                    {
+                        authorized = true;
+                        break;
+                    }
+                }
+
+                if (!authorized)
+                {
+                    throw new ForbiddenAccessException();
+                }
+            }
+
+            var authorizeAttributesWithPermissions = authorizeAttributes.Where(a => !string.IsNullOrWhiteSpace(a.Permission));
+
+            if (authorizeAttributesWithPermissions.Any())
+            {
+                foreach (var permission in authorizeAttributesWithPermissions.Select(a => a.Permission))
+                {
+                    var hasPermission = await _currentUserService.HasPermissionAsync(permission.Trim());
+                    if (!hasPermission)
+                    {
+                        throw new ForbiddenAccessException();
+                    }
+                }
+            }
+        }
+
+        return await next();
+    }
+}

ConfigBackEnd/Behaviours/LoggingBehaviour.cs

@@ -0,0 +1,30 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using Indotalent.ConfigBackEnd.Interfaces;
+using MediatR.Pipeline;
+using Microsoft.Extensions.Logging;
+
+public class LoggingBehaviour<TRequest> : IRequestPreProcessor<TRequest>
+    where TRequest : notnull
+{
+    private readonly ILogger _logger;
+    private readonly ICurrentUserService _currentUserService;
+
+    public LoggingBehaviour(ILogger<TRequest> logger, ICurrentUserService currentUserService)
+    {
+        _logger = logger;
+        _currentUserService = currentUserService;
+    }
+
+    public Task Process(TRequest request, CancellationToken cancellationToken)
+    {
+        var requestName = typeof(TRequest).Name;
+        var userId = _currentUserService.UserId ?? string.Empty;
+        var userName = _currentUserService.UserName ?? string.Empty;
+
+        _logger.LogInformation("Request: {Name} {UserId} {UserName} {@Request}",
+            requestName, userId, userName, request);
+
+        return Task.CompletedTask;
+    }
+}

ConfigBackEnd/Behaviours/PerformanceBehaviour.cs

@@ -0,0 +1,46 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using Indotalent.ConfigBackEnd.Interfaces;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using System.Diagnostics;
+
+public class PerformanceBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly Stopwatch _timer;
+    private readonly ILogger<TRequest> _logger;
+    private readonly ICurrentUserService _currentUserService;
+
+    public PerformanceBehaviour(
+        ILogger<TRequest> logger,
+        ICurrentUserService currentUserService)
+    {
+        _timer = new Stopwatch();
+        _logger = logger;
+        _currentUserService = currentUserService;
+    }
+
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+    {
+        _timer.Start();
+
+        var response = await next();
+
+        _timer.Stop();
+
+        var elapsedMilliseconds = _timer.ElapsedMilliseconds;
+
+        if (elapsedMilliseconds > 500)
+        {
+            var requestName = typeof(TRequest).Name;
+            var userId = _currentUserService.UserId ?? string.Empty;
+            var userName = _currentUserService.UserName ?? string.Empty;
+
+            _logger.LogWarning("Long Running Request: {Name} ({ElapsedMilliseconds} milliseconds) {@UserId} {@UserName} {@Request}",
+                requestName, elapsedMilliseconds, userId, userName, request);
+        }
+
+        return response;
+    }
+}

ConfigBackEnd/Behaviours/UnhandledExceptionBehaviour.cs

@@ -0,0 +1,33 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using Indotalent.Shared.Consts;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+public class UnhandledExceptionBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly ILogger<TRequest> _logger;
+
+    public UnhandledExceptionBehaviour(ILogger<TRequest> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+    {
+        try
+        {
+            return await next();
+        }
+        catch (Exception ex)
+        {
+            var requestName = typeof(TRequest).Name;
+
+            _logger.LogError(ex, GlobalConsts.BehaviourError + " {Name} {@Request}",
+                requestName, request);
+
+            throw;
+        }
+    }
+}

ConfigBackEnd/Behaviours/ValidationBehaviour.cs

@@ -0,0 +1,42 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using FluentValidation;
+using MediatR;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+public class ValidationBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly IEnumerable<IValidator<TRequest>> _validators;
+
+    public ValidationBehaviour(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, cancellationToken)));
+
+            var failures = validationResults
+                .SelectMany(r => r.Errors)
+                .Where(f => f != null)
+                .ToList();
+
+            if (failures.Count != 0)
+            {
+                throw new ValidationException(failures);
+            }
+        }
+
+        return await next();
+    }
+}