refactor: code restructuring

Endpoint/Configuration/Core/Middleware/CacheMaxAgeMiddleware.cs

@@ -0,0 +1,81 @@
+using Cronos;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Mirea.Api.Endpoint.Common.Attributes;
+using Mirea.Api.Endpoint.Configuration.Model;
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Mirea.Api.Endpoint.Middleware;
+
+public class CacheMaxAgeMiddleware(RequestDelegate next, IServiceProvider serviceProvider)
+{
+    public async Task InvokeAsync(HttpContext context)
+    {
+        if (!context.Response.StatusCode.ToString().StartsWith('2'))
+        {
+            await next(context);
+            return;
+        }
+
+        var endpoint = context.GetEndpoint();
+
+        var actionDescriptor = endpoint?.Metadata.GetMetadata<Microsoft.AspNetCore.Mvc.Controllers.ControllerActionDescriptor>();
+
+        if (actionDescriptor == null)
+        {
+            await next(context);
+            return;
+        }
+
+        var controllerType = actionDescriptor.ControllerTypeInfo;
+        var methodInfo = actionDescriptor.MethodInfo;
+
+        var maxAgeAttribute = methodInfo.GetCustomAttribute<CacheMaxAgeAttribute>() ?? controllerType.GetCustomAttribute<CacheMaxAgeAttribute>();
+
+        if (maxAgeAttribute == null)
+        {
+            await next(context);
+            return;
+        }
+
+        switch (maxAgeAttribute.MaxAge)
+        {
+            case < 0:
+                {
+                    DateTime? nextDate;
+                    var now = DateTime.UtcNow;
+
+                    using (var scope = serviceProvider.CreateScope())
+                    {
+                        var updateCronString = scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<GeneralConfig>>().Value.ScheduleSettings?.CronUpdateSchedule;
+
+                        if (string.IsNullOrEmpty(updateCronString) ||
+                            !CronExpression.TryParse(updateCronString, CronFormat.Standard, out var updateCron))
+                        {
+                            await next(context);
+                            return;
+                        }
+
+                        nextDate = updateCron.GetNextOccurrence(now);
+                    }
+
+                    if (!nextDate.HasValue)
+                    {
+                        await next(context);
+                        return;
+                    }
+
+                    context.Response.Headers.CacheControl = "max-age=" + (int)(nextDate.Value - now).TotalSeconds;
+                    break;
+                }
+            case > 0:
+                context.Response.Headers.CacheControl = "max-age=" + maxAgeAttribute.MaxAge;
+                break;
+        }
+
+        await next(context);
+    }
+}

Endpoint/Configuration/Core/Middleware/CustomExceptionHandlerMiddleware.cs

@@ -0,0 +1,60 @@
+using FluentValidation;
+using Microsoft.AspNetCore.Http;
+using Mirea.Api.DataAccess.Application.Common.Exceptions;
+using Mirea.Api.Dto.Responses;
+using Mirea.Api.Endpoint.Common.Exceptions;
+using System;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Mirea.Api.Endpoint.Middleware;
+
+public class CustomExceptionHandlerMiddleware(RequestDelegate next)
+{
+    public async Task InvokeAsync(HttpContext context)
+    {
+        try
+        {
+            await next(context);
+        }
+        catch (Exception exception)
+        {
+            await HandleExceptionAsync(context, exception);
+        }
+    }
+
+    private static Task HandleExceptionAsync(HttpContext context, Exception exception)
+    {
+        var code = StatusCodes.Status500InternalServerError;
+        var result = string.Empty;
+        switch (exception)
+        {
+            case ValidationException validationException:
+                code = StatusCodes.Status400BadRequest;
+                result = JsonSerializer.Serialize(new ErrorResponse()
+                {
+                    Error = validationException.Message,
+                    Code = code
+                });
+                break;
+            case NotFoundException:
+                code = StatusCodes.Status404NotFound;
+                break;
+            case ControllerArgumentException:
+                code = StatusCodes.Status400BadRequest;
+                break;
+        }
+
+        context.Response.ContentType = "application/json";
+        context.Response.StatusCode = code;
+
+        if (string.IsNullOrEmpty(result))
+            result = JsonSerializer.Serialize(new ErrorResponse()
+            {
+                Error = exception.Message,
+                Code = code
+            });
+
+        return context.Response.WriteAsync(result);
+    }
+}

Endpoint/Configuration/Core/Middleware/JwtRevocationMiddleware.cs

@@ -0,0 +1,23 @@
+using Microsoft.AspNetCore.Http;
+using Mirea.Api.Security.Common.Interfaces;
+using System.Threading.Tasks;
+
+namespace Mirea.Api.Endpoint.Middleware;
+
+public class JwtRevocationMiddleware(RequestDelegate next)
+{
+    public async Task InvokeAsync(HttpContext context, IRevokedToken revokedTokenStore)
+    {
+        if (context.Request.Headers.ContainsKey("Authorization"))
+        {
+            var token = context.Request.Headers.Authorization.ToString().Replace("Bearer ", "");
+            if (await revokedTokenStore.IsTokenRevokedAsync(token))
+            {
+                context.Response.StatusCode = StatusCodes.Status401Unauthorized;
+                return;
+            }
+        }
+
+        await next(context);
+    }
+}

Endpoint/Configuration/Core/Middleware/MaintenanceModeMiddleware.cs

@@ -0,0 +1,39 @@
+using Microsoft.AspNetCore.Http;
+using Mirea.Api.Endpoint.Common.Attributes;
+using Mirea.Api.Endpoint.Common.Interfaces;
+using System.Threading.Tasks;
+
+namespace Mirea.Api.Endpoint.Middleware;
+
+public class MaintenanceModeMiddleware(RequestDelegate next, IMaintenanceModeService maintenanceModeService, IMaintenanceModeNotConfigureService maintenanceModeNotConfigureService)
+{
+    private static bool IsIgnoreMaintenanceMode(HttpContext context)
+    {
+        var endpoint = context.GetEndpoint();
+        return endpoint?.Metadata.GetMetadata<MaintenanceModeIgnoreAttribute>() != null;
+    }
+
+    public async Task InvokeAsync(HttpContext context)
+    {
+        if (!maintenanceModeService.IsMaintenanceMode && !maintenanceModeNotConfigureService.IsMaintenanceMode || IsIgnoreMaintenanceMode(context))
+            await next(context);
+        else
+        {
+
+            context.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
+            context.Response.ContentType = "plain/text";
+
+            string error;
+            if (maintenanceModeService.IsMaintenanceMode)
+            {
+                context.Response.Headers.RetryAfter = "600";
+                error = "The service is currently undergoing maintenance. Please try again later.";
+            }
+            else
+                error =
+                    "The service is currently not configured. Go to the setup page if you are an administrator or try again later.";
+
+            await context.Response.WriteAsync(error);
+        }
+    }
+}