Merge pull request #25 from NiceOneFox/develop

Sprint 2

Author: NiceOneFox

README.md

@@ -22,12 +22,20 @@ Input parameters:
 * Amount of requests
 * Modeling time (max time)
 * SimulationType (Type of buffer modeling, FIFO, LIFO etc.)
-* Lambda (amount of flow) parameter for Poissonian flow
+* Lambda for devices (amount of flow) parameter for Poissonian flow
+* Lambda for sources
 
 ## Technologies
 - ASP .NET 6
 - C# 10
 - AutoMapper
+- FluentValidation
+- CORS
+- NLog
+
+### For testing
+- NUnit
+- Moq
 
 ## Architecture 
 N-Layer Web API

backend/ServiceSimulation/Api/Api.csproj

@@ -8,7 +8,14 @@
 
   <ItemGroup>
     <PackageReference Include="AutoMapper" Version="11.0.1" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.3.0" />
+    <PackageReference Include="FluentValidation" Version="10.4.0" />
+    <PackageReference Include="FluentValidation.AspNetCore" Version="10.4.0" />
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="10.4.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Cors" Version="2.2.0" />
+    <PackageReference Include="NLog" Version="4.7.15" />
+    <PackageReference Include="NLog.Schema" Version="4.7.15" />
+    <PackageReference Include="NLog.Web.AspNetCore" Version="4.14.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.3.1" />
   </ItemGroup>
 
   <ItemGroup>

backend/ServiceSimulation/Api/Configuration/ApiMapperConfigurator.cs

@@ -1,6 +1,6 @@
 using Api.Entities;
 using AutoMapper;
-using Bll.Domain.Entities;
+using Bll.Domain.Models;
 using Bll.Domain.Interfaces;
 
 namespace Api.Configuration;

backend/ServiceSimulation/Api/Configuration/CorsPolicies.cs

@@ -0,0 +1,23 @@
+using Microsoft.AspNetCore.Cors.Infrastructure;
+
+namespace Api.Configuration;
+
+public static class CorsPolicies
+{
+    public static readonly (string Name, Action<CorsPolicyBuilder> ConfigurePolicy) AllowRemoteFrontendWithCredentials =
+    (
+        "AllowRemoteFrontendWithCredentials",
+        builder =>
+        {
+            var host = Environment.GetEnvironmentVariable("REMOTE_FRONTEND_HOST");
+            var port = Environment.GetEnvironmentVariable("REMOTE_FRONTEND_PORT");
+            var scheme = Environment.GetEnvironmentVariable("REMOTE_FRONTEND_SCHEME");
+            var origin = $"{scheme}://{host}:{port}";
+            builder
+                .WithOrigins(origin)
+                .AllowAnyHeader()
+                .AllowAnyMethod()
+                .AllowCredentials();
+        }
+    );
+}

backend/ServiceSimulation/Api/Controllers/Simulation.cs

@@ -1,8 +1,9 @@
 using Api.Entities;
-using Api.enums;
+using Api.Validation;
 using AutoMapper;
-using Bll.Domain.Entities;
 using Bll.Domain.Interfaces;
+using Bll.Domain.Models;
+using FluentValidation;
 using Microsoft.AspNetCore.Mvc;
 
 namespace Api.Controllers;
@@ -31,6 +32,8 @@ public Simulation(ISimulationService simulationService,
     [HttpGet("/start")]
     public IActionResult Start(InputParameters parameters)
     {
+        new InputParametersValidator().ValidateAndThrow(parameters);
+
         _simulationService.StartSimulation(parameters);
         var endResultsOfModeling = _resultManager.CalculateResultsOfModeling();
         var apiResults = _mapper.Map<ApiResults>((endResultsOfModeling, _results));

backend/ServiceSimulation/Api/Extensions/CorsOptionsExtensions.cs

@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Cors.Infrastructure;
+
+namespace Api.Extensions;
+
+public static class CorsOptionsExtensions
+{
+    public static void AddPolicy(this CorsOptions options, (string Name, Action<CorsPolicyBuilder> ConfigurePolicy) arg)
+    {
+        options.AddPolicy(arg.Name, arg.ConfigurePolicy);
+    }
+
+}

backend/ServiceSimulation/Api/Extensions/CustomExceptionHandlerMiddlewareExtensions.cs

@@ -0,0 +1,12 @@
+using Api.Middlewares;
+
+namespace Api.Extensions
+{
+    public static class CustomExceptionHandlerMiddlewareExtensions
+    {
+        public static IApplicationBuilder UseCustomExceptionHandler(this IApplicationBuilder builder)
+        {
+            return builder.UseMiddleware<CustomExceptionHandlerMiddleware>();
+        }
+    }
+}

backend/ServiceSimulation/Api/Middlewares/CustomExceptionHandlerMiddleware.cs

@@ -0,0 +1,59 @@
+using System.Net;
+using System.Text.Json;
+using FluentValidation;
+
+namespace Api.Middlewares
+{
+    public class CustomExceptionHandlerMiddleware
+    {
+        private readonly RequestDelegate _next;
+
+        private readonly ILogger _logger;
+        public CustomExceptionHandlerMiddleware(RequestDelegate next,
+            ILogger<CustomExceptionHandlerMiddleware> logger)
+        {
+            _next = next;
+            _logger = logger;
+        }
+
+        public async Task Invoke(HttpContext context)
+        {
+            try
+            {
+                await _next(context);
+            }
+            catch (Exception ex)
+            {
+                await HandleExceptionAsync(context, ex);
+            }
+        }
+
+        private Task HandleExceptionAsync(HttpContext context, Exception ex)
+        {
+            var statusCode = HttpStatusCode.InternalServerError;
+            var result = string.Empty;
+
+            switch (ex)
+            {
+                case ValidationException validationException:
+                    statusCode = HttpStatusCode.BadRequest;
+                    result = JsonSerializer.Serialize(validationException.Errors);
+                    _logger.LogDebug(validationException.Message);
+                    break;
+
+                default:
+                    statusCode = HttpStatusCode.NotFound;
+                    break;
+
+            }
+            context.Response.ContentType = "application/json";
+            context.Response.StatusCode = (int)statusCode;
+
+            if (result == string.Empty)
+            {
+                result = JsonSerializer.Serialize(new { error = ex.Message });
+            }
+            return context.Response.WriteAsync(result);
+        }
+    }
+}

backend/ServiceSimulation/Api/Program.cs

@@ -1,34 +1,57 @@
 using Api.Configuration;
+using Api.Extensions;
+using Api.Validation;
 using Bll.Domain.Entities;
 using Bll.Domain.Factories;
 using Bll.Domain.Interfaces;
+using Bll.Domain.Models;
 using Bll.Domain.Services;
+using FluentValidation;
+using FluentValidation.AspNetCore;
+using NLog.Web;
 
 var builder = WebApplication.CreateBuilder(args);
 
-builder.Services.AddControllers();
+builder.Services.AddControllers().AddFluentValidation(fv =>
+{
+fv.RegisterValidatorsFromAssemblyContaining<InputParametersValidator>();
+});
+
+#region Logger
+builder.Logging.ClearProviders();
+builder.Logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
+builder.Host.UseNLog();
+#endregion
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
 
 #region servicesDI
 builder.Services.AddTransient<ISimulationService, SimulationService>();
 
 builder.Services.AddScoped<ITimeProvider, TimeProvider>();
+builder.Services.AddScoped<IFlowProvider, PoissonianFlowProvider>();
+
 builder.Services.AddScoped<IResults, Bll.Domain.Entities.Results>();
 builder.Services.AddScoped<IResultManager, ResultManager>();
-builder.Services.AddScoped<IResultManager, ResultManager>();
-//builder.Services.AddTransient<IBufferManager, StandardBufferManager>();
+
 builder.Services.AddTransient<IBufferManagerFactory, BufferManagerFactory>();
 builder.Services.AddTransient<IDeviceManager, DeviceManager>();
 builder.Services.AddTransient<ISourceManager, SourceManager>();
-//builder.Services.AddScoped<StandardBufferManager>()
-//    .AddScoped<IBufferManager, StandardBufferManager>(s => s.GetRequiredService<StandardBufferManager>());
 
-//builder.Services.AddScoped<IBufferManager>(s =>
-//    ActivatorUtilities.CreateInstance<StandardBufferManager>(s));
+builder.Services.AddTransient<IValidator<InputParameters>, InputParametersValidator>();
 #endregion
 
+#region Mapper
 builder.Services.AddMapper();
+#endregion
+
+#region CORS
+builder.Services.AddCors(opts =>
+{
+    opts.AddPolicy(CorsPolicies.AllowRemoteFrontendWithCredentials);
+});
+#endregion
+
 
 var app = builder.Build();
 
@@ -38,6 +61,8 @@
     app.UseSwaggerUI();
 }
 
+app.UseCustomExceptionHandler();
+
 app.UseHttpsRedirection();
 
 app.UseAuthorization();

backend/ServiceSimulation/Api/Validation/InputParametersValidator.cs

@@ -0,0 +1,21 @@
+using FluentValidation;
+using Bll.Domain.Models;
+using Api.enums;
+
+namespace Api.Validation
+{
+    public class InputParametersValidator : AbstractValidator<InputParameters>
+    {
+        public InputParametersValidator()
+        {
+            RuleFor(p => p.NumberOfSources).NotEmpty().InclusiveBetween(1, 100);
+            RuleFor(p => p.NumberOfDevices).NotEmpty().InclusiveBetween(1, 100);
+            RuleFor(p => p.AmountOfRequests).NotEmpty().InclusiveBetween(1, 5000);
+            RuleFor(p => p.BufferSize).NotEmpty().InclusiveBetween(1, 100);
+            RuleFor(p => p.LambdaForDevice).NotEmpty().ExclusiveBetween(0, 10000);
+            RuleFor(p => p.NumberOfSources).NotEmpty().ExclusiveBetween(0, 10000);
+            RuleFor(p => p.ModelingTime).NotEmpty().ExclusiveBetween(0, 10000);
+            RuleFor(p => p.BufferType).IsInEnum();
+        }
+    }
+}