init

server/src/API/CleanArc.Web.Api/CleanArc.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\CleanArc.Infrastructure.Monitoring\CleanArc.Infrastructure.Monitoring.csproj" />
+    <ProjectReference Include="..\CleanArc.WebFramework\CleanArc.WebFramework.csproj" />
+    <ProjectReference Include="..\Plugins\CleanArc.Web.Plugins.Grpc\CleanArc.Web.Plugins.Grpc.csproj" />
+  </ItemGroup>
+
+</Project>

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

@@ -0,0 +1,37 @@
+using Asp.Versioning;
+using CleanArc.Application.Features.Admin.Commands.AddAdminCommand;
+using CleanArc.Application.Features.Admin.Queries.GetToken;
+using CleanArc.Application.Models.Jwt;
+using CleanArc.WebFramework.Attributes;
+using CleanArc.WebFramework.BaseController;
+using Mediator;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CleanArc.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/CleanArc.Web.Api/Controllers/V1/Admin/OrderManagementController.cs

@@ -0,0 +1,36 @@
+using CleanArc.Infrastructure.Identity.Identity.PermissionManager;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations;
+using Asp.Versioning;
+using CleanArc.Application.Features.Order.Queries.GetAllOrders;
+using CleanArc.WebFramework.Attributes;
+using CleanArc.WebFramework.BaseController;
+using Mediator;
+
+namespace CleanArc.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/CleanArc.Web.Api/Controllers/V1/Admin/RoleManagerController.cs

@@ -0,0 +1,67 @@
+using System.ComponentModel.DataAnnotations;
+using Asp.Versioning;
+using CleanArc.Application.Features.Role.Commands.AddRoleCommand;
+using CleanArc.Application.Features.Role.Commands.UpdateRoleClaimsCommand;
+using CleanArc.Application.Features.Role.Queries.GetAllRolesQuery;
+using CleanArc.Application.Features.Role.Queries.GetAuthorizableRoutesQuery;
+using CleanArc.Infrastructure.Identity.Identity.PermissionManager;
+using CleanArc.WebFramework.Attributes;
+using CleanArc.WebFramework.BaseController;
+using Mediator;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CleanArc.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/CleanArc.Web.Api/Controllers/V1/Admin/UserManagementController.cs

@@ -0,0 +1,36 @@
+using CleanArc.Infrastructure.Identity.Identity.PermissionManager;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations;
+using Asp.Versioning;
+using CleanArc.Application.Features.Users.Queries.GetUsers;
+using CleanArc.WebFramework.Attributes;
+using CleanArc.WebFramework.BaseController;
+using Mediator;
+
+namespace CleanArc.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/CleanArc.Web.Api/Controllers/V1/Order/OrderController.cs

@@ -0,0 +1,52 @@
+using Asp.Versioning;
+using CleanArc.Application.Features.Order.Commands;
+using CleanArc.Application.Features.Order.Queries.GetUserOrders;
+using CleanArc.WebFramework.Attributes;
+using CleanArc.WebFramework.BaseController;
+using Mediator;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CleanArc.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/CleanArc.Web.Api/Controllers/V1/UserManagement/UserController.cs

@@ -0,0 +1,88 @@
+using Asp.Versioning;
+using CleanArc.Application.Features.Users.Commands.Create;
+using CleanArc.Application.Features.Users.Commands.RefreshUserTokenCommand;
+using CleanArc.Application.Features.Users.Commands.RequestLogout;
+using CleanArc.Application.Features.Users.Queries.GenerateUserToken;
+using CleanArc.Application.Features.Users.Queries.TokenRequest;
+using CleanArc.Application.Models.Jwt;
+using CleanArc.WebFramework.Attributes;
+using CleanArc.WebFramework.BaseController;
+using CleanArc.WebFramework.Swagger;
+using Mediator;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CleanArc.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/CleanArc.Web.Api/Program.cs

@@ -0,0 +1,118 @@
+using System.Diagnostics;
+using CleanArc.Application.Features.Users.Commands.Create;
+using CleanArc.Application.Models.ApiResult;
+using CleanArc.Application.Models.Identity;
+using CleanArc.Application.ServiceConfiguration;
+using CleanArc.Domain.Entities.User;
+using CleanArc.Infrastructure.CrossCutting.Logging;
+using CleanArc.Infrastructure.Identity.Identity.Dtos;
+using CleanArc.Infrastructure.Identity.Jwt;
+using CleanArc.Infrastructure.Identity.ServiceConfiguration;
+using CleanArc.Infrastructure.Monitoring.Configurations;
+using CleanArc.Infrastructure.Persistence.ServiceConfiguration;
+using CleanArc.SharedKernel.Extensions;
+using CleanArc.Web.Api.Controllers.V1.UserManagement;
+using CleanArc.Web.Plugins.Grpc;
+using CleanArc.WebFramework.Filters;
+using CleanArc.WebFramework.Middlewares;
+using CleanArc.WebFramework.ServiceConfiguration;
+using CleanArc.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/CleanArc.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/CleanArc.Web.Api/appsettings.Development.json

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

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

@@ -0,0 +1,20 @@
+{
+  "ConnectionStrings": {
+    "SqlServer": "Server=sql_server2022;Database=CleanArc_DB_Docker;User Id=SA;Password=A&VeryComplex123Password;MultipleActiveResultSets=true;encrypt=false",
+    "logDb": "Server=sql_server2022;Database=CleanArc_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"
+    }
+  }
+}

server/src/API/CleanArc.WebFramework/Attributes/ProducesOkApiResponseTypeAttribute.cs

@@ -0,0 +1,39 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CleanArc.WebFramework.Attributes;
+
+/// <summary>
+/// Documents the 200 OK response type of endpoint as ApiResult
+/// </summary>
+/// <typeparam name="TResponse">API response type that will be in data JSON property</typeparam>
+public class ProducesOkApiResponseType<TResponse>:ProducesResponseTypeAttribute
+{
+    private ProducesOkApiResponseType(int statusCode) : base(statusCode)
+    {
+    }
+
+    public ProducesOkApiResponseType() : base(typeof(ApiResult<TResponse>), StatusCodes.Status200OK)
+    {
+    }
+
+    private ProducesOkApiResponseType(Type type, int statusCode, string contentType, params string[] additionalContentTypes) : base(type, statusCode, contentType, additionalContentTypes)
+    {
+    }
+}
+
+public class ProducesOkApiResponseType:ProducesResponseTypeAttribute
+{
+    private ProducesOkApiResponseType(int statusCode) : base(statusCode)
+    {
+    }
+
+    public ProducesOkApiResponseType() : base(typeof(ApiResult), StatusCodes.Status200OK)
+    {
+    }
+
+    private ProducesOkApiResponseType(Type type, int statusCode, string contentType, params string[] additionalContentTypes) : base(type, statusCode, contentType, additionalContentTypes)
+    {
+    }
+}

server/src/API/CleanArc.WebFramework/BaseController/BaseController.cs

@@ -0,0 +1,52 @@
+using System.Security.Claims;
+using CleanArc.Application.Models.Common;
+using CleanArc.SharedKernel.Extensions;
+using CleanArc.WebFramework.Filters;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CleanArc.WebFramework.BaseController;
+
+public class BaseController : ControllerBase
+{
+    protected string UserName => User.Identity?.Name;
+    protected int UserId => int.Parse(User.Identity.GetUserId());
+    protected string UserEmail => User.Identity.FindFirstValue(ClaimTypes.Email);
+    protected string UserRole => User.Identity.FindFirstValue(ClaimTypes.Role);
+
+    protected string UserKey => User.FindFirstValue(ClaimTypes.UserData);
+
+    protected IActionResult OperationResult<TModel>(OperationResult<TModel> result)
+    {
+        if (result is null)
+            return new ServerErrorResult("Server Error");
+
+
+        if (result.IsSuccess)
+            return result.Result is bool ? Ok() : Ok(result.Result);
+
+        if (result.IsNotFound)
+        {
+
+            AddErrors(result);
+
+            var notFoundErrors = new ValidationProblemDetails(ModelState);
+
+            return NotFound(notFoundErrors.Errors);
+        }
+
+        AddErrors(result);
+        
+        var badRequestErrors = new ValidationProblemDetails(ModelState);
+
+        return BadRequest(badRequestErrors.Errors);
+
+    }
+    
+    private void AddErrors<TModel>(OperationResult<TModel> result)
+    {
+        foreach (var error in result.ErrorMessages)
+        {
+            ModelState.AddModelError(error.Key,error.Value);
+        }
+    }
+}

server/src/API/CleanArc.WebFramework/CleanArc.WebFramework.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+	  <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="NSwag.AspNetCore" />
+    <PackageReference Include="NuGet.Packaging" />
+    <PackageReference Include="Asp.Versioning.Http" />
+    <PackageReference Include="Asp.Versioning.Mvc" />
+    <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Core\CleanArc.Application\CleanArc.Application.csproj" />
+    <ProjectReference Include="..\..\Infrastructure\CleanArc.Infrastructure.CrossCutting\CleanArc.Infrastructure.CrossCutting.csproj" />
+    <ProjectReference Include="..\..\Infrastructure\CleanArc.Infrastructure.Identity\CleanArc.Infrastructure.Identity.csproj" />
+    <ProjectReference Include="..\..\Infrastructure\CleanArc.Infrastructure.Persistence\CleanArc.Infrastructure.Persistence.csproj" />
+  </ItemGroup>
+
+</Project>

server/src/API/CleanArc.WebFramework/EndpointFilters/BadRequestResultEndpointFilter.cs

@@ -0,0 +1,28 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Http;
+
+namespace CleanArc.WebFramework.EndpointFilters;
+
+public class BadRequestResultEndpointFilter:IEndpointFilter
+{
+    public async ValueTask<object> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
+    {
+        var result = await next(context);
+
+        if (result is not IStatusCodeHttpResult statusCodeResult)
+        {
+            return result;
+        }
+
+        if (statusCodeResult.StatusCode != StatusCodes.Status400BadRequest)
+            return result;
+
+
+        if (result is IValueHttpResult valueHttp)
+        {
+            return Results.BadRequest(new ApiResult<object>(false, ApiResultStatusCode.BadRequest, valueHttp.Value));
+        }
+
+        return Results.BadRequest(new ApiResult(false, ApiResultStatusCode.BadRequest));
+    }
+}

server/src/API/CleanArc.WebFramework/EndpointFilters/ModelStateValidationEndpointFilter.cs

@@ -0,0 +1,46 @@
+using FluentValidation;
+using Microsoft.AspNetCore.Http;
+
+namespace CleanArc.WebFramework.EndpointFilters;
+
+public class ModelStateValidationEndpointFilter:IEndpointFilter
+{
+    public async ValueTask<object> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
+    {
+
+        var validationSummery = new Dictionary<string, List<string>>();
+
+        foreach (var contextArgument in context.Arguments)
+        {
+            if (contextArgument is null)
+                continue;
+
+            var validator =
+                context.HttpContext.RequestServices.GetService(
+                    typeof(IValidator<>).MakeGenericType(contextArgument.GetType())) as IValidator;
+
+            if (validator is null)
+                continue;
+
+            var validationResult = await validator.ValidateAsync(new ValidationContext<object>(contextArgument));
+
+            if (validationResult.IsValid) continue;
+
+            foreach (var validationResultError in validationResult.Errors)
+            {
+                if (validationSummery.TryGetValue(validationResultError.PropertyName, out var value))
+                {
+                    value.Add(validationResultError.ErrorMessage);
+                    continue;
+                }
+
+                validationSummery.Add(validationResultError.PropertyName, new (){validationResultError.ErrorMessage});
+            }
+        }
+
+        if (validationSummery.Count == 0)
+            return await next(context);
+
+        return Results.BadRequest(validationSummery);
+    }
+}

server/src/API/CleanArc.WebFramework/EndpointFilters/NotFoundResultEndpointFilter.cs

@@ -0,0 +1,28 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Http;
+
+namespace CleanArc.WebFramework.EndpointFilters;
+
+public class NotFoundResultEndpointFilter:IEndpointFilter
+{
+    public async ValueTask<object> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
+    {
+        var result = await next(context);
+
+        if (result is not IStatusCodeHttpResult statusCodeResult)
+        {
+            return result;
+        }
+
+        if (statusCodeResult.StatusCode != StatusCodes.Status404NotFound)
+            return result;
+
+
+        if (result is IValueHttpResult valueHttp)
+        {
+            return Results.BadRequest(new ApiResult<object>(false, ApiResultStatusCode.NotFound, valueHttp.Value));
+        }
+
+        return Results.BadRequest(new ApiResult(false, ApiResultStatusCode.NotFound));
+    }
+}

server/src/API/CleanArc.WebFramework/EndpointFilters/OkResultEndpointFilter.cs

@@ -0,0 +1,28 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Http;
+
+namespace CleanArc.WebFramework.EndpointFilters;
+
+public class OkResultEndpointFilter:IEndpointFilter
+{
+    public async ValueTask<object> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
+    {
+        var result=await next(context);
+
+        if (result is not IStatusCodeHttpResult statusCodeResult)
+        {
+                return result;
+        }
+
+        if(statusCodeResult.StatusCode !=StatusCodes.Status200OK)
+            return result;
+
+
+        if (result is IValueHttpResult valueHttp)
+        {
+            return Results.Ok(new ApiResult<object>(true, ApiResultStatusCode.Success, valueHttp.Value));
+        }
+
+        return Results.Ok(new ApiResult(true, ApiResultStatusCode.Success)); 
+    }
+}

server/src/API/CleanArc.WebFramework/Filters/ApiResultFilterAttribute.cs

@@ -0,0 +1,65 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace CleanArc.WebFramework.Filters;
+
+[Obsolete(message:"Separated filters added")]
+public class ApiResultFilterAttribute : ResultFilterAttribute
+{
+    public override void OnResultExecuting(ResultExecutingContext context)
+    {
+        if (context.Result is OkObjectResult okObjectResult)
+        {
+            var apiResult = new ApiResult<object>(true, ApiResultStatusCode.Success, okObjectResult.Value);
+            context.Result = new JsonResult(apiResult) { StatusCode = okObjectResult.StatusCode };
+        }
+        else if (context.Result is OkResult okResult)
+        {
+            var apiResult = new ApiResult(true, ApiResultStatusCode.Success);
+            context.Result = new JsonResult(apiResult) { StatusCode = okResult.StatusCode };
+        }
+        else if (context.Result is BadRequestResult badRequestResult)
+        {
+            var apiResult = new ApiResult(false, ApiResultStatusCode.BadRequest);
+            context.Result = new JsonResult(apiResult) { StatusCode = badRequestResult.StatusCode };
+            context.HttpContext.Response.StatusCode = 400;
+        }
+        else if (context.Result is BadRequestObjectResult badRequestObjectResult)
+        {
+            var message = badRequestObjectResult.Value.ToString();
+            if (badRequestObjectResult.Value is SerializableError errors)
+            {
+                var errorMessages = errors.SelectMany(p => (string[])p.Value).Distinct();
+                message = string.Join(" | ", errorMessages);
+            }
+            var apiResult = new ApiResult(false, ApiResultStatusCode.BadRequest, message);
+            context.Result = new JsonResult(apiResult) { StatusCode = badRequestObjectResult.StatusCode };
+            context.HttpContext.Response.StatusCode = 400;
+        }
+        else if (context.Result is ContentResult contentResult)
+        {
+            var apiResult = new ApiResult(true, ApiResultStatusCode.Success, contentResult.Content);
+            context.Result = new JsonResult(apiResult) { StatusCode = contentResult.StatusCode };
+        }
+        else if (context.Result is NotFoundResultAttribute notFoundResult)
+        {
+            var apiResult = new ApiResult(false, ApiResultStatusCode.NotFound);
+            context.Result = new JsonResult(apiResult) { StatusCode = StatusCodes.Status404NotFound };
+        }
+        else if (context.Result is NotFoundObjectResult notFoundObjectResult)
+        {
+            var apiResult = new ApiResult<object>(false, ApiResultStatusCode.NotFound, notFoundObjectResult.Value);
+            context.Result = new JsonResult(apiResult) { StatusCode = notFoundObjectResult.StatusCode };
+        }
+        else if (context.Result is ObjectResult objectResult && objectResult.StatusCode == null 
+                                                             && !(objectResult.Value is ApiResult))
+        {
+            var apiResult = new ApiResult<object>(true, ApiResultStatusCode.Success, objectResult.Value);
+            context.Result = new JsonResult(apiResult) { StatusCode = objectResult.StatusCode };
+        }
+
+        base.OnResultExecuting(context);
+    }
+}

server/src/API/CleanArc.WebFramework/Filters/BadRequestResultFilterAttribute.cs

@@ -0,0 +1,37 @@
+using CleanArc.Application.Models.ApiResult;
+using CleanArc.SharedKernel.Extensions;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace CleanArc.WebFramework.Filters;
+
+public class BadRequestResultFilterAttribute : ActionFilterAttribute
+{
+    public override void OnResultExecuting(ResultExecutingContext context)
+    {
+        if (!(context.Result is BadRequestObjectResult badRequestObjectResult)) return;
+
+        var modelState = context.ModelState;
+
+        if (!modelState.IsValid)
+        {
+            var errors = new ValidationProblemDetails(modelState);
+
+            var message = ApiResultStatusCode.BadRequest.ToDisplay();
+
+            var apiResult = new ApiResult<IDictionary<string, string[]>>(false, ApiResultStatusCode.BadRequest, errors.Errors, message);
+            context.Result = new JsonResult(apiResult) { StatusCode = badRequestObjectResult.StatusCode };
+            context.HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
+            return;
+        }
+        else
+        {
+               
+
+            var apiResult = new ApiResult<object>(false, ApiResultStatusCode.BadRequest,badRequestObjectResult.Value,ApiResultStatusCode.BadRequest.ToDisplay());
+            context.Result = new JsonResult(apiResult) { StatusCode = badRequestObjectResult.StatusCode };
+            context.HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
+        }
+    }
+}

server/src/API/CleanArc.WebFramework/Filters/ContentResultFilterAttribute.cs

@@ -0,0 +1,15 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace CleanArc.WebFramework.Filters;
+
+public class ContentResultFilterAttribute : ResultFilterAttribute
+{
+    public override void OnResultExecuting(ResultExecutingContext context)
+    {
+        if (!(context.Result is ContentResult contentResult)) return;
+        var apiResult = new ApiResult(true, ApiResultStatusCode.Success, contentResult.Content);
+        context.Result = new JsonResult(apiResult) { StatusCode = contentResult.StatusCode };
+    }
+}

server/src/API/CleanArc.WebFramework/Filters/ModelStateValidationAttribute.cs

@@ -0,0 +1,62 @@
+using CleanArc.Application.Models.ApiResult;
+using CleanArc.SharedKernel.Extensions;
+using FluentValidation;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using StatusCodes = Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace CleanArc.WebFramework.Filters;
+
+public class ModelStateValidationAttribute : ActionFilterAttribute
+{
+    public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+    {
+        foreach (var contextActionArgument in context.ActionArguments.Values)
+        {
+            var viewModelValidator =
+                context.HttpContext.RequestServices.GetService(
+                    typeof(IValidator<>).MakeGenericType(contextActionArgument.GetType()));
+
+            if (viewModelValidator is IValidator validator)
+            {
+                var validationResult =await validator.ValidateAsync(new ValidationContext<object>(contextActionArgument));
+
+                if (!validationResult.IsValid)
+                {
+                    foreach (var validationResultError in validationResult.Errors)
+                    {
+                        context.ModelState.AddModelError(validationResultError.PropertyName, validationResultError.ErrorMessage);
+                    }
+                }
+            }
+        }
+
+        var modelState = context.ModelState;
+
+        if (!modelState.IsValid)
+        {
+
+            var model = context.ActionArguments.FirstOrDefault().Value;
+
+            if (model != null)
+            {
+                var errors = new ValidationProblemDetails(modelState);
+
+                var message = ApiResultStatusCode.BadRequest.ToDisplay();
+
+                var apiResult = new ApiResult<IDictionary<string, string[]>>(false, ApiResultStatusCode.BadRequest, errors.Errors, message);
+                context.Result = new JsonResult(apiResult) { StatusCode = StatusCodes.Status400BadRequest };
+                context.HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
+            }
+
+            else
+            {
+                var apiResult = new ApiResult(false, ApiResultStatusCode.BadRequest);
+                context.Result = new JsonResult(apiResult) { StatusCode = 400 };
+                context.HttpContext.Response.StatusCode = 400;
+            }
+        }
+
+        await base.OnActionExecutionAsync(context, next);
+    }
+}

server/src/API/CleanArc.WebFramework/Filters/NotFoundResultAttribute.cs

@@ -0,0 +1,24 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace CleanArc.WebFramework.Filters;
+
+public class NotFoundResultAttribute : ResultFilterAttribute
+{
+    public override void OnResultExecuting(ResultExecutingContext context)
+    {
+        if ((context.Result is NotFoundObjectResult notFoundObjectResult))
+        {
+            var apiResult = new ApiResult<object>(false, ApiResultStatusCode.NotFound, notFoundObjectResult.Value);
+            context.Result = new JsonResult(apiResult) { StatusCode = notFoundObjectResult.StatusCode };
+        }
+
+        else if(context.Result is NotFoundResult)
+        {
+            var apiResult = new ApiResult(false, ApiResultStatusCode.NotFound);
+            context.Result = new JsonResult(apiResult) { StatusCode =StatusCodes.Status404NotFound };
+        }
+    }
+}

server/src/API/CleanArc.WebFramework/Filters/OkResultAttribute.cs

@@ -0,0 +1,28 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace CleanArc.WebFramework.Filters;
+
+public class OkResultAttribute:ResultFilterAttribute
+{
+    public override void OnResultExecuting(ResultExecutingContext context)
+    {
+        switch (context.Result)
+        {
+            case OkObjectResult okObjectResult:
+            {
+                var apiResult = new ApiResult<object>(true, ApiResultStatusCode.Success, okObjectResult.Value);
+                context.Result = new JsonResult(apiResult) { StatusCode = okObjectResult.StatusCode };
+                break;
+            }
+            case OkResult okResult:
+            {
+                var apiResult = new ApiResult(true, ApiResultStatusCode.Success);
+                context.Result = new JsonResult(apiResult) { StatusCode = okResult.StatusCode };
+                break;
+            }
+            default:return;
+        }
+    }
+}

server/src/API/CleanArc.WebFramework/Filters/ServerErrorResult.cs

@@ -0,0 +1,22 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CleanArc.WebFramework.Filters;
+
+public class ServerErrorResult:IActionResult
+{
+    public string Message { get;}
+
+    public ServerErrorResult(string message)
+    {
+        Message = message;
+    }
+
+    public async Task ExecuteResultAsync(ActionContext context)
+    {
+        context.HttpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
+        var response = new ApiResult(false, ApiResultStatusCode.ServerError, Message);
+        await context.HttpContext.Response.WriteAsJsonAsync(response);
+    }
+}

server/src/API/CleanArc.WebFramework/Middlewares/ExceptionHandler.cs

@@ -0,0 +1,63 @@
+using CleanArc.Application.Models.ApiResult;
+using Microsoft.AspNetCore.Diagnostics;
+using Microsoft.AspNetCore.Http;
+using CleanArc.SharedKernel.Extensions;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace CleanArc.WebFramework.Middlewares;
+
+public class ExceptionHandler(ILogger<ExceptionHandler> logger,IWebHostEnvironment environment) : IExceptionHandler
+{
+    
+    public async ValueTask<bool> TryHandleAsync(HttpContext context, Exception exception, CancellationToken cancellationToken)
+    {
+        if (environment.IsDevelopment())
+            return false;
+
+        if (exception is FluentValidation.ValidationException validationException)
+        {
+            context.Response.StatusCode = StatusCodes.Status422UnprocessableEntity;
+
+            var errors = new Dictionary<string, List<string>>();
+
+            foreach (var validationExceptionError in validationException.Errors)
+            {
+                if (!errors.ContainsKey(validationExceptionError.PropertyName))
+                    errors.Add(validationExceptionError.PropertyName, new List<string>() { validationExceptionError.ErrorMessage });
+                else
+                    errors[validationExceptionError.PropertyName].Add(validationExceptionError.ErrorMessage);
+
+            }
+
+            var apiResult = new ApiResult<IDictionary<string, List<string>>>(false, ApiResultStatusCode.EntityProcessError, errors, ApiResultStatusCode.EntityProcessError.ToDisplay());
+
+            context.Response.ContentType = "application/problem+json";
+            await context.Response.WriteAsJsonAsync(apiResult, cancellationToken: cancellationToken);
+
+            return true;
+        }
+
+        var exceptionFeature = context.Features.Get<IExceptionHandlerPathFeature>();
+
+        if (exceptionFeature is not null)
+            logger.LogError(exceptionFeature.Error,
+                "Unhandled exception occured. Path: {exceptionUrlPath} ."
+                , exceptionFeature.Path
+            );
+
+        else
+            logger.LogError(exception, "Error captured in global exception handler");
+
+        context.Response.StatusCode = StatusCodes.Status500InternalServerError;
+
+        context.Response.ContentType = "application/problem+json";
+        var response = new ApiResult(false,
+            ApiResultStatusCode.ServerError, "Internal Server Error");
+        context.Response.StatusCode = StatusCodes.Status500InternalServerError;
+        await context.Response.WriteAsJsonAsync(response, cancellationToken: cancellationToken);
+
+        return true;
+    }
+}

server/src/API/CleanArc.WebFramework/ServiceConfiguration/ServiceCollectionExtension.cs

@@ -0,0 +1,45 @@
+using Asp.Versioning;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace CleanArc.WebFramework.ServiceConfiguration;
+
+public static class ServiceCollectionExtension
+{
+    public static IServiceCollection AddWebFrameworkServices(this IServiceCollection services)
+    {
+        services.AddApiVersioning(options =>
+        {
+            //url segment => {version}
+            options.AssumeDefaultVersionWhenUnspecified = true; //default => false;
+            options.DefaultApiVersion = new ApiVersion(1, 0); //v1.0 == v1
+            options.ReportApiVersions = true;
+
+            //ApiVersion.TryParse("1.0", out var version10);
+            //ApiVersion.TryParse("1", out var version1);
+            //var a = version10 == version1;
+
+            //options.ApiVersionReader = new QueryStringApiVersionReader("api-version");
+            // api/posts?api-version=1
+
+            //options.ApiVersionReader = new UrlSegmentApiVersionReader();
+            // api/v1/posts
+
+            //options.ApiVersionReader = new HeaderApiVersionReader(new[] { "Api-Version" });
+            // header => Api-Version : 1
+
+            //options.ApiVersionReader = new MediaTypeApiVersionReader()
+
+            //options.ApiVersionReader = ApiVersionReader.Combine(new QueryStringApiVersionReader("api-version"), new UrlSegmentApiVersionReader())
+            // combine of [querystring] & [urlsegment]
+        }).AddMvc() 
+        .AddApiExplorer(options =>
+        {
+            options.GroupNameFormat = "'v'V";
+            options.SubstituteApiVersionInUrl = true;
+        });;
+
+        return services;
+
+
+    }
+}

server/src/API/CleanArc.WebFramework/Swagger/ApiVersionDocumentProcessor.cs

@@ -0,0 +1,25 @@
+using CleanArc.SharedKernel.Extensions;
+using NSwag.Generation.Processors;
+using NSwag.Generation.Processors.Contexts;
+
+namespace CleanArc.WebFramework.Swagger;
+
+public class ApiVersionDocumentProcessor: IDocumentProcessor
+{
+    public void Process(DocumentProcessorContext context)
+    {
+        // Filter out operations that do not match the current document version
+        var version = context.Document.Info.Version; // e.g., "v1"
+
+        var pathsToRemove = context.Document.Paths
+            .Where(pathItem => !RegExHelpers.MatchesApiVersion( version,pathItem.Key))
+            .Select(path => path.Key)
+            .ToList();
+
+        
+        foreach (var path in pathsToRemove)
+        {
+            context.Document.Paths.Remove(path);
+        }
+    }
+}

server/src/API/CleanArc.WebFramework/Swagger/ApplySummariesOperationFilter.cs

@@ -0,0 +1,122 @@
+using NSwag.Generation.Processors;
+using NSwag.Generation.Processors.Contexts;
+using Pluralize.NET;
+
+
+namespace CleanArc.WebFramework.Swagger;
+
+public class ApplySummariesOperationFilter : IOperationProcessor
+{
+  
+
+    public bool Process(OperationProcessorContext context)
+    {
+
+        if (context.ControllerType is null)
+            return true;
+        
+        var actionName = context.MethodInfo.Name;
+        var controllerName = context.ControllerType.Name.Replace("Controller", "");
+        
+        var pluralizer = new Pluralizer();
+        
+        var singularizeName =pluralizer.Singularize(controllerName);
+        var pluralizeName = pluralizer.Pluralize(singularizeName);
+
+        var parameterCount = context.OperationDescription.Operation.Parameters
+                              .Count(p => p.Name != "version" && p.Name != "api-version");
+
+        if (IsGetAllAction(actionName, pluralizeName, singularizeName, parameterCount))
+        {
+            if (string.IsNullOrEmpty(context.OperationDescription.Operation.Summary))
+            {
+                context.OperationDescription.Operation.Summary = $"Returns all {pluralizeName}";
+            }
+        }
+        else if (IsActionName(actionName, singularizeName, "Post", "Create"))
+        {
+            if (string.IsNullOrEmpty(context.OperationDescription.Operation.Summary))
+            {
+                context.OperationDescription.Operation.Summary = $"Creates a {singularizeName}";
+            }
+
+            if (context.OperationDescription.Operation.Parameters.Count > 0 &&
+                string.IsNullOrEmpty(context.OperationDescription.Operation.Parameters[0].Description))
+            {
+                context.OperationDescription.Operation.Parameters[0].Description = $"A {singularizeName} representation";
+            }
+        }
+        else if (IsActionName(actionName, singularizeName, "Read", "Get"))
+        {
+            if (string.IsNullOrEmpty(context.OperationDescription.Operation.Summary))
+            {
+                context.OperationDescription.Operation.Summary = $"Retrieves a {singularizeName} by unique id";
+            }
+
+            if (context.OperationDescription.Operation.Parameters.Count > 0 &&
+                string.IsNullOrEmpty(context.OperationDescription.Operation.Parameters[0].Description))
+            {
+                context.OperationDescription.Operation.Parameters[0].Description = $"A unique id for the {singularizeName}";
+            }
+        }
+        else if (IsActionName(actionName, singularizeName, "Put", "Edit", "Update"))
+        {
+            if (string.IsNullOrEmpty(context.OperationDescription.Operation.Summary))
+            {
+                context.OperationDescription.Operation.Summary = $"Updates a {singularizeName} by unique id";
+            }
+
+            if (context.OperationDescription.Operation.Parameters.Count > 0 &&
+                string.IsNullOrEmpty(context.OperationDescription.Operation.Parameters[0].Description))
+            {
+                context.OperationDescription.Operation.Parameters[0].Description = $"A {singularizeName} representation";
+            }
+        }
+        else if (IsActionName(actionName, singularizeName, "Delete", "Remove"))
+        {
+            if (string.IsNullOrEmpty(context.OperationDescription.Operation.Summary))
+            {
+                context.OperationDescription.Operation.Summary = $"Deletes a {singularizeName} by unique id";
+            }
+
+            if (context.OperationDescription.Operation.Parameters.Count > 0 &&
+                string.IsNullOrEmpty(context.OperationDescription.Operation.Parameters[0].Description))
+            {
+                context.OperationDescription.Operation.Parameters[0].Description = $"A unique id for the {singularizeName}";
+            }
+        }
+
+        return true;
+    }
+    private bool IsActionName(string actionName, string singularizeName, params string[] names)
+    {
+        foreach (var name in names)
+        {
+            if (actionName.Equals(name, StringComparison.OrdinalIgnoreCase) ||
+                actionName.Equals($"{name}ById", StringComparison.OrdinalIgnoreCase) ||
+                actionName.Equals($"{name}{singularizeName}", StringComparison.OrdinalIgnoreCase) ||
+                actionName.Equals($"{name}{singularizeName}ById", StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+    private bool IsGetAllAction(string actionName, string pluralizeName, string singularizeName, int parameterCount)
+    {
+        var actionNames = new[] { "Get", "Read", "Select" };
+        foreach (var name in actionNames)
+        {
+            if ((actionName.Equals(name, StringComparison.OrdinalIgnoreCase) && parameterCount == 0) ||
+                actionName.Equals($"{name}All", StringComparison.OrdinalIgnoreCase) ||
+                actionName.Equals($"{name}{pluralizeName}", StringComparison.OrdinalIgnoreCase) ||
+                actionName.Equals($"{name}All{singularizeName}", StringComparison.OrdinalIgnoreCase) ||
+                actionName.Equals($"{name}All{pluralizeName}", StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+}

server/src/API/CleanArc.WebFramework/Swagger/CustomTokenRequiredOperationFilter.cs

@@ -0,0 +1,36 @@
+using NSwag;
+using NSwag.Generation.Processors;
+using NSwag.Generation.Processors.Contexts;
+
+
+namespace CleanArc.WebFramework.Swagger;
+
+public class CustomTokenRequiredOperationFilter : IOperationProcessor
+{
+    
+    public bool Process(OperationProcessorContext context)
+    {
+        var hasAttribute = context.MethodInfo
+            .GetCustomAttributes(typeof(RequireTokenWithoutAuthorizationAttribute), false).Any();
+
+        if (hasAttribute)
+        {
+            // Add security requirements to the operation
+            var securityScheme = new OpenApiSecurityScheme
+            {
+                Type = OpenApiSecuritySchemeType.Http,
+                Scheme = "bearer",
+                BearerFormat = "JWT",
+                In = OpenApiSecurityApiKeyLocation.Header,
+                Name = "Authorization"
+            };
+
+            var securityRequirement = new OpenApiSecurityRequirement { { securityScheme.Scheme, new List<string>() } };
+
+            
+            context.OperationDescription.Operation.Security=[securityRequirement];
+        }
+
+        return true;
+    }
+}

server/src/API/CleanArc.WebFramework/Swagger/RequireTokenWithoutAuthorizationAttribute.cs

@@ -0,0 +1,11 @@
+namespace CleanArc.WebFramework.Swagger;
+
+
+/// <summary>
+/// Marker Attribute for Custom Actions or controllers that need token but without authorization check
+/// </summary>
+[AttributeUsage(AttributeTargets.Class| AttributeTargets.Method)]
+public class RequireTokenWithoutAuthorizationAttribute : Attribute
+{
+
+};

server/src/API/CleanArc.WebFramework/Swagger/SwaggerConfigurationExtensions.cs

@@ -0,0 +1,69 @@
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using NSwag;
+
+namespace CleanArc.WebFramework.Swagger;
+
+public static class SwaggerConfigurationExtensions
+{
+    public static void AddSwagger(this IServiceCollection services,
+        params string[] versions)
+    {
+        ArgumentNullException.ThrowIfNull(services, nameof(services));
+
+
+        foreach (var version in versions)
+        {
+            services.AddOpenApiDocument(options =>
+            {
+                options.Title = "Clean Architecture OpenAPI docs";
+                options.Version = version;
+                options.DocumentName = version;
+               
+                
+                options.AddSecurity("Bearer", new NSwag.OpenApiSecurityScheme()
+                {
+                    Description = "Enter JWT Token ONLY",
+                    In = OpenApiSecurityApiKeyLocation.Header,
+                    Name = "Authorization",
+                    Type = OpenApiSecuritySchemeType.Http,
+                    Scheme = JwtBearerDefaults.AuthenticationScheme,
+                });
+
+                options.DocumentProcessors.Add(new ApiVersionDocumentProcessor());
+                options.OperationProcessors.Add(new ApplySummariesOperationFilter());
+                options.OperationProcessors.Add(new CustomTokenRequiredOperationFilter());
+
+                options.OperationProcessors.Add(
+                    new NSwag.Generation.Processors.Security.AspNetCoreOperationSecurityScopeProcessor("Bearer"));
+                
+                
+            });
+        }
+    }
+
+    public static void UseSwaggerAndUi(this WebApplication app)
+    {
+        ArgumentNullException.ThrowIfNull(app, nameof(app));
+
+        app.UseOpenApi();
+
+        app.UseSwaggerUi(options =>
+        {
+            options.PersistAuthorization = true;
+
+            options.EnableTryItOut = true;
+
+            options.Path = "/swagger";
+            
+        });
+
+        app.UseReDoc(settings =>
+        {
+            settings.Path = "/api-docs/{documentName}";
+            settings.DocumentTitle = "Clean Architecture API doc sample";
+        });
+    }
+}

server/src/API/Plugins/CleanArc.Web.Plugins.Grpc/CleanArc.Web.Plugins.Grpc.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Grpc.AspNetCore" />
+    <PackageReference Include="Grpc.AspNetCore.Server.Reflection" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Core\CleanArc.Application\CleanArc.Application.csproj" />
+  </ItemGroup>
+
+	<ItemGroup>
+		<Protobuf Include="ProtoModels\UserGrpcServiceModels.proto" GrpcServices="Server" />
+		<Protobuf Include="ProtoModels\OrderGrpcServiceModels.proto" GrpcServices="Server" />
+	</ItemGroup>
+
+	
+	<ItemGroup>
+		<FrameworkReference Include="Microsoft.AspNetCore.App" />
+	</ItemGroup>	
+</Project>

server/src/API/Plugins/CleanArc.Web.Plugins.Grpc/GrpcPluginStartup.cs

@@ -0,0 +1,39 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using CleanArc.Web.Plugins.Grpc.Services;
+
+namespace CleanArc.Web.Plugins.Grpc;
+
+public static class GrpcPluginStartup
+{
+    public static IServiceCollection ConfigureGrpcPluginServices(this IServiceCollection services)
+    {
+     
+        
+        services.AddGrpc();
+        services.AddGrpcReflection();
+
+        return services;
+    }
+
+    public static void ConfigureGrpcPipeline(this WebApplication app)
+    {
+
+        app.MapGrpcService<UserGrpcServices>();
+        app.MapGrpcService<OrderGrpcServices>();
+        app.MapGrpcReflectionService();
+
+        app.MapGet("/GrpcUser", async context =>
+        {
+            await context.Response.WriteAsync(
+                "Communication with this gRPC endpoint must be made through a gRPC client.");
+        });
+
+        app.MapGet("/GrpcUserOrder", async context =>
+        {
+            await context.Response.WriteAsync(
+                "Communication with this gRPC endpoint must be made through a gRPC client.");
+        });
+    }
+}

server/src/API/Plugins/CleanArc.Web.Plugins.Grpc/ProtoModels/OrderGrpcServiceModels.proto

@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+option csharp_namespace = "CleanArc.Web.Plugins.Grpc.ProtoModels";
+import "google/protobuf/empty.proto";
+
+package GrpcOrderController;
+
+
+service OrderServices {
+	rpc GetUserOrders(google.protobuf.Empty) returns (stream GetUserOrdersModel);
+}
+
+message GetUserOrdersModel{
+	int32 OrderId=1;
+	string OrderName=2;
+}
+

server/src/API/Plugins/CleanArc.Web.Plugins.Grpc/ProtoModels/UserGrpcServiceModels.proto

@@ -0,0 +1,44 @@
+
+syntax = "proto3";
+
+option csharp_namespace = "CleanArc.Web.Plugins.Grpc.ProtoModels";
+
+package GrpcUserController;
+
+service UserServices {
+	rpc TokenRequest(UserTokenRequest) returns (TokenRequestResult);
+	rpc GetUserToken(GetUserTokenRequestModel) returns (GetUserTokenRequestResult);
+}
+
+message UserTokenRequest{
+	string PhoneNumber=1;
+}
+
+message TokenRequestResult{
+	string Message=1;
+	bool IsSuccess=2;
+ 	TokenRequestResultModel UserTokenRequestResult=3;
+}
+
+message TokenRequestResultModel{
+	string UserKey=1;
+}
+
+message GetUserTokenRequestModel
+{
+	string UserKey=1;
+	string Code=2;
+}
+
+message GetUserTokenRequestResult{
+	string Message=1;
+	bool IsSuccess=2;
+	UserToken Token=3;
+}
+
+message UserToken{
+	string AccessToken=1;
+	string RefreshToken=2;
+	string TokenType=3;
+	int32 ExpiresIn=4;
+}

server/src/API/Plugins/CleanArc.Web.Plugins.Grpc/Services/OrderGrpcServices.cs

@@ -0,0 +1,46 @@
+using CleanArc.Application.Features.Order.Queries.GetUserOrders;
+using CleanArc.SharedKernel.Extensions;
+using CleanArc.Web.Plugins.Grpc.ProtoModels;
+using Google.Protobuf.WellKnownTypes;
+using Grpc.Core;
+using Mediator;
+using Microsoft.AspNetCore.Authorization;
+
+namespace CleanArc.Web.Plugins.Grpc.Services
+{
+    [Authorize]
+    public class OrderGrpcServices:OrderServices.OrderServicesBase
+    {
+       
+
+        private readonly ISender _sender;
+
+        public OrderGrpcServices(ISender sender)
+        {
+            _sender = sender;
+        }
+
+        public override async Task GetUserOrders(Empty request, IServerStreamWriter<GetUserOrdersModel> responseStream, ServerCallContext context)
+        {
+            var userId = int.Parse(context.GetHttpContext().User.Identity.GetUserId());
+
+            var query = await _sender.Send(new GetUserOrdersQueryModel(userId));
+
+            if (!query.IsSuccess)
+            {
+                context.Status = new Status(StatusCode.InvalidArgument, query.GetErrorMessage());
+                return;
+            }
+
+            foreach (var getUsersQueryResultModel in query.Result)
+            {
+                    await responseStream.WriteAsync(new GetUserOrdersModel()
+                        { OrderId = getUsersQueryResultModel.OrderId, OrderName = getUsersQueryResultModel.OrderName });
+
+                    await Task.Delay(400);
+                
+            }
+
+        }
+    }
+}

server/src/API/Plugins/CleanArc.Web.Plugins.Grpc/Services/UserGrpcServices.cs

@@ -0,0 +1,83 @@
+using CleanArc.Application.Features.Users.Queries.GenerateUserToken;
+using CleanArc.Application.Features.Users.Queries.TokenRequest;
+using CleanArc.Web.Plugins.Grpc.ProtoModels;
+using Grpc.Core;
+using Mediator;
+
+namespace CleanArc.Web.Plugins.Grpc.Services;
+
+public class UserGrpcServices : UserServices.UserServicesBase
+{
+    private readonly IMediator _mediator;
+
+    public UserGrpcServices(IMediator mediator)
+    {
+        _mediator = mediator;
+    }
+
+    public override async Task<TokenRequestResult> TokenRequest(UserTokenRequest request, ServerCallContext context)
+    {
+        if (request is null)
+        {
+            context.Status = new Status(StatusCode.InvalidArgument, "Required Arguments Not Found");
+
+            return new TokenRequestResult() { IsSuccess = false, Message = "Input Model Not Found" };
+        }
+
+        var tokenQuery = await _mediator.Send(new UserTokenRequestQuery(request.PhoneNumber));
+
+        if (!tokenQuery.IsSuccess)
+        {
+            context.Status = new Status(StatusCode.InvalidArgument, "User not found");
+
+            return new TokenRequestResult()
+            { IsSuccess = false, Message = tokenQuery.GetErrorMessage(), UserTokenRequestResult = null };
+        }
+
+        if (tokenQuery.IsNotFound)
+        {
+            context.Status = new Status(StatusCode.NotFound, "User Not Found");
+
+            return new TokenRequestResult()
+            { IsSuccess = false, Message = tokenQuery.GetErrorMessage(), UserTokenRequestResult = null };
+        }
+
+        return new TokenRequestResult()
+        {
+            IsSuccess = true,
+            Message = string.Empty,
+            UserTokenRequestResult = new TokenRequestResultModel() { UserKey = tokenQuery.Result.UserKey }
+        };
+    }
+
+    public override async Task<GetUserTokenRequestResult> GetUserToken(GetUserTokenRequestModel request, ServerCallContext context)
+    {
+
+        if (request is null)
+        {
+            context.Status = new Status(StatusCode.InvalidArgument, "Required Arguments Not Found");
+
+            return new GetUserTokenRequestResult() { IsSuccess = false, Message = "Input Model Not Found" };
+        }
+
+        var tokenQuery = await _mediator.Send(new GenerateUserTokenQuery(request.UserKey, request.Code));
+
+        if (!tokenQuery.IsSuccess)
+        {
+            context.Status = new Status(StatusCode.InvalidArgument, tokenQuery.GetErrorMessage());
+
+            return new GetUserTokenRequestResult() { IsSuccess = false, Message = tokenQuery.GetErrorMessage() };
+        }
+
+
+        return new GetUserTokenRequestResult()
+        {
+            IsSuccess = true, Message = string.Empty,
+            Token = new UserToken()
+            {
+                AccessToken = tokenQuery.Result.access_token, ExpiresIn = tokenQuery.Result.expires_in,
+                RefreshToken = tokenQuery.Result.refresh_token, TokenType = tokenQuery.Result.token_type
+            }
+        };
+    }
+}

server/src/Core/CleanArc.Application/CleanArc.Application.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+	  <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Common\ValidationBase\**" />
+    <EmbeddedResource Remove="Common\ValidationBase\**" />
+    <None Remove="Common\ValidationBase\**" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CleanArc.Domain\CleanArc.Domain.csproj" />
+    <PackageReference Include="Mediator.SourceGenerator">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Mediator.Abstractions" />
+    <PackageReference Include="System.Linq.Async" />
+  </ItemGroup>
+
+</Project>

server/src/Core/CleanArc.Application/Common/LoggingBehavior.cs

@@ -0,0 +1,34 @@
+using CleanArc.Application.Models.Common;
+using Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace CleanArc.Application.Common;
+
+public class LoggingBehavior<TRequest, TResponse>(ILogger<LoggingBehavior<TRequest, TResponse>> logger)
+    : IPipelineBehavior<TRequest, TResponse>
+    where TResponse : class
+    where TRequest : IRequest<TResponse>
+{
+    
+    public async ValueTask<TResponse> Handle(TRequest message, MessageHandlerDelegate<TRequest, TResponse> next, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var response = await next(message,cancellationToken);
+            return response;
+        }
+        catch (Exception e)
+        {
+            logger.LogError(e, e.Message);
+
+            if (typeof(TResponse).GetGenericTypeDefinition() == typeof(OperationResult<>))
+            {
+                var response = new OperationResult<TResponse> { IsException = true };
+
+                return response as TResponse;
+            }
+
+            return default;
+        }
+    }
+}

server/src/Core/CleanArc.Application/Common/MetricsBehaviour.cs

@@ -0,0 +1,33 @@
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+using Mediator;
+
+namespace CleanArc.Application.Common;
+
+public class MetricsBehaviour<TRequest, TResponse> : 
+    IPipelineBehavior<TRequest, TResponse>  where TRequest : IRequest<TResponse>
+{
+    private readonly Histogram<long> _requestResponseDurationHistogram;
+
+    public MetricsBehaviour(IMeterFactory meterFactory)
+    {
+        var meter = meterFactory.Create("mediator_meter");
+        _requestResponseDurationHistogram = meter.CreateHistogram<long>(
+            "Request_Response_Duration", "ms"
+            , "Determines the total request response durations");
+    }
+    
+
+    public async ValueTask<TResponse> Handle(TRequest message, MessageHandlerDelegate<TRequest, TResponse> next, CancellationToken cancellationToken)
+    {
+        var stopWatch = Stopwatch.StartNew();
+
+        var response = await next(message,cancellationToken);
+        
+        stopWatch.Stop();
+        
+        _requestResponseDurationHistogram.Record(stopWatch.ElapsedMilliseconds,new []{new KeyValuePair<string, object>("Request",message.GetType().Name)});
+
+        return response;
+    }
+}

server/src/Core/CleanArc.Application/Common/ValidateCommandBehavior.cs

@@ -0,0 +1,40 @@
+using CleanArc.Application.Models.Common;
+using FluentValidation;
+using FluentValidation.Results;
+using Mediator;
+
+namespace CleanArc.Application.Common;
+
+public class ValidateCommandBehavior<TRequest, TResponse>(IEnumerable<IValidator<TRequest>> validators)
+    : IPipelineBehavior<TRequest, TResponse>
+    where TResponse : IOperationResult, new()
+    where TRequest : IRequest<TResponse>
+{
+   
+    public async ValueTask<TResponse> Handle(TRequest message, MessageHandlerDelegate<TRequest, TResponse> next, CancellationToken cancellationToken)
+    {
+        var errors = new List<ValidationFailure>();
+
+
+        foreach (var validator in validators)
+        {
+            var validationResult =
+                await validator.ValidateAsync(new ValidationContext<TRequest>(message), cancellationToken);
+
+            if (!validationResult.IsValid)
+                errors.AddRange(validationResult.Errors);
+        }
+
+        if (errors.Any())
+        {
+            return new TResponse()
+            {
+                ErrorMessages = errors.Select(c => new KeyValuePair<string, string>(c.PropertyName, c.ErrorMessage))
+                    .ToList()
+            };
+        }
+
+
+        return await next(message, cancellationToken);
+    }
+}

server/src/Core/CleanArc.Application/Contracts/IJwtService.cs

@@ -0,0 +1,13 @@
+using System.Security.Claims;
+using CleanArc.Application.Models.Jwt;
+using CleanArc.Domain.Entities.User;
+
+namespace CleanArc.Application.Contracts;
+
+public interface IJwtService
+{
+    Task<AccessToken> GenerateAsync(User user);
+    Task<ClaimsPrincipal> GetPrincipalFromExpiredToken(string token);
+    Task<AccessToken> GenerateByPhoneNumberAsync(string phoneNumber);
+    Task<AccessToken> RefreshToken(Guid refreshTokenId);
+}

server/src/Core/CleanArc.Application/Contracts/Identity/IAppUserManager.cs

@@ -0,0 +1,31 @@
+using CleanArc.Domain.Entities.User;
+using Microsoft.AspNetCore.Identity;
+
+namespace CleanArc.Application.Contracts.Identity;
+
+public interface IAppUserManager
+{
+    Task<IdentityResult> CreateUser(User user);
+    Task<IdentityResult> CreateUser(User user,string password);
+    Task<bool> IsExistUser(string phoneNumber);
+    Task<bool> IsExistUserName(string userName);
+    Task<string> GeneratePhoneNumberConfirmationToken(User user, string phoneNumber);
+    Task<User> GetUserByCode(string code);
+    Task<IdentityResult> ChangePhoneNumber(User user, string phoneNumber, string code);
+    Task<IdentityResult> VerifyUserCode(User user,string code);
+    Task<string> GenerateOtpCode(User user);
+    Task<User> GetUserByPhoneNumber(string phoneNumber);
+    Task<User> GetByUserName(string userName);
+    Task<User> GetUserByIdAsync(int userId);
+    Task<List<User>> GetAllUsersAsync();
+    Task<IdentityResult> CreateUserWithPasswordAsync(User user,string password);
+    Task<IdentityResult> AddUserToRoleAsync(User user, Role role);
+    Task<IdentityResult> IncrementAccessFailedCountAsync(User user);
+    Task<bool> IsUserLockedOutAsync(User user);
+    Task ResetUserLockoutAsync(User user);
+    Task UpdateUserAsync(User user);
+    Task UpdateSecurityStampAsync(User user);
+    
+    Task<bool> IsPasswordValidAsync(User user, string password);
+    Task<string[]> GetRoleAsync(User user);
+}

server/src/Core/CleanArc.Application/Contracts/Identity/IRoleManagerService.cs

@@ -0,0 +1,16 @@
+using CleanArc.Application.Models.Identity;
+using CleanArc.Domain.Entities.User;
+using Microsoft.AspNetCore.Identity;
+
+namespace CleanArc.Application.Contracts.Identity;
+
+public interface IRoleManagerService
+{
+    Task<List<GetRolesDto>> GetRolesAsync();
+    Task<IdentityResult> CreateRoleAsync(CreateRoleDto model);
+    Task<bool> DeleteRoleAsync(int roleId);
+    Task<List<ActionDescriptionDto>> GetPermissionActionsAsync();
+    Task<RolePermissionDto> GetRolePermissionsAsync(int roleId);
+    Task<bool> ChangeRolePermissionsAsync(EditRolePermissionsDto model);
+    Task<Role> GetRoleByIdAsync(int roleId);
+}

server/src/Core/CleanArc.Application/Contracts/Persistence/IOrderRepository.cs

@@ -0,0 +1,12 @@
+using CleanArc.Domain.Entities.Order;
+
+namespace CleanArc.Application.Contracts.Persistence;
+
+public interface IOrderRepository
+{
+    Task AddOrderAsync(Order order);
+    Task<List<Order>> GetAllUserOrdersAsync(int userId);
+    Task<List<Order>> GetAllOrdersWithRelatedUserAsync();
+    Task<Order> GetUserOrderByIdAndUserIdAsync(int userId,int orderId,bool trackEntity);
+    Task DeleteUserOrdersAsync(int userId);
+}

server/src/Core/CleanArc.Application/Contracts/Persistence/IUnitOfWork.cs

@@ -0,0 +1,9 @@
+namespace CleanArc.Application.Contracts.Persistence;
+
+public interface IUnitOfWork
+{
+    public IUserRefreshTokenRepository UserRefreshTokenRepository { get; }
+    public IOrderRepository OrderRepository { get; }
+    Task CommitAsync();
+    ValueTask RollBackAsync();
+}

server/src/Core/CleanArc.Application/Contracts/Persistence/IUserRefreshTokenRepository.cs

@@ -0,0 +1,11 @@
+using CleanArc.Domain.Entities.User;
+
+namespace CleanArc.Application.Contracts.Persistence;
+
+public interface IUserRefreshTokenRepository
+{
+    Task<Guid> CreateToken(int userId);
+    Task<UserRefreshToken> GetTokenWithInvalidation(Guid id);
+    Task<User> GetUserByRefreshToken(Guid tokenId);
+    Task RemoveUserOldTokens(int userId, CancellationToken cancellationToken);
+}

server/src/Core/CleanArc.Application/Features/Admin/Commands/AddAdminCommand/AddAdminCommand.Handler.cs

@@ -0,0 +1,44 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using CleanArc.Domain.Entities.User;
+using CleanArc.SharedKernel.Extensions;
+using Mediator;
+
+namespace CleanArc.Application.Features.Admin.Commands.AddAdminCommand
+{
+    internal class AddAdminCommandHandler:IRequestHandler<AddAdminCommand,OperationResult<bool>>
+    {
+        private readonly IAppUserManager _userManager;
+        private readonly IRoleManagerService _roleManagerService;
+
+        public AddAdminCommandHandler(IAppUserManager userManager, IRoleManagerService roleManagerService)
+        {
+            _userManager = userManager;
+            _roleManagerService = roleManagerService;
+        }
+
+        public async ValueTask<OperationResult<bool>> Handle(AddAdminCommand request, CancellationToken cancellationToken)
+        {
+            var role = await _roleManagerService.GetRoleByIdAsync(request.RoleId);
+
+            if(role is null)
+                return OperationResult<bool>.NotFoundResult("Specified role not found");
+
+            var newAdmin = new User { UserName = request.UserName, Email = request.Email };
+
+            var adminCreateResult =
+                await _userManager.CreateUserWithPasswordAsync(
+                    newAdmin, request.Password);
+
+            if(!adminCreateResult.Succeeded)
+                return OperationResult<bool>.FailureResult(adminCreateResult.Errors.StringifyIdentityResultErrors());
+
+            var addAdminToRoleResult = await _userManager.AddUserToRoleAsync(newAdmin, role);
+
+            if(addAdminToRoleResult.Succeeded)
+                return OperationResult<bool>.SuccessResult(true);
+
+            return OperationResult<bool>.FailureResult(addAdminToRoleResult.Errors.StringifyIdentityResultErrors());
+        }
+    }
+}

server/src/Core/CleanArc.Application/Features/Admin/Commands/AddAdminCommand/AddAdminCommand.cs

@@ -0,0 +1,31 @@
+using CleanArc.Application.Models.Common;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+
+namespace CleanArc.Application.Features.Admin.Commands.AddAdminCommand;
+
+public record AddAdminCommand
+    (string UserName, string Email, string Password, int RoleId) : IRequest<OperationResult<bool>>,
+        IValidatableModel<AddAdminCommand>
+{
+    public IValidator<AddAdminCommand> ValidateApplicationModel(ApplicationBaseValidationModelProvider<AddAdminCommand> validator)
+    {
+        validator.RuleFor(c => c.Email)
+            .EmailAddress()
+            .WithMessage("Please enter an valid email");
+
+        validator.RuleFor(c => c.UserName)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("Please specify a valid username");
+
+        validator
+            .RuleFor(c => c.RoleId)
+            .GreaterThan(0)
+            .WithMessage("Please select a valid role");
+
+        return validator;
+    }
+};

server/src/Core/CleanArc.Application/Features/Admin/Queries/GetToken/AdminGetTokenQuery.Handler.cs

@@ -0,0 +1,47 @@
+using CleanArc.Application.Contracts;
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Jwt;
+using Mediator;
+
+namespace CleanArc.Application.Features.Admin.Queries.GetToken;
+
+public class AdminGetTokenQueryHandler:IRequestHandler<AdminGetTokenQuery,OperationResult<AdminGetTokenQueryResult>>
+{
+    private readonly IAppUserManager _userManager;
+    private readonly IJwtService _jwtService;
+    public AdminGetTokenQueryHandler(IAppUserManager userManager, IJwtService jwtService)
+    {
+        _userManager = userManager;
+        _jwtService = jwtService;
+    }
+
+    public async ValueTask<OperationResult<AdminGetTokenQueryResult>> Handle(AdminGetTokenQuery request, CancellationToken cancellationToken)
+    {
+        var user = await _userManager.GetByUserName(request.UserName);
+
+        if(user is null)
+            return OperationResult<AdminGetTokenQueryResult>.FailureResult("User not found");
+
+        var isUserLockedOut = await _userManager.IsUserLockedOutAsync(user);
+
+        if(isUserLockedOut)
+            if (user.LockoutEnd != null)
+                return OperationResult<AdminGetTokenQueryResult>.FailureResult(
+                    $"User is locked out. Try in {(user.LockoutEnd-DateTimeOffset.Now).Value.Minutes} Minutes");
+
+        var userRoles = await _userManager.GetRoleAsync(user);
+
+
+       if(!userRoles.Any())
+           return OperationResult<AdminGetTokenQueryResult>.FailureResult("This user does not have any role assigned");
+
+       if(!await _userManager.IsPasswordValidAsync(user, request.Password))
+              return OperationResult<AdminGetTokenQueryResult>.NotFoundResult("User not found");
+       
+        var token= await _jwtService.GenerateAsync(user);
+
+
+        return OperationResult<AdminGetTokenQueryResult>.SuccessResult(new(token,userRoles));
+    }
+}

server/src/Core/CleanArc.Application/Features/Admin/Queries/GetToken/AdminGetTokenQuery.Result.cs

@@ -0,0 +1,5 @@
+using CleanArc.Application.Models.Jwt;
+
+namespace CleanArc.Application.Features.Admin.Queries.GetToken;
+
+public record AdminGetTokenQueryResult(AccessToken Token,string[] Roles);

server/src/Core/CleanArc.Application/Features/Admin/Queries/GetToken/AdminGetTokenQuery.cs

@@ -0,0 +1,27 @@
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Jwt;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+
+namespace CleanArc.Application.Features.Admin.Queries.GetToken;
+
+public record AdminGetTokenQuery(string UserName, string Password) : IRequest<OperationResult<AdminGetTokenQueryResult>>,
+    IValidatableModel<AdminGetTokenQuery>
+{
+    public IValidator<AdminGetTokenQuery> ValidateApplicationModel(ApplicationBaseValidationModelProvider<AdminGetTokenQuery> validator)
+    {
+        validator.RuleFor(c => c.UserName)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("Please enter admin username");
+
+        validator.RuleFor(c => c.Password)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("Please enter admin password");
+
+        return validator;
+    }
+};

server/src/Core/CleanArc.Application/Features/Order/Commands/AddOrderCommand.Handler.cs

@@ -0,0 +1,25 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Contracts.Persistence;
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Commands;
+
+internal class AddOrderCommandHandler(IUnitOfWork unitOfWork, IAppUserManager userManager)
+    : IRequestHandler<AddOrderCommand, OperationResult<bool>>
+{
+    public async ValueTask<OperationResult<bool>> Handle(AddOrderCommand request, CancellationToken cancellationToken)
+    {
+        var user = await userManager.GetUserByIdAsync(request.UserId);
+
+        if(user==null)
+            return OperationResult<bool>.FailureResult("User Not Found");
+
+        await unitOfWork.OrderRepository.AddOrderAsync(new Domain.Entities.Order.Order()
+            { UserId = user.Id, OrderName = request.OrderName });
+
+        await unitOfWork.CommitAsync();
+
+        return OperationResult<bool>.SuccessResult(true);
+    }
+}

server/src/Core/CleanArc.Application/Features/Order/Commands/AddOrderCommand.cs

@@ -0,0 +1,25 @@
+using System.Text.Json.Serialization;
+using CleanArc.Application.Models.Common;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Commands;
+
+public record AddOrderCommand( string OrderName) : IRequest<OperationResult<bool>>,
+    IValidatableModel<AddOrderCommand>
+{
+    [JsonIgnore]
+    public int UserId { get; set; }
+
+    public IValidator<AddOrderCommand> ValidateApplicationModel(ApplicationBaseValidationModelProvider<AddOrderCommand> validator)
+    {
+        validator.RuleFor(c => c.OrderName)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("Please enter your role name");
+
+        return validator;
+    }
+}

server/src/Core/CleanArc.Application/Features/Order/Commands/DeleteUserOrdersCommand.Handler.cs

@@ -0,0 +1,15 @@
+using CleanArc.Application.Contracts.Persistence;
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Commands;
+
+public class DeleteUserOrdersCommandHandler(IUnitOfWork unitOfWork) : IRequestHandler<DeleteUserOrdersCommand,OperationResult<bool>>
+{
+    public async ValueTask<OperationResult<bool>> Handle(DeleteUserOrdersCommand request, CancellationToken cancellationToken)
+    {
+        await unitOfWork.OrderRepository.DeleteUserOrdersAsync(request.UserId);
+
+        return OperationResult<bool>.SuccessResult(true);
+    }
+}

server/src/Core/CleanArc.Application/Features/Order/Commands/DeleteUserOrdersCommand.cs

@@ -0,0 +1,6 @@
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Commands;
+
+public record DeleteUserOrdersCommand(int UserId):IRequest<OperationResult<bool>>;

server/src/Core/CleanArc.Application/Features/Order/Commands/UpdateUserOrderCommand.Handler.cs

@@ -0,0 +1,25 @@
+using CleanArc.Application.Contracts.Persistence;
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Commands;
+
+public class UpdateUserOrderCommandHandler(IUnitOfWork unitOfWork) : IRequestHandler<UpdateUserOrderCommand,OperationResult<bool>>
+{
+
+
+    public async ValueTask<OperationResult<bool>> Handle(UpdateUserOrderCommand request, CancellationToken cancellationToken)
+    {
+        var order = await unitOfWork.OrderRepository.GetUserOrderByIdAndUserIdAsync(request.UserId, request.OrderId,
+            true);
+
+        if(order is null)
+            return OperationResult<bool>.NotFoundResult("Specified Order not found");
+
+        order.OrderName=request.OrderName;
+
+        await unitOfWork.CommitAsync();
+
+        return OperationResult<bool>.SuccessResult(true);
+    }
+}

server/src/Core/CleanArc.Application/Features/Order/Commands/UpdateUserOrderCommand.cs

@@ -0,0 +1,23 @@
+using System.Text.Json.Serialization;
+using CleanArc.Application.Models.Common;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Commands;
+
+public record UpdateUserOrderCommand
+    (int OrderId, string OrderName) : IRequest<OperationResult<bool>>,IValidatableModel<UpdateUserOrderCommand>
+{
+    [JsonIgnore]
+    public int UserId { get; set; }
+
+    public IValidator<UpdateUserOrderCommand> ValidateApplicationModel(ApplicationBaseValidationModelProvider<UpdateUserOrderCommand> validator)
+    {
+        validator.RuleFor(c => c.OrderId).NotEmpty().GreaterThan(0);
+        validator.RuleFor(c => c.OrderName).NotEmpty().NotNull();
+
+        return validator;
+    }
+};

server/src/Core/CleanArc.Application/Features/Order/Queries/GetAllOrders/GetAllOrdersQuery.cs

@@ -0,0 +1,6 @@
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Queries.GetAllOrders;
+
+public record GetAllOrdersQuery():IRequest<OperationResult<List<GetAllOrdersQueryResult>>>;

server/src/Core/CleanArc.Application/Features/Order/Queries/GetAllOrders/GetAllOrdersQueryHandler.cs

@@ -0,0 +1,20 @@
+using CleanArc.Application.Contracts.Persistence;
+using CleanArc.Application.Models.Common;
+using MapsterMapper;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Queries.GetAllOrders
+{
+    internal class GetAllOrdersQueryHandler(IUnitOfWork unitOfWork, IMapper mapper)
+        : IRequestHandler<GetAllOrdersQuery, OperationResult<List<GetAllOrdersQueryResult>>>
+    {
+        public async ValueTask<OperationResult<List<GetAllOrdersQueryResult>>> Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
+        {
+            var orders = await unitOfWork.OrderRepository.GetAllOrdersWithRelatedUserAsync();
+
+            var result = orders.Select(mapper.Map<Domain.Entities.Order.Order,GetAllOrdersQueryResult>).ToList();
+
+            return OperationResult<List<GetAllOrdersQueryResult>>.SuccessResult(result);
+        }
+    }
+}

server/src/Core/CleanArc.Application/Features/Order/Queries/GetAllOrders/GetAllOrdersQueryResult.cs

@@ -0,0 +1,19 @@
+
+
+using Mapster;
+
+namespace CleanArc.Application.Features.Order.Queries.GetAllOrders;
+
+public record GetAllOrdersQueryResult(int OrderId, string OrderName, int OrderOwnerId, string OrderOwnerUserName);
+
+class GetAllOrdersQueryResultMapping : IRegister
+{
+    public void Register(TypeAdapterConfig config)
+    {
+        config.NewConfig<Domain.Entities.Order.Order, GetAllOrdersQueryResult>()
+            .Map(dest => dest.OrderId, src => src.Id)
+            .Map(dest => dest.OrderName, src => src.OrderName)
+            .Map(dest => dest.OrderOwnerId, src => src.User.Id)
+            .Map(dest => dest.OrderOwnerUserName, src => src.User.UserName);
+    }
+}

server/src/Core/CleanArc.Application/Features/Order/Queries/GetUserOrders/GetUserOrdersQueryHandler.cs

@@ -0,0 +1,21 @@
+using CleanArc.Application.Contracts.Persistence;
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Queries.GetUserOrders;
+
+internal class GetUserOrdersQueryHandler(IUnitOfWork unitOfWork)
+    : IRequestHandler<GetUserOrdersQueryModel, OperationResult<List<GetUsersQueryResultModel>>>
+{
+    public async ValueTask<OperationResult<List<GetUsersQueryResultModel>>> Handle(GetUserOrdersQueryModel request, CancellationToken cancellationToken)
+    {
+        var orders = await unitOfWork.OrderRepository.GetAllUserOrdersAsync(request.UserId);
+
+        if(!orders.Any())
+            return OperationResult<List<GetUsersQueryResultModel>>.NotFoundResult("You Don't Have Any Orders");
+
+        var result = orders.Select(c => new GetUsersQueryResultModel(c.Id, c.OrderName));
+
+        return OperationResult<List<GetUsersQueryResultModel>>.SuccessResult(result.ToList());
+    }
+}

server/src/Core/CleanArc.Application/Features/Order/Queries/GetUserOrders/GetUserOrdersQueryModel.cs

@@ -0,0 +1,6 @@
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Order.Queries.GetUserOrders;
+
+public record GetUserOrdersQueryModel(int UserId) : IRequest<OperationResult<List<GetUsersQueryResultModel>>>;

server/src/Core/CleanArc.Application/Features/Order/Queries/GetUserOrders/GetUsersQueryResultModel.cs

@@ -0,0 +1,3 @@
+namespace CleanArc.Application.Features.Order.Queries.GetUserOrders;
+
+public record GetUsersQueryResultModel(int OrderId, string OrderName);

server/src/Core/CleanArc.Application/Features/Role/Commands/AddRoleCommand/AddRoleCommand.Handler.cs

@@ -0,0 +1,24 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Identity;
+using Mediator;
+
+namespace CleanArc.Application.Features.Role.Commands.AddRoleCommand
+{
+    internal class AddRoleCommandHandler(IRoleManagerService roleManagerService)
+        : IRequestHandler<AddRoleCommand, OperationResult<bool>>
+    {
+        public async ValueTask<OperationResult<bool>> Handle(AddRoleCommand request, CancellationToken cancellationToken)
+        {
+            var addRoleResult =
+                await roleManagerService.CreateRoleAsync(new CreateRoleDto() { RoleName = request.RoleName });
+
+            if (addRoleResult.Succeeded)
+                return OperationResult<bool>.SuccessResult(true);
+
+            var errors = string.Join("\n", addRoleResult.Errors.Select(c => c.Description));
+
+            return OperationResult<bool>.FailureResult(errors);
+        }
+    }
+}

server/src/Core/CleanArc.Application/Features/Role/Commands/AddRoleCommand/AddRoleCommand.cs

@@ -0,0 +1,22 @@
+using CleanArc.Application.Models.Common;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+
+namespace CleanArc.Application.Features.Role.Commands.AddRoleCommand;
+
+public record AddRoleCommand(string RoleName) : IRequest<OperationResult<bool>>,
+    IValidatableModel<AddRoleCommand>
+{
+    public IValidator<AddRoleCommand> ValidateApplicationModel(ApplicationBaseValidationModelProvider<AddRoleCommand> validator)
+    {
+        validator
+            .RuleFor(c => c.RoleName)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("Please enter role name");
+
+        return validator;
+    }
+};

server/src/Core/CleanArc.Application/Features/Role/Commands/UpdateRoleClaimsCommand/UpdateRoleClaimsCommand.Handler.cs

@@ -0,0 +1,21 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Identity;
+using Mediator;
+
+namespace CleanArc.Application.Features.Role.Commands.UpdateRoleClaimsCommand
+{
+    internal class UpdateRoleClaimsCommandHandler(IRoleManagerService roleManagerService)
+        : IRequestHandler<UpdateRoleClaimsCommand, OperationResult<bool>>
+    {
+        public async ValueTask<OperationResult<bool>> Handle(UpdateRoleClaimsCommand request, CancellationToken cancellationToken)
+        {
+            var updateRoleResult = await roleManagerService.ChangeRolePermissionsAsync(new EditRolePermissionsDto()
+                { RoleId = request.RoleId, Permissions = request.RoleClaimValue });
+
+            return updateRoleResult
+                ? OperationResult<bool>.SuccessResult(true)
+                : OperationResult<bool>.FailureResult("Could Not Update Claims for given Role");
+        }
+    }
+}

server/src/Core/CleanArc.Application/Features/Role/Commands/UpdateRoleClaimsCommand/UpdateRoleClaimsCommand.cs

@@ -0,0 +1,7 @@
+
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Role.Commands.UpdateRoleClaimsCommand;
+
+public record UpdateRoleClaimsCommand( int RoleId, List<string> RoleClaimValue):IRequest<OperationResult<bool>>;

server/src/Core/CleanArc.Application/Features/Role/Queries/GetAllRolesQuery/GetAllRolesQuery.Handler.cs

@@ -0,0 +1,22 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Role.Queries.GetAllRolesQuery
+{
+    internal class GetAllRolesQueryHandler(IRoleManagerService roleManagerService)
+        : IRequestHandler<GetAllRolesQuery, OperationResult<List<GetAllRolesQueryResponse>>>
+    {
+        public async ValueTask<OperationResult<List<GetAllRolesQueryResponse>>> Handle(GetAllRolesQuery request, CancellationToken cancellationToken)
+        {
+            var roles = await roleManagerService.GetRolesAsync();
+
+            if(!roles.Any())
+                return OperationResult<List<GetAllRolesQueryResponse>>.NotFoundResult("No Roles Found");
+
+            var result = roles.Select(c => new GetAllRolesQueryResponse(int.Parse(c.Id), c.Name)).ToList();
+
+            return OperationResult<List<GetAllRolesQueryResponse>>.SuccessResult(result);
+        }
+    }
+}

server/src/Core/CleanArc.Application/Features/Role/Queries/GetAllRolesQuery/GetAllRolesQuery.Response.cs

@@ -0,0 +1,3 @@
+namespace CleanArc.Application.Features.Role.Queries.GetAllRolesQuery;
+
+public record GetAllRolesQueryResponse(int RoleId,string RoleName);

server/src/Core/CleanArc.Application/Features/Role/Queries/GetAllRolesQuery/GetAllRolesQuery.cs

@@ -0,0 +1,6 @@
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Role.Queries.GetAllRolesQuery;
+
+public record GetAllRolesQuery():IRequest<OperationResult<List<GetAllRolesQueryResponse>>>;

server/src/Core/CleanArc.Application/Features/Role/Queries/GetAuthorizableRoutesQuery/GetAuthorizableRoutesQuery.Handler.cs

@@ -0,0 +1,24 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Role.Queries.GetAuthorizableRoutesQuery
+{
+    internal class GetAuthorizableRoutesQueryHandler(IRoleManagerService roleManagerService)
+        : IRequestHandler<GetAuthorizableRoutesQuery, OperationResult<List<GetAuthorizableRoutesQueryResponse>>>
+    {
+        public async ValueTask<OperationResult<List<GetAuthorizableRoutesQueryResponse>>> Handle(GetAuthorizableRoutesQuery request, CancellationToken cancellationToken)
+        {
+            var authRoutes = await roleManagerService.GetPermissionActionsAsync();
+
+            if(!authRoutes.Any())
+                return OperationResult<List<GetAuthorizableRoutesQueryResponse>>.NotFoundResult("No Special auth route found");
+
+            var result = authRoutes.Select(c =>
+                    new GetAuthorizableRoutesQueryResponse(c.Key, c.AreaName, c.ControllerName, c.ActionName,c.ControllerDescription))
+                .ToList();
+
+            return OperationResult<List<GetAuthorizableRoutesQueryResponse>>.SuccessResult(result);
+        }
+    }
+}

server/src/Core/CleanArc.Application/Features/Role/Queries/GetAuthorizableRoutesQuery/GetAuthorizableRoutesQuery.Response.cs

@@ -0,0 +1,3 @@
+namespace CleanArc.Application.Features.Role.Queries.GetAuthorizableRoutesQuery;
+
+public record GetAuthorizableRoutesQueryResponse(string RouteKey,string AreaName,string ControllerName,string ActionName,string ControllerDescription);

server/src/Core/CleanArc.Application/Features/Role/Queries/GetAuthorizableRoutesQuery/GetAuthorizableRoutesQuery.cs

@@ -0,0 +1,6 @@
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Role.Queries.GetAuthorizableRoutesQuery;
+
+public record GetAuthorizableRoutesQuery():IRequest<OperationResult<List<GetAuthorizableRoutesQueryResponse>>>;

server/src/Core/CleanArc.Application/Features/Users/Commands/Create/UserCreateCommand.Handler.cs

@@ -0,0 +1,54 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using CleanArc.Domain.Entities.User;
+using MapsterMapper;
+using Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace CleanArc.Application.Features.Users.Commands.Create;
+
+internal class UserCreateCommandHandler(
+    IAppUserManager userManager,
+    ILogger<UserCreateCommandHandler> logger,
+    IMapper mapper)
+    : IRequestHandler<UserCreateCommand, OperationResult<UserCreateCommandResult>>
+{
+    public async ValueTask<OperationResult<UserCreateCommandResult>> Handle(UserCreateCommand request,
+        CancellationToken cancellationToken)
+    {
+        var userNameExist = await userManager.IsExistUser(request.PhoneNumber);
+
+        if (userNameExist)
+            return OperationResult<UserCreateCommandResult>.FailureResult("Phone number already exists");
+
+        var phoneNumberExist = await userManager.IsExistUserName(request.UserName);
+
+        if (phoneNumberExist)
+            return OperationResult<UserCreateCommandResult>.FailureResult("Username already exists");
+
+        //var user = new User { UserName = request.UserName, Name = request.FirstName, FamilyName = request.LastName, PhoneNumber = request.PhoneNumber };
+
+        var user = mapper.Map<User>(request);
+
+        
+            var createResult =string.IsNullOrEmpty(request.Password)? 
+                await userManager.CreateUser(user)
+                :await  userManager.CreateUser(user, request.Password);
+
+        if (!createResult.Succeeded)
+        {
+            return OperationResult<UserCreateCommandResult>.FailureResult(string.Join(",",
+                createResult.Errors.Select(c => c.Description)));
+        }
+
+        var code = await userManager.GeneratePhoneNumberConfirmationToken(user, user.PhoneNumber);
+
+
+        logger.LogWarning($"Generated Code for User ID {user.Id} is {code}");
+
+        //TODO Send Code Via Sms Provider
+
+        return OperationResult<UserCreateCommandResult>.SuccessResult(new UserCreateCommandResult
+            { UserGeneratedKey = user.GeneratedCode });
+    }
+}

server/src/Core/CleanArc.Application/Features/Users/Commands/Create/UserCreateCommand.Result.cs

@@ -0,0 +1,6 @@
+namespace CleanArc.Application.Features.Users.Commands.Create;
+
+public class UserCreateCommandResult
+{
+    public string UserGeneratedKey { get; set; }
+}

server/src/Core/CleanArc.Application/Features/Users/Commands/Create/UserCreateCommand.cs

@@ -0,0 +1,50 @@
+using System.Text.RegularExpressions;
+using CleanArc.Application.Models.Common;
+using CleanArc.Domain.Entities.User;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Commands.Create;
+
+public record UserCreateCommand
+    (string UserName, string Name, string FamilyName, string PhoneNumber,string Password,string RepeatPassword) 
+    : IRequest<OperationResult<UserCreateCommandResult>>
+        ,IValidatableModel<UserCreateCommand>
+{
+
+    public IValidator<UserCreateCommand> ValidateApplicationModel(ApplicationBaseValidationModelProvider<UserCreateCommand> validator)
+    {
+
+        validator
+            .RuleFor(c => c.Name)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("User must have first name");
+
+        validator.RuleFor(c => c.UserName)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("Please enter your username");
+
+        validator
+            .RuleFor(c => c.FamilyName)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("User must have last name");
+
+
+        validator.RuleFor(c => c.PhoneNumber).NotEmpty()
+            .NotNull().WithMessage("Phone Number is required.")
+            .MinimumLength(10).WithMessage("PhoneNumber must not be less than 10 characters.")
+            .MaximumLength(20).WithMessage("PhoneNumber must not exceed 50 characters.")
+            .Matches(new Regex(@"^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$")).WithMessage("Phone number is not valid");
+
+        validator.RuleFor(c => c.Password)
+            .Matches(c => c.RepeatPassword)
+            .WithMessage("passwords do not match");
+        
+        return validator;
+    }
+}

server/src/Core/CleanArc.Application/Features/Users/Commands/RefreshUserTokenCommand/RefreshUserTokenCommand.Handler.cs

@@ -0,0 +1,21 @@
+using CleanArc.Application.Contracts;
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Jwt;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Commands.RefreshUserTokenCommand
+{
+    internal class RefreshUserTokenCommandHandler(IJwtService jwtService)
+        : IRequestHandler<RefreshUserTokenCommand, OperationResult<AccessToken>>
+    {
+        public async ValueTask<OperationResult<AccessToken>> Handle(RefreshUserTokenCommand request, CancellationToken cancellationToken)
+        {
+            var newToken = await jwtService.RefreshToken(request.RefreshToken);
+
+            if(newToken is null)
+                return OperationResult<AccessToken>.FailureResult("Invalid refresh token");
+
+            return OperationResult<AccessToken>.SuccessResult(newToken);
+        }
+    }
+}

server/src/Core/CleanArc.Application/Features/Users/Commands/RefreshUserTokenCommand/RefreshUserTokenCommand.cs

@@ -0,0 +1,22 @@
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Jwt;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Commands.RefreshUserTokenCommand;
+
+public record RefreshUserTokenCommand(Guid RefreshToken) : IRequest<OperationResult<AccessToken>>,
+    IValidatableModel<RefreshUserTokenCommand>
+{
+    public IValidator<RefreshUserTokenCommand> ValidateApplicationModel(ApplicationBaseValidationModelProvider<RefreshUserTokenCommand> validator)
+    {
+        validator.RuleFor(c => c.RefreshToken)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("Please enter valid user refresh token");
+
+        return validator;
+    }
+};

server/src/Core/CleanArc.Application/Features/Users/Commands/RequestLogout/RequestLogoutCommand.Handler.cs

@@ -0,0 +1,22 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Commands.RequestLogout
+{
+    internal class RequestLogoutCommandHandler(IAppUserManager userManager)
+        : IRequestHandler<RequestLogoutCommand, OperationResult<bool>>
+    {
+        public async ValueTask<OperationResult<bool>> Handle(RequestLogoutCommand request, CancellationToken cancellationToken)
+        {
+            var user = await userManager.GetUserByIdAsync(request.UserId);
+
+            if (user == null) 
+                return OperationResult<bool>.FailureResult("User not found");
+
+            await userManager.UpdateSecurityStampAsync(user);
+
+            return OperationResult<bool>.SuccessResult(true);
+        }
+    }
+}

server/src/Core/CleanArc.Application/Features/Users/Commands/RequestLogout/RequestLogoutCommand.cs

@@ -0,0 +1,6 @@
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Commands.RequestLogout;
+
+public record RequestLogoutCommand(int UserId):IRequest<OperationResult<bool>>;

server/src/Core/CleanArc.Application/Features/Users/Queries/GenerateUserToken/GenerateUserTokenQuery.Handler.cs

@@ -0,0 +1,33 @@
+using CleanArc.Application.Contracts;
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Jwt;
+using CleanArc.SharedKernel.Extensions;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Queries.GenerateUserToken;
+
+internal class GenerateUserTokenQueryHandler(IJwtService jwtService, IAppUserManager userManager)
+    : IRequestHandler<GenerateUserTokenQuery, OperationResult<AccessToken>>
+{
+    public async ValueTask<OperationResult<AccessToken>> Handle(GenerateUserTokenQuery request, CancellationToken cancellationToken)
+    {
+        var user = await userManager.GetUserByCode(request.UserKey);
+
+        if (user is null)
+            return OperationResult<AccessToken>.FailureResult("User Not found");
+
+        var result = user.PhoneNumberConfirmed? await userManager.VerifyUserCode(
+            user, request.Code):await userManager.ChangePhoneNumber(user,user.PhoneNumber,request.Code);
+
+
+        if (!result.Succeeded)
+            return OperationResult<AccessToken>.FailureResult(result.Errors.StringifyIdentityResultErrors());
+
+        await userManager.UpdateUserAsync(user);
+
+        var token = await jwtService.GenerateAsync(user);
+
+        return OperationResult<AccessToken>.SuccessResult(token);
+    }
+}

server/src/Core/CleanArc.Application/Features/Users/Queries/GenerateUserToken/GenerateUserTokenQuery.cs

@@ -0,0 +1,28 @@
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Jwt;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Queries.GenerateUserToken;
+
+public record GenerateUserTokenQuery(string UserKey, string Code) : IRequest<OperationResult<AccessToken>>,
+    IValidatableModel<GenerateUserTokenQuery>
+{
+    public IValidator<GenerateUserTokenQuery> ValidateApplicationModel(ApplicationBaseValidationModelProvider<GenerateUserTokenQuery> validator)
+    {
+        validator.RuleFor(c => c.Code)
+            .NotEmpty()
+            .NotNull()
+            .Length(6)
+            .WithMessage("User code is not valid");
+
+        validator.RuleFor(c => c.UserKey)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("Invalid user key");
+
+        return validator;
+    }
+};

server/src/Core/CleanArc.Application/Features/Users/Queries/GetUsers/GetUsersQuery.Handler.cs

@@ -0,0 +1,22 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using CleanArc.Domain.Entities.User;
+using MapsterMapper;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Queries.GetUsers;
+
+internal class GetUsersQueryHandler(IAppUserManager userManager, IMapper mapper)
+    : IRequestHandler<GetUsersQuery, OperationResult<List<GetUsersQueryResponse>>>
+{
+    public async ValueTask<OperationResult<List<GetUsersQueryResponse>>> Handle(GetUsersQuery request, CancellationToken cancellationToken)
+    {
+        var usersModel =
+            (await userManager.GetAllUsersAsync()).Select(mapper.Map<User, GetUsersQueryResponse>).ToList();
+
+        if(!usersModel.Any())
+            return OperationResult<List<GetUsersQueryResponse>>.NotFoundResult("No Users Found!");
+
+        return OperationResult<List<GetUsersQueryResponse>>.SuccessResult(usersModel);
+    }
+}

server/src/Core/CleanArc.Application/Features/Users/Queries/GetUsers/GetUsersQuery.Response.cs

@@ -0,0 +1,11 @@
+
+using CleanArc.Domain.Entities.User;
+
+namespace CleanArc.Application.Features.Users.Queries.GetUsers;
+
+public record GetUsersQueryResponse 
+{
+    public string UserName { get; set; }
+    public string Email { get; set; }
+    public int UserId { get; set; }
+}

server/src/Core/CleanArc.Application/Features/Users/Queries/GetUsers/GetUsersQuery.cs

@@ -0,0 +1,6 @@
+using CleanArc.Application.Models.Common;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Queries.GetUsers;
+
+public record GetUsersQuery : IRequest<OperationResult<List<GetUsersQueryResponse>>>;

server/src/Core/CleanArc.Application/Features/Users/Queries/TokenRequest/PasswordUserTokenRequestQuery.Handler.cs

@@ -0,0 +1,27 @@
+using CleanArc.Application.Contracts;
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Jwt;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Queries.TokenRequest;
+
+public class PasswordUserTokenRequestQueryResult
+(IAppUserManager userManager,IJwtService jwtService)
+:IRequestHandler<PasswordUserTokenRequestQuery,OperationResult<AccessToken>>
+{
+    public async ValueTask<OperationResult<AccessToken>> Handle(PasswordUserTokenRequestQuery request, CancellationToken cancellationToken)
+    {
+        var user = await userManager.GetByUserName(request.UserName);
+        
+        if(user is null)
+            return OperationResult<AccessToken>.NotFoundResult("User not found");
+        
+        if(!await userManager.IsPasswordValidAsync(user,request.Password))
+            return OperationResult<AccessToken>.NotFoundResult("User not found");
+        
+        var token = await jwtService.GenerateAsync(user);
+        
+        return OperationResult<AccessToken>.SuccessResult(token);
+    }
+}

server/src/Core/CleanArc.Application/Features/Users/Queries/TokenRequest/PasswordUserTokenRequestQuery.cs

@@ -0,0 +1,24 @@
+using CleanArc.Application.Models.Common;
+using CleanArc.Application.Models.Jwt;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+
+namespace CleanArc.Application.Features.Users.Queries.TokenRequest;
+
+public record PasswordUserTokenRequestQuery
+(string UserName,string Password)
+:IValidatableModel<PasswordUserTokenRequestQuery>,IRequest<OperationResult<AccessToken>>
+{
+    public IValidator<PasswordUserTokenRequestQuery> ValidateApplicationModel(ApplicationBaseValidationModelProvider<PasswordUserTokenRequestQuery> validator)
+    {
+        validator.RuleFor(c => c.UserName)
+            .NotEmpty();
+
+        validator.RuleFor(c => c.Password)
+            .NotEmpty();
+
+        return validator;
+    }
+}

server/src/Core/CleanArc.Application/Features/Users/Queries/TokenRequest/UserTokenRequestQuery.Handler.cs

@@ -0,0 +1,30 @@
+using CleanArc.Application.Contracts.Identity;
+using CleanArc.Application.Models.Common;
+using Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace CleanArc.Application.Features.Users.Queries.TokenRequest;
+
+public class UserTokenRequestQueryHandler(
+    IAppUserManager userManager,
+    ILogger<UserTokenRequestQueryHandler> logger)
+    : IRequestHandler<UserTokenRequestQuery, OperationResult<UserTokenRequestQueryResponse>>
+{
+  
+    
+    public async ValueTask<OperationResult<UserTokenRequestQueryResponse>> Handle(UserTokenRequestQuery request, CancellationToken cancellationToken)
+    {
+        var user = await userManager.GetUserByPhoneNumber(request.UserPhoneNumber);
+
+        if(user is null)
+            return OperationResult<UserTokenRequestQueryResponse>.NotFoundResult("User Not found");
+
+        var code = user.PhoneNumberConfirmed? await userManager.GenerateOtpCode(user) : await userManager.GeneratePhoneNumberConfirmationToken(user,user.PhoneNumber);
+
+        logger.LogWarning($"Generated Code for user Id {user.Id} is {code}");
+
+        //TODO Send Code Via Sms Provider
+
+        return OperationResult<UserTokenRequestQueryResponse>.SuccessResult(new UserTokenRequestQueryResponse {UserKey = user.GeneratedCode});
+    }
+}

server/src/Core/CleanArc.Application/Features/Users/Queries/TokenRequest/UserTokenRequestQuery.Response.cs

@@ -0,0 +1,6 @@
+namespace CleanArc.Application.Features.Users.Queries.TokenRequest;
+
+public class UserTokenRequestQueryResponse
+{
+    public string UserKey { get; set; }
+}

server/src/Core/CleanArc.Application/Features/Users/Queries/TokenRequest/UserTokenRequestQuery.cs

@@ -0,0 +1,25 @@
+using CleanArc.Application.Models.Common;
+using CleanArc.SharedKernel.ValidationBase;
+using CleanArc.SharedKernel.ValidationBase.Contracts;
+using FluentValidation;
+using Mediator;
+using System.Text.RegularExpressions;
+
+namespace CleanArc.Application.Features.Users.Queries.TokenRequest;
+
+public record UserTokenRequestQuery(string UserPhoneNumber) : IRequest<OperationResult<UserTokenRequestQueryResponse>>,
+    IValidatableModel<UserTokenRequestQuery>
+{
+    public IValidator<UserTokenRequestQuery> ValidateApplicationModel(ApplicationBaseValidationModelProvider<UserTokenRequestQuery> validator)
+    {
+
+        validator.RuleFor(c => c.UserPhoneNumber).NotEmpty()
+            .NotNull().WithMessage("Phone Number is required.")
+            .MinimumLength(10).WithMessage("PhoneNumber must not be less than 10 characters.")
+            .MaximumLength(20).WithMessage("PhoneNumber must not exceed 50 characters.")
+            .Matches(new Regex(@"^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$")).WithMessage("Phone number is not valid");
+
+
+        return validator;
+    }
+};

server/src/Core/CleanArc.Application/Models/ApiResult/ApiResult.cs

@@ -0,0 +1,37 @@
+using System.Diagnostics;
+using CleanArc.SharedKernel.Extensions;
+
+namespace CleanArc.Application.Models.ApiResult;
+
+public class ApiResult
+{
+    public bool IsSuccess { get; set; }
+    public ApiResultStatusCode StatusCode { get; set; }
+
+    public string Message { get; set; }
+    public string RequestId { get;  }
+
+    public ApiResult(bool isSuccess, ApiResultStatusCode statusCode, string message = null)
+    {
+        IsSuccess = isSuccess;
+        StatusCode = statusCode;
+        Message = message ?? statusCode.ToDisplay();
+        RequestId = Activity.Current?.TraceId.ToHexString() ?? string.Empty;
+    }
+
+    
+}
+
+public class ApiResult<TData> : ApiResult
+
+{
+    public TData Data { get; set; }
+
+    public ApiResult(bool isSuccess, ApiResultStatusCode statusCode, TData data, string message = null)
+        : base(isSuccess, statusCode, message)
+    {
+        Data = data;
+    }
+
+    
+}

server/src/Core/CleanArc.Application/Models/ApiResult/ApiResultStatusCodecs.cs

@@ -0,0 +1,34 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace CleanArc.Application.Models.ApiResult;
+
+public enum ApiResultStatusCode
+{
+    [Display(Name = "Success")]
+    Success = 200,
+
+    [Display(Name = "Server Error")]
+    ServerError = 500,
+
+    [Display(Name = "Bad Request Error")]
+    BadRequest = 400,
+
+    [Display(Name = "Not Found")]
+    NotFound = 404,
+
+
+    [Display(Name = "Request Process Error")]
+    EntityProcessError = 422,
+
+    [Display(Name = "Authentication Error")]
+    UnAuthorized = 401,
+
+    [Display(Name = "Authorization Error")]
+    Forbidden = 403,
+
+    [Display(Name = "Not Acceptable")]
+    NotAcceptable = 406,
+
+    [Display(Name = "Failed Dependency")]
+    FailedDependency = 424
+}

server/src/Core/CleanArc.Application/Models/Common/OperationResult.cs

@@ -0,0 +1,62 @@
+namespace CleanArc.Application.Models.Common;
+
+/// <summary>
+/// Marker Interface To Mark Operation Result Response In Validation Pipeline
+/// </summary>
+public interface IOperationResult
+{
+    bool IsSuccess { get; set; }
+    List<KeyValuePair<string,string>> ErrorMessages { get; set; }
+    bool IsException { get; set; }
+    bool IsNotFound { get; set; }
+}
+
+public class OperationResult<TResult> : IOperationResult
+{
+    public TResult Result { get;  set; }
+
+    public bool IsSuccess { get; set; }
+    public List<KeyValuePair<string,string>> ErrorMessages { get; set; } = new();
+    public bool IsException { get; set; }
+    public bool IsNotFound { get; set; }
+
+    public static OperationResult<TResult> SuccessResult(TResult result)
+    {
+        return new OperationResult<TResult> { Result = result, IsSuccess = true };
+    }
+
+    public static OperationResult<TResult> FailureResult(string propertyName, string message, TResult result = default)
+    {
+        var operationResult = new OperationResult<TResult> { Result = result, IsSuccess = false };
+
+        operationResult.ErrorMessages.Add(new(propertyName,message));
+
+        return operationResult;
+    }    
+    public static OperationResult<TResult> FailureResult(string message, TResult result = default)
+    {
+        var operationResult = new OperationResult<TResult> { Result = result, IsSuccess = false };
+
+        operationResult.ErrorMessages.Add(new("GeneralError",message));
+
+        return operationResult;
+    }
+    public static OperationResult<TResult> NotFoundResult(string message)
+    {
+        var operationResult = new OperationResult<TResult> { IsSuccess = false, IsNotFound = true };
+
+        operationResult.ErrorMessages.Add(new("GeneralError", message));
+
+        return operationResult;
+    }
+
+    public void AddError(string propertyName, string message)
+    {
+        IsSuccess = false;
+        
+        ErrorMessages.Add(new(propertyName,message));
+    }
+    
+    public string GetErrorMessage()
+    => string.Join(Environment.NewLine, ErrorMessages.Select(x => $"{x.Key}: {x.Value}"));
+}

server/src/Core/CleanArc.Application/Models/Identity/ActionDescriptionDto.cs

@@ -0,0 +1,16 @@
+namespace CleanArc.Application.Models.Identity;
+
+public class ActionDescriptionDto
+{
+    public string Key => $"{AreaName}:{ControllerName}:{ActionName}";
+
+    public string AreaName { get; set; }
+
+    public string ControllerName { get; set; }
+    public string ControllerDisplayName { get; set; }
+
+    public string ActionName { get; set; }
+
+    public string ActionDisplayName { get; set; }
+    public string ControllerDescription { get; set; }
+}

server/src/Core/CleanArc.Application/Models/Identity/CreateRoleDto.cs

@@ -0,0 +1,6 @@
+namespace CleanArc.Application.Models.Identity;
+
+public class CreateRoleDto
+{
+    public string RoleName { get; set; }
+}

server/src/Core/CleanArc.Application/Models/Identity/EditRolePermissionsDto.cs

@@ -0,0 +1,7 @@
+namespace CleanArc.Application.Models.Identity;
+
+public class EditRolePermissionsDto
+{
+    public int RoleId { get; set; }
+    public List<string> Permissions { get; set; }
+}

server/src/Core/CleanArc.Application/Models/Identity/GetRolesDto.cs

@@ -0,0 +1,9 @@
+using CleanArc.Domain.Entities.User;
+
+namespace CleanArc.Application.Models.Identity;
+
+public class GetRolesDto
+{
+    public string Id { get; set; }
+    public string Name { get; set; }
+}

server/src/Core/CleanArc.Application/Models/Identity/RolePermissionDto.cs

@@ -0,0 +1,14 @@
+using CleanArc.Domain.Entities.User;
+
+namespace CleanArc.Application.Models.Identity;
+
+public class RolePermissionDto
+{
+    public List<string> Keys { get; set; } = new List<string>();
+
+    public Role Role { get; set; }
+
+    public int RoleId { get; set; }
+
+    public List<ActionDescriptionDto> Actions { get; set; }
+}