Adding tests

This reverts commit 61f7504e66.

.github/workflows/build.yml

@@ -49,6 +49,7 @@ jobs:
         shell: powershell
         run: |
           .\.sonar\scanner\dotnet-sonarscanner begin /k:"csimonapastore_BasicDotnetTemplate" /o:"csimonapastore-github" /d:sonar.token="${{ secrets.SONAR_TOKEN }}" /d:sonar.host.url="https://sonarcloud.io" /d:sonar.cs.vscoveragexml.reportsPaths=coverage.xml /d:sonar.exclusions="**/Migrations/**.cs, **/Models/Database/**.cs, **/Core/Database/**.cs"
+          dotnet clean
           dotnet restore
           dotnet build --no-incremental
           dotnet-coverage collect "dotnet test" -f xml -o "coverage.xml"          

MainProject.Tests/Controllers/AuthController_Tests.cs

@@ -0,0 +1,229 @@
+using System;
+using System.Reflection;
+using System.Net;
+using System.Net.Http;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Microsoft.Extensions.Configuration;
+using Moq;
+using Newtonsoft.Json;
+using BasicDotnetTemplate.MainProject;
+using BasicDotnetTemplate.MainProject.Controllers;
+using BasicDotnetTemplate.MainProject.Services;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using BasicDotnetTemplate.MainProject.Models.Settings;
+using BasicDotnetTemplate.MainProject.Models.Api.Request.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+using Microsoft.AspNetCore.Http;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class AuthController_Tests
+{
+    [TestMethod]
+    public void AuthController_NullConfiguration()
+    {
+        Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
+        var exception = true;
+        try
+        {
+            var authServiceMock = new Mock<IAuthService>();
+            _ = new AuthController(null, authServiceMock.Object);
+            exception = false;
+            Assert.Fail($"This test should not pass as configuration is null");
+        }
+        catch (Exception)
+        {
+            Assert.IsTrue(exception);
+        }
+    }
+
+
+    [TestMethod]
+    public async Task AuthenticateAsync_Should_Return_200_When_Successful()
+    {
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+        var authServiceMock = new Mock<IAuthService>();
+        var controller = new AuthController(configuration, authServiceMock.Object);
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+        AuthenticatedUser authenticatedUser = new AuthenticatedUser(user);
+
+        var request = new AuthenticateRequest { Data = new AuthenticateRequestData { Email = "user", Password = "pass" } };
+        authServiceMock.Setup(s => s.AuthenticateAsync(It.IsAny<AuthenticateRequestData>())).ReturnsAsync(authenticatedUser);
+        ObjectResult response = (ObjectResult)(await controller.AuthenticateAsync(request));
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status200OK);
+                Assert.IsInstanceOfType(result.Data, typeof(AuthenticatedUser));
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task AuthenticateAsync_AuthenticateRequestDataNull()
+    {
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+        var authServiceMock = new Mock<IAuthService>();
+        var controller = new AuthController(configuration, authServiceMock.Object);
+
+        var request = new AuthenticateRequest
+        {
+            Data = null
+        };
+        AuthenticatedUser? authenticatedUser = null;
+        authServiceMock.Setup(s => s.AuthenticateAsync(It.IsAny<AuthenticateRequestData>())).ReturnsAsync(authenticatedUser);
+        ObjectResult response = (ObjectResult)(await controller.AuthenticateAsync(request));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Request is not well formed");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task AuthenticateAsync_NotFound()
+    {
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+        var authServiceMock = new Mock<IAuthService>();
+        var controller = new AuthController(configuration, authServiceMock.Object);
+
+        var request = new AuthenticateRequest
+        {
+            Data = new AuthenticateRequestData()
+            {
+                Email = "d2ejdI1f4GYpq2kTB1nmeQkZXqR3QSxH8Yqkl7iv7zgfQ13qG/0dUUsreG/WGHWRBE5mVWaV43A=",
+                Password = "d2ejdI1f4GYpq2kTB1nmeQkZXqR3QSxH8Yqkl7iv7zgfQ13qG/0dUUsreG/WGHWRBE5mVWaV43A="
+            }
+        };
+        AuthenticatedUser? authenticatedUser = null;
+        authServiceMock.Setup(s => s.AuthenticateAsync(It.IsAny<AuthenticateRequestData>())).ReturnsAsync(authenticatedUser);
+        NotFoundResult response = (NotFoundResult)(await controller.AuthenticateAsync(request));
+
+        Assert.IsInstanceOfType(response, typeof(NotFoundResult));
+
+        if (response != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status404NotFound);
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task AuthenticateAsync_ModelInvalid()
+    {
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+        var authServiceMock = new Mock<IAuthService>();
+        var controller = new AuthController(configuration, authServiceMock.Object);
+
+        var request = new AuthenticateRequest
+        {
+            Data = null
+        };
+        AuthenticatedUser? authenticatedUser = null;
+        authServiceMock.Setup(s => s.AuthenticateAsync(It.IsAny<AuthenticateRequestData>())).ReturnsAsync(authenticatedUser);
+        controller.ModelState.AddModelError("Data", "Invalid data");
+        ObjectResult response = (ObjectResult)(await controller.AuthenticateAsync(request));
+
+        Assert.IsInstanceOfType(response, typeof(ObjectResult));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Request is not well formed");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task AuthenticateAsync_Exception()
+    {
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+        var authServiceMock = new Mock<IAuthService>();
+        var controller = new AuthController(configuration, authServiceMock.Object);
+
+        var request = new AuthenticateRequest
+        {
+            Data = new AuthenticateRequestData { Email = "user", Password = "pass" }
+        };
+
+        authServiceMock.Setup(s => s.AuthenticateAsync(It.IsAny<AuthenticateRequestData>())).ThrowsAsync(new Exception("Unexpected error"));
+
+        ObjectResult response = (ObjectResult)(await controller.AuthenticateAsync(request));
+
+        Assert.IsInstanceOfType(response, typeof(ObjectResult));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+
+}

MainProject.Tests/Controllers/RootController_Tests.cs

@@ -10,6 +10,7 @@ using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Infrastructure;
 using BasicDotnetTemplate.MainProject.Models.Api.Response;
 using BasicDotnetTemplate.MainProject.Models.Settings;
+using Microsoft.AspNetCore.Http;
 
 
 namespace BasicDotnetTemplate.MainProject.Tests;
@@ -29,7 +30,7 @@ public class RootController_Test
             if (result != null)
             {
                 var data = (OkResult)result;
-                Assert.IsTrue(data.StatusCode == 200);
+                Assert.IsTrue(data.StatusCode == StatusCodes.Status200OK);
             }
             else
             {
@@ -39,7 +40,7 @@ public class RootController_Test
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 }

MainProject.Tests/Controllers/UserController_Tests.cs

@@ -0,0 +1,597 @@
+using System;
+using System.Reflection;
+using System.Net;
+using System.Net.Http;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Microsoft.Extensions.Configuration;
+using Moq;
+using Newtonsoft.Json;
+using BasicDotnetTemplate.MainProject;
+using BasicDotnetTemplate.MainProject.Controllers;
+using BasicDotnetTemplate.MainProject.Services;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using BasicDotnetTemplate.MainProject.Models.Settings;
+using BasicDotnetTemplate.MainProject.Models.Api.Request.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+using AutoMapper;
+using BasicDotnetTemplate.MainProject.Core.Middlewares;
+using Microsoft.AspNetCore.Http;
+using BasicDotnetTemplate.MainProject.Models.Api.Request.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.User;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class UserControllerTests
+{
+    private Mock<IUserService>? _userServiceMock;
+    private Mock<IRoleService>? _roleServiceMock;
+    private UserController? _userController;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+        _userServiceMock = new Mock<IUserService>();
+        _roleServiceMock = new Mock<IRoleService>();
+        _userController = new UserController(configuration, _userServiceMock?.Object, _roleServiceMock.Object);
+    }
+
+    [TestMethod]
+    public void UserController_NullConfiguration()
+    {
+        Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
+        var exception = true;
+        try
+        {
+            var userServiceMock = new Mock<IUserService>();
+            var roleServiceMock = new Mock<IRoleService>();
+            _ = new UserController(null, userServiceMock.Object, roleServiceMock.Object);
+            exception = false;
+            Assert.Fail($"This test should not pass as configuration is null");
+        }
+        catch (Exception)
+        {
+            Assert.IsTrue(exception);
+        }
+    }
+
+
+    [TestMethod]
+    public async Task GetUserByGuidAsync_Should_Return_200_When_Successful()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+        var guid = Guid.NewGuid().ToString();
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+
+        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
+        ObjectResult response = (ObjectResult)(await _userController.GetUserByGuidAsync(guid));
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status200OK);
+                Assert.IsInstanceOfType(result.Data, typeof(UserDto));
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetUserByGuidAsync_AuthenticateRequestDataNull()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        var guid = String.Empty;
+        DatabaseSqlServer.User? user = null;
+
+        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
+        ObjectResult response = (ObjectResult)(await _userController.GetUserByGuidAsync(guid));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Request is not well formed");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetUserByGuidAsync_NotFound()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        var guid = Guid.NewGuid().ToString();
+        DatabaseSqlServer.User? user = null;
+        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
+        NotFoundResult response = (NotFoundResult)(await _userController.GetUserByGuidAsync(guid));
+
+        Assert.IsInstanceOfType(response, typeof(NotFoundResult));
+
+        if (response != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status404NotFound);
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetUserByGuidAsync_ModelInvalid()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        var guid = Guid.NewGuid().ToString();
+        DatabaseSqlServer.User? user = null;
+        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
+        _userController.ModelState.AddModelError("Data", "Invalid data");
+        ObjectResult response = (ObjectResult)(await _userController.GetUserByGuidAsync(guid));
+
+        Assert.IsInstanceOfType(response, typeof(ObjectResult));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Request is not well formed");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetUserByGuidAsync_Exception()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        var guid = Guid.NewGuid().ToString();
+        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ThrowsAsync(new Exception("Unexpected error"));
+        ObjectResult response = (ObjectResult)(await _userController.GetUserByGuidAsync(guid));
+
+        Assert.IsInstanceOfType(response, typeof(ObjectResult));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateUserAsync_Should_Return_200_When_Successful()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        if (_roleServiceMock == null)
+        {
+            Assert.Fail($"_roleServiceMock is null");
+        }
+
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
+
+        CreateUserRequest request = new CreateUserRequest()
+        {
+            Data = new CreateUserRequestData()
+            {
+                FirstName = user.FirstName,
+                LastName = user.LastName,
+                Email = user.Email,
+                Password = user.Password
+            }
+        };
+
+        _userServiceMock?.Setup(s => s.CheckIfEmailIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+        _roleServiceMock.Setup(s => s.GetRoleForUser(null)).ReturnsAsync(role);
+        _userServiceMock?.Setup(s => s.CreateUserAsync(request.Data, role)).ReturnsAsync(user);
+
+        ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status200OK);
+                Assert.IsInstanceOfType(result.Data, typeof(UserDto));
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateUserAsync_InvalidEmail()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+
+        CreateUserRequest request = new CreateUserRequest()
+        {
+            Data = new CreateUserRequestData()
+            {
+                FirstName = user.FirstName,
+                LastName = user.LastName,
+                Email = user.Email,
+                Password = user.Password
+            }
+        };
+
+        _userServiceMock?.Setup(s => s.CheckIfEmailIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(false);
+
+        ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Invalid email");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateUserAsync_RoleNull()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+
+        CreateUserRequest request = new CreateUserRequest()
+        {
+            Data = new CreateUserRequestData()
+            {
+                FirstName = user.FirstName,
+                LastName = user.LastName,
+                Email = user.Email,
+                Password = user.Password
+            }
+        };
+
+        _userServiceMock?.Setup(s => s.CheckIfEmailIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+
+        _userServiceMock?.Setup(s => s.CreateUserAsync(
+            It.IsAny<CreateUserRequestData>(),
+            It.IsAny<Role>()
+        )).ReturnsAsync(user);
+
+        ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Role not found");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateUserAsync_CreateUserRequestDataNull()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+
+        CreateUserRequest request = new CreateUserRequest()
+        {
+            Data = null
+        };
+
+        _userServiceMock?.Setup(s => s.CheckIfEmailIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+
+        _userServiceMock?.Setup(s => s.CreateUserAsync(
+            It.IsAny<CreateUserRequestData>(),
+            It.IsAny<Role>()
+        )).ReturnsAsync(user);
+
+        ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Request is not well formed");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateUserAsync_NotCreated()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        if (_roleServiceMock == null)
+        {
+            Assert.Fail($"_roleServiceMock is null");
+        }
+
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
+        DatabaseSqlServer.User? expectedUser = null;
+
+        CreateUserRequest request = new CreateUserRequest()
+        {
+            Data = new CreateUserRequestData()
+            {
+                FirstName = user.FirstName,
+                LastName = user.LastName,
+                Email = user.Email,
+                Password = user.Password
+            }
+        };
+
+        _userServiceMock?.Setup(s => s.CheckIfEmailIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+
+        _roleServiceMock.Setup(s => s.GetRoleForUser(null)).ReturnsAsync(role);
+        _userServiceMock?.Setup(s => s.CreateUserAsync(request.Data, role)).ReturnsAsync(expectedUser);
+
+        ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Not created");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateUserAsync_ModelInvalid()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+
+        CreateUserRequest request = new CreateUserRequest()
+        {
+            Data = new CreateUserRequestData()
+            {
+                FirstName = user.FirstName,
+                LastName = user.LastName,
+                Email = user.Email,
+                Password = user.Password
+            }
+        };
+
+        _userServiceMock?.Setup(s => s.CheckIfEmailIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+
+        _userServiceMock?.Setup(s => s.CreateUserAsync(
+            It.IsAny<CreateUserRequestData>(),
+            It.IsAny<Role>()
+        )).ReturnsAsync(user);
+        _userController.ModelState.AddModelError("Data", "Invalid data");
+        ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
+
+        Assert.IsInstanceOfType(response, typeof(ObjectResult));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Request is not well formed");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateUserAsync_Exception()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        if (_roleServiceMock == null)
+        {
+            Assert.Fail($"_roleServiceMock is null");
+        }
+
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
+
+        CreateUserRequest request = new CreateUserRequest()
+        {
+            Data = new CreateUserRequestData()
+            {
+                FirstName = user.FirstName,
+                LastName = user.LastName,
+                Email = user.Email,
+                Password = user.Password
+            }
+        };
+
+        _userServiceMock?.Setup(s => s.CheckIfEmailIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+
+        _roleServiceMock.Setup(s => s.GetRoleForUser(null)).ReturnsAsync(role);
+        _userServiceMock?.Setup(s => s.CreateUserAsync(request.Data, role)).ReturnsAsync(user);
+
+        _userServiceMock?.Setup(s => s.CreateUserAsync(
+            It.IsAny<CreateUserRequestData>(),
+            It.IsAny<Role>()
+        )).ThrowsAsync(new Exception("Unexpected error"));
+
+        ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
+        Assert.IsInstanceOfType(response, typeof(ObjectResult));
+
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+}

MainProject.Tests/Controllers/VersionController_Tests.cs

@@ -10,15 +10,16 @@ using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Infrastructure;
 using BasicDotnetTemplate.MainProject.Models.Api.Response;
 using BasicDotnetTemplate.MainProject.Models.Settings;
+using Microsoft.AspNetCore.Http;
 
 
 namespace BasicDotnetTemplate.MainProject.Tests;
 
 [TestClass]
-public class BaseController_Tests
+public class VersionController_Tests
 {
     [TestMethod]
-    public void BaseController_NullConfiguration()
+    public void VersionController_NullConfiguration()
     {
         Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
         var exception = true;
@@ -34,7 +35,6 @@ public class BaseController_Tests
         }
     }
 
-
     [TestMethod]
     public void VersionController_GetVersion_Valid()
     {
@@ -48,13 +48,13 @@ public class BaseController_Tests
             var objectResult = ((ObjectResult)result).Value;
             if (objectResult != null)
             {
-                var data = (BaseResponse)objectResult;
+                var data = (BaseResponse<object>)objectResult;
                 if (data.Data != null)
                 {
                     AppSettings appSettings = new AppSettings();
                     configuration.GetSection("AppSettings").Bind(appSettings);
                     string version = data.Data != null ? (string)data.Data : "";
-                    Assert.IsTrue((((IStatusCodeActionResult)result).StatusCode == 200) && (version == appSettings.Settings?.Version));
+                    Assert.IsTrue((((IStatusCodeActionResult)result).StatusCode == StatusCodes.Status200OK) && (version == appSettings.Settings?.Version));
                 }
                 else
                 {
@@ -69,7 +69,7 @@ public class BaseController_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -87,8 +87,8 @@ public class BaseController_Tests
             var objectResult = ((ObjectResult)result).Value;
             if (objectResult != null)
             {
-                var data = (BaseResponse)objectResult;
-                Assert.IsTrue((((IStatusCodeActionResult)result).StatusCode == 200) && String.IsNullOrEmpty(data.Data));
+                var data = (BaseResponse<object>)objectResult;
+                Assert.IsTrue((((IStatusCodeActionResult)result).StatusCode == StatusCodes.Status200OK) && String.IsNullOrEmpty(data.Data));
             }
             else
             {
@@ -98,7 +98,7 @@ public class BaseController_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 }

MainProject.Tests/Core/Attributes/JwtAuthorizationAttribute_Tests.cs

@@ -0,0 +1,146 @@
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using Microsoft.AspNetCore.Builder;
+using BasicDotnetTemplate.MainProject.Models.Settings;
+using BasicDotnetTemplate.MainProject.Utils;
+using Microsoft.AspNetCore.Mvc.Filters;
+using BasicDotnetTemplate.MainProject.Core.Attributes;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using Microsoft.Extensions.Configuration;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Routing;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class JwtAuthorizationAttribute_Tests
+{
+    private static AuthenticatedUser? _authenticatedUser = null;
+    private static string? _token = null;
+    private static JwtAuthorizationAttribute? _attribute;
+    private static JwtTokenUtils? _jwtTokenUtils;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        _attribute = new JwtAuthorizationAttribute();
+
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+        _authenticatedUser = new AuthenticatedUser(user);
+
+        WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+        AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
+        _jwtTokenUtils = new JwtTokenUtils(appSettings);
+        _token = _jwtTokenUtils.GenerateToken(user.Guid);
+    }
+
+    private static AuthorizationFilterContext CreateAuthorizationContextWithAllowAnonymous()
+    {
+        var httpContext = new DefaultHttpContext();
+        var routeData = new RouteData();
+        var actionDescriptor = new ControllerActionDescriptor
+        {
+            EndpointMetadata = new List<object> { new AllowAnonymousAttribute() }
+        };
+        var actionContext = new ActionContext(httpContext, routeData, actionDescriptor);
+
+        actionContext.ActionDescriptor.EndpointMetadata.Add(new AllowAnonymousAttribute());
+
+        return new AuthorizationFilterContext(actionContext, []);
+    }
+
+    [TestMethod]
+    public void OnAuthorization_AllowAnonymous_SkipsAuthorization()
+    {
+        try
+        {
+            var context = CreateAuthorizationContextWithAllowAnonymous();
+            _attribute?.OnAuthorization(context);
+
+            Assert.IsNull(context.Result);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void OnAuthorization_NoAuthenticatedUser_ReturnsUnauthorized()
+    {
+        var context = TestUtils.CreateAuthorizationContext();
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+
+        context.HttpContext.RequestServices = new ServiceCollection()
+            .AddSingleton(configuration)
+            .BuildServiceProvider();
+
+        context.HttpContext.Items["User"] = null;
+        _attribute?.OnAuthorization(context);
+        Assert.IsInstanceOfType(context.Result, typeof(UnauthorizedResult));
+    }
+
+    [TestMethod]
+    public void OnAuthorization_EmptyAuthorizationHeader_ReturnsUnauthorized()
+    {
+        var context = TestUtils.CreateAuthorizationContext();
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+
+        context.HttpContext.RequestServices = new ServiceCollection()
+            .AddSingleton(configuration)
+            .BuildServiceProvider();
+
+        context.HttpContext.Items["User"] = _authenticatedUser;
+        context.HttpContext.Request.Headers.Authorization = string.Empty;
+
+        _attribute?.OnAuthorization(context);
+
+        Assert.IsInstanceOfType(context.Result, typeof(UnauthorizedResult));
+    }
+
+
+    [TestMethod]
+    public void OnAuthorization_InvalidToken_ReturnsUnauthorized()
+    {
+        var context = TestUtils.CreateAuthorizationContext();
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+
+        context.HttpContext.RequestServices = new ServiceCollection()
+            .AddSingleton(configuration)
+            .BuildServiceProvider();
+
+        var invalidToken = _jwtTokenUtils?.GenerateToken(Guid.NewGuid().ToString());
+        context.HttpContext.Request.Headers.Authorization = $"Bearer {invalidToken}";
+
+        context.HttpContext.Items["User"] = _authenticatedUser;
+
+        _attribute?.OnAuthorization(context);
+
+        Assert.IsInstanceOfType(context.Result, typeof(UnauthorizedResult));
+    }
+
+    [TestMethod]
+    public void OnAuthorization_ValidToken()
+    {
+        var context = TestUtils.CreateAuthorizationContext();
+        IConfiguration configuration = TestUtils.CreateConfiguration();
+
+        context.HttpContext.RequestServices = new ServiceCollection()
+            .AddSingleton(configuration)
+            .BuildServiceProvider();
+        context.HttpContext.Request.Headers.Authorization = $"Bearer {_token}";
+
+        context.HttpContext.Items["User"] = _authenticatedUser;
+
+        _attribute?.OnAuthorization(context);
+
+        Assert.IsNotInstanceOfType(context.Result, typeof(UnauthorizedResult));
+    }
+
+}

MainProject.Tests/Core/Middlewares/AutoMapperConfiguration_Tests.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Reflection;
+using System.Net;
+using System.Net.Http;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using BasicDotnetTemplate.MainProject;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using Microsoft.Extensions.DependencyModel.Resolution;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.User;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+using BasicDotnetTemplate.MainProject.Core.Middlewares;
+using AutoMapper;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class AutoMapperConfiguration_Tests
+{
+    private IMapper? _mapper;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.AddProfile<AutoMapperConfiguration>();
+        });
+
+        _mapper = config.CreateMapper();
+    }
+
+    [TestMethod]
+    public void Mapper_UserDto()
+    {
+        try
+        {
+            DatabaseSqlServer.User user = ModelsInit.CreateUser();
+            UserDto? data = _mapper?.Map<UserDto>(user);
+
+            Assert.IsTrue(data?.Guid == user.Guid);
+            Assert.IsTrue(data?.FirstName == user.FirstName);
+            Assert.IsTrue(data?.LastName == user.LastName);
+            Assert.IsTrue(data?.Email == user.Email);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+}
+
+
+
+

MainProject.Tests/JsonData/appsettings.json

@@ -21,6 +21,22 @@
                 "Name": "MIT License",
                 "Url": "https://github.com/csimonapastore/BasicDotnetTemplate/blob/main/LICENSE.md"
             }
+        },
+        "Logging": {
+            "LogLevel": {
+                "Default": "Information",
+                "Microsoft.AspNetCore": "Warning"
+            }
+        },
+        "JwtSettings": {
+            "ValidAudience": "http://localhost:4200",
+            "ValidIssuer": "http://localhost:5000",
+            "Secret": "JWTAuthenticationHIGHsecuredPasswordVVVp1OH7Xzyr",
+            "ExpiredAfterMinsOfInactivity": 15
+        },
+        "EncryptionSettings": {
+            "Salt": "S7VIidfXQf1tOQYX",
+            "Pepper": ""
         }
     }
 

MainProject.Tests/JsonData/invalidCryptAppsettings.json

@@ -0,0 +1,43 @@
+{
+    "AppSettings" : 
+    {
+        "Settings": {
+            "Name": "MainProject",
+            "Version": "v1.0",
+            "Description": "This template contains basic configuration for a .Net 8 backend"            
+        },
+        "DatabaseSettings": {
+            "SqlServerConnectionString": "SQLSERVER_DB_SERVER",
+            "MongoDbConnectionString": "MONGO_DB_SERVER",
+            "PostgreSQLConnectionString": "POSTGRESQL_DB_SERVER"
+        },
+        "OpenApiSettings": {
+            "TermsOfServiceUrl": "",
+            "OpenApiContact": {
+                "Name": "",
+                "Url": ""
+            },
+            "OpenApiLicense": {
+                "Name": "MIT License",
+                "Url": "https://github.com/csimonapastore/BasicDotnetTemplate/blob/main/LICENSE.md"
+            }
+        },
+        "Logging": {
+            "LogLevel": {
+                "Default": "Information",
+                "Microsoft.AspNetCore": "Warning"
+            }
+        },
+        "JwtSettings": {
+            "ValidAudience": "http://localhost:4200",
+            "ValidIssuer": "http://localhost:5000",
+            "Secret": "JWTAuthenticationHIGHsecuredPasswordVVVp1OH7Xzyr",
+            "ExpiredAfterMinsOfInactivity": 15
+        },
+        "EncryptionSettings": {
+            "Salt": "AAAAA",
+            "Pepper": ""
+        }
+    }
+
+}

MainProject.Tests/MainProject.Tests.csproj

@@ -11,9 +11,12 @@
 
   <ItemGroup>
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.3" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
     <PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
     <PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
   </ItemGroup>
 
   <ItemGroup>

MainProject.Tests/Models/Api/Common/Role/UserRole_Tests.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Reflection;
+using System.Net;
+using System.Net.Http;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using BasicDotnetTemplate.MainProject;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using Microsoft.Extensions.DependencyModel.Resolution;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class UserRole_Tests
+{
+    [TestMethod]
+    public void InitializeUserRoleFromRole()
+    {
+        try
+        {
+            DatabaseSqlServer.Role role = ModelsInit.CreateRole();
+            UserRole userRole = new UserRole(role);
+
+            Assert.IsTrue(userRole.Name == role.Name);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+}

MainProject.Tests/Models/Api/Common/User/AuthenticatedUser_Tests.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Reflection;
+using System.Net;
+using System.Net.Http;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using BasicDotnetTemplate.MainProject;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using Microsoft.Extensions.DependencyModel.Resolution;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class AuthenticatedUser_Tests
+{
+    [TestMethod]
+    public void InitializeAuthenticatedUserFromUser()
+    {
+        try
+        {
+            DatabaseSqlServer.User user = ModelsInit.CreateUser();
+            AuthenticatedUser authenticatedUser = new AuthenticatedUser(user);
+
+            Assert.IsTrue(authenticatedUser.FirstName == user.FirstName);
+            Assert.IsTrue(authenticatedUser.LastName == user.LastName);
+            Assert.IsTrue(authenticatedUser.Email == user.Email);
+            Assert.IsInstanceOfType(authenticatedUser.Role, typeof(UserRole));
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+}

MainProject.Tests/Models/Api/Response/ApiResponse_Tests.cs

@@ -6,6 +6,7 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
 using BasicDotnetTemplate.MainProject;
 using BasicDotnetTemplate.MainProject.Models.Api.Response;
 using Microsoft.Extensions.DependencyModel.Resolution;
+using Microsoft.AspNetCore.Http;
 
 
 namespace BasicDotnetTemplate.MainProject.Tests;
@@ -18,13 +19,13 @@ public class ApiResponse_Tests
     {
         try
         {
-            var baseResponse = new BaseResponse(200, null, null);
-            Assert.IsTrue(baseResponse.Status == 200 && String.IsNullOrEmpty(baseResponse.Message) && baseResponse.Data == null);
+            var baseResponse = new BaseResponse<object>(200, null, null);
+            Assert.IsTrue(baseResponse.Status == StatusCodes.Status200OK && String.IsNullOrEmpty(baseResponse.Message) && baseResponse.Data == null);
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -33,13 +34,13 @@ public class ApiResponse_Tests
     {
         try
         {
-            var baseResponse = new BaseResponse(201, null, null);
-            Assert.IsFalse(baseResponse.Status == 200);
+            var baseResponse = new BaseResponse<object>(201, null, null);
+            Assert.IsFalse(baseResponse.Status == StatusCodes.Status200OK);
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -48,13 +49,13 @@ public class ApiResponse_Tests
     {
         try
         {
-            var baseResponse = new BaseResponse(200, "This is a test message", null);
-            Assert.IsTrue(baseResponse.Status == 200 && baseResponse.Message == "This is a test message" && baseResponse.Data == null);
+            var baseResponse = new BaseResponse<object>(200, "This is a test message", null);
+            Assert.IsTrue(baseResponse.Status == StatusCodes.Status200OK && baseResponse.Message == "This is a test message" && baseResponse.Data == null);
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -64,13 +65,13 @@ public class ApiResponse_Tests
         try
         {
             string[] data = { "Volvo", "BMW", "Ford", "Mazda" };
-            var baseResponse = new BaseResponse(200, "This is a test message", data);
-            Assert.IsTrue(baseResponse.Status == 200 && baseResponse.Message == "This is a test message" && baseResponse.Data == data);
+            var baseResponse = new BaseResponse<string[]>(200, "This is a test message", data);
+            Assert.IsTrue(baseResponse.Status == StatusCodes.Status200OK && baseResponse.Message == "This is a test message" && baseResponse.Data == data);
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 }

MainProject.Tests/Models/Api/Response/Auth/AuthenticateResponse_Tests.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Reflection;
+using System.Net;
+using System.Net.Http;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using BasicDotnetTemplate.MainProject;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using Microsoft.Extensions.DependencyModel.Resolution;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+using Microsoft.AspNetCore.Http;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class AuthenticateResponse_Tests
+{
+    [TestMethod]
+    public void IstantiateAuthenticateResponse_OnlyStatus_Valid()
+    {
+        try
+        {
+            var authenticateResponse = new AuthenticateResponse(200, null, null);
+            Assert.IsTrue(authenticateResponse.Status == StatusCodes.Status200OK && String.IsNullOrEmpty(authenticateResponse.Message) && authenticateResponse.Data == null);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void IstantiateAuthenticateResponse_OnlyStatus_IsInvalid()
+    {
+        try
+        {
+            var authenticateResponse = new AuthenticateResponse(201, null, null);
+            Assert.IsFalse(authenticateResponse.Status == StatusCodes.Status200OK);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void IstantiateAuthenticateResponse_StatusAndMessage_Valid()
+    {
+        try
+        {
+            var authenticateResponse = new AuthenticateResponse(200, "This is a test message", null);
+            Assert.IsTrue(authenticateResponse.Status == StatusCodes.Status200OK && authenticateResponse.Message == "This is a test message" && authenticateResponse.Data == null);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void IstantiateAuthenticateResponse_AllFields_Valid()
+    {
+        try
+        {
+            DatabaseSqlServer.User user = ModelsInit.CreateUser();
+            AuthenticatedUser data = new AuthenticatedUser(user);
+            var authenticateResponse = new AuthenticateResponse(200, "This is a test message", data);
+            Assert.IsTrue(authenticateResponse.Status == StatusCodes.Status200OK && authenticateResponse.Message == "This is a test message" && authenticateResponse.Data == data);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+}
+
+
+
+

MainProject.Tests/Models/Api/Response/User/GetUserResponse_Tests.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Reflection;
+using System.Net;
+using System.Net.Http;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using BasicDotnetTemplate.MainProject;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using Microsoft.Extensions.DependencyModel.Resolution;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.User;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+using BasicDotnetTemplate.MainProject.Core.Middlewares;
+using AutoMapper;
+using Microsoft.AspNetCore.Http;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class GetUserResponse_Tests
+{
+    private IMapper? _mapper;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.AddProfile<AutoMapperConfiguration>();
+        });
+
+        _mapper = config.CreateMapper();
+    }
+
+    [TestMethod]
+    public void IstantiateGetUserResponse_OnlyStatus_Valid()
+    {
+        try
+        {
+            var getUserResponse = new GetUserResponse(200, null, null);
+            Assert.IsTrue(getUserResponse.Status == StatusCodes.Status200OK && String.IsNullOrEmpty(getUserResponse.Message) && getUserResponse.Data == null);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void IstantiateGetUserResponse_OnlyStatus_IsInvalid()
+    {
+        try
+        {
+            var getUserResponse = new GetUserResponse(201, null, null);
+            Assert.IsFalse(getUserResponse.Status == StatusCodes.Status200OK);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void IstantiateGetUserResponse_StatusAndMessage_Valid()
+    {
+        try
+        {
+            var getUserResponse = new GetUserResponse(200, "This is a test message", null);
+            Assert.IsTrue(getUserResponse.Status == StatusCodes.Status200OK && getUserResponse.Message == "This is a test message" && getUserResponse.Data == null);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void IstantiateGetUserResponse_AllFields_Valid()
+    {
+        try
+        {
+            DatabaseSqlServer.User user = ModelsInit.CreateUser();
+            UserDto? data = _mapper?.Map<UserDto>(user);
+            var getUserResponse = new GetUserResponse(200, "This is a test message", data);
+            Assert.IsTrue(getUserResponse.Status == StatusCodes.Status200OK && getUserResponse.Message == "This is a test message" && getUserResponse.Data == data);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+}
+
+
+
+

MainProject.Tests/Models/Settings/Settings_Tests.cs

@@ -7,6 +7,7 @@ using BasicDotnetTemplate.MainProject;
 using BasicDotnetTemplate.MainProject.Models.Api.Response;
 using Microsoft.Extensions.DependencyModel.Resolution;
 using BasicDotnetTemplate.MainProject.Models.Settings;
+using Microsoft.AspNetCore.Http;
 
 
 namespace BasicDotnetTemplate.MainProject.Tests;
@@ -25,7 +26,8 @@ public class Settings_Tests
 
             var privateSettings = new PrivateSettings()
             {
-                DatabaseConnection = new DatabaseConnection() {
+                DatabaseConnection = new DatabaseConnection()
+                {
                     SqlServer = sqlServer,
                     Mongodb = mongodb,
                     Postgres = postgres,
@@ -42,7 +44,7 @@ public class Settings_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -51,13 +53,13 @@ public class Settings_Tests
     {
         try
         {
-            var baseResponse = new BaseResponse(201, null, null);
-            Assert.IsFalse(baseResponse.Status == 200);
+            var baseResponse = new BaseResponse<object>(201, null, null);
+            Assert.IsFalse(baseResponse.Status == StatusCodes.Status200OK);
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -66,13 +68,13 @@ public class Settings_Tests
     {
         try
         {
-            var baseResponse = new BaseResponse(200, "This is a test message", null);
-            Assert.IsTrue(baseResponse.Status == 200 && baseResponse.Message == "This is a test message" && baseResponse.Data == null);
+            var baseResponse = new BaseResponse<object>(200, "This is a test message", null);
+            Assert.IsTrue(baseResponse.Status == StatusCodes.Status200OK && baseResponse.Message == "This is a test message" && baseResponse.Data == null);
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -82,13 +84,13 @@ public class Settings_Tests
         try
         {
             string[] data = { "Volvo", "BMW", "Ford", "Mazda" };
-            var baseResponse = new BaseResponse(200, "This is a test message", data);
-            Assert.IsTrue(baseResponse.Status == 200 && baseResponse.Message == "This is a test message" && baseResponse.Data == data);
+            var baseResponse = new BaseResponse<string[]>(200, "This is a test message", data);
+            Assert.IsTrue(baseResponse.Status == StatusCodes.Status200OK && baseResponse.Message == "This is a test message" && baseResponse.Data == data);
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 }

MainProject.Tests/Program_Tests.cs

@@ -70,7 +70,7 @@ public class Program_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 

MainProject.Tests/Services/AuthService_Tests.cs

@@ -0,0 +1,114 @@
+using BasicDotnetTemplate.MainProject.Models.Settings;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.EntityFrameworkCore;
+using BasicDotnetTemplate.MainProject.Utils;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
+using Moq;
+using Newtonsoft.Json;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Services;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using BasicDotnetTemplate.MainProject.Models.Api.Request.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class AuthService_Tests
+{
+    [TestMethod]
+    public void Inizialize()
+    {
+        try
+        {
+            var authService = TestUtils.CreateAuthService();
+            if (authService != null)
+            {
+                Assert.IsInstanceOfType(authService, typeof(AuthService));
+            }
+            else
+            {
+                Assert.Fail($"AuthService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task AuthenticateAsync_UserNotFound()
+    {
+        try
+        {
+            var request = new AuthenticateRequest
+            {
+                Data = new AuthenticateRequestData
+                {
+                    Email = "d2ejdI1f4GYpq2kTB1nmeQkZXqR3QSxH8Yqkl7iv7zgfQ13qG/0dUUsreG/WGHWRBE5mVWaV43A=",
+                    Password = "d2ejdI1f4GYpq2kTB1nmeQkZXqR3QSxH8Yqkl7iv7zgfQ13qG/0dUUsreG/WGHWRBE5mVWaV43A="
+                }
+            };
+            var authService = TestUtils.CreateAuthService();
+            if (authService != null)
+            {
+                var authenticatedUser = await authService.AuthenticateAsync(request.Data);
+                Assert.IsTrue(authenticatedUser == null);
+            }
+            else
+            {
+                Assert.Fail($"AuthService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task AuthenticateAsync_UsernamePasswordInvalid()
+    {
+        try
+        {
+            var request = new AuthenticateRequest
+            {
+                Data = new AuthenticateRequestData
+                {
+                    Email = "WGHWRBE5mVWaV=",
+                    Password = "WGHWRBE5mVWaV="
+                }
+            };
+            var authService = TestUtils.CreateAuthService();
+            if (authService != null)
+            {
+                var authenticatedUser = await authService.AuthenticateAsync(request.Data);
+                Assert.IsTrue(authenticatedUser == null);
+            }
+            else
+            {
+                Assert.Fail($"AuthService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+}
+
+
+
+

MainProject.Tests/Services/JwtService_Tests.cs

@@ -0,0 +1,76 @@
+using BasicDotnetTemplate.MainProject.Models.Settings;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.EntityFrameworkCore;
+using BasicDotnetTemplate.MainProject.Utils;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
+using Moq;
+using Newtonsoft.Json;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Services;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using BasicDotnetTemplate.MainProject.Models.Api.Request.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class JwtService_Tests
+{
+    [TestMethod]
+    public void Inizialize()
+    {
+        try
+        {
+            var jwtService = TestUtils.CreateJwtService();
+            if (jwtService != null)
+            {
+                Assert.IsInstanceOfType(jwtService, typeof(JwtService));
+            }
+            else
+            {
+                Assert.Fail($"JwtService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void GenerateToken()
+    {
+        try
+        {
+            var jwtService = TestUtils.CreateJwtService();
+            var testString = "test";
+            if (jwtService != null)
+            {
+                var jwt = jwtService.GenerateToken(testString);
+                Assert.IsTrue(jwt != null);
+                Assert.IsInstanceOfType(jwt, typeof(string));
+            }
+            else
+            {
+                Assert.Fail($"JwtService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+
+}
+
+
+
+

MainProject.Tests/Services/RoleService_Tests.cs

@@ -0,0 +1,293 @@
+
+using BasicDotnetTemplate.MainProject.Services;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.Role;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class RoleService_Tests
+{
+    private static Role? _expectedRole = ModelsInit.CreateRole();
+    private static Role? _role;
+    private static RoleService _roleService = TestUtils.CreateRoleService();
+
+
+    [TestMethod]
+    public void Inizialize()
+    {
+        try
+        {
+            var roleService = TestUtils.CreateRoleService();
+            if (roleService != null)
+            {
+                Assert.IsInstanceOfType(roleService, typeof(RoleService));
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CheckIfNameIsValid_NameNotExists()
+    {
+        try
+        {
+            var expectedRole = ModelsInit.CreateRole();
+
+            if (_roleService != null)
+            {
+                var valid = await _roleService.CheckIfNameIsValid(expectedRole.Name);
+                Assert.IsTrue(valid);
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateRoleData()
+    {
+        try
+        {
+            CreateRoleRequestData data = new CreateRoleRequestData()
+            {
+                Name = _expectedRole?.Name ?? String.Empty,
+                IsNotEditable = false
+            };
+
+            if (_roleService != null)
+            {
+                var role = await _roleService.CreateRoleAsync(data);
+                Assert.IsInstanceOfType(role, typeof(Role));
+                Assert.IsNotNull(role);
+                Assert.IsTrue(_expectedRole?.Name == role.Name);
+                Assert.IsTrue(_expectedRole?.IsNotEditable == role.IsNotEditable);
+                _role = role;
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CheckIfNameIsValid_NameCurrentRole()
+    {
+        try
+        {
+            var expectedRole = ModelsInit.CreateRole();
+            if (_roleService != null)
+            {
+                var valid = await _roleService.CheckIfNameIsValid(expectedRole.Name, _role?.Guid ?? String.Empty);
+                Assert.IsTrue(valid);
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CheckIfNameIsValid_NameAlreadyExists()
+    {
+        try
+        {
+            var expectedRole = ModelsInit.CreateRole();
+
+            if (_roleService != null)
+            {
+                var valid = await _roleService.CheckIfNameIsValid(expectedRole.Name);
+                Assert.IsFalse(valid);
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetRoleByIdAsync()
+    {
+        try
+        {
+            if (_roleService != null)
+            {
+                var role = await _roleService.GetRoleByIdAsync(_role?.Id ?? 0);
+                Assert.IsNotNull(role);
+                Assert.IsTrue(role.Id == _role?.Id);
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetRoleByGuidAsync()
+    {
+        try
+        {
+            if (_roleService != null)
+            {
+                var role = await _roleService.GetRoleByGuidAsync(_role?.Guid ?? String.Empty);
+                Assert.IsNotNull(role);
+                Assert.IsTrue(role.Guid == _role?.Guid);
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetRoleByGuidAsync_CurrentRole()
+    {
+        try
+        {
+            if (_roleService != null)
+            {
+                var role = await _roleService.GetRoleForUser(_role?.Guid);
+                Assert.IsNotNull(role);
+                Assert.IsTrue(role.Guid == _role?.Guid);
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetRoleByGuidAsync_Default()
+    {
+        try
+        {
+            if (_roleService != null)
+            {
+                CreateRoleRequestData data = new()
+                {
+                    Name = "Default",
+                    IsNotEditable = true
+                };
+                var roleCreated = await _roleService.CreateRoleAsync(data);
+                var role = await _roleService.GetRoleForUser(String.Empty);
+                Assert.IsNotNull(role);
+                Assert.IsTrue(roleCreated?.Guid == role?.Guid);
+                Assert.IsTrue(role?.Name == "Default");
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetRoleByGuidAsync_Null()
+    {
+        try
+        {
+            if (_roleService != null)
+            {
+                var role = await _roleService.GetRoleForUser(Guid.NewGuid().ToString());
+                Assert.IsNull(role);
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task DeleteRoleAsync()
+    {
+        try
+        {
+            if (_roleService != null)
+            {
+                var role = await _roleService.GetRoleByGuidAsync(_role?.Guid ?? String.Empty);
+                Assert.IsNotNull(role);
+                var deleted = await _roleService.DeleteRoleAsync(role);
+                Assert.IsTrue(deleted);
+            }
+            else
+            {
+                Assert.Fail($"RoleService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+
+}
+
+
+
+

MainProject.Tests/Services/UserService_Tests.cs

@@ -0,0 +1,245 @@
+using BasicDotnetTemplate.MainProject.Services;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.User;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using Newtonsoft.Json;
+
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class UserService_Tests
+{
+    private static User _user = ModelsInit.CreateUser();
+    private static UserService _userService = TestUtils.CreateUserService();
+
+    [TestMethod]
+    public void Inizialize()
+    {
+        try
+        {
+            var userService = TestUtils.CreateUserService();
+            if (userService != null)
+            {
+                Assert.IsInstanceOfType(userService, typeof(UserService));
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex.Message}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetUserByUsernameAndPassword_Null()
+    {
+        try
+        {
+            var testString = "test";
+            if (_userService != null)
+            {
+                var user = await _userService.GetUserByUsernameAndPassword(testString, testString);
+                Assert.IsTrue(user == null);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CheckIfEmailIsValid_EmailNotExists()
+    {
+        try
+        {
+            if (_userService != null)
+            {
+                var valid = await _userService.CheckIfEmailIsValid(_user.Email ?? String.Empty);
+                Assert.IsTrue(valid);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateUserAsync_Success()
+    {
+        try
+        {
+
+            var expectedUser = ModelsInit.CreateUser();
+
+            CreateUserRequestData data = new CreateUserRequestData()
+            {
+                FirstName = expectedUser.FirstName ?? String.Empty,
+                LastName = expectedUser.LastName ?? String.Empty,
+                Email = expectedUser.Email ?? String.Empty
+            };
+
+            Role role = new()
+            {
+                Name = expectedUser.Role?.Name ?? String.Empty,
+                IsNotEditable = expectedUser.Role?.IsNotEditable ?? false,
+                Guid = expectedUser.Role?.Guid ?? String.Empty
+            };
+
+            var user = await _userService.CreateUserAsync(data, role);
+            Assert.IsInstanceOfType(user, typeof(User));
+            Assert.IsNotNull(user);
+            Assert.IsTrue(expectedUser.FirstName == user.FirstName);
+            Assert.IsTrue(expectedUser.LastName == user.LastName);
+            Assert.IsTrue(expectedUser.Email == user.Email);
+            Assert.IsTrue(expectedUser.Role?.Name == user.Role?.Name);
+            _user = user;
+
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CheckIfEmailIsValid_EmailCurrentUser()
+    {
+        try
+        {
+
+            if (_userService != null)
+            {
+                var valid = await _userService.CheckIfEmailIsValid(_user.Email ?? String.Empty, _user.Guid ?? String.Empty);
+                Assert.IsTrue(valid);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CheckIfEmailIsValid_EmailAlreadyExists()
+    {
+        try
+        {
+
+            if (_userService != null)
+            {
+                var valid = await _userService.CheckIfEmailIsValid(_user.Email ?? String.Empty);
+                Assert.IsFalse(valid);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetUserByIdAsync()
+    {
+        try
+        {
+
+            if (_userService != null)
+            {
+                var user = await _userService.GetUserByIdAsync(_user.Id);
+                Assert.IsNotNull(user);
+                Assert.IsTrue(user.Id == _user?.Id);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetUserByGuidAsync()
+    {
+        try
+        {
+
+            if (_userService != null)
+            {
+                var user = await _userService.GetUserByGuidAsync(_user.Guid ?? String.Empty);
+                Assert.IsNotNull(user);
+                Assert.IsTrue(user.Guid == _user?.Guid);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task DeleteUser()
+    {
+        try
+        {
+
+            if (_userService != null)
+            {
+                var user = await _userService.GetUserByGuidAsync(_user.Guid ?? String.Empty);
+                Assert.IsNotNull(user);
+                var deleted = await _userService.DeleteUserAsync(user);
+                Assert.IsTrue(deleted);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+
+}
+
+
+

MainProject.Tests/TestsUtils/ModelsInit.cs

@@ -0,0 +1,35 @@
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+public static class ModelsInit
+{
+    public static DatabaseSqlServer.User CreateUser()
+    {
+        DatabaseSqlServer.User user = new DatabaseSqlServer.User()
+        {
+            Guid = Guid.NewGuid().ToString(),
+            FirstName = "FirstName",
+            LastName = "LastName",
+            Email = "test-new@email.it",
+            PasswordHash = "PasswordHash",
+            PasswordSalt = "PasswordSalt",
+            Password = "Password",
+            Role = CreateRole(),
+            IsTestUser = true
+        };
+        return user;
+    }
+
+    public static DatabaseSqlServer.Role CreateRole()
+    {
+        DatabaseSqlServer.Role role = new DatabaseSqlServer.Role()
+        {
+            Guid = Guid.NewGuid().ToString(),
+            Name = "Name",
+            IsNotEditable = false
+        };
+        return role;
+    }
+}

MainProject.Tests/TestsUtils/TestUtils.cs

@@ -13,12 +13,30 @@ using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Configuration;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Interfaces;
+using Microsoft.EntityFrameworkCore;
+using Moq;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Services;
+using Microsoft.AspNetCore.Http;
+using Newtonsoft.Json;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.AspNetCore.Mvc.Controllers;
 
 
 namespace BasicDotnetTemplate.MainProject.Tests;
 
 public static class TestUtils
 {
+
+    public static AuthorizationFilterContext CreateAuthorizationContext()
+    {
+        var httpContext = new DefaultHttpContext();
+        var actionContext = new ActionContext(httpContext, new RouteData(), new ControllerActionDescriptor());
+        return new AuthorizationFilterContext(actionContext, new List<IFilterMetadata>());
+    }
+
     public static IConfiguration CreateConfiguration()
     {
         WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
@@ -38,6 +56,74 @@ public static class TestUtils
             .AddEnvironmentVariables()
             .Build();
     }
+
+    public static string GetSqlConnectionString(IConfiguration configuration)
+    {
+        AppSettings _appSettings = new AppSettings();
+        configuration.GetSection("AppSettings").Bind(_appSettings);
+        return _appSettings.DatabaseSettings?.SqlServerConnectionString ?? String.Empty;
+    }
+
+    public static SqlServerContext CreateInMemorySqlContext()
+    {
+        var options = new DbContextOptionsBuilder<SqlServerContext>()
+            .UseSqlite("DataSource=:memory:") // Database in-memory
+            .Options;
+
+        var context = new SqlServerContext(options);
+        context.Database.OpenConnection();
+        context.Database.EnsureCreated();
+        return context;
+    }
+
+    public static BaseService CreateBaseService()
+    {
+        IConfiguration configuration = CreateConfiguration();
+        var optionsBuilder = new DbContextOptionsBuilder<SqlServerContext>();
+        optionsBuilder.UseSqlServer(GetSqlConnectionString(configuration));
+        SqlServerContext sqlServerContext = CreateInMemorySqlContext();
+        var httpContextAccessor = new Mock<IHttpContextAccessor>();
+        return new BaseService(httpContextAccessor.Object, configuration, sqlServerContext);
+    }
+
+    public static AuthService CreateAuthService()
+    {
+        IConfiguration configuration = CreateConfiguration();
+        var optionsBuilder = new DbContextOptionsBuilder<SqlServerContext>();
+        optionsBuilder.UseSqlServer(GetSqlConnectionString(configuration));
+        SqlServerContext sqlServerContext = CreateInMemorySqlContext();
+        var userServiceMock = new Mock<IUserService>();
+        var httpContextAccessor = new Mock<IHttpContextAccessor>();
+        return new AuthService(httpContextAccessor.Object, configuration, sqlServerContext, userServiceMock.Object);
+    }
+
+    public static UserService CreateUserService()
+    {
+        IConfiguration configuration = CreateConfiguration();
+        SqlServerContext sqlServerContext = CreateInMemorySqlContext();
+        var httpContextAccessor = new Mock<IHttpContextAccessor>();
+        return new UserService(httpContextAccessor.Object, configuration, sqlServerContext);
+    }
+
+    public static JwtService CreateJwtService()
+    {
+        IConfiguration configuration = CreateConfiguration();
+        var optionsBuilder = new DbContextOptionsBuilder<SqlServerContext>();
+        optionsBuilder.UseSqlServer(GetSqlConnectionString(configuration));
+        SqlServerContext sqlServerContext = CreateInMemorySqlContext();
+        var httpContextAccessor = new Mock<IHttpContextAccessor>();
+        return new JwtService(httpContextAccessor.Object, configuration, sqlServerContext);
+    }
+
+    public static RoleService CreateRoleService()
+    {
+        IConfiguration configuration = CreateConfiguration();
+        var optionsBuilder = new DbContextOptionsBuilder<SqlServerContext>();
+        optionsBuilder.UseSqlServer(GetSqlConnectionString(configuration));
+        SqlServerContext sqlServerContext = CreateInMemorySqlContext();
+        var httpContextAccessor = new Mock<IHttpContextAccessor>();
+        return new RoleService(httpContextAccessor.Object, configuration, sqlServerContext);
+    }
 }
 
 

MainProject.Tests/Utils/CryptoUtils_Tests.cs

@@ -0,0 +1,169 @@
+using System;
+using BasicDotnetTemplate.MainProject.Models.Settings;
+using Microsoft.AspNetCore.Builder;
+using BasicDotnetTemplate.MainProject.Utils;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class CryptoUtils_Tests
+{
+    [TestMethod]
+    public void Decrypt_Success()
+    {
+        try
+        {
+            string encryptedData = "d2ejdI1f4GYpq2kTB1nmeQkZXqR3QSxH8Yqkl7iv7zgfQ13qG/0dUUsreG/WGHWRBE5mVWaV43A=";
+            WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+            AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
+            CryptUtils cryptoUtils = new CryptUtils(appSettings);
+            var decryptedData = cryptoUtils.Decrypt(encryptedData);
+            var isEqual = decryptedData == "ThisIsASuccessfullTest";
+            Assert.IsTrue(isEqual);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void Decrypt_Error()
+    {
+        try
+        {
+            string encryptedData = "d1ejdI1f4GYpq2kTB1nmeQkZXqR3QSxH8Yqkl7iv7zgfQ13qG/0dUUsreG/WGHWRBE5mVWaV43A=";
+            WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+            AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
+            CryptUtils cryptoUtils = new CryptUtils(appSettings);
+            var decryptedData = cryptoUtils.Decrypt(encryptedData);
+            var isEqual = decryptedData == "ThisIsASuccessfullTest";
+            Assert.IsFalse(isEqual);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void Decrypt_ArgumentException()
+    {
+        try
+        {
+            string encryptedData = "d1ejdI1f4GYpq2kTB1nmeQkZXqR3QSxH8Yqkl7iv7zgfQ13qG/0dUUsreG/WGHWRBE5mVWaV43A=";
+            WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+            AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData", "invalidCryptAppsettings.json");
+            CryptUtils cryptoUtils = new CryptUtils(appSettings);
+            try
+            {
+                var decryptedData = cryptoUtils.Decrypt(encryptedData);
+                Assert.Fail($"Expected exception instead of response: {decryptedData}");
+            }
+            catch (ArgumentException argumentException)
+            {
+                Assert.IsInstanceOfType(argumentException, typeof(ArgumentException));
+            }
+            catch (Exception exception)
+            {
+                Assert.IsInstanceOfType(exception, typeof(ArgumentException));
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void Decrypt_Empty()
+    {
+        try
+        {
+            string encryptedData = "WGHWRBE5mVWaV=";
+            WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+            AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
+            CryptUtils cryptoUtils = new CryptUtils(appSettings);
+            var decryptedData = cryptoUtils.Decrypt(encryptedData);
+            var isEqual = decryptedData == String.Empty;
+            Assert.IsTrue(isEqual);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void GenerateSalt()
+    {
+        try
+        {
+            var salt = CryptUtils.GenerateSalt();
+            Assert.IsTrue(!String.IsNullOrEmpty(salt));
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void ComputeHash_Hashed()
+    {
+        try
+        {
+            var password = "P4ssw0rd@1!";
+            var salt = CryptUtils.GenerateSalt();
+            Assert.IsTrue(!String.IsNullOrEmpty(salt));
+
+            WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+            AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
+            CryptUtils cryptoUtils = new CryptUtils(appSettings);
+            var encryptedPassword = cryptoUtils.GeneratePassword(password, salt, 0);
+            Assert.IsTrue(password != encryptedPassword);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void VerifyPassword_True()
+    {
+        try
+        {
+            var password = "P4ssw0rd@1!";
+            var salt = "Afi7PQYgEL2sPbNyVzduvg==";
+            var hashedPassword = "2lMeySZ9ciH1KtSg1Z7oSJRmJEjHMeDvdaNRcJcGutM=";
+
+            WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+            AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
+            CryptUtils cryptoUtils = new CryptUtils(appSettings);
+            var verified = cryptoUtils.VerifyPassword(password, salt, 0, hashedPassword);
+            Console.WriteLine(cryptoUtils.GeneratePassword(password, salt, 0));
+
+            Assert.IsTrue(verified);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+}
+
+
+
+

MainProject.Tests/Utils/JwtTokenUtils_Tests.cs

@@ -0,0 +1,76 @@
+using System;
+using BasicDotnetTemplate.MainProject.Models.Settings;
+using Microsoft.AspNetCore.Builder;
+using BasicDotnetTemplate.MainProject.Utils;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class JwtTokenUtils_Tests
+{
+    private static string _guid = "15e4be58-e655-475e-b4b8-a9779b359f57";
+
+    [TestMethod]
+    public void GenerateToken()
+    {
+        try
+        {
+            WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+            AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
+            JwtTokenUtils jwtUtils = new JwtTokenUtils(appSettings);
+            var jwt = jwtUtils.GenerateToken(_guid);
+            Assert.IsTrue(!String.IsNullOrEmpty(jwt));
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void ValidateToken()
+    {
+        try
+        {
+            WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+            AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
+            JwtTokenUtils jwtUtils = new JwtTokenUtils(appSettings);
+            var jwt = jwtUtils.GenerateToken(_guid);
+            var guid = jwtUtils.ValidateToken($"Bearer {jwt}");
+            Assert.IsTrue(_guid == guid);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public void ValidateToken_Empty()
+    {
+        try
+        {
+            WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
+            AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
+            JwtTokenUtils jwtUtils = new JwtTokenUtils(appSettings);
+            var jwt = jwtUtils.GenerateToken(_guid);
+            var guid = jwtUtils.ValidateToken(jwt);
+            Assert.IsTrue(String.IsNullOrEmpty(guid));
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+}
+
+
+
+

MainProject.Tests/Utils/ProgramUtils_Tests.cs

@@ -1,11 +1,3 @@
-using System;
-using System.Reflection;
-using System.Net;
-using System.Net.Http;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using BasicDotnetTemplate.MainProject;
-using BasicDotnetTemplate.MainProject.Models.Api.Response;
-using Microsoft.Extensions.DependencyModel.Resolution;
 using BasicDotnetTemplate.MainProject.Models.Settings;
 using Microsoft.AspNetCore.Builder;
 using BasicDotnetTemplate.MainProject.Utils;
@@ -52,7 +44,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -88,7 +80,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -105,7 +97,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -134,7 +126,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -168,7 +160,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -204,7 +196,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -228,7 +220,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -248,7 +240,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -268,7 +260,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -288,7 +280,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 
@@ -299,7 +291,7 @@ public class ProgramUtils_Tests
         {
             DatabaseSettings expectedDbSettings = new DatabaseSettings()
             {
-                SqlServerConnectionString = ""
+                SqlServerConnectionString = null
             };
 
             WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
@@ -313,7 +305,7 @@ public class ProgramUtils_Tests
         catch (Exception ex)
         {
             Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex.Message}");
+            Assert.Fail($"An exception was thrown: {ex}");
         }
     }
 

MainProject/Controllers/AuthController.cs

@@ -0,0 +1,68 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using BasicDotnetTemplate.MainProject.Core.Attributes;
+using BasicDotnetTemplate.MainProject.Models.Api.Request.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+using BasicDotnetTemplate.MainProject.Services;
+
+namespace BasicDotnetTemplate.MainProject.Controllers
+{
+    [Route("[controller]")]
+    public class AuthController : BaseController
+    {
+        private readonly IAuthService _authService;
+        public AuthController(
+            IConfiguration configuration,
+            IAuthService authService
+        ) : base(configuration)
+        {
+            this._authService = authService;
+        }
+
+        [HttpPost("authenticate")]
+        [ProducesResponseType<AuthenticateResponse>(StatusCodes.Status200OK)]
+        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status404NotFound)]
+        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> AuthenticateAsync([FromBody] AuthenticateRequest request)
+        {
+            try
+            {
+                if (!ModelState.IsValid)
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+
+                if (
+                    request == null ||
+                    request.Data == null ||
+                    String.IsNullOrEmpty(request.Data.Email) ||
+                    String.IsNullOrEmpty(request.Data.Password)
+                )
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+                var data = await this._authService.AuthenticateAsync(request.Data);
+
+                if (data == null)
+                {
+                    return NotFound();
+                }
+
+                return Success(String.Empty, data);
+            }
+            catch (Exception exception)
+            {
+                var message = "Something went wrong";
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
+            }
+
+        }
+    }
+}

MainProject/Controllers/BaseController.cs

@@ -2,13 +2,17 @@ using System.Net;
 using Microsoft.AspNetCore.Mvc;
 using BasicDotnetTemplate.MainProject.Models.Api.Response;
 using BasicDotnetTemplate.MainProject.Models.Settings;
+using AutoMapper;
+using BasicDotnetTemplate.MainProject.Core.Middlewares;
 
 namespace BasicDotnetTemplate.MainProject.Controllers
 {
     public abstract class BaseController : ControllerBase
     {
+        protected readonly IMapper? _mapper;
         protected readonly IConfiguration _configuration;
         protected readonly AppSettings _appSettings;
+        protected readonly string _requestNotWellFormed = "Request is not well formed";
 
         protected BaseController(
             IConfiguration configuration
@@ -17,12 +21,19 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             _configuration = configuration;
             _appSettings = new AppSettings();
             _configuration.GetSection("AppSettings").Bind(_appSettings);
+
+            var config = new MapperConfiguration(cfg =>
+            {
+                cfg.AddProfile<AutoMapperConfiguration>();
+            });
+
+            _mapper = config.CreateMapper();
         }
 
 #nullable enable
-        private static BaseResponse CreateResponse(HttpStatusCode status, string message, object? data = null)
+        private static BaseResponse<T> CreateResponse<T>(HttpStatusCode status, string message, T? data)
         {
-            return new BaseResponse((int)status, message, data);
+            return new BaseResponse<T>((int)status, message, data);
         }
 
         protected new IActionResult Created(string message, object? data = null)
@@ -37,6 +48,12 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             return StatusCode((int)HttpStatusCode.OK, CreateResponse(HttpStatusCode.OK, message, data));
         }
 
+        protected IActionResult NotModified(string message, object? data = null)
+        {
+            message = String.IsNullOrEmpty(message) ? "Not modified" : message;
+            return StatusCode((int)HttpStatusCode.NotModified, CreateResponse(HttpStatusCode.NotModified, message, data));
+        }
+
         protected IActionResult NotFound(string message, object? data = null)
         {
             message = String.IsNullOrEmpty(message) ? "Not found" : message;
@@ -52,7 +69,7 @@ namespace BasicDotnetTemplate.MainProject.Controllers
         protected IActionResult InternalServerError(string message)
         {
             message = String.IsNullOrEmpty(message) ? "Internal server error" : message;
-            return StatusCode((int)HttpStatusCode.InternalServerError, CreateResponse(HttpStatusCode.InternalServerError, message));
+            return StatusCode((int)HttpStatusCode.InternalServerError, CreateResponse(HttpStatusCode.InternalServerError, message, new object()));
         }
 
 #nullable disable

MainProject/Controllers/UserController.cs

@@ -0,0 +1,134 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using BasicDotnetTemplate.MainProject.Core.Attributes;
+using BasicDotnetTemplate.MainProject.Services;
+using BasicDotnetTemplate.MainProject.Models.Api.Request.User;
+using BasicDotnetTemplate.MainProject.Models.Api.Response;
+using BasicDotnetTemplate.MainProject.Models.Api.Response.User;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+
+namespace BasicDotnetTemplate.MainProject.Controllers
+{
+    [Route("[controller]")]
+    public class UserController : BaseController
+    {
+        private readonly IUserService _userService;
+        private readonly IRoleService _roleService;
+        public UserController(
+            IConfiguration configuration,
+            IUserService userService,
+            IRoleService roleService
+        ) : base(configuration)
+        {
+            this._userService = userService;
+            this._roleService = roleService;
+        }
+
+        [JwtAuthorization()]
+        [HttpGet("get/{guid}")]
+        [ProducesResponseType<GetUserResponse>(StatusCodes.Status200OK)]
+        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status404NotFound)]
+        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetUserByGuidAsync(string guid)
+        {
+            try
+            {
+                if (!ModelState.IsValid)
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+
+                if (String.IsNullOrEmpty(guid))
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+                var user = await this._userService.GetUserByGuidAsync(guid);
+
+                if (user == null || String.IsNullOrEmpty(user.Guid))
+                {
+                    return NotFound();
+                }
+
+                var userDto = _mapper?.Map<UserDto>(user);
+
+                return Success(String.Empty, userDto);
+            }
+            catch (Exception exception)
+            {
+                var message = "Something went wrong";
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
+            }
+
+        }
+
+        [JwtAuthorization()]
+        [HttpPost("create")]
+        [ProducesResponseType<GetUserResponse>(StatusCodes.Status201Created)]
+        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateUserAsync([FromBody] CreateUserRequest request)
+        {
+            try
+            {
+                if (!ModelState.IsValid)
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+
+                if (request == null || request.Data == null ||
+                    String.IsNullOrEmpty(request.Data.FirstName) ||
+                    String.IsNullOrEmpty(request.Data.LastName) ||
+                    String.IsNullOrEmpty(request.Data.Email) ||
+                    String.IsNullOrEmpty(request.Data.Password)
+                )
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+
+                if (await this._userService.CheckIfEmailIsValid(request.Data.Email))
+                {
+                    var role = await this._roleService.GetRoleForUser(request.Data.RoleGuid);
+                    if (role == null)
+                    {
+                        return BadRequest("Role not found");
+                    }
+
+                    var user = await this._userService.CreateUserAsync(request.Data, role);
+
+                    if (user == null || String.IsNullOrEmpty(user.Guid))
+                    {
+                        return BadRequest("Not created");
+                    }
+
+                    var userDto = _mapper?.Map<UserDto>(user);
+
+                    return Success(String.Empty, userDto);
+                }
+                else
+                {
+                    return BadRequest("Invalid email");
+                }
+
+            }
+            catch (Exception exception)
+            {
+                var message = "Something went wrong";
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
+            }
+
+        }
+
+
+
+    }
+}

MainProject/Core/Attributes/JwtAuthorizationAttribute .cs

@@ -0,0 +1,85 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.IdentityModel.Tokens;
+using System;
+using System.IdentityModel.Tokens.Jwt;
+using System.Linq;
+using System.Text;
+using Microsoft.AspNetCore.Authorization;
+using BasicDotnetTemplate.MainProject.Models.Settings;
+using BasicDotnetTemplate.MainProject.Services;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Utils;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+
+
+namespace BasicDotnetTemplate.MainProject.Core.Attributes
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
+    public class JwtAuthorizationAttribute : Attribute, IAuthorizationFilter
+    {
+        public JwtAuthorizationAttribute(
+        )
+        {
+        }
+
+        public static void Unauthorized(AuthorizationFilterContext context)
+        {
+            context.Result = new UnauthorizedResult();
+        }
+
+        public void OnAuthorization(AuthorizationFilterContext context)
+        {
+            // If [AllowAnonymous], skip
+            if (context.ActionDescriptor.EndpointMetadata.Any(em => em is AllowAnonymousAttribute))
+            {
+                return;
+            }
+
+            string? userGuidFromToken = null;
+
+            var configuration = context.HttpContext.RequestServices.GetRequiredService<IConfiguration>();
+            var appSettings = new AppSettings();
+            configuration.GetSection("AppSettings").Bind(appSettings);
+            string? headerAuthorization = context.HttpContext.Request.Headers.Authorization.FirstOrDefault();
+            AuthenticatedUser? userContext = context.HttpContext.Items["User"] != null ? (AuthenticatedUser?)context.HttpContext.Items["User"] : null;
+
+            if (userContext == null)
+            {
+                Unauthorized(context);
+            }
+            else
+            {
+                if (!String.IsNullOrEmpty(headerAuthorization))
+                {
+                    userGuidFromToken = JwtAuthorizationAttribute.ValidateToken(headerAuthorization!, appSettings);
+                    if (String.IsNullOrEmpty(userGuidFromToken))
+                    {
+                        Unauthorized(context);
+                    }
+                    else
+                    {
+                        if (userContext!.Guid != userGuidFromToken)
+                        {
+                            Unauthorized(context);
+                        }
+                    }
+                }
+                else
+                {
+                    Unauthorized(context);
+                }
+            }
+
+
+        }
+
+        private static string? ValidateToken(string headerAuthorization, AppSettings appSettings)
+        {
+            JwtTokenUtils _jwtTokenUtils = new(appSettings);
+            return _jwtTokenUtils.ValidateToken(headerAuthorization);
+        }
+    }
+}

MainProject/Core/Database/SqlServerContext.cs

@@ -13,6 +13,23 @@ namespace BasicDotnetTemplate.MainProject.Core.Database
         }
 
         public DbSet<User> Users { get; set; }
+        public DbSet<Role> Roles { get; set; }
+
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<User>()
+                .HasIndex(x => x.Email, "IX_Email");
+
+            modelBuilder.Entity<User>()
+                .HasIndex(x => new { x.IsDeleted, x.Guid }, "IX_IsDeleted_Guid")
+                .HasFilter("[IsDeleted] = 0");
+
+
+            modelBuilder.Entity<Role>()
+                .HasIndex(x => new { x.IsDeleted, x.Guid }, "IX_IsDeleted_Guid")
+                .HasFilter("[IsDeleted] = 0");
+        }
     }
 }
 

MainProject/Core/Middlewares/AutoMapperConfiguration.cs

@@ -0,0 +1,14 @@
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using SqlServerDatabase = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using AutoMapper;
+
+
+namespace BasicDotnetTemplate.MainProject.Core.Middlewares;
+public class AutoMapperConfiguration : Profile
+{
+    public AutoMapperConfiguration()
+    {
+        CreateMap<SqlServerDatabase.User, UserDto>();
+
+    }
+}

MainProject/MainProject.csproj

@@ -2,29 +2,35 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
+    <Configuration>Debug</Configuration>
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="AutoMapper" Version="14.0.0" />
     <PackageReference Include="coverlet.msbuild" Version="6.0.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.1" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="9.0.1" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.8">
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.13" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.13" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="9.0.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.8" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.8">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Identity.Web" Version="3.7.1" />
     <PackageReference Include="MongoDB.Driver" Version="2.28.0" />
     <PackageReference Include="MongoDB.EntityFrameworkCore" Version="8.1.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />

MainProject/Migrations/20250311195750_AlterTableUser.Designer.cs

@@ -0,0 +1,154 @@
+// <auto-generated />
+using System;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    [DbContext(typeof(SqlServerContext))]
+    [Migration("20250311195750_AlterTableUser")]
+    partial class AlterTableUser
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.2")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Role");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MainProject/Migrations/20250311195750_AlterTableUser.cs

@@ -0,0 +1,84 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    /// <inheritdoc />
+    public partial class AlterTableUser : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "Guid",
+                table: "Users",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Users",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Password",
+                table: "Users",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddColumn<string>(
+                name: "PasswordSalt",
+                table: "Users",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Guid",
+                table: "Role",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Role",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Guid",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "Password",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "PasswordSalt",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "Guid",
+                table: "Role");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Role");
+        }
+    }
+}

MainProject/Migrations/20250312234517_AlterTableUserMaxLengthIndexes.Designer.cs

@@ -0,0 +1,170 @@
+// <auto-generated />
+using System;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    [DbContext(typeof(SqlServerContext))]
+    [Migration("20250312234517_AlterTableUserMaxLengthIndexes")]
+    partial class AlterTableUserMaxLengthIndexes
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.2")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Role");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsTestUser")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex(new[] { "Email" }, "IX_Email");
+
+                    b.HasIndex(new[] { "IsDeleted", "Guid" }, "IX_IsDeleted_Guid")
+                        .HasFilter("[IsDeleted] = 0");
+
+                    b.HasIndex(new[] { "Username" }, "IX_Username");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MainProject/Migrations/20250312234517_AlterTableUserMaxLengthIndexes.cs

@@ -0,0 +1,165 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    /// <inheritdoc />
+    public partial class AlterTableUserMaxLengthIndexes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "Username",
+                table: "Users",
+                type: "nvarchar(200)",
+                maxLength: 200,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LastName",
+                table: "Users",
+                type: "nvarchar(200)",
+                maxLength: 200,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Guid",
+                table: "Users",
+                type: "nvarchar(45)",
+                maxLength: 45,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "FirstName",
+                table: "Users",
+                type: "nvarchar(200)",
+                maxLength: 200,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Email",
+                table: "Users",
+                type: "nvarchar(200)",
+                maxLength: 200,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsTestUser",
+                table: "Users",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Guid",
+                table: "Role",
+                type: "nvarchar(45)",
+                maxLength: 45,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Email",
+                table: "Users",
+                column: "Email");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_IsDeleted_Guid",
+                table: "Users",
+                columns: new[] { "IsDeleted", "Guid" },
+                filter: "[IsDeleted] = 0");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Username",
+                table: "Users",
+                column: "Username");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_Email",
+                table: "Users");
+
+            migrationBuilder.DropIndex(
+                name: "IX_IsDeleted_Guid",
+                table: "Users");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Username",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "IsTestUser",
+                table: "Users");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Username",
+                table: "Users",
+                type: "nvarchar(max)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(200)",
+                oldMaxLength: 200);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LastName",
+                table: "Users",
+                type: "nvarchar(max)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(200)",
+                oldMaxLength: 200);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Guid",
+                table: "Users",
+                type: "nvarchar(max)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(45)",
+                oldMaxLength: 45);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "FirstName",
+                table: "Users",
+                type: "nvarchar(max)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(200)",
+                oldMaxLength: 200);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Email",
+                table: "Users",
+                type: "nvarchar(max)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(200)",
+                oldMaxLength: 200);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Guid",
+                table: "Role",
+                type: "nvarchar(max)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(45)",
+                oldMaxLength: 45);
+        }
+    }
+}

MainProject/Migrations/20250316014620_AlterTablesUsersAndRoles.Designer.cs

@@ -0,0 +1,167 @@
+// <auto-generated />
+using System;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    [DbContext(typeof(SqlServerContext))]
+    [Migration("20250316014620_AlterTablesUsersAndRoles")]
+    partial class AlterTablesUsersAndRoles
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.2")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTime>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex(new[] { "IsDeleted", "Guid" }, "IX_IsDeleted_Guid")
+                        .HasFilter("[IsDeleted] = 0");
+
+                    b.ToTable("Roles");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsTestUser")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex(new[] { "Email" }, "IX_Email");
+
+                    b.HasIndex(new[] { "IsDeleted", "Guid" }, "IX_IsDeleted_Guid")
+                        .HasFilter("[IsDeleted] = 0");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MainProject/Migrations/20250316014620_AlterTablesUsersAndRoles.cs

@@ -0,0 +1,225 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    /// <inheritdoc />
+    public partial class AlterTablesUsersAndRoles : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Users_Role_RoleId",
+                table: "Users");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Username",
+                table: "Users");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Role",
+                table: "Role");
+
+            migrationBuilder.DropColumn(
+                name: "Username",
+                table: "Users");
+
+            migrationBuilder.RenameTable(
+                name: "Role",
+                newName: "Roles");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "UpdateUserId",
+                table: "Users",
+                type: "int",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "DeletionUserId",
+                table: "Users",
+                type: "int",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "CreationUserId",
+                table: "Users",
+                type: "int",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "UpdateUserId",
+                table: "Roles",
+                type: "int",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "Roles",
+                type: "nvarchar(100)",
+                maxLength: 100,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "DeletionUserId",
+                table: "Roles",
+                type: "int",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "CreationUserId",
+                table: "Roles",
+                type: "int",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Roles",
+                table: "Roles",
+                column: "Id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_IsDeleted_Guid",
+                table: "Roles",
+                columns: new[] { "IsDeleted", "Guid" },
+                filter: "[IsDeleted] = 0");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Users_Roles_RoleId",
+                table: "Users",
+                column: "RoleId",
+                principalTable: "Roles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Users_Roles_RoleId",
+                table: "Users");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Roles",
+                table: "Roles");
+
+            migrationBuilder.DropIndex(
+                name: "IX_IsDeleted_Guid",
+                table: "Roles");
+
+            migrationBuilder.RenameTable(
+                name: "Roles",
+                newName: "Role");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "UpdateUserId",
+                table: "Users",
+                type: "int",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "int",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "DeletionUserId",
+                table: "Users",
+                type: "int",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "int",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "CreationUserId",
+                table: "Users",
+                type: "int",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "int",
+                oldNullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Username",
+                table: "Users",
+                type: "nvarchar(200)",
+                maxLength: 200,
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "UpdateUserId",
+                table: "Role",
+                type: "int",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "int",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "Role",
+                type: "nvarchar(max)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(100)",
+                oldMaxLength: 100);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "DeletionUserId",
+                table: "Role",
+                type: "int",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "int",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "CreationUserId",
+                table: "Role",
+                type: "int",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "int",
+                oldNullable: true);
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Role",
+                table: "Role",
+                column: "Id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Username",
+                table: "Users",
+                column: "Username");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Users_Role_RoleId",
+                table: "Users",
+                column: "RoleId",
+                principalTable: "Role",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

MainProject/Migrations/20250316212343_AlterBaseUpdateTimeDeletionTimeNullable.Designer.cs

@@ -0,0 +1,167 @@
+// <auto-generated />
+using System;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    [DbContext(typeof(SqlServerContext))]
+    [Migration("20250316212343_AlterBaseUpdateTimeDeletionTimeNullable")]
+    partial class AlterBaseUpdateTimeDeletionTimeNullable
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.2")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTime?>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex(new[] { "IsDeleted", "Guid" }, "IX_IsDeleted_Guid")
+                        .HasFilter("[IsDeleted] = 0");
+
+                    b.ToTable("Roles");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsTestUser")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex(new[] { "Email" }, "IX_Email");
+
+                    b.HasIndex(new[] { "IsDeleted", "Guid" }, "IX_IsDeleted_Guid")
+                        .HasFilter("[IsDeleted] = 0");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MainProject/Migrations/20250316212343_AlterBaseUpdateTimeDeletionTimeNullable.cs

@@ -0,0 +1,91 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    /// <inheritdoc />
+    public partial class AlterBaseUpdateTimeDeletionTimeNullable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "UpdateTime",
+                table: "Users",
+                type: "datetime2",
+                nullable: true,
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2");
+
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "DeletionTime",
+                table: "Users",
+                type: "datetime2",
+                nullable: true,
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2");
+
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "UpdateTime",
+                table: "Roles",
+                type: "datetime2",
+                nullable: true,
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2");
+
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "DeletionTime",
+                table: "Roles",
+                type: "datetime2",
+                nullable: true,
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "UpdateTime",
+                table: "Users",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified),
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "DeletionTime",
+                table: "Users",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified),
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "UpdateTime",
+                table: "Roles",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified),
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "DeletionTime",
+                table: "Roles",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified),
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2",
+                oldNullable: true);
+        }
+    }
+}

MainProject/Migrations/20250316212722_AlterTableRoleAddedIsNotEditable.Designer.cs

@@ -0,0 +1,170 @@
+// <auto-generated />
+using System;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    [DbContext(typeof(SqlServerContext))]
+    [Migration("20250316212722_AlterTableRoleAddedIsNotEditable")]
+    partial class AlterTableRoleAddedIsNotEditable
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.2")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsNotEditable")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTime?>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex(new[] { "IsDeleted", "Guid" }, "IX_IsDeleted_Guid")
+                        .HasFilter("[IsDeleted] = 0");
+
+                    b.ToTable("Roles");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("CreationUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DeletionUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsTestUser")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("UpdateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("UpdateUserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex(new[] { "Email" }, "IX_Email");
+
+                    b.HasIndex(new[] { "IsDeleted", "Guid" }, "IX_IsDeleted_Guid")
+                        .HasFilter("[IsDeleted] = 0");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
+                {
+                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MainProject/Migrations/20250316212722_AlterTableRoleAddedIsNotEditable.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MainProject.Migrations
+{
+    /// <inheritdoc />
+    public partial class AlterTableRoleAddedIsNotEditable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsNotEditable",
+                table: "Roles",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsNotEditable",
+                table: "Roles");
+        }
+    }
+}

MainProject/Migrations/SqlServerContextModelSnapshot.cs

@@ -17,7 +17,7 @@ namespace MainProject.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "8.0.8")
+                .HasAnnotation("ProductVersion", "9.0.2")
                 .HasAnnotation("Relational:MaxIdentifierLength", 128);
 
             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
@@ -33,28 +33,43 @@ namespace MainProject.Migrations
                     b.Property<DateTime>("CreationTime")
                         .HasColumnType("datetime2");
 
-                    b.Property<int>("CreationUserId")
+                    b.Property<int?>("CreationUserId")
                         .HasColumnType("int");
 
-                    b.Property<DateTime>("DeletionTime")
+                    b.Property<DateTime?>("DeletionTime")
                         .HasColumnType("datetime2");
 
-                    b.Property<int>("DeletionUserId")
+                    b.Property<int?>("DeletionUserId")
                         .HasColumnType("int");
 
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsNotEditable")
+                        .HasColumnType("bit");
+
                     b.Property<string>("Name")
                         .IsRequired()
-                        .HasColumnType("nvarchar(max)");
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
 
-                    b.Property<DateTime>("UpdateTime")
+                    b.Property<DateTime?>("UpdateTime")
                         .HasColumnType("datetime2");
 
-                    b.Property<int>("UpdateUserId")
+                    b.Property<int?>("UpdateUserId")
                         .HasColumnType("int");
 
                     b.HasKey("Id");
 
-                    b.ToTable("Role");
+                    b.HasIndex(new[] { "IsDeleted", "Guid" }, "IX_IsDeleted_Guid")
+                        .HasFilter("[IsDeleted] = 0");
+
+                    b.ToTable("Roles");
                 });
 
             modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
@@ -68,24 +83,42 @@ namespace MainProject.Migrations
                     b.Property<DateTime>("CreationTime")
                         .HasColumnType("datetime2");
 
-                    b.Property<int>("CreationUserId")
+                    b.Property<int?>("CreationUserId")
                         .HasColumnType("int");
 
-                    b.Property<DateTime>("DeletionTime")
+                    b.Property<DateTime?>("DeletionTime")
                         .HasColumnType("datetime2");
 
-                    b.Property<int>("DeletionUserId")
+                    b.Property<int?>("DeletionUserId")
                         .HasColumnType("int");
 
                     b.Property<string>("Email")
                         .IsRequired()
-                        .HasColumnType("nvarchar(max)");
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
 
                     b.Property<string>("FirstName")
                         .IsRequired()
-                        .HasColumnType("nvarchar(max)");
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Guid")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("nvarchar(45)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsTestUser")
+                        .HasColumnType("bit");
 
                     b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Password")
                         .IsRequired()
                         .HasColumnType("nvarchar(max)");
 
@@ -93,23 +126,28 @@ namespace MainProject.Migrations
                         .IsRequired()
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<string>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<int>("RoleId")
                         .HasColumnType("int");
 
-                    b.Property<DateTime>("UpdateTime")
+                    b.Property<DateTime?>("UpdateTime")
                         .HasColumnType("datetime2");
 
-                    b.Property<int>("UpdateUserId")
+                    b.Property<int?>("UpdateUserId")
                         .HasColumnType("int");
 
-                    b.Property<string>("Username")
-                        .IsRequired()
-                        .HasColumnType("nvarchar(max)");
-
                     b.HasKey("Id");
 
                     b.HasIndex("RoleId");
 
+                    b.HasIndex(new[] { "Email" }, "IX_Email");
+
+                    b.HasIndex(new[] { "IsDeleted", "Guid" }, "IX_IsDeleted_Guid")
+                        .HasFilter("[IsDeleted] = 0");
+
                     b.ToTable("Users");
                 });
 

MainProject/Models/Api/Common/Role/UserRole.cs

@@ -0,0 +1,19 @@
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+namespace BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
+
+public class UserRole
+{
+#nullable enable
+    public string? Guid { get; set; }
+    public string? Name { get; set; }
+#nullable disable
+
+    public UserRole() {}
+
+    public UserRole(DatabaseSqlServer.Role role)
+    {
+        Guid = role.Guid;
+        Name = role.Name;
+    }
+}

MainProject/Models/Api/Common/User/AuthenticatedUser.cs

@@ -0,0 +1,28 @@
+using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+namespace BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+
+public class AuthenticatedUser
+{
+#nullable enable
+    public string? Guid { get; set; }
+    public string? FirstName { get; set; }
+    public string? LastName { get; set; }
+    public string? Email { get; set; }
+    public UserRole? Role { get; set; }
+#nullable disable
+
+    public AuthenticatedUser(DatabaseSqlServer.User user)
+    {
+        Guid = user.Guid;
+        FirstName = user.FirstName;
+        LastName = user.LastName;
+        Email = user.Email;
+        Role = new UserRole();
+    }
+}
+
+
+
+

MainProject/Models/Api/Common/User/UserDto.cs

@@ -0,0 +1,18 @@
+using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+namespace BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+
+public class UserDto
+{
+#nullable enable
+    public string? Guid { get; set; }
+    public string? FirstName { get; set; }
+    public string? LastName { get; set; }
+    public string? Email { get; set; }
+#nullable disable
+}
+
+
+
+

MainProject/Models/Api/Data/Auth/AuthenticateRequestData.cs

@@ -0,0 +1,13 @@
+namespace BasicDotnetTemplate.MainProject.Models.Api.Data.Auth;
+
+public class AuthenticateRequestData
+{
+#nullable enable
+    public string? Email { get; set; }
+    public string? Password { get; set; }
+#nullable disable
+}
+
+
+
+

MainProject/Models/Api/Data/Role/CreateRoleRequestData.cs

@@ -0,0 +1,8 @@
+namespace BasicDotnetTemplate.MainProject.Models.Api.Data.Role;
+
+public class CreateRoleRequestData
+{
+    public string Name { get; set; } = String.Empty;
+    public required bool IsNotEditable { get; set; }
+
+}

MainProject/Models/Api/Data/User/CreateUserRequestData.cs

@@ -0,0 +1,15 @@
+namespace BasicDotnetTemplate.MainProject.Models.Api.Data.User;
+
+public class CreateUserRequestData
+{
+    public string FirstName { get; set; } = String.Empty;
+    public string LastName { get; set; } = String.Empty;
+    public string Email { get; set; } = String.Empty;
+    public string Password { get; set; } = String.Empty;
+    public string? RoleGuid { get; set; }
+
+}
+
+
+
+

MainProject/Models/Api/Request/Auth/AuthenticateRequest.cs

@@ -0,0 +1,14 @@
+using BasicDotnetTemplate.MainProject.Models.Api.Data.Auth;
+
+namespace BasicDotnetTemplate.MainProject.Models.Api.Request.Auth;
+
+public class AuthenticateRequest
+{
+#nullable enable
+    public AuthenticateRequestData? Data { get; set; }
+#nullable disable
+}
+
+
+
+

MainProject/Models/Api/Request/User/CreateUserRequest.cs

@@ -0,0 +1,14 @@
+using BasicDotnetTemplate.MainProject.Models.Api.Data.User;
+
+namespace BasicDotnetTemplate.MainProject.Models.Api.Request.User;
+
+public class CreateUserRequest
+{
+#nullable enable
+    public CreateUserRequestData? Data { get; set; }
+#nullable disable
+}
+
+
+
+

MainProject/Models/Api/Response/Auth/AuthenticateResponse.cs

@@ -0,0 +1,8 @@
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+
+namespace BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
+
+public class AuthenticateResponse : BaseResponse<AuthenticatedUser>
+{
+    public AuthenticateResponse(int status, string? message, AuthenticatedUser? data) : base(status, message, data) { }
+}

MainProject/Models/Api/Response/BaseResponse.cs

@@ -1,9 +1,9 @@
 namespace BasicDotnetTemplate.MainProject.Models.Api.Response;
 
-public class BaseResponse
+public class BaseResponse<T>
 {
 #nullable enable
-    public BaseResponse(int status, string? message, dynamic? data)
+    public BaseResponse(int status, string? message, T? data)
     {
         this.Status = status;
         this.Message = message;

MainProject/Models/Api/Response/User/GetUserResponse.cs

@@ -0,0 +1,8 @@
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+
+namespace BasicDotnetTemplate.MainProject.Models.Api.Response.User;
+
+public class GetUserResponse : BaseResponse<UserDto>
+{
+    public GetUserResponse(int status, string? message, UserDto? data) : base(status, message, data) { }
+}

MainProject/Models/Database/SqlServer/Base.cs

@@ -1,16 +1,24 @@
-namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+public class Base
 {
-    public class Base
-    {
-        public int Id { get; set; }
-        public DateTime CreationTime { get; set; }
-        public int CreationUserId { get; set; }
-        public DateTime UpdateTime { get; set; }
-        public int UpdateUserId { get; set; }
-        public DateTime DeletionTime { get; set; }
-        public int DeletionUserId { get; set; }
-    }
+    public int Id { get; set; }
+    [MaxLength(45)]
+    public string Guid { get; set; }
+    public bool IsDeleted { get; set; }
+    public DateTime CreationTime { get; set; }
+#nullable enable
+    public int? CreationUserId { get; set; }
+    public DateTime? UpdateTime { get; set; }
+    public int? UpdateUserId { get; set; }
+    public DateTime? DeletionTime { get; set; }
+    public int? DeletionUserId { get; set; }
+#nullable disable
 }
 
 
 
+

MainProject/Models/Database/SqlServer/Role.cs

@@ -1,10 +1,12 @@
-using System.Text.Json.Serialization;
+using System.ComponentModel.DataAnnotations;
 
 namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer
 {
     public class Role : Base
     {
+        [MaxLength(100)]
         public required string Name { get; set; }
+        public required bool IsNotEditable { get; set; }
     }
 }
 

MainProject/Models/Database/SqlServer/User.cs

@@ -1,19 +1,26 @@
+using System.ComponentModel.DataAnnotations;
 using System.Text.Json.Serialization;
+using Microsoft.EntityFrameworkCore;
 
-namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer
+namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+public class User : Base
 {
-    public class User : Base
-    {
-        public required string Username { get; set; }
-        public required string FirstName { get; set; }
-        public required string LastName { get; set; }
-        public required string Email { get; set; }
-        public required Role Role { get; set; }
+    [MaxLength(200)]
+    public required string FirstName { get; set; }
+    [MaxLength(200)]
+    public required string LastName { get; set; }
+    [MaxLength(200)]
+    public required string Email { get; set; }
+    public required string PasswordSalt { get; set; }
+    public required string PasswordHash { get; set; }
+    public required Role Role { get; set; }
+    public required bool IsTestUser { get; set; }
 
-        [JsonIgnore]
-        public required string PasswordHash { get; set; }
-    }
+    [JsonIgnore]
+    public required string Password { get; set; }
 }
 
 
 
+

MainProject/Models/Settings/AppSettings.cs

@@ -7,6 +7,8 @@ public class AppSettings
     public PrivateSettings? PrivateSettings { get; set; }
     public OpenApiSettings? OpenApiSettings { get; set; }
     public DatabaseSettings? DatabaseSettings { get; set; }
+    public JwtSettings? JwtSettings { get; set; }
+    public EncryptionSettings? EncryptionSettings { get; set; }
 
 #nullable disable
 }

MainProject/Models/Settings/EncryptionSettings.cs

@@ -0,0 +1,9 @@
+namespace BasicDotnetTemplate.MainProject.Models.Settings;
+
+public class EncryptionSettings
+{
+#nullable enable
+    public string? Salt { get; set; }
+    public string? Pepper { get; set; }
+#nullable disable
+}

MainProject/Models/Settings/JwtSettings.cs

@@ -0,0 +1,12 @@
+namespace BasicDotnetTemplate.MainProject.Models.Settings;
+
+public class JwtSettings
+{
+#nullable enable
+    public string? ValidAudience { get; set; }
+    public string? ValidIssuer { get; set; }
+    public string? Secret { get; set; }
+    public int? ExpiredAfterMinsOfInactivity { get; set; }
+
+#nullable disable
+}

MainProject/Program.cs

@@ -44,6 +44,7 @@ internal static class Program
         ProgramUtils.AddDbContext(ref builder, appSettings);
         WebApplication app = builder.Build();
         ProgramUtils.AddMiddlewares(ref app);
+        ProgramUtils.CreateRoles(ref app);
 
         Logger.Info("[Program][Initialize] End building");
         return app;

MainProject/Services/AuthService.cs

@@ -0,0 +1,49 @@
+
+using BasicDotnetTemplate.MainProject.Models.Api.Data.Auth;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Utils;
+
+namespace BasicDotnetTemplate.MainProject.Services;
+
+public interface IAuthService
+{
+    Task<AuthenticatedUser?> AuthenticateAsync(AuthenticateRequestData data);
+}
+
+public class AuthService : BaseService, IAuthService
+{
+    protected CryptUtils _cryptUtils;
+    protected readonly IUserService _userService;
+
+    public AuthService(
+        IHttpContextAccessor httpContextAccessor,
+        IConfiguration configuration,
+        SqlServerContext sqlServerContext,
+        IUserService userService
+    ) : base(httpContextAccessor, configuration, sqlServerContext)
+    {
+        _cryptUtils = new CryptUtils(_appSettings);
+        _userService = userService;
+    }
+
+    public async Task<AuthenticatedUser?> AuthenticateAsync(AuthenticateRequestData data)
+    {
+        AuthenticatedUser? authenticatedUser = null;
+
+        var decryptedUsername = _cryptUtils.Decrypt(data.Email ?? String.Empty);
+        var decryptedPassword = _cryptUtils.Decrypt(data.Password ?? String.Empty);
+
+        if (!String.IsNullOrEmpty(decryptedUsername) && !String.IsNullOrEmpty(decryptedPassword))
+        {
+            var user = await this._userService.GetUserByUsernameAndPassword(decryptedUsername, decryptedPassword);
+            if (user != null)
+            {
+                authenticatedUser = new AuthenticatedUser(user);
+            }
+        }
+
+        return authenticatedUser;
+    }
+}
+

MainProject/Services/BaseService.cs

@@ -0,0 +1,43 @@
+using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
+using BasicDotnetTemplate.MainProject.Models.Settings;
+
+namespace BasicDotnetTemplate.MainProject.Services;
+
+public class BaseService
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    protected readonly IConfiguration _configuration;
+    protected readonly AppSettings _appSettings;
+    protected readonly SqlServerContext _sqlServerContext;
+
+    public BaseService(
+        IHttpContextAccessor httpContextAccessor,
+        IConfiguration configuration,
+        SqlServerContext sqlServerContext
+    )
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _configuration = configuration;
+        _appSettings = new AppSettings();
+        _configuration.GetSection("AppSettings").Bind(_appSettings);
+        _sqlServerContext = sqlServerContext;
+    }
+
+    protected int? GetCurrentUserId()
+    {
+        int? userId = null;
+        var user = this.GetCurrentUser();
+        if (user != null)
+        {
+            userId = this._sqlServerContext.Users.Where(x => !x.IsDeleted && x.Guid == user.Guid).FirstOrDefault()?.Id;
+        }
+        return userId;
+    }
+
+    protected AuthenticatedUser? GetCurrentUser()
+    {
+        return _httpContextAccessor.HttpContext?.Items["User"] as AuthenticatedUser;
+    }
+}
+

MainProject/Services/JwtService.cs

@@ -0,0 +1,41 @@
+using Microsoft.IdentityModel.Tokens;
+using System;
+using System.Collections.Generic;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Utils;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+
+namespace BasicDotnetTemplate.MainProject.Services;
+
+public interface IJwtService
+{
+    string GenerateToken(string guid);
+}
+
+public class JwtService : BaseService, IJwtService
+{
+    private readonly JwtTokenUtils _jwtTokenUtils;
+
+    public JwtService(
+        IHttpContextAccessor httpContextAccessor,
+        IConfiguration configuration,
+        SqlServerContext sqlServerContext
+    ) : base(httpContextAccessor, configuration, sqlServerContext)
+    {
+        _jwtTokenUtils = new JwtTokenUtils(_appSettings);
+    }
+
+
+    public string GenerateToken(string guid)
+    {
+        return _jwtTokenUtils.GenerateToken(guid);
+    }
+
+
+
+}
+

MainProject/Services/RoleService.cs

@@ -0,0 +1,151 @@
+
+using System.Collections;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.Role;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using Microsoft.EntityFrameworkCore;
+
+namespace BasicDotnetTemplate.MainProject.Services;
+
+public interface IRoleService
+{
+    Task<Role?> GetRoleByIdAsync(int id);
+    Task<Role?> GetRoleByGuidAsync(string guid);
+    Task<bool> CheckIfNameIsValid(string name, string? guid = "");
+    Task<Role?> CreateRoleAsync(CreateRoleRequestData data);
+    Task<Role?> GetRoleForUser(string? guid);
+    Task<bool?> DeleteRoleAsync(Role role);
+}
+
+public class RoleService : BaseService, IRoleService
+{
+    private readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();
+    public RoleService(
+        IHttpContextAccessor httpContextAccessor,
+        IConfiguration configuration,
+        SqlServerContext sqlServerContext
+    ) : base(httpContextAccessor, configuration, sqlServerContext)
+    { }
+
+    private IQueryable<Role> GetRolesQueryable()
+    {
+        return this._sqlServerContext.Roles.Where(x => !x.IsDeleted);
+    }
+    private IQueryable<Role> GetRoleByNameQueryable(string name)
+    {
+        return this.GetRolesQueryable().Where(x =>
+            x.Name.ToString() == name.ToString()
+        );
+    }
+
+
+
+    private Role CreateRoleData(CreateRoleRequestData data)
+    {
+        Role role = new()
+        {
+            CreationTime = DateTime.UtcNow,
+            CreationUserId = this.GetCurrentUserId(),
+            IsDeleted = false,
+            Guid = Guid.NewGuid().ToString(),
+            Name = data.Name,
+            IsNotEditable = data.IsNotEditable
+        };
+
+        return role;
+    }
+
+
+
+
+
+    public async Task<Role?> GetRoleByIdAsync(int id)
+    {
+        return await this.GetRolesQueryable().Where(x => x.Id == id).FirstOrDefaultAsync();
+    }
+
+    public async Task<Role?> GetRoleByGuidAsync(string guid)
+    {
+        return await this.GetRolesQueryable().Where(x => x.Guid == guid).FirstOrDefaultAsync();
+    }
+
+    public async Task<bool> CheckIfNameIsValid(string name, string? guid = "")
+    {
+        var valid = false;
+
+        Role? role = await this.GetRoleByNameQueryable(name).FirstOrDefaultAsync();
+        if (role != null)
+        {
+            if (!String.IsNullOrEmpty(guid))
+            {
+                valid = role.Guid == guid && role.Name == name;
+            }
+        }
+        else
+        {
+            valid = true;
+        }
+
+        return valid;
+    }
+
+    public async Task<Role?> CreateRoleAsync(CreateRoleRequestData data)
+    {
+        Role? role = null;
+
+        using var transaction = await _sqlServerContext.Database.BeginTransactionAsync();
+
+        try
+        {
+            var tempRole = this.CreateRoleData(data);
+            await _sqlServerContext.Roles.AddAsync(tempRole);
+            await _sqlServerContext.SaveChangesAsync();
+            await transaction.CommitAsync();
+            role = tempRole;
+        }
+        catch (Exception exception)
+        {
+            await transaction.RollbackAsync();
+            Logger.Error(exception, $"[RoleService][CreateRoleAsync]");
+            throw;
+        }
+
+        return role;
+    }
+
+    public async Task<Role?> GetRoleForUser(string? guid)
+    {
+        Role? role = null;
+
+        if (String.IsNullOrEmpty(guid))
+        {
+            role = await this.GetRoleByNameQueryable("Default").FirstOrDefaultAsync();
+        }
+        else
+        {
+            role = await this.GetRoleByGuidAsync(guid);
+        }
+
+        return role;
+    }
+
+    public async Task<bool?> DeleteRoleAsync(Role role)
+    {
+        bool? deleted = false;
+
+        using (var transaction = _sqlServerContext.Database.BeginTransactionAsync())
+        {
+            role.IsDeleted = true;
+            role.DeletionTime = DateTime.UtcNow;
+            _sqlServerContext.Update(role);
+            await _sqlServerContext.SaveChangesAsync();
+            await (await transaction).CommitAsync();
+            deleted = true;
+        }
+
+        return deleted;
+    }
+
+
+}
+

MainProject/Services/UserService.cs

@@ -0,0 +1,148 @@
+
+using System.Collections;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.User;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using Microsoft.EntityFrameworkCore;
+
+namespace BasicDotnetTemplate.MainProject.Services;
+
+public interface IUserService
+{
+    Task<User?> GetUserByIdAsync(int id);
+    Task<User?> GetUserByGuidAsync(string guid);
+    Task<User?> GetUserByUsernameAndPassword(string email, string password);
+    Task<bool> CheckIfEmailIsValid(string email, string? guid = "");
+    Task<User?> CreateUserAsync(CreateUserRequestData data, Role role);
+    Task<bool?> DeleteUserAsync(User user);
+}
+
+public class UserService : BaseService, IUserService
+{
+    private readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();
+    public UserService(
+        IHttpContextAccessor httpContextAccessor,
+        IConfiguration configuration,
+        SqlServerContext sqlServerContext
+    ) : base(httpContextAccessor, configuration, sqlServerContext)
+    { }
+
+    private IQueryable<User> GetUsersQueryable()
+    {
+        return this._sqlServerContext.Users.Where(x => !x.IsDeleted);
+    }
+
+    private IQueryable<User> GetUserByEmailQueryable(string email)
+    {
+        return this.GetUsersQueryable().Where(x =>
+            x.Email.ToString() == email.ToString()
+        );
+    }
+
+    private User CreateUserData(CreateUserRequestData data, Role role)
+    {
+        User user = new()
+        {
+            CreationTime = DateTime.UtcNow,
+            CreationUserId = this.GetCurrentUserId(),
+            IsDeleted = false,
+            Guid = Guid.NewGuid().ToString(),
+            FirstName = data.FirstName,
+            LastName = data.LastName,
+            Email = data.Email,
+            PasswordSalt = "",
+            PasswordHash = "",
+            Password = "",
+            Role = role,
+            IsTestUser = false
+        };
+
+        return user;
+    }
+
+
+    public async Task<User?> GetUserByIdAsync(int id)
+    {
+        return await this.GetUsersQueryable().Where(x => x.Id == id).FirstOrDefaultAsync();
+    }
+
+    public async Task<User?> GetUserByGuidAsync(string guid)
+    {
+        return await this.GetUsersQueryable().Where(x => x.Guid == guid).FirstOrDefaultAsync();
+    }
+
+    public async Task<User?> GetUserByUsernameAndPassword(string email, string password)
+    {
+        User? user = await this.GetUserByEmailQueryable(email).FirstOrDefaultAsync();
+        if (user != null)
+        {
+            var encryptedPassword = user.PasswordHash;
+            Console.WriteLine(encryptedPassword);
+        }
+
+        return user;
+    }
+
+    public async Task<bool> CheckIfEmailIsValid(string email, string? guid = "")
+    {
+        var valid = false;
+
+        User? user = await this.GetUserByEmailQueryable(email).FirstOrDefaultAsync();
+        if (user != null)
+        {
+            if (!String.IsNullOrEmpty(guid))
+            {
+                valid = user.Guid == guid && user.Email == email;
+            }
+        }
+        else
+        {
+            valid = true;
+        }
+        return valid;
+    }
+
+    public async Task<User?> CreateUserAsync(CreateUserRequestData data, Role role)
+    {
+        using var transaction = await _sqlServerContext.Database.BeginTransactionAsync();
+
+        User? user;
+        var tempUser = CreateUserData(data, role);
+        try
+        {
+            await _sqlServerContext.Users.AddAsync(tempUser);
+            await _sqlServerContext.SaveChangesAsync();
+            await transaction.CommitAsync();
+            user = tempUser;
+        }
+        catch (Exception exception)
+        {
+            await transaction.RollbackAsync();
+            Logger.Error(exception, $"[UserService][CreateUserAsync]");
+            throw;
+        }
+
+
+        return user;
+    }
+
+    public async Task<bool?> DeleteUserAsync(User user)
+    {
+        bool? deleted = false;
+
+        using (var transaction = _sqlServerContext.Database.BeginTransactionAsync())
+        {
+            user.IsDeleted = true;
+            user.DeletionTime = DateTime.UtcNow;
+            _sqlServerContext.Update(user);
+            await _sqlServerContext.SaveChangesAsync();
+            await (await transaction).CommitAsync();
+            deleted = true;
+        }
+
+        return deleted;
+    }
+
+
+}
+

MainProject/Utils/CryptoUtils.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+using BasicDotnetTemplate.MainProject.Models.Settings;
+
+namespace BasicDotnetTemplate.MainProject.Utils;
+public class CryptUtils
+{
+    private readonly string _secretKey;
+    private readonly string _pepper;
+    private const int _M = 16;
+    private const int _N = 32;
+
+    public CryptUtils(AppSettings appSettings)
+    {
+        _secretKey = appSettings.EncryptionSettings?.Salt ?? String.Empty;
+        _pepper = appSettings.EncryptionSettings?.Pepper ?? String.Empty;
+    }
+
+    public string Decrypt(string encryptedData)
+    {
+        var decrypted = String.Empty;
+
+        if (String.IsNullOrEmpty(this._secretKey) || this._secretKey.Length < _M)
+        {
+            throw new ArgumentException("Unable to proceed with decryption due to invalid settings");
+        }
+
+        if (!String.IsNullOrEmpty(encryptedData) && encryptedData.Length > _N)
+        {
+            var iv = encryptedData.Substring(0, _M);
+
+            var cipherText = encryptedData.Substring(_N);
+            var fullCipher = Convert.FromBase64String(cipherText);
+
+            using (var aes = Aes.Create())
+            {
+                aes.Key = Encoding.UTF8.GetBytes(this._secretKey);
+                aes.IV = Encoding.UTF8.GetBytes(iv);
+
+                using (var decryptor = aes.CreateDecryptor(aes.Key, aes.IV))
+                {
+                    using (var msDecrypt = new MemoryStream(fullCipher))
+                    {
+                        using (var cryptoStream = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
+                        {
+                            using (var srDecrypt = new StreamReader(cryptoStream))
+                            {
+                                decrypted = srDecrypt.ReadToEnd();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return decrypted;
+    }
+
+    public static string GenerateSalt()
+    {
+        using var rng = RandomNumberGenerator.Create();
+        var byteSalt = new byte[16];
+        rng.GetBytes(byteSalt);
+        var salt = Convert.ToBase64String(byteSalt);
+        return salt;
+    }
+
+    public string GeneratePassword(string password, string salt, int iteration)
+    {
+        string hashedPassword = password;
+        for(var i = 0; i <= iteration; i++)
+        {
+            var passwordSaltPepper = $"{hashedPassword}{salt}{this._pepper}";
+            var byteValue = Encoding.UTF8.GetBytes(passwordSaltPepper);
+            var byteHash = SHA256.HashData(byteValue);
+            hashedPassword = Convert.ToBase64String(byteHash);
+        }
+
+        return hashedPassword;
+    }
+
+    public bool VerifyPassword(string password, string salt, int iteration, string userPassword)
+    {
+        string hashedPassword = this.GeneratePassword(password, salt, iteration);
+        return hashedPassword.Equals(userPassword, StringComparison.OrdinalIgnoreCase);
+    }
+
+
+
+}
+

MainProject/Utils/JwtTokenUtils.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Cryptography;
+using System.Security.Claims;
+using System.Text;
+using Microsoft.IdentityModel.Tokens;
+using BasicDotnetTemplate.MainProject.Models.Settings;
+using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+namespace BasicDotnetTemplate.MainProject.Utils;
+
+public class JwtTokenUtils
+{
+    private readonly string _jwtKey;
+    private readonly string _jwtIssuer;
+    private readonly string _jwtAudience;
+    private readonly int _expiration;
+    private readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();
+
+    public JwtTokenUtils(AppSettings appSettings)
+    {
+        _jwtKey = appSettings?.JwtSettings?.Secret ?? String.Empty;
+        _jwtIssuer = appSettings?.JwtSettings?.ValidIssuer ?? String.Empty;
+        _jwtAudience = appSettings?.JwtSettings?.ValidAudience ?? String.Empty;
+        _expiration = appSettings?.JwtSettings?.ExpiredAfterMinsOfInactivity ?? 15;
+    }
+
+    public string GenerateToken(string guid)
+    {
+        var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtKey));
+        var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
+
+        var claims = new List<Claim>
+        {
+            new Claim(JwtRegisteredClaimNames.Sub, guid),
+            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
+            new Claim("guid", guid)
+        };
+
+        var token = new JwtSecurityToken(
+            _jwtIssuer,
+            _jwtAudience,
+            claims,
+            expires: DateTime.Now.AddMinutes(_expiration),
+            signingCredentials: credentials);
+
+        return new JwtSecurityTokenHandler().WriteToken(token);
+    }
+
+    public string? ValidateToken(string headerAuthorization)
+    {
+        string? token = null;
+        string? guid = null;
+
+        if (
+            String.IsNullOrEmpty(_jwtKey) ||
+            String.IsNullOrEmpty(_jwtIssuer) ||
+            String.IsNullOrEmpty(_jwtAudience)
+        )
+        {
+            return guid;
+        }
+
+        string[] authorizations = headerAuthorization.Split(" ");
+        if (authorizations.Length == 2)
+        {
+            token = authorizations[1];
+        }
+
+        if (!String.IsNullOrEmpty(token))
+        {
+            try
+            {
+                var tokenHandler = new JwtSecurityTokenHandler();
+                var key = Encoding.ASCII.GetBytes(_jwtKey);
+                tokenHandler.ValidateToken(token, new TokenValidationParameters
+                {
+                    ValidateIssuerSigningKey = true,
+                    IssuerSigningKey = new SymmetricSecurityKey(key),
+                    ValidateIssuer = true,
+                    ValidIssuer = _jwtIssuer,
+                    ValidateAudience = true,
+                    ValidAudience = _jwtAudience,
+                    ValidateLifetime = true,
+                    ClockSkew = TimeSpan.Zero
+                }, out SecurityToken validatedToken);
+
+                var jwtToken = (JwtSecurityToken)validatedToken;
+
+                if (jwtToken != null)
+                {
+                    var claimedUserId = jwtToken.Claims.FirstOrDefault(c => c.Type == "guid");
+                    if (claimedUserId != null && !String.IsNullOrEmpty(claimedUserId.Value))
+                    {
+                        guid = claimedUserId.Value;
+                    }
+                }
+            }
+            catch (Exception exception)
+            {
+                Logger.Error(exception, $"[JwtTokenUtils][ValidateToken]");
+                return guid;
+            }
+        }
+        return guid;
+    }
+
+}
+

MainProject/Utils/ProgramUtils.cs

@@ -3,7 +3,11 @@ using Microsoft.OpenApi.Models;
 using MongoDB.Driver;
 using NLog;
 using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Core.Middlewares;
 using BasicDotnetTemplate.MainProject.Models.Settings;
+using BasicDotnetTemplate.MainProject.Services;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.Role;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
 
 
 
@@ -11,6 +15,7 @@ namespace BasicDotnetTemplate.MainProject.Utils;
 
 public static class ProgramUtils
 {
+    private static readonly string[] _newStringArray = Array.Empty<string>();
     private static readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();
 
     public static AppSettings AddConfiguration(ref WebApplicationBuilder builder, string? path = "", string? filename = "")
@@ -41,7 +46,6 @@ public static class ProgramUtils
 
         return appSettings;
     }
-
     public static OpenApiInfo CreateOpenApiInfo(AppSettings appSettings)
     {
         OpenApiInfo openApiInfo = new OpenApiInfo
@@ -83,11 +87,53 @@ public static class ProgramUtils
         builder.Services.AddSwaggerGen(options =>
         {
             options.SwaggerDoc("v1", CreateOpenApiInfo(appSettings));
+
+            options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+            {
+                Description = "Inserisci il Bearer Token nel formato **'Bearer {token}'**",
+                Name = "Authorization",
+                In = ParameterLocation.Header,
+                Type = SecuritySchemeType.Http,
+                Scheme = "Bearer"
+            });
+
+            options.AddSecurityDefinition("ApiKey", new OpenApiSecurityScheme
+            {
+                Description = "Inserisci la tua API Key nel campo appropriato.",
+                Name = "ApiKey",
+                In = ParameterLocation.Header,
+                Type = SecuritySchemeType.ApiKey
+            });
+
+            options.AddSecurityRequirement(new OpenApiSecurityRequirement
+            {
+                {
+                    new OpenApiSecurityScheme
+                    {
+                        Reference = new OpenApiReference
+                        {
+                            Type = ReferenceType.SecurityScheme,
+                            Id = "Bearer"
+                        }
+                    },
+                    _newStringArray
+                },
+                {
+                    new OpenApiSecurityScheme
+                    {
+                        Reference = new OpenApiReference
+                        {
+                            Type = ReferenceType.SecurityScheme,
+                            Id = "ApiKey"
+                        }
+                    },
+                    _newStringArray
+                }
+            });
         });
 
         Logger.Info("[ProgramUtils][AddOpenApi] Ended swagger doc");
     }
-
     public static void AddServices(ref WebApplicationBuilder builder)
     {
         Logger.Info("[ProgramUtils][AddServices] Adding services");
@@ -99,7 +145,6 @@ public static class ProgramUtils
 
         Logger.Info("[ProgramUtils][AddServices] Done services");
     }
-
     public static void AddMiddlewares(ref WebApplication app)
     {
         Logger.Info("[ProgramUtils][AddMiddlewares] Adding middlewares");
@@ -126,7 +171,6 @@ public static class ProgramUtils
 
         Logger.Info("[ProgramUtils][AddMiddlewares] Done middlewares");
     }
-
     public static void AddDbContext(ref WebApplicationBuilder builder, AppSettings appSettings)
     {
         Logger.Info("[ProgramUtils][AddDbContext] Adding DbContext");
@@ -168,11 +212,63 @@ public static class ProgramUtils
         messages = String.IsNullOrEmpty(messages) ? "No context" : messages;
         Logger.Info($"[ProgramUtils][AddDbContext] {messages} added");
     }
-
     public static void AddScopes(ref WebApplicationBuilder builder)
     {
         Logger.Info("[ProgramUtils][AddScopes] Adding scopes");
+        builder.Services.AddHttpContextAccessor();
+        builder.Services.AddScoped<IAuthService, AuthService>();
+        builder.Services.AddScoped<IJwtService, JwtService>();
+        builder.Services.AddScoped<IRoleService, RoleService>();
+        builder.Services.AddScoped<IUserService, UserService>();
         Logger.Info("[ProgramUtils][AddScopes] Done scopes");
     }
 
+    public static void AddAutoMapper(ref WebApplicationBuilder builder)
+    {
+        Logger.Info("[ProgramUtils][AddAutoMapper] Adding AutoMapperConfiguration");
+        builder.Services.AddAutoMapper(typeof(AutoMapperConfiguration));
+        Logger.Info("[ProgramUtils][AddScopes] Done AutoMapperConfiguration");
+    }
+
+    public static void CreateRoles(ref WebApplication app)
+    {
+        Logger.Info("[ProgramUtils][CreateRoles] Adding roles...");
+        using (var scope = app.Services.CreateScope())
+        {
+            var roleService = scope.ServiceProvider.GetRequiredService<IRoleService>;
+            CreateRole(roleService, "Administrator");
+            CreateRole(roleService, "Default");
+        }
+
+        Logger.Info("[ProgramUtils][CreateRoles] Done roles");
+    }
+
+    private static void CreateRole(Func<IRoleService?> roleService, string roleName)
+    {
+        Logger.Info($"[ProgramUtils][CreateRole] Adding role {roleName}...");
+        if (roleService != null)
+        {
+            var isValidThread = Task.Run(() => roleService!.Invoke()?.CheckIfNameIsValid(roleName));
+            if (isValidThread.Result)
+            {
+                CreateRoleRequestData data = new()
+                {
+                    Name = roleName,
+                    IsNotEditable = true
+                };
+                var createThread = Task.Run(() => roleService!.Invoke()?.CreateRoleAsync(data));
+                Role? role = createThread.Result;
+                if (role != null)
+                {
+                    Logger.Info($"[ProgramUtils][CreateRole] Role {roleName} created...");
+                }
+            }
+            else
+            {
+                Logger.Info($"[ProgramUtils][CreateRole] Role {roleName} already exists...");
+            }
+        }
+
+    }
+
 }

MainProject/appsettings.json

@@ -3,7 +3,7 @@
     {
         "Settings": {
             "Name": "MainProject",
-            "Version": "v1.0",
+            "Version": "v1",
             "Description": "This template contains basic configuration for a .Net 8 backend"            
         },
         "DatabaseSettings": {
@@ -27,6 +27,16 @@
                 "Default": "Information",
                 "Microsoft.AspNetCore": "Warning"
             }
+        },
+        "JwtSettings": {
+            "ValidAudience": "http://localhost:4200",
+            "ValidIssuer": "http://localhost:5000",
+            "Secret": "JWTAuthenticationHIGHsecuredPasswordVVVp1OH7Xzyr",
+            "ExpiredAfterMinsOfInactivity": 15
+        },
+        "EncryptionSettings": {
+            "Salt": "S7VIidfXQf1tOQYX",
+            "Pepper": ""
         }
     }
 }