server cleanup

server/src/API/Baya.Web.Api/Baya.Web.Api.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+	  <ImplicitUsings>enable</ImplicitUsings>
+	  <IsPackable>true</IsPackable>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <NoWarn>$(NoWarn);1591</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+	  <PackageReference Include="Microsoft.EntityFrameworkCore.Design">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
+	  <PackageReference Include="Serilog.AspNetCore" />
+	  <PackageReference Include="Microsoft.AspNetCore.OpenApi" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Debug" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Infrastructure\Baya.Infrastructure.Monitoring\Baya.Infrastructure.Monitoring.csproj" />
+    <ProjectReference Include="..\Baya.WebFramework\Baya.WebFramework.csproj" />
+    <ProjectReference Include="..\Plugins\Baya.Web.Plugins.Grpc\Baya.Web.Plugins.Grpc.csproj" />
+  </ItemGroup>
+
+</Project>

server/src/API/Baya.Web.Api/Controllers/V1/Admin/AdminManagerController.cs

@@ -0,0 +1,37 @@
+using Asp.Versioning;
+using Baya.Application.Features.Admin.Commands.AddAdminCommand;
+using Baya.Application.Features.Admin.Queries.GetToken;
+using Baya.Application.Models.Jwt;
+using Baya.WebFramework.Attributes;
+using Baya.WebFramework.BaseController;
+using Mediator;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Baya.Web.Api.Controllers.V1.Admin
+{
+    [ApiVersion("1")]
+    [ApiController]
+    [Route("api/v{version:apiVersion}/AdminManager")]
+    public class AdminManagerController(ISender sender) : BaseController
+    {
+        [HttpPost("Login")]
+        [ProducesOkApiResponseType<AccessToken>]
+        public async Task<IActionResult> AdminLogin(AdminGetTokenQuery model)
+        {
+            var query = await sender.Send(model);
+
+            return base.OperationResult(query);
+        }
+
+        [Authorize(Roles = "admin")]
+        [HttpPost("NewAdmin")]
+        [ProducesOkApiResponseType]
+        public async Task<IActionResult> AddNewAdmin(AddAdminCommand model)
+        {
+            var commandResult = await sender.Send(model);
+
+            return base.OperationResult(commandResult);
+        }
+    }
+}

server/src/API/Baya.Web.Api/Controllers/V1/Admin/OrderManagementController.cs

@@ -0,0 +1,36 @@
+using Baya.Infrastructure.Identity.Identity.PermissionManager;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations;
+using Asp.Versioning;
+using Baya.Application.Features.Order.Queries.GetAllOrders;
+using Baya.WebFramework.Attributes;
+using Baya.WebFramework.BaseController;
+using Mediator;
+
+namespace Baya.Web.Api.Controllers.V1.Admin
+{
+    [ApiVersion("1")]
+    [ApiController]
+    [Route("api/v{version:apiVersion}/OrderManagement")]
+    [Display(Description= "Managing Users related Orders")]
+    [Authorize(ConstantPolicies.DynamicPermission)]
+    public class OrderManagementController : BaseController
+    {
+        private readonly ISender _sender;
+
+        public OrderManagementController(ISender sender)
+        {
+            _sender = sender;
+        }
+
+        [HttpGet("OrderList")]
+        [ProducesOkApiResponseType<List<GetAllOrdersQueryResult>>]
+        public async Task<IActionResult> GetOrders()
+        {
+            var queryResult = await _sender.Send(new GetAllOrdersQuery());
+
+            return base.OperationResult(queryResult);
+        }
+    }
+}

server/src/API/Baya.Web.Api/Controllers/V1/Admin/RoleManagerController.cs

@@ -0,0 +1,67 @@
+using System.ComponentModel.DataAnnotations;
+using Asp.Versioning;
+using Baya.Application.Features.Role.Commands.AddRoleCommand;
+using Baya.Application.Features.Role.Commands.UpdateRoleClaimsCommand;
+using Baya.Application.Features.Role.Queries.GetAllRolesQuery;
+using Baya.Application.Features.Role.Queries.GetAuthorizableRoutesQuery;
+using Baya.Infrastructure.Identity.Identity.PermissionManager;
+using Baya.WebFramework.Attributes;
+using Baya.WebFramework.BaseController;
+using Mediator;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Baya.Web.Api.Controllers.V1.Admin
+{
+    [ApiVersion("1")]
+    [ApiController]
+    [Route("api/v{version:apiVersion}/RoleManager")]
+    [Authorize(ConstantPolicies.DynamicPermission)]
+    [Display(Description = "Managing Related Roles for the System")]
+
+    public class RoleManagerController(ISender sender) : BaseController
+    {
+        [HttpGet("Roles")]
+        [ProducesOkApiResponseType<List<GetAllRolesQueryResponse>>]
+        public async Task<IActionResult> GetRoles()
+        {
+            var queryResult = await sender.Send(new GetAllRolesQuery());
+
+            return base.OperationResult(queryResult);
+        }
+
+        [HttpGet("AuthRoutes")]
+        [ProducesOkApiResponseType<List<GetAuthorizableRoutesQueryResponse>>]
+        public async Task<IActionResult> GetAuthRoutes()
+        {
+            var queryModel = await sender.Send(new GetAuthorizableRoutesQuery());
+
+            return base.OperationResult(queryModel);
+        }
+
+        /// <summary>
+        /// Update a role permissions (claims) based on RouteKey received in AuthRoutes API
+        /// </summary>
+        /// <param name="model"></param>
+        /// <returns></returns>
+        [HttpPut("UpdateRolePermissions")]
+        [ProducesOkApiResponseType]
+        public async Task<IActionResult> UpdateRolePermissions(UpdateRoleClaimsCommand model)
+        {
+            var commandResult =
+                await sender.Send(new UpdateRoleClaimsCommand(model.RoleId, model.RoleClaimValue));
+
+            return base.OperationResult(commandResult);
+        }
+
+        [HttpPost("NewRole")]
+        [ProducesOkApiResponseType]
+        public async Task<IActionResult> AddRole(AddRoleCommand model)
+        {
+            var commandResult = await sender.Send(model);
+
+            return base.OperationResult(commandResult);
+        }
+
+    }
+}

server/src/API/Baya.Web.Api/Controllers/V1/Admin/UserManagementController.cs

@@ -0,0 +1,36 @@
+using Baya.Infrastructure.Identity.Identity.PermissionManager;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations;
+using Asp.Versioning;
+using Baya.Application.Features.Users.Queries.GetUsers;
+using Baya.WebFramework.Attributes;
+using Baya.WebFramework.BaseController;
+using Mediator;
+
+namespace Baya.Web.Api.Controllers.V1.Admin
+{
+    [ApiVersion("1")]
+    [ApiController]
+    [Route("api/v{version:apiVersion}/UserManagement")]
+    [Display(Description = "Managing API Users")]
+    [Authorize(ConstantPolicies.DynamicPermission)]
+    public class UserManagementController : BaseController
+    {
+        private readonly ISender _sender;
+
+        public UserManagementController(ISender sender)
+        {
+            _sender = sender;
+        }
+
+        [HttpGet("CurrentUsers")]
+        [ProducesOkApiResponseType<List<GetUsersQueryResponse>>]
+        public async Task<IActionResult> GetAllUsers()
+        {
+            var queryResult = await _sender.Send(new GetUsersQuery());
+
+            return base.OperationResult(queryResult);
+        }
+    }
+}

server/src/API/Baya.Web.Api/Controllers/V1/Order/OrderController.cs

@@ -0,0 +1,52 @@
+using Asp.Versioning;
+using Baya.Application.Features.Order.Commands;
+using Baya.Application.Features.Order.Queries.GetUserOrders;
+using Baya.WebFramework.Attributes;
+using Baya.WebFramework.BaseController;
+using Mediator;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Baya.Web.Api.Controllers.V1.Order;
+
+[ApiVersion("1")]
+[ApiController]
+[Route("api/v{version:apiVersion}/User")]
+[Authorize]
+public class OrderController(ISender sender) : BaseController
+{
+    [HttpPost("CreateNewOrder")]
+    [ProducesOkApiResponseType]
+    public async Task<IActionResult> CreateNewOrder(AddOrderCommand model)
+    {
+        model.UserId = base.UserId;
+        var command = await sender.Send(model);
+
+        return base.OperationResult(command);
+    }
+
+    [HttpGet("GetUserOrders")]
+    [ProducesOkApiResponseType<List<GetUsersQueryResultModel>>]
+    public async Task<IActionResult> GetUserOrders()
+    {
+        var query = await sender.Send(new GetUserOrdersQueryModel(UserId));
+
+        return base.OperationResult(query);
+    }
+
+    [HttpPut("UpdateOrder")]
+    [ProducesOkApiResponseType]
+    public async Task<IActionResult> UpdateOrder(UpdateUserOrderCommand model)
+    {
+        model.UserId=base.UserId;
+
+        var command = await sender.Send(model);
+
+        return base.OperationResult(command);
+    }
+
+    [HttpDelete("DeleteAllUserOrders")]
+    [ProducesOkApiResponseType]
+    public async Task<IActionResult> DeleteAllUserOrders()
+        => base.OperationResult(await sender.Send(new DeleteUserOrdersCommand(base.UserId)));
+}

server/src/API/Baya.Web.Api/Controllers/V1/UserManagement/UserController.cs

@@ -0,0 +1,88 @@
+using Asp.Versioning;
+using Baya.Application.Features.Users.Commands.Create;
+using Baya.Application.Features.Users.Commands.RefreshUserTokenCommand;
+using Baya.Application.Features.Users.Commands.RequestLogout;
+using Baya.Application.Features.Users.Queries.GenerateUserToken;
+using Baya.Application.Features.Users.Queries.TokenRequest;
+using Baya.Application.Models.Jwt;
+using Baya.WebFramework.Attributes;
+using Baya.WebFramework.BaseController;
+using Baya.WebFramework.Swagger;
+using Mediator;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Baya.Web.Api.Controllers.V1.UserManagement;
+
+[ApiVersion("1")]
+[ApiController]
+[Route("api/v{version:apiVersion}/User")]
+public class UserController : BaseController
+{
+    private readonly IMediator _mediator;
+
+    public UserController(IMediator mediator)
+    {
+        _mediator = mediator;
+    }
+
+    [HttpPost("Register")]
+    [ProducesOkApiResponseType<UserCreateCommandResult>]
+    public async Task<IActionResult> CreateUser(UserCreateCommand model)
+    {
+        var command = await _mediator.Send(model);
+
+        return base.OperationResult(command);
+    }
+
+
+    [HttpPost("TokenRequest")]
+    [ProducesOkApiResponseType<UserTokenRequestQueryResponse>]
+    public async Task<IActionResult> TokenRequest(UserTokenRequestQuery model)
+    {
+        var query = await _mediator.Send(model);
+
+        return base.OperationResult(query);
+    }
+
+    [HttpPost("LoginConfirmation")]
+    [ProducesOkApiResponseType<AccessToken>]
+    public async Task<IActionResult> ValidateUser(GenerateUserTokenQuery model)
+    {
+        var result = await _mediator.Send(model);
+
+        return base.OperationResult(result);
+    }
+
+    [HttpPost("RefreshSignIn")]
+    [RequireTokenWithoutAuthorization]
+    [ProducesOkApiResponseType<AccessToken>]
+    public async Task<IActionResult> RefreshUserToken(RefreshUserTokenCommand model)
+    {
+        var checkCurrentAccessTokenValidity =await HttpContext.AuthenticateAsync(JwtBearerDefaults.AuthenticationScheme);
+
+        if (checkCurrentAccessTokenValidity.Succeeded)
+            return BadRequest("Current access token is valid. No need to refresh");
+
+        var newTokenResult = await _mediator.Send(model);
+
+        return base.OperationResult(newTokenResult);
+    }
+
+    [HttpPost("Logout")]
+    [Authorize]
+    [ProducesOkApiResponseType]
+    public async Task<IActionResult> RequestLogout()
+    {
+        var commandResult = await _mediator.Send(new RequestLogoutCommand(base.UserId));
+
+        return base.OperationResult(commandResult);
+    }
+    
+    [HttpPost("PasswordTokenRequest")]
+    [ProducesOkApiResponseType<AccessToken>]
+    public async Task<IActionResult> PasswordTokenRequest(PasswordUserTokenRequestQuery model)
+    => base.OperationResult(await _mediator.Send(model));
+}

server/src/API/Baya.Web.Api/Program.cs

@@ -0,0 +1,118 @@
+using System.Diagnostics;
+using Baya.Application.Features.Users.Commands.Create;
+using Baya.Application.Models.ApiResult;
+using Baya.Application.Models.Identity;
+using Baya.Application.ServiceConfiguration;
+using Baya.Domain.Entities.User;
+using Baya.Infrastructure.CrossCutting.Logging;
+using Baya.Infrastructure.Identity.Identity.Dtos;
+using Baya.Infrastructure.Identity.Jwt;
+using Baya.Infrastructure.Identity.ServiceConfiguration;
+using Baya.Infrastructure.Monitoring.Configurations;
+using Baya.Infrastructure.Persistence.ServiceConfiguration;
+using Baya.SharedKernel.Extensions;
+using Baya.Web.Api.Controllers.V1.UserManagement;
+using Baya.Web.Plugins.Grpc;
+using Baya.WebFramework.Filters;
+using Baya.WebFramework.Middlewares;
+using Baya.WebFramework.ServiceConfiguration;
+using Baya.WebFramework.Swagger;
+using Mapster;
+using Microsoft.AspNetCore.Mvc;
+using Serilog;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Host.UseSerilog(LoggingConfiguration.ConfigureLogger);
+
+var configuration = builder.Configuration;
+
+Activity.DefaultIdFormat = ActivityIdFormat.W3C;
+
+builder
+    .ConfigureHealthChecks()
+    .SetupOpenTelemetry();
+
+builder.Services.Configure<IdentitySettings>(configuration.GetSection(nameof(IdentitySettings)));
+
+var identitySettings = configuration.GetSection(nameof(IdentitySettings)).Get<IdentitySettings>();
+
+builder.Services.AddControllers(options =>
+{
+    options.Filters.Add(typeof(OkResultAttribute));
+    options.Filters.Add(typeof(NotFoundResultAttribute));
+    options.Filters.Add(typeof(ContentResultFilterAttribute));
+    options.Filters.Add(typeof(ModelStateValidationAttribute));
+    options.Filters.Add(typeof(BadRequestResultFilterAttribute));
+    options.Filters.Add(new ProducesResponseTypeAttribute(typeof(ApiResult<Dictionary<string, List<string>>>),
+        StatusCodes.Status400BadRequest));
+    options.Filters.Add(new ProducesResponseTypeAttribute(typeof(ApiResult),
+        StatusCodes.Status401Unauthorized));
+    options.Filters.Add(new ProducesResponseTypeAttribute(typeof(ApiResult),
+        StatusCodes.Status403Forbidden));
+    options.Filters.Add(new ProducesResponseTypeAttribute(typeof(ApiResult),
+        StatusCodes.Status500InternalServerError));
+
+}).ConfigureApiBehaviorOptions(options =>
+{
+    options.SuppressModelStateInvalidFilter = true;
+    options.SuppressMapClientErrors = true;
+});
+
+
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwagger("v1","v1.1");
+
+
+builder.Services.AddApplicationServices()
+    .RegisterIdentityServices(identitySettings)
+    .AddPersistenceServices(configuration)
+    .AddWebFrameworkServices();
+
+builder.Services.RegisterValidatorsAsServices();
+builder.Services.AddExceptionHandler<ExceptionHandler>();
+
+builder.Services.AddMapster();
+
+TypeAdapterConfig.GlobalSettings.Scan(typeof(UserCreateCommand).Assembly,
+    typeof(GetRolesDto).Assembly);
+
+
+#region Plugin Services Configuration
+
+builder.Services.ConfigureGrpcPluginServices();
+
+#endregion
+
+
+
+var app = builder.Build();
+
+
+await app.ApplyMigrationsAsync();
+await app.SeedDefaultUsersAsync();
+
+if (app.Environment.IsDevelopment())
+{
+    app.UseDeveloperExceptionPage();
+}
+else
+    app.UseExceptionHandler(_=>{});
+
+app.UseSwaggerAndUi();
+
+app.UseRouting();
+
+app.UseAuthentication();
+app.UseAuthorization();
+app.MapControllers();
+
+app.UseMetrics()
+    .UseHealthChecks();
+
+app.ConfigureGrpcPipeline();
+
+await app.RunAsync();
+
+
+

server/src/API/Baya.Web.Api/Properties/launchSettings.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:8746",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "Web.Api": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:5002",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

server/src/API/Baya.Web.Api/appsettings.Development.json

@@ -0,0 +1,12 @@
+{
+  "ConnectionStrings": {
+    "SqlServer": "Data Source=localhost;Initial Catalog=Baya_DB_8_0;Integrated Security=true;Encrypt=False"
+  },
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  }
+}

server/src/API/Baya.Web.Api/appsettings.json

@@ -0,0 +1,20 @@
+{
+  "ConnectionStrings": {
+    "SqlServer": "Server=sql_server2022;Database=Baya_DB_Docker;User Id=SA;Password=A&VeryComplex123Password;MultipleActiveResultSets=true;encrypt=false",
+    "logDb": "Server=sql_server2022;Database=Baya_Log_DB_Docker;User Id=SA;Password=A&VeryComplex123Password;MultipleActiveResultSets=true;encrypt=false"
+  },
+  "IdentitySettings": {
+    "SecretKey": "ShouldBe-LongerThan-16Char-SecretKey",
+    "Encryptkey": "16CharEncryptKey",
+    "Issuer": "MyWebsite",
+    "Audience": "MyWebsite",
+    "NotBeforeMinutes": "0",
+    "ExpirationMinutes": "10000"
+  },
+  "AllowedHosts": "*",
+  "Kestrel": {
+    "EndpointDefaults": {
+      "Protocols": "Http2"
+    }
+  }
+}