Fixed error in PermissionService

.editorconfig

@@ -1,15 +0,0 @@
-# top-most EditorConfig file
-root = true
-
-# Core EditorConfig properties
-[*]
-indent_style = space
-indent_size = 4
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-csharp_prefer_braced_block = true:suggestion
-csharp_preserve_single_line_blocks = true
-csharp_style_expression_bodied_methods = when_on_single_line:suggestion

.github/dependabot.yml

@@ -1,15 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "nuget"
-    directory: "/MainProject"
-    schedule:
-      interval: "daily"
-    open-pull-requests-limit: 5
-    target-branch: "main"
-
-  - package-ecosystem: "nuget"
-    directory: "/MainProject.Tests"
-    schedule:
-      interval: "daily"
-    open-pull-requests-limit: 5
-    target-branch: "main"

MainProject.Tests/Controllers/AuthController_Tests.cs

@@ -61,12 +61,12 @@ public class AuthController_Tests
         ObjectResult response = (ObjectResult)(await controller.AuthenticateAsync(request));
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status200OK, result.Status);
+                Assert.IsTrue(result.Status == StatusCodes.Status200OK);
                 Assert.IsInstanceOfType(result.Data, typeof(AuthenticatedUser));
             }
             else
@@ -81,6 +81,42 @@ public class AuthController_Tests
         }
     }
 
+    [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()
     {
@@ -104,7 +140,46 @@ public class AuthController_Tests
 
         if (response != null)
         {
-            Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
+            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
         {
@@ -132,13 +207,13 @@ public class AuthController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
             }
             else
             {

MainProject.Tests/Controllers/RoleController_Tests.cs

@@ -70,12 +70,12 @@ public class RoleController_Tests
         ObjectResult response = (ObjectResult)(await _roleController.GetRoleByGuidAsync(guid));
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status200OK, result.Status);
+                Assert.IsTrue(result.Status == StatusCodes.Status200OK);
                 Assert.IsInstanceOfType(result.Data, typeof(RoleDto));
             }
             else
@@ -89,6 +89,41 @@ public class RoleController_Tests
         }
     }
 
+    [TestMethod]
+    public async Task GetRoleByGuidAsync_GuidIsEmpty()
+    {
+        if (_roleController == null)
+        {
+            Assert.Fail($"_roleController is null");
+        }
+
+        var guid = String.Empty;
+        DatabaseSqlServer.Role? role = null;
+
+        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
+        ObjectResult response = (ObjectResult)(await _roleController.GetRoleByGuidAsync(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 GetRoleByGuidAsync_NotFound()
     {
@@ -106,7 +141,44 @@ public class RoleController_Tests
 
         if (response != null)
         {
-            Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status404NotFound);
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetRoleByGuidAsync_ModelInvalid()
+    {
+        if (_roleController == null)
+        {
+            Assert.Fail($"_roleController is null");
+        }
+
+        var guid = Guid.NewGuid().ToString();
+        DatabaseSqlServer.Role? role = null;
+        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
+        _roleController.ModelState.AddModelError("Data", "Invalid data");
+        ObjectResult response = (ObjectResult)(await _roleController.GetRoleByGuidAsync(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
         {
@@ -130,13 +202,13 @@ public class RoleController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
             }
             else
             {
@@ -183,12 +255,12 @@ public class RoleController_Tests
         ObjectResult response = (ObjectResult)(await _roleController.CreateRoleAsync(request));
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status200OK, result.Status);
+                Assert.IsTrue(result.Status == StatusCodes.Status200OK);
                 Assert.IsInstanceOfType(result.Data, typeof(RoleDto));
             }
             else
@@ -225,13 +297,57 @@ public class RoleController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
-                Assert.AreEqual("Invalid name", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Invalid name");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateRoleAsync_CreateRoleRequestDataNull()
+    {
+        if (_roleController == null)
+        {
+            Assert.Fail($"_roleController is null");
+        }
+
+        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
+
+        CreateRoleRequest request = new CreateRoleRequest()
+        {
+            Data = null
+        };
+
+        _roleServiceMock?.Setup(s => s.CheckIfNameIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+
+        _roleServiceMock?.Setup(s => s.CreateRoleAsync(
+            It.IsAny<CreateRoleRequestData>()
+        )).ReturnsAsync(role);
+
+        ObjectResult response = (ObjectResult)(await _roleController.CreateRoleAsync(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
             {
@@ -275,13 +391,13 @@ public class RoleController_Tests
         ObjectResult response = (ObjectResult)(await _roleController.CreateRoleAsync(request));
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
-                Assert.AreEqual("Not created", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Not created");
             }
             else
             {
@@ -294,6 +410,56 @@ public class RoleController_Tests
         }
     }
 
+    [TestMethod]
+    public async Task CreateRoleAsync_ModelInvalid()
+    {
+        if (_roleController == null)
+        {
+            Assert.Fail($"_roleController is null");
+        }
+
+        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
+
+        CreateRoleRequest request = new CreateRoleRequest()
+        {
+            Data = new CreateRoleRequestData()
+            {
+                Name = "RoleTest",
+                IsNotEditable = true
+            }
+        };
+
+        _roleServiceMock?.Setup(s => s.CheckIfNameIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+
+        _roleServiceMock?.Setup(s => s.CreateRoleAsync(
+            It.IsAny<CreateRoleRequestData>()
+        )).ReturnsAsync(role);
+        _roleController.ModelState.AddModelError("Data", "Invalid data");
+        ObjectResult response = (ObjectResult)(await _roleController.CreateRoleAsync(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 CreateRoleAsync_Exception()
     {
@@ -328,13 +494,13 @@ public class RoleController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
             }
             else
             {
@@ -365,7 +531,42 @@ public class RoleController_Tests
         ObjectResult response = (ObjectResult)(await _roleController.DeleteRoleByGuidAsync(guid));
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task DeleteRoleByGuidAsync_GuidIsEmpty()
+    {
+        if (_roleController == null)
+        {
+            Assert.Fail($"_roleController is null");
+        }
+
+        var guid = String.Empty;
+        DatabaseSqlServer.Role? role = null;
+
+        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
+        ObjectResult response = (ObjectResult)(await _roleController.DeleteRoleByGuidAsync(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
         {
@@ -390,7 +591,44 @@ public class RoleController_Tests
 
         if (response != null)
         {
-            Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status404NotFound);
+        }
+        else
+        {
+            Assert.Fail($"Response is null");
+        }
+    }
+
+    [TestMethod]
+    public async Task DeleteRoleByGuidAsync_ModelInvalid()
+    {
+        if (_roleController == null)
+        {
+            Assert.Fail($"_roleController is null");
+        }
+
+        var guid = Guid.NewGuid().ToString();
+        DatabaseSqlServer.Role? role = null;
+        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
+        _roleController.ModelState.AddModelError("Data", "Invalid data");
+        ObjectResult response = (ObjectResult)(await _roleController.DeleteRoleByGuidAsync(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
         {
@@ -414,13 +652,13 @@ public class RoleController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
             }
             else
             {
@@ -435,6 +673,8 @@ public class RoleController_Tests
 
     #endregion
 
+
+
     #region "UPDATE"
 
     [TestMethod]
@@ -468,12 +708,12 @@ public class RoleController_Tests
         ObjectResult response = (ObjectResult)(await _roleController.UpdateRoleAsync(request, role.Guid));
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status200OK, result.Status);
+                Assert.IsTrue(result.Status == StatusCodes.Status200OK);
                 Assert.IsInstanceOfType(result.Data, typeof(RoleDto));
             }
             else
@@ -512,7 +752,7 @@ public class RoleController_Tests
 
         if (response != null)
         {
-            Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status404NotFound);
         }
         else
         {
@@ -546,13 +786,13 @@ public class RoleController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
-                Assert.AreEqual("Invalid name", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Invalid name");
             }
             else
             {
@@ -592,13 +832,13 @@ public class RoleController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
-                Assert.AreEqual("This role is not editable", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "This role is not editable");
             }
             else
             {
@@ -611,6 +851,96 @@ public class RoleController_Tests
         }
     }
 
+    [TestMethod]
+    public async Task UpdateRoleAsync_CreateRoleRequestDataNull()
+    {
+        if (_roleController == null)
+        {
+            Assert.Fail($"_roleController is null");
+        }
+
+        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
+
+        CreateRoleRequest request = new CreateRoleRequest()
+        {
+            Data = null
+        };
+
+        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
+        _roleServiceMock?.Setup(s => s.CheckIfNameIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+        _roleServiceMock?.Setup(s => s.UpdateRoleAsync(It.IsAny<CreateRoleRequestData>(), It.IsAny<Role>())).ReturnsAsync(role);
+
+        ObjectResult response = (ObjectResult)(await _roleController.UpdateRoleAsync(request, role.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 UpdateRoleAsync_ModelInvalid()
+    {
+        if (_roleController == null)
+        {
+            Assert.Fail($"_roleController is null");
+        }
+
+        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
+
+        CreateRoleRequest request = new CreateRoleRequest()
+        {
+            Data = new CreateRoleRequestData()
+            {
+                Name = "RoleTest",
+                IsNotEditable = true
+            }
+        };
+
+        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
+        _roleServiceMock?.Setup(s => s.CheckIfNameIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+        _roleServiceMock?.Setup(s => s.UpdateRoleAsync(It.IsAny<CreateRoleRequestData>(), It.IsAny<Role>())).ReturnsAsync(role);
+        _roleController.ModelState.AddModelError("Data", "Invalid data");
+        ObjectResult response = (ObjectResult)(await _roleController.UpdateRoleAsync(request, role.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 UpdateRoleAsync_Exception()
     {
@@ -641,18 +971,18 @@ public class RoleController_Tests
             It.IsAny<CreateRoleRequestData>(), It.IsAny<Role>()
         )).ThrowsAsync(new Exception("Unexpected error"));
 
-        ObjectResult response = (ObjectResult)await _roleController.UpdateRoleAsync(request, role.Guid);
+        ObjectResult response = (ObjectResult)(await _roleController.UpdateRoleAsync(request, role.Guid));
         Assert.IsInstanceOfType(response, typeof(ObjectResult));
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
             }
             else
             {
@@ -666,5 +996,4 @@ public class RoleController_Tests
     }
 
     #endregion
-
 }

MainProject.Tests/Controllers/RootController_Tests.cs

@@ -30,7 +30,7 @@ public class RootController_Test
             if (result != null)
             {
                 var data = (OkResult)result;
-                Assert.AreEqual(StatusCodes.Status200OK, data.StatusCode);
+                Assert.IsTrue(data.StatusCode == StatusCodes.Status200OK);
             }
             else
             {

MainProject.Tests/Controllers/UserController_Tests.cs

@@ -66,7 +66,6 @@ public class UserController_Tests
     }
 
 
-#region "GET"
     [TestMethod]
     public async Task GetUserByGuidAsync_Should_Return_200_When_Successful()
     {
@@ -81,12 +80,12 @@ public class UserController_Tests
         ObjectResult response = (ObjectResult)(await _userController.GetUserByGuidAsync(guid));
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status200OK, result.Status);
+                Assert.IsTrue(result.Status == StatusCodes.Status200OK);
                 Assert.IsInstanceOfType(result.Data, typeof(UserDto));
             }
             else
@@ -100,6 +99,41 @@ public class UserController_Tests
         }
     }
 
+    [TestMethod]
+    public async Task GetUserByGuidAsync_GuidIsEmpty()
+    {
+        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()
     {
@@ -117,7 +151,44 @@ public class UserController_Tests
 
         if (response != null)
         {
-            Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
+            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
         {
@@ -141,13 +212,13 @@ public class UserController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
             }
             else
             {
@@ -160,10 +231,6 @@ public class UserController_Tests
         }
     }
 
-#endregion
-
-
-#region "CREATE"
     [TestMethod]
     public async Task CreateUserAsync_Success()
     {
@@ -198,12 +265,12 @@ public class UserController_Tests
         ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status200OK, result.Status);
+                Assert.IsTrue(result.Status == StatusCodes.Status200OK);
                 Assert.IsInstanceOfType(result.Data, typeof(UserDto));
             }
             else
@@ -244,13 +311,13 @@ public class UserController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
-                Assert.AreEqual("Invalid email", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Invalid email");
             }
             else
             {
@@ -295,13 +362,58 @@ public class UserController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
-                Assert.AreEqual("Role not found", result.Message);
+                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
             {
@@ -350,13 +462,13 @@ public class UserController_Tests
         ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
-                Assert.AreEqual("Not created", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Not created");
             }
             else
             {
@@ -369,6 +481,59 @@ public class UserController_Tests
         }
     }
 
+    [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()
     {
@@ -411,13 +576,13 @@ public class UserController_Tests
 
         if (response != null && response.Value != null)
         {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
 
             var result = (BaseResponse<object>)response.Value;
             if (result != null)
             {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
+                Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
+                Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
             }
             else
             {
@@ -429,479 +594,4 @@ public class UserController_Tests
             Assert.Fail($"Response is null");
         }
     }
-
-#endregion
-
-#region "DELETE"
-
-    [TestMethod]
-    public async Task DeleteRoleByGuidAsync_Success()
-    {
-        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.DeleteUserByGuidAsync(guid);
-        if (response != null && response.Value != null)
-        {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
-        }
-        else
-        {
-            Assert.Fail($"Response value is null");
-        }
-    }
-
-    [TestMethod]
-    public async Task DeleteRoleByGuidAsync_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.DeleteUserByGuidAsync(guid);
-
-        Assert.IsInstanceOfType(response, typeof(NotFoundResult));
-
-        if (response != null)
-        {
-            Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
-        }
-        else
-        {
-            Assert.Fail($"Response is null");
-        }
-    }
-
-    [TestMethod]
-    public async Task DeleteRoleByGuidAsync_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.DeleteUserByGuidAsync(guid);
-
-        Assert.IsInstanceOfType(response, typeof(ObjectResult));
-
-        if (response != null && response.Value != null)
-        {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
-
-            var result = (BaseResponse<object>)response.Value;
-            if (result != null)
-            {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
-            }
-            else
-            {
-                Assert.Fail($"Result value is null");
-            }
-        }
-        else
-        {
-            Assert.Fail($"Response is null");
-        }
-    }
-
-    #endregion
-
-    #region "UPDATE"
-
-    [TestMethod]
-    public async Task UpdateUserAsync_Should_Return_200_When_Successful()
-    {
-        if (_userController == null)
-        {
-            Assert.Fail($"_userController is null");
-        }
-
-        DatabaseSqlServer.User user = ModelsInit.CreateUser();
-
-        UpdateUserRequest request = new UpdateUserRequest()
-        {
-            Data = new UpdateUserRequestData()
-            {
-                FirstName = "NewFirstName",
-                LastName = "NewLastName"
-            }
-        };
-
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-        _userServiceMock?.Setup(s => s.UpdateUserAsync(It.IsAny<UpdateUserRequestData>(), It.IsAny<User>())).ReturnsAsync(user);
-
-        ObjectResult response = (ObjectResult)await _userController.UpdateUserAsync(request, user.Guid);
-        if (response != null && response.Value != null)
-        {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
-
-            var result = (BaseResponse<object>)response.Value;
-            if (result != null)
-            {
-                Assert.AreEqual(StatusCodes.Status200OK, result.Status);
-                Assert.IsInstanceOfType(result.Data, typeof(UserDto));
-            }
-            else
-            {
-                Assert.Fail($"Result value is null");
-            }
-        }
-        else
-        {
-            Assert.Fail($"Response value is null");
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserAsync_UserNotFound()
-    {
-        if (_userController == null)
-        {
-            Assert.Fail($"_userController is null");
-        }
-
-        DatabaseSqlServer.User? user = null;
-
-        UpdateUserRequest request = new UpdateUserRequest()
-        {
-            Data = new UpdateUserRequestData()
-            {
-                FirstName = "NewFirstName",
-                LastName = "NewLastName"
-            }
-        };
-
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-
-        NotFoundResult response = (NotFoundResult)await _userController.UpdateUserAsync(request, Guid.NewGuid().ToString());
-
-        if (response != null)
-        {
-            Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
-        }
-        else
-        {
-            Assert.Fail($"Response is null");
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserAsync_Exception()
-    {
-        if (_userController == null)
-        {
-            Assert.Fail($"_userController is null");
-        }
-
-        DatabaseSqlServer.User user = ModelsInit.CreateUser();
-
-        UpdateUserRequest request = new UpdateUserRequest()
-        {
-            Data = new UpdateUserRequestData()
-            {
-                FirstName = "NewFirstName",
-                LastName = "NewLastName"
-            }
-        };
-
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-        _userServiceMock?.Setup(s => s.UpdateUserAsync(
-            It.IsAny<UpdateUserRequestData>(), It.IsAny<User>()
-        )).ThrowsAsync(new Exception("Unexpected error"));
-
-        ObjectResult response = (ObjectResult)await _userController.UpdateUserAsync(request, user.Guid);
-        Assert.IsInstanceOfType(response, typeof(ObjectResult));
-
-        if (response != null && response.Value != null)
-        {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
-
-            var result = (BaseResponse<object>)response.Value;
-            if (result != null)
-            {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
-            }
-            else
-            {
-                Assert.Fail($"Result value is null");
-            }
-        }
-        else
-        {
-            Assert.Fail($"Response is null");
-        }
-    }
-
-
-
-
-    [TestMethod]
-    public async Task UpdateUserPasswordAsync_Should_Return_200_When_Successful()
-    {
-        if (_userController == null)
-        {
-            Assert.Fail($"_userController is null");
-        }
-
-        DatabaseSqlServer.User user = ModelsInit.CreateUser();
-
-        string newPassword = "This!s4T3stP4ssw0rd#";
-
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-        _userServiceMock?.Setup(s => s.UpdateUserPasswordAsync(It.IsAny<User>(), newPassword)).ReturnsAsync(user);
-
-        ObjectResult response = (ObjectResult)await _userController.UpdateUserPasswordAsync(user.Guid, newPassword);
-        if (response != null && response.Value != null)
-        {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
-
-            var result = (BaseResponse<object>)response.Value;
-            if (result != null)
-            {
-                Assert.AreEqual(StatusCodes.Status200OK, result.Status);
-                Assert.IsInstanceOfType(result.Data, typeof(UserDto));
-            }
-            else
-            {
-                Assert.Fail($"Result value is null");
-            }
-        }
-        else
-        {
-            Assert.Fail($"Response value is null");
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserPasswordAsync_UserNotFound()
-    {
-        if (_userController == null)
-        {
-            Assert.Fail($"_userController is null");
-        }
-
-        DatabaseSqlServer.User? user = null;
-
-        string newPassword = "This!s4T3stP4ssw0rd#";
-
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-
-        NotFoundResult response = (NotFoundResult)await _userController.UpdateUserPasswordAsync(Guid.NewGuid().ToString(), newPassword);
-
-        if (response != null)
-        {
-            Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
-        }
-        else
-        {
-            Assert.Fail($"Response is null");
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserPasswordAsync_Exception()
-    {
-        if (_userController == null)
-        {
-            Assert.Fail($"_userController is null");
-        }
-
-        DatabaseSqlServer.User user = ModelsInit.CreateUser();
-
-        string newPassword = "This!s4T3stP4ssw0rd#";
-
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-        _userServiceMock?.Setup(s => s.UpdateUserPasswordAsync(
-            It.IsAny<User>(), It.IsAny<string>()
-        )).ThrowsAsync(new Exception("Unexpected error"));
-
-        ObjectResult response = (ObjectResult)await _userController.UpdateUserPasswordAsync(user.Guid, newPassword);
-        Assert.IsInstanceOfType(response, typeof(ObjectResult));
-
-        if (response != null && response.Value != null)
-        {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
-
-            var result = (BaseResponse<object>)response.Value;
-            if (result != null)
-            {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
-            }
-            else
-            {
-                Assert.Fail($"Result value is null");
-            }
-        }
-        else
-        {
-            Assert.Fail($"Response is null");
-        }
-    }
-
-
-
-    [TestMethod]
-    public async Task UpdateUserRoleAsync_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();
-
-        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-        _userServiceMock?.Setup(s => s.UpdateUserRoleAsync(It.IsAny<User>(), It.IsAny<Role>())).ReturnsAsync(user);
-
-        ObjectResult response = (ObjectResult)await _userController.UpdateUserRoleAsync(user.Guid, role.Guid);
-
-        if (response != null && response.Value != null)
-        {
-            Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
-
-            var result = (BaseResponse<object>)response.Value;
-            if (result != null)
-            {
-                Assert.AreEqual(StatusCodes.Status200OK, result.Status);
-                Assert.IsInstanceOfType(result.Data, typeof(UserDto));
-            }
-            else
-            {
-                Assert.Fail($"Result value is null");
-            }
-        }
-        else
-        {
-            Assert.Fail($"Response value is null");
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserPasswordAsync_RoleNotFound()
-    {
-        if (_userController == null)
-        {
-            Assert.Fail($"_userController is null");
-        }
-
-        DatabaseSqlServer.User user = ModelsInit.CreateUser();
-        DatabaseSqlServer.Role? role = null;
-
-        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-        ObjectResult response = (ObjectResult)await _userController.UpdateUserRoleAsync(user.Guid, Guid.NewGuid().ToString());
-        if (response != null)
-        {
-            Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
-            Assert.IsNotNull(response.Value);
-            var result = (BaseResponse<object>)response.Value;
-            if (result != null)
-            {
-                Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
-                Assert.AreEqual("Role not found", result.Message);
-            }
-            else
-            {
-                Assert.Fail($"Result value is null");
-            }
-        }
-        else
-        {
-            Assert.Fail($"Response is null");
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserRoleAsync_UserNotFound()
-    {
-        if (_userController == null)
-        {
-            Assert.Fail($"_userController is null");
-        }
-
-        DatabaseSqlServer.User? user = null;
-        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
-
-        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-        _userServiceMock?.Setup(s => s.UpdateUserRoleAsync(It.IsAny<User>(), It.IsAny<Role>())).ReturnsAsync(user);
-
-        NotFoundResult response = (NotFoundResult)await _userController.UpdateUserRoleAsync(Guid.NewGuid().ToString(), role.Guid);
-
-        if (response != null)
-        {
-            Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
-        }
-        else
-        {
-            Assert.Fail($"Response is null");
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserRoleAsync_Exception()
-    {
-        if (_userController == null)
-        {
-            Assert.Fail($"_userController is null");
-        }
-
-        DatabaseSqlServer.User user = ModelsInit.CreateUser();
-        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
-
-        _roleServiceMock?.Setup(s => s.GetRoleByGuidAsync(It.IsAny<string>())).ReturnsAsync(role);
-        _userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
-        _userServiceMock?.Setup(s => s.UpdateUserRoleAsync(
-            It.IsAny<User>(), It.IsAny<Role>()
-        )).ThrowsAsync(new Exception("Unexpected error"));
-
-        ObjectResult response = (ObjectResult)await _userController.UpdateUserRoleAsync(user.Guid, role.Guid);
-        Assert.IsInstanceOfType(response, typeof(ObjectResult));
-
-        if (response != null && response.Value != null)
-        {
-            Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
-
-            var result = (BaseResponse<object>)response.Value;
-            if (result != null)
-            {
-                Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
-                Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
-            }
-            else
-            {
-                Assert.Fail($"Result value is null");
-            }
-        }
-        else
-        {
-            Assert.Fail($"Response is null");
-        }
-    }
-
-
-    #endregion
-
-
 }

MainProject.Tests/Core/Attributes/JwtAuthorizationAttribute_Tests.cs

@@ -143,4 +143,4 @@ public class JwtAuthorizationAttribute_Tests
         Assert.IsNotInstanceOfType(context.Result, typeof(UnauthorizedResult));
     }
 
-}
+}

MainProject.Tests/Core/Filters/ValidationActionFilter_Tests.cs

@@ -1,135 +0,0 @@
-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;
-using Microsoft.AspNetCore.Mvc.ModelBinding;
-using BasicDotnetTemplate.MainProject.Core.Filters;
-using Newtonsoft.Json;
-using BasicDotnetTemplate.MainProject.Models.Api.Base;
-
-
-namespace BasicDotnetTemplate.MainProject.Tests;
-
-[TestClass]
-public class ValidationActionFilter_Tests
-{
-    private readonly string _requestNotWellFormedMessage = "Request is not well formed";
-
-    private static ActionExecutingContext CreateContext(ModelStateDictionary modelState, object? requestBody = null)
-    {
-        var actionContext = new ActionContext(
-            new DefaultHttpContext(),
-            new Microsoft.AspNetCore.Routing.RouteData(),
-            new Microsoft.AspNetCore.Mvc.Controllers.ControllerActionDescriptor(),
-            modelState
-        );
-        var actionArguments = new Dictionary<string, object?>();
-
-        if (requestBody != null)
-        {
-            actionArguments.Add("request", requestBody);
-        }
-        return new ActionExecutingContext(
-            actionContext,
-            [],
-            actionArguments,
-            new Mock<Controller>().Object
-        );
-    }
-
-    [TestMethod]
-    public void OnActionExecutionAsync_ModelStateInvalid_ReturnsBadRequestAndDoesNotCallNext()
-    {
-        // Arrange
-        var modelState = new ModelStateDictionary();
-        modelState.AddModelError("MissingProperty", "MissingProperty is required");
-        var context = CreateContext(modelState, new { SomeProp = "Value" });
-        var nextCalled = false;
-        ActionExecutionDelegate next = () => {
-            nextCalled = true;
-            return Task.FromResult(new ActionExecutedContext(context, [], new Mock<Controller>().Object));
-        };
-        var filter = new ValidationActionFilter();
-        // Act
-        filter.OnActionExecutionAsync(context, next).GetAwaiter().GetResult();
-        // Assert
-        Assert.IsNotNull(context.Result);
-        var badRequestResult = context.Result as BadRequestObjectResult;
-        Assert.IsNotNull(badRequestResult);
-        Assert.IsNotNull(badRequestResult!.Value);
-
-        ValidationError validationError = (ValidationError)badRequestResult.Value;
-        Assert.AreEqual(_requestNotWellFormedMessage, validationError?.Message);
-        Assert.IsNotNull(validationError?.Errors);
-        Assert.IsFalse(modelState.IsValid);
-        Assert.IsFalse(nextCalled);
-    }
-
-    [TestMethod]
-    public void OnActionExecutionAsync_ModelStateValid_RequestBodyNull_ReturnsBadRequestAndDoesNotCallNext()
-    {
-
-        var modelState = new ModelStateDictionary();
-
-        var context = CreateContext(modelState, null);
-        var nextCalled = false;
-        ActionExecutionDelegate next = () => {
-            nextCalled = true;
-            return Task.FromResult(new ActionExecutedContext(context, [], new Mock<Controller>().Object));
-        };
-        var filter = new ValidationActionFilter();
-        // Act
-        filter.OnActionExecutionAsync(context, next).GetAwaiter().GetResult();
-        // Assert
-        Assert.IsNotNull(context.Result);
-        var badRequestResult = context.Result as BadRequestObjectResult;
-        Assert.IsNotNull(badRequestResult);
-        Assert.IsNotNull(badRequestResult!.Value);
-
-        ValidationError validationError = (ValidationError)badRequestResult.Value;
-        Assert.AreEqual(_requestNotWellFormedMessage, validationError?.Message);
-        Assert.IsNull(validationError?.Errors);
-        Assert.IsTrue(modelState.IsValid);
-        Assert.IsFalse(nextCalled);
-    }
-
-
-    [TestMethod]
-    public void OnActionExecutionAsync_ModelStateValid_RequestBodyValid_CallsNextAndDoesNotSetResult()
-    {
-        // Arrange
-        var modelState = new ModelStateDictionary();
-
-        var requestBody = new TestRequestBody { Value = "Test" };
-        var context = CreateContext(modelState, requestBody);
-        var nextCalled = false;
-        ActionExecutionDelegate next = () => {
-            nextCalled = true;
-            return Task.FromResult(new ActionExecutedContext(context, [], new Mock<Controller>().Object));
-        };
-        var filter = new ValidationActionFilter();
-        // Act
-        filter.OnActionExecutionAsync(context, next).GetAwaiter().GetResult();
-        // Assert
-        Assert.IsNull(context.Result);
-        Assert.IsTrue(nextCalled);
-    }
-
-
-    private class TestRequestBody
-    {
-        public string? Value { get; set; }
-    }
-
-}

MainProject.Tests/Core/Middlewares/AutoMapperConfiguration_Tests.cs

@@ -40,10 +40,10 @@ public class AutoMapperConfiguration_Tests
             DatabaseSqlServer.User user = ModelsInit.CreateUser();
             UserDto? data = _mapper?.Map<UserDto>(user);
 
-            Assert.AreEqual(user.Guid, data?.Guid);
-            Assert.AreEqual(user.FirstName, data?.FirstName);
-            Assert.AreEqual(user.LastName, data?.LastName);
-            Assert.AreEqual(user.Email, data?.Email);
+            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)
         {

MainProject.Tests/JsonData/appsettings.json

@@ -35,9 +35,8 @@
             "ExpiredAfterMinsOfInactivity": 15
         },
         "EncryptionSettings": {
-            "SaltKey": "S7VIidfXQf1tOQYX",
-            "Salt": "u5CZAwq9vLGysC",
-            "Iterations": 10
+            "Salt": "S7VIidfXQf1tOQYX",
+            "Pepper": ""
         }
     }
 

MainProject.Tests/JsonData/invalidCryptAppsettings.json

@@ -35,9 +35,8 @@
             "ExpiredAfterMinsOfInactivity": 15
         },
         "EncryptionSettings": {
-            "SaltKey": "AAAAA",
-            "Salt": "",
-            "Iterations": 10
+            "Salt": "AAAAA",
+            "Pepper": ""
         }
     }
 

MainProject.Tests/MainProject.Tests.csproj

@@ -10,15 +10,12 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.4">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.6" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <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.9.3" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.9.3" />
+    <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>
 

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

@@ -23,9 +23,9 @@ public class UserRole_Tests
         try
         {
             DatabaseSqlServer.Role role = ModelsInit.CreateRole();
-            UserRole userRole = new(role);
+            UserRole userRole = new UserRole(role);
 
-            Assert.AreEqual(role.Name, userRole.Name);
+            Assert.IsTrue(userRole.Name == role.Name);
         }
         catch (Exception ex)
         {
@@ -33,4 +33,4 @@ public class UserRole_Tests
             Assert.Fail($"An exception was thrown: {ex}");
         }
     }
-}
+}

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

@@ -25,9 +25,9 @@ public class AuthenticatedUser_Tests
             DatabaseSqlServer.User user = ModelsInit.CreateUser();
             AuthenticatedUser authenticatedUser = new AuthenticatedUser(user);
 
-            Assert.AreEqual(user.FirstName, authenticatedUser.FirstName);
-            Assert.AreEqual(user.LastName, authenticatedUser.LastName);
-            Assert.AreEqual(user.Email, authenticatedUser.Email);
+            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)
@@ -36,4 +36,4 @@ public class AuthenticatedUser_Tests
             Assert.Fail($"An exception was thrown: {ex}");
         }
     }
-}
+}

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

@@ -35,7 +35,7 @@ public class ApiResponse_Tests
         try
         {
             var baseResponse = new BaseResponse<object>(201, null, null);
-            Assert.AreNotEqual(StatusCodes.Status200OK, baseResponse.Status);
+            Assert.IsFalse(baseResponse.Status == StatusCodes.Status200OK);
         }
         catch (Exception ex)
         {

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

@@ -39,7 +39,7 @@ public class AuthenticateResponse_Tests
         try
         {
             var authenticateResponse = new AuthenticateResponse(201, null, null);
-            Assert.AreNotEqual(StatusCodes.Status200OK, authenticateResponse.Status);
+            Assert.IsFalse(authenticateResponse.Status == StatusCodes.Status200OK);
         }
         catch (Exception ex)
         {

MainProject.Tests/Models/Api/Response/Role/GetRoleResponse_Tests.cs

@@ -54,7 +54,7 @@ public class GetRoleResponse_Tests
         try
         {
             var getRoleResponse = new GetRoleResponse(201, null, null);
-            Assert.AreNotEqual(StatusCodes.Status200OK, getRoleResponse.Status);
+            Assert.IsFalse(getRoleResponse.Status == StatusCodes.Status200OK);
         }
         catch (Exception ex)
         {

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

@@ -54,7 +54,7 @@ public class GetUserResponse_Tests
         try
         {
             var getUserResponse = new GetUserResponse(201, null, null);
-            Assert.AreNotEqual(StatusCodes.Status200OK, getUserResponse.Status);
+            Assert.IsFalse(getUserResponse.Status == StatusCodes.Status200OK);
         }
         catch (Exception ex)
         {

MainProject.Tests/Models/Settings/Settings_Tests.cs

@@ -54,7 +54,7 @@ public class Settings_Tests
         try
         {
             var baseResponse = new BaseResponse<object>(201, null, null);
-            Assert.AreNotEqual(StatusCodes.Status200OK, baseResponse.Status);
+            Assert.IsFalse(baseResponse.Status == StatusCodes.Status200OK);
         }
         catch (Exception ex)
         {

MainProject.Tests/Services/AuthService_Tests.cs

@@ -62,7 +62,7 @@ public class AuthService_Tests
             if (authService != null)
             {
                 var authenticatedUser = await authService.AuthenticateAsync(request.Data);
-                Assert.IsNull(authenticatedUser);
+                Assert.IsTrue(authenticatedUser == null);
             }
             else
             {
@@ -93,7 +93,7 @@ public class AuthService_Tests
             if (authService != null)
             {
                 var authenticatedUser = await authService.AuthenticateAsync(request.Data);
-                Assert.IsNull(authenticatedUser);
+                Assert.IsTrue(authenticatedUser == null);
             }
             else
             {

MainProject.Tests/Services/JwtService_Tests.cs

@@ -53,7 +53,7 @@ public class JwtService_Tests
             if (jwtService != null)
             {
                 var jwt = jwtService.GenerateToken(testString);
-                Assert.IsNotNull(jwt);
+                Assert.IsTrue(jwt != null);
                 Assert.IsInstanceOfType(jwt, typeof(string));
             }
             else

MainProject.Tests/Services/PermissionService_Tests.cs

@@ -94,7 +94,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 var permission = await _permissionService.GetPermissionSystemByGuidAsync(Guid.NewGuid().ToString());
-                Assert.IsNull(permission);
+                Assert.IsTrue(permission == null);
             }
             else
             {
@@ -117,7 +117,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 var permission = await _permissionService.GetPermissionSystemByNameAsync(Guid.NewGuid().ToString());
-                Assert.IsNull(permission);
+                Assert.IsTrue(permission == null);
             }
             else
             {
@@ -139,7 +139,7 @@ public class PermissionService_Tests
             var permission = await _permissionService.CreatePermissionSystemAsync(_permissionSystem.Name, true);
             Assert.IsInstanceOfType(permission, typeof(PermissionSystem));
             Assert.IsNotNull(permission);
-            Assert.AreEqual(_permissionSystem.Name, permission.Name);
+            Assert.IsTrue(permission.Name == _permissionSystem.Name);
             Assert.IsTrue(permission.Enabled);
             _permissionSystem = permission;
 
@@ -189,7 +189,7 @@ public class PermissionService_Tests
         {
             var updated = await _permissionService.HandleEnabledPermissionSystemAsync(_permissionSystem, false);
             Assert.IsTrue(updated);
-            Assert.IsFalse(_permissionSystem.Enabled);
+            Assert.IsTrue(!_permissionSystem.Enabled);
 
         }
         catch (Exception ex)
@@ -210,8 +210,8 @@ public class PermissionService_Tests
                 var permission = await _permissionService.GetPermissionSystemByGuidAsync(_permissionSystem.Guid);
                 Assert.IsNotNull(permission);
                 Assert.IsInstanceOfType(permission, typeof(PermissionSystem));
-                Assert.AreEqual(_permissionSystem.Name, permission.Name);
-                Assert.AreEqual( _permissionSystem.Enabled, permission.Enabled);
+                Assert.IsTrue(permission.Name == _permissionSystem.Name);
+                Assert.IsTrue(permission.Enabled == _permissionSystem.Enabled);
             }
             else
             {
@@ -236,8 +236,8 @@ public class PermissionService_Tests
                 var permission = await _permissionService.GetPermissionSystemByNameAsync(_permissionSystem.Name);
                 Assert.IsNotNull(permission);
                 Assert.IsInstanceOfType(permission, typeof(PermissionSystem));
-                Assert.AreEqual(_permissionSystem.Guid, permission.Guid);
-                Assert.AreEqual( _permissionSystem.Enabled, permission.Enabled);
+                Assert.IsTrue(permission.Guid == _permissionSystem.Guid);
+                Assert.IsTrue(permission.Enabled == _permissionSystem.Enabled);
             }
             else
             {
@@ -265,7 +265,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 var permission = await _permissionService.GetPermissionModuleByGuidAsync(Guid.NewGuid().ToString());
-                Assert.IsNull(permission);
+                Assert.IsTrue(permission == null);
             }
             else
             {
@@ -288,7 +288,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 var permission = await _permissionService.GetPermissionModuleByNameAsync(Guid.NewGuid().ToString());
-                Assert.IsNull(permission);
+                Assert.IsTrue(permission == null);
             }
             else
             {
@@ -310,7 +310,7 @@ public class PermissionService_Tests
             var permission = await _permissionService.CreatePermissionModuleAsync(_permissionModule.Name, true);
             Assert.IsInstanceOfType(permission, typeof(PermissionModule));
             Assert.IsNotNull(permission);
-            Assert.AreEqual(_permissionModule.Name, permission.Name);
+            Assert.IsTrue(permission.Name == _permissionModule.Name);
             Assert.IsTrue(permission.Enabled);
             _permissionModule = permission;
 
@@ -362,7 +362,7 @@ public class PermissionService_Tests
         {
             var updated = await _permissionService.HandleEnabledPermissionModuleAsync(_permissionModule, false);
             Assert.IsTrue(updated);
-            Assert.IsFalse(_permissionModule.Enabled);
+            Assert.IsTrue(!_permissionModule.Enabled);
 
         }
         catch (Exception ex)
@@ -383,8 +383,8 @@ public class PermissionService_Tests
                 var permission = await _permissionService.GetPermissionModuleByGuidAsync(_permissionModule.Guid);
                 Assert.IsNotNull(permission);
                 Assert.IsInstanceOfType(permission, typeof(PermissionModule));
-                Assert.AreEqual(_permissionModule.Name, permission.Name);
-                Assert.AreEqual( _permissionModule.Enabled, permission.Enabled);
+                Assert.IsTrue(permission.Name == _permissionModule.Name);
+                Assert.IsTrue(permission.Enabled == _permissionModule.Enabled);
             }
             else
             {
@@ -409,8 +409,8 @@ public class PermissionService_Tests
                 var permission = await _permissionService.GetPermissionModuleByNameAsync(_permissionModule.Name);
                 Assert.IsNotNull(permission);
                 Assert.IsInstanceOfType(permission, typeof(PermissionModule));
-                Assert.AreEqual(_permissionModule.Guid, permission.Guid);
-                Assert.AreEqual( _permissionModule.Enabled, permission.Enabled);
+                Assert.IsTrue(permission.Guid == _permissionModule.Guid);
+                Assert.IsTrue(permission.Enabled == _permissionModule.Enabled);
             }
             else
             {
@@ -438,7 +438,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 var permission = await _permissionService.GetPermissionOperationByGuidAsync(Guid.NewGuid().ToString());
-                Assert.IsNull(permission);
+                Assert.IsTrue(permission == null);
             }
             else
             {
@@ -461,7 +461,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 var permission = await _permissionService.GetPermissionOperationByNameAsync(Guid.NewGuid().ToString());
-                Assert.IsNull(permission);
+                Assert.IsTrue(permission == null);
             }
             else
             {
@@ -483,7 +483,7 @@ public class PermissionService_Tests
             var permission = await _permissionService.CreatePermissionOperationAsync(_permissionOperation.Name);
             Assert.IsInstanceOfType(permission, typeof(PermissionOperation));
             Assert.IsNotNull(permission);
-            Assert.AreEqual(_permissionOperation.Name, permission.Name);
+            Assert.IsTrue(permission.Name == _permissionOperation.Name);
             _permissionOperation = permission;
 
         }
@@ -536,7 +536,7 @@ public class PermissionService_Tests
                 var permission = await _permissionService.GetPermissionOperationByGuidAsync(_permissionOperation.Guid);
                 Assert.IsNotNull(permission);
                 Assert.IsInstanceOfType(permission, typeof(PermissionOperation));
-                Assert.AreEqual(_permissionOperation.Name, permission.Name);
+                Assert.IsTrue(permission.Name == _permissionOperation.Name);
             }
             else
             {
@@ -561,7 +561,7 @@ public class PermissionService_Tests
                 var permission = await _permissionService.GetPermissionOperationByNameAsync(_permissionOperation.Name);
                 Assert.IsNotNull(permission);
                 Assert.IsInstanceOfType(permission, typeof(PermissionOperation));
-                Assert.AreEqual(_permissionOperation.Guid, permission.Guid);
+                Assert.IsTrue(permission.Guid == _permissionOperation.Guid);
             }
             else
             {
@@ -589,7 +589,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 var permission = await _permissionService.GetPermissionSystemModuleByGuidAsync(Guid.NewGuid().ToString());
-                Assert.IsNull(permission);
+                Assert.IsTrue(permission == null);
             }
             else
             {
@@ -660,7 +660,7 @@ public class PermissionService_Tests
         {
             var updated = await _permissionService.HandleEnabledPermissionSystemModuleAsync(_permissionSystemModule, false);
             Assert.IsTrue(updated);
-            Assert.IsFalse(_permissionSystemModule.Enabled);
+            Assert.IsTrue(!_permissionSystemModule.Enabled);
 
         }
         catch (Exception ex)
@@ -681,7 +681,7 @@ public class PermissionService_Tests
                 var permission = await _permissionService.GetPermissionSystemModuleByGuidAsync(_permissionSystemModule.Guid);
                 Assert.IsNotNull(permission);
                 Assert.IsInstanceOfType(permission, typeof(PermissionSystemModule));
-                Assert.AreEqual( _permissionSystemModule.Enabled, permission.Enabled);
+                Assert.IsTrue(permission.Enabled == _permissionSystemModule.Enabled);
             }
             else
             {
@@ -709,7 +709,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 var permission = await _permissionService.GetPermissionSystemModuleOperationByGuidAsync(Guid.NewGuid().ToString());
-                Assert.IsNull(permission);
+                Assert.IsTrue(permission == null);
             }
             else
             {
@@ -780,7 +780,7 @@ public class PermissionService_Tests
         {
             var updated = await _permissionService.HandleEnabledPermissionSystemModuleOperationAsync(_permissionSystemModuleOperation, false);
             Assert.IsTrue(updated);
-            Assert.IsFalse(_permissionSystemModuleOperation.Enabled);
+            Assert.IsTrue(!_permissionSystemModuleOperation.Enabled);
 
         }
         catch (Exception ex)
@@ -801,7 +801,7 @@ public class PermissionService_Tests
                 var permission = await _permissionService.GetPermissionSystemModuleOperationByGuidAsync(_permissionSystemModuleOperation.Guid);
                 Assert.IsNotNull(permission);
                 Assert.IsInstanceOfType(permission, typeof(PermissionSystemModuleOperation));
-                Assert.AreEqual(_permissionSystemModuleOperation.Enabled, permission.Enabled);
+                Assert.IsTrue(permission.Enabled == _permissionSystemModuleOperation.Enabled);
             }
             else
             {
@@ -829,7 +829,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 var permission = await _permissionService.GetRolePermissionSystemModuleOperationByGuidAsync(Guid.NewGuid().ToString());
-                Assert.IsNull(permission);
+                Assert.IsTrue(permission == null);
             }
             else
             {
@@ -916,7 +916,7 @@ public class PermissionService_Tests
         {
             var updated = await _permissionService.HandleEnabledRolePermissionSystemModuleOperationAsync(_rolePermissionSystemModuleOperation, false);
             Assert.IsTrue(updated);
-            Assert.IsFalse(_rolePermissionSystemModuleOperation.Active);
+            Assert.IsTrue(!_rolePermissionSystemModuleOperation.Active);
 
         }
         catch (Exception ex)
@@ -937,7 +937,7 @@ public class PermissionService_Tests
                 var permission = await _permissionService.GetRolePermissionSystemModuleOperationByGuidAsync(_rolePermissionSystemModuleOperation.Guid);
                 Assert.IsNotNull(permission);
                 Assert.IsInstanceOfType(permission, typeof(RolePermissionSystemModuleOperation));
-                Assert.AreEqual( _rolePermissionSystemModuleOperation.Active, permission.Active);
+                Assert.IsTrue(permission.Active == _rolePermissionSystemModuleOperation.Active);
             }
             else
             {
@@ -1067,7 +1067,7 @@ public class PermissionService_Tests
             if (_permissionService != null)
             {
                 List<string> permissions = _permissionService.CreatePermissionsOnStartupAsync();
-                Assert.IsNotNull(permissions);
+                Assert.IsFalse(permissions == null);
                 List<string> cleanedPermissions = new();
 
                 foreach (var permission in permissions)

MainProject.Tests/Services/RoleService_Tests.cs

@@ -79,8 +79,8 @@ public class RoleService_Tests
                 var role = await _roleService.CreateRoleAsync(data);
                 Assert.IsInstanceOfType(role, typeof(Role));
                 Assert.IsNotNull(role);
-                Assert.AreEqual(_expectedRole?.Name, role.Name);
-                Assert.AreEqual(_expectedRole?.IsNotEditable, role.IsNotEditable);
+                Assert.IsTrue(_expectedRole?.Name == role.Name);
+                Assert.IsTrue(_expectedRole?.IsNotEditable == role.IsNotEditable);
                 _role = role;
             }
             else
@@ -188,7 +188,7 @@ public class RoleService_Tests
             {
                 var role = await _roleService.GetRoleByIdAsync(_role?.Id ?? 0);
                 Assert.IsNotNull(role);
-                Assert.AreEqual(_role?.Id, _role?.Id);
+                Assert.IsTrue(role.Id == _role?.Id);
             }
             else
             {
@@ -211,7 +211,7 @@ public class RoleService_Tests
             {
                 var role = await _roleService.GetRoleByGuidAsync(_role?.Guid ?? String.Empty);
                 Assert.IsNotNull(role);
-                Assert.AreEqual(_role?.Guid, role.Guid);
+                Assert.IsTrue(role.Guid == _role?.Guid);
             }
             else
             {
@@ -234,7 +234,7 @@ public class RoleService_Tests
             {
                 var role = await _roleService.GetRoleForUser(_role?.Guid);
                 Assert.IsNotNull(role);
-                Assert.AreEqual(_role?.Guid, role.Guid);
+                Assert.IsTrue(role.Guid == _role?.Guid);
             }
             else
             {
@@ -263,8 +263,8 @@ public class RoleService_Tests
                 var roleCreated = await _roleService.CreateRoleAsync(data);
                 var role = await _roleService.GetRoleForUser(String.Empty);
                 Assert.IsNotNull(role);
-                Assert.AreEqual(role?.Guid, roleCreated?.Guid);
-                Assert.AreEqual("Default", role?.Name);
+                Assert.IsTrue(roleCreated?.Guid == role?.Guid);
+                Assert.IsTrue(role?.Name == "Default");
             }
             else
             {
@@ -317,8 +317,8 @@ public class RoleService_Tests
                 var role = await _roleService.UpdateRoleAsync(data, _role!);
                 Assert.IsInstanceOfType(role, typeof(Role));
                 Assert.IsNotNull(role);
-                Assert.AreEqual(data.Name, role.Name);
-                Assert.AreEqual(data.IsNotEditable, role.IsNotEditable);
+                Assert.IsTrue(data.Name == role.Name);
+                Assert.IsTrue(data.IsNotEditable == role.IsNotEditable);
                 _role = role;
             }
             else
@@ -359,8 +359,8 @@ public class RoleService_Tests
                 var roleUpdatedRole = await _roleService.UpdateRoleAsync(updateRoleData, role!);
                 Assert.IsInstanceOfType(roleUpdatedRole, typeof(Role));
                 Assert.IsNotNull(roleUpdatedRole);
-                Assert.AreEqual(createRoleData.Name, roleUpdatedRole.Name);
-                Assert.AreEqual(createRoleData.IsNotEditable, roleUpdatedRole.IsNotEditable);
+                Assert.IsTrue(roleUpdatedRole.Name == createRoleData.Name);
+                Assert.IsTrue(roleUpdatedRole.IsNotEditable == createRoleData.IsNotEditable);
             }
             else
             {

MainProject.Tests/Services/UserService_Tests.cs

@@ -36,6 +36,29 @@ public class UserService_Tests
         }
     }
 
+    [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()
     {
@@ -70,8 +93,7 @@ public class UserService_Tests
             {
                 FirstName = expectedUser.FirstName ?? String.Empty,
                 LastName = expectedUser.LastName ?? String.Empty,
-                Email = expectedUser.Email ?? String.Empty,
-                Password = "Password"
+                Email = expectedUser.Email ?? String.Empty
             };
 
             Role role = new()
@@ -84,14 +106,10 @@ public class UserService_Tests
             var user = await _userService.CreateUserAsync(data, role);
             Assert.IsInstanceOfType(user, typeof(User));
             Assert.IsNotNull(user);
-            Assert.AreEqual(expectedUser.FirstName, user.FirstName);
-            Assert.AreEqual(expectedUser.LastName, user.LastName);
-            Assert.AreEqual(expectedUser.Email, user.Email);
-            Assert.AreEqual(expectedUser.Role?.Name, user.Role?.Name);
-            Assert.AreEqual(10, user.PasswordIterations);
-            Assert.IsNotNull(expectedUser.PasswordSalt);
-            Assert.IsNotNull(expectedUser.PasswordPepper);
-            Assert.IsNotNull(expectedUser.Password);
+            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;
 
         }
@@ -102,51 +120,6 @@ public class UserService_Tests
         }
     }
 
-    [TestMethod]
-    public async Task GetUserByUsernameAndPassword_Null()
-    {
-        try
-        {
-            if (_userService != null)
-            {
-                var user = await _userService.GetUserByUsernameAndPassword(_user.Email, "WrongPassword");
-                Assert.IsNull(user);
-            }
-            else
-            {
-                Assert.Fail($"UserService is null");
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex}");
-        }
-    }
-
-    [TestMethod]
-    public async Task GetUserByUsernameAndPassword_Success()
-    {
-        try
-        {
-            var password = "Password";
-            if (_userService != null)
-            {
-                var user = await _userService.GetUserByUsernameAndPassword(_user.Email, password);
-                Assert.IsNotNull(user);
-            }
-            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_Exception()
     {
@@ -158,8 +131,7 @@ public class UserService_Tests
             {
                 FirstName = expectedUser.FirstName ?? String.Empty,
                 LastName = expectedUser.LastName ?? String.Empty,
-                Email = expectedUser.Email ?? String.Empty,
-                Password = expectedUser.Password ?? String.Empty
+                Email = expectedUser.Email ?? String.Empty
             };
 
             Role role = new()
@@ -251,7 +223,7 @@ public class UserService_Tests
             {
                 var user = await _userService.GetUserByIdAsync(_user.Id);
                 Assert.IsNotNull(user);
-                Assert.AreEqual(user.Id, _user?.Id);
+                Assert.IsTrue(user.Id == _user?.Id);
             }
             else
             {
@@ -275,7 +247,7 @@ public class UserService_Tests
             {
                 var user = await _userService.GetUserByGuidAsync(_user.Guid ?? String.Empty);
                 Assert.IsNotNull(user);
-                Assert.AreEqual(user.Guid, _user?.Guid);
+                Assert.IsTrue(user.Guid == _user?.Guid);
             }
             else
             {
@@ -289,186 +261,6 @@ public class UserService_Tests
         }
     }
 
-    [TestMethod]
-    public async Task UpdateUserAsync_Success()
-    {
-        try
-        {
-            UpdateUserRequestData data = new UpdateUserRequestData()
-            {
-                FirstName = "ChangedUserFirstName",
-                LastName = "ChangedUserLastName"
-            };
-
-            if (_userService != null)
-            {
-                Assert.IsNotNull(_user);
-                var user = await _userService.UpdateUserAsync(data, _user!);
-                Assert.IsInstanceOfType(user, typeof(User));
-                Assert.IsNotNull(user);
-                Assert.AreEqual(data.FirstName, user.FirstName);
-                Assert.AreEqual(data.LastName, user.LastName);
-                _user = user;
-            }
-            else
-            {
-                Assert.Fail($"UserService is null");
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex}");
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserAsync_Exception()
-    {
-        try
-        {
-            UpdateUserRequestData data = new UpdateUserRequestData()
-            {
-                FirstName = "ChangedUserFirstName",
-                LastName = "ChangedUserLastName"
-            };
-
-            var exceptionUserService = TestUtils.CreateUserServiceException();
-
-            if (exceptionUserService != null)
-            {
-                Assert.IsNotNull(_user);
-                var user = await exceptionUserService.UpdateUserAsync(data, _user!);
-                Assert.Fail($"Expected exception instead of response: {user?.Guid}");
-
-            }
-            else
-            {
-                Assert.Fail($"UserService is null");
-            }
-        }
-        catch (Exception ex)
-        {
-            Assert.IsInstanceOfType(ex, typeof(Exception));
-        }
-    }
-
-
-    [TestMethod]
-    public async Task UpdateUserPasswordAsync_Success()
-    {
-        try
-        {
-            if (_userService != null)
-            {
-                Assert.IsNotNull(_user);
-                var oldPassword = _user.Password;
-                var user = await _userService.UpdateUserPasswordAsync(_user!, "this-is-a-new-password");
-                Assert.IsInstanceOfType(user, typeof(User));
-                Assert.IsNotNull(user);
-                Assert.AreNotEqual(user.Password, oldPassword);
-            }
-            else
-            {
-                Assert.Fail($"UserService is null");
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine(ex.InnerException);
-            Assert.Fail($"An exception was thrown: {ex}");
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserPasswordAsync_Exception()
-    {
-        try
-        {
-            var exceptionUserService = TestUtils.CreateUserServiceException();
-
-            if (exceptionUserService != null)
-            {
-                Assert.IsNotNull(_user);
-                var user = await exceptionUserService.UpdateUserPasswordAsync(_user!, "this-is-a-new-password");
-                Assert.Fail($"Expected exception instead of response: {user?.Guid}");
-
-            }
-            else
-            {
-                Assert.Fail($"UserService is null");
-            }
-        }
-        catch (Exception ex)
-        {
-            Assert.IsInstanceOfType(ex, typeof(Exception));
-        }
-    }
-
-    [TestMethod]
-    public async Task UpdateUserRoleAsync_Success()
-    {
-        try
-        {
-            if (_userService != null)
-            {
-                Assert.IsNotNull(_user);
-                Role role = new()
-                {
-                    Name = "NewRole",
-                    IsNotEditable = false,
-                    Guid = Guid.NewGuid().ToString()
-                };
-
-                var oldRole = _user.Role;
-                var user = await _userService.UpdateUserRoleAsync(_user!, role);
-                Assert.IsInstanceOfType(user, typeof(User));
-                Assert.IsNotNull(user);
-                Assert.AreNotEqual(user.Role?.Id, oldRole?.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 UpdateUserRoleAsync_Exception()
-    {
-        try
-        {
-            var exceptionUserService = TestUtils.CreateUserServiceException();
-
-            if (exceptionUserService != null)
-            {
-                Assert.IsNotNull(_user);
-                Role role = new()
-                {
-                    Name = "NewRole",
-                    IsNotEditable = false,
-                    Guid = Guid.NewGuid().ToString()
-                };
-                var user = await exceptionUserService.UpdateUserRoleAsync(_user!, role);
-                Assert.Fail($"Expected exception instead of response: {user?.Guid}");
-
-            }
-            else
-            {
-                Assert.Fail($"UserService is null");
-            }
-        }
-        catch (Exception ex)
-        {
-            Assert.IsInstanceOfType(ex, typeof(Exception));
-        }
-    }
-
     [TestMethod]
     public async Task DeleteUser()
     {

MainProject.Tests/TestsUtils/ExceptionSqlServerContext.cs

@@ -21,4 +21,4 @@ public class ExceptionSqlServerContext : SqlServerContext
         }
         return base.SaveChangesAsync(cancellationToken);
     }
-}
+}

MainProject.Tests/TestsUtils/ModelsInit.cs

@@ -13,9 +13,8 @@ public static class ModelsInit
             FirstName = "FirstName",
             LastName = "LastName",
             Email = "test-new@email.it",
-            PasswordPepper = "PasswordPepper",
+            PasswordHash = "PasswordHash",
             PasswordSalt = "PasswordSalt",
-            PasswordIterations = 0,
             Password = "Password",
             Role = CreateRole(),
             IsTestUser = true
@@ -33,4 +32,4 @@ public static class ModelsInit
         };
         return role;
     }
-}
+}

MainProject.Tests/Utils/CryptoUtils_Tests.cs

@@ -102,12 +102,12 @@ public class CryptoUtils_Tests
     }
 
     [TestMethod]
-    public void GeneratePepper()
+    public void GenerateSalt()
     {
         try
         {
-            var salt = CryptUtils.GeneratePepper();
-            Assert.IsFalse(String.IsNullOrEmpty(salt));
+            var salt = CryptUtils.GenerateSalt();
+            Assert.IsTrue(!String.IsNullOrEmpty(salt));
         }
         catch (Exception ex)
         {
@@ -122,14 +122,14 @@ public class CryptoUtils_Tests
         try
         {
             var password = "P4ssw0rd@1!";
-            var pepper = CryptUtils.GeneratePepper();
-            Assert.IsFalse(String.IsNullOrEmpty(pepper));
+            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");
-            var salt = appSettings?.EncryptionSettings?.Salt ?? String.Empty;
-            var encryptedPassword = CryptUtils.GeneratePassword(password, salt, 0, pepper);
-            Assert.AreNotEqual(encryptedPassword, password);
+            CryptUtils cryptoUtils = new CryptUtils(appSettings);
+            var encryptedPassword = cryptoUtils.GeneratePassword(password, salt, 0);
+            Assert.IsTrue(password != encryptedPassword);
         }
         catch (Exception ex)
         {
@@ -147,7 +147,10 @@ public class CryptoUtils_Tests
             var salt = "Afi7PQYgEL2sPbNyVzduvg==";
             var hashedPassword = "2lMeySZ9ciH1KtSg1Z7oSJRmJEjHMeDvdaNRcJcGutM=";
 
-            var verified = CryptUtils.VerifyPassword(hashedPassword, password, salt, 0);
+            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);
             Assert.IsTrue(verified);
         }
         catch (Exception ex)

MainProject.Tests/Utils/FileUtils_Tests.cs

@@ -49,7 +49,7 @@ public class FileUtils_Tests
         try
         {
             PermissionsFile? permissionsFile = FileUtils.ConvertFileToObject<PermissionsFile>(System.AppDomain.CurrentDomain.BaseDirectory + "Config/permissions.json");
-            Assert.IsNotNull(permissionsFile);
+            Assert.IsTrue(permissionsFile != null);
         }
         catch (Exception exception)
         {

MainProject.Tests/Utils/JwtTokenUtils_Tests.cs

@@ -22,7 +22,7 @@ public class JwtTokenUtils_Tests
             AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
             JwtTokenUtils jwtUtils = new JwtTokenUtils(appSettings);
             var jwt = jwtUtils.GenerateToken(_guid);
-            Assert.IsFalse(String.IsNullOrEmpty(jwt));
+            Assert.IsTrue(!String.IsNullOrEmpty(jwt));
         }
         catch (Exception ex)
         {
@@ -41,7 +41,7 @@ public class JwtTokenUtils_Tests
             JwtTokenUtils jwtUtils = new JwtTokenUtils(appSettings);
             var jwt = jwtUtils.GenerateToken(_guid);
             var guid = jwtUtils.ValidateToken($"Bearer {jwt}");
-            Assert.AreEqual(_guid, guid);
+            Assert.IsTrue(_guid == guid);
         }
         catch (Exception ex)
         {

MainProject.Tests/Utils/PasswordUtils_Test.cs

@@ -1,62 +0,0 @@
-using BasicDotnetTemplate.MainProject.Utils;
-using BasicDotnetTemplate.MainProject.Models.Common;
-using BasicDotnetTemplate.MainProject.Enum;
-
-
-namespace BasicDotnetTemplate.MainProject.Tests;
-
-[TestClass]
-public class PasswordUtils_Test
-{
-    [TestMethod]
-    public void PasswordValidation_Valid()
-    {
-        try
-        {
-            List<string> errors = PasswordUtils.ValidatePassword("#aBcDeFgHi01245#");
-            Assert.IsTrue(errors == null || errors.Count == 0);
-        }
-        catch (Exception exception)
-        {
-            Assert.Fail($"An exception was thrown: {exception}");
-        }
-    }
-
-    [TestMethod]
-    public void PasswordValidation_Invalid()
-    {
-        try
-        {
-            List<string> errors = PasswordUtils.ValidatePassword("aAa1#");
-            Assert.IsTrue(errors.Contains(PasswordValidationEnum.MIN_LENGTH));
-            Assert.IsTrue(errors.Contains(PasswordValidationEnum.MIN_UPPER));
-            Assert.IsTrue(errors.Contains(PasswordValidationEnum.MIN_NUMBER));
-            Assert.IsTrue(errors.Contains(PasswordValidationEnum.MIN_SPECIAL));
-            Assert.IsTrue(errors.Contains(PasswordValidationEnum.IDENTICAL_CHARS));
-            Assert.IsFalse(errors.Contains(PasswordValidationEnum.MIN_LOWER));
-        }
-        catch (Exception exception)
-        {
-            Assert.Fail($"An exception was thrown: {exception}");
-        }
-    }
-
-    [TestMethod]
-    public void PasswordValidation_ToLowerInvalid()
-    {
-        try
-        {
-            List<string> errors = PasswordUtils.ValidatePassword("AaBC0*TGH1#");
-            Assert.IsTrue(errors.Contains(PasswordValidationEnum.MIN_LOWER));
-        }
-        catch (Exception exception)
-        {
-            Assert.Fail($"An exception was thrown: {exception}");
-        }
-    }
-
-}
-
-
-
-

MainProject.Tests/Utils/ProgramUtils_Tests.cs

@@ -92,7 +92,7 @@ public class ProgramUtils_Tests
 
             AppSettings appSettings = new AppSettings();
             OpenApiInfo realOpenApiInfo = ProgramUtils.CreateOpenApiInfo(appSettings);
-            Assert.IsNotNull(realOpenApiInfo);
+            Assert.IsTrue(realOpenApiInfo != null);
         }
         catch (Exception ex)
         {
@@ -118,10 +118,10 @@ public class ProgramUtils_Tests
                 OpenApiSettings = null
             };
             OpenApiInfo realOpenApiInfo = ProgramUtils.CreateOpenApiInfo(appSettings);
-            Assert.IsNotNull(realOpenApiInfo);
-            Assert.AreEqual(appSettings.Settings.Name, realOpenApiInfo.Title);
-            Assert.AreEqual(appSettings.Settings.Description, realOpenApiInfo.Description);
-            Assert.AreEqual(appSettings.Settings.Version, realOpenApiInfo.Version);
+            Assert.IsTrue(realOpenApiInfo != null);
+            Assert.IsTrue(realOpenApiInfo.Title == appSettings.Settings.Name);
+            Assert.IsTrue(realOpenApiInfo.Description == appSettings.Settings.Description);
+            Assert.IsTrue(realOpenApiInfo.Version == appSettings.Settings.Version);
         }
         catch (Exception ex)
         {
@@ -151,11 +151,11 @@ public class ProgramUtils_Tests
                 }
             };
             OpenApiInfo realOpenApiInfo = ProgramUtils.CreateOpenApiInfo(appSettings);
-            Assert.IsNotNull(realOpenApiInfo);
-            Assert.AreEqual(appSettings.Settings.Name, realOpenApiInfo.Title);
-            Assert.AreEqual(appSettings.Settings.Description, realOpenApiInfo.Description);
-            Assert.AreEqual(appSettings.Settings.Version, realOpenApiInfo.Version);
-            Assert.IsNull(realOpenApiInfo.TermsOfService);
+            Assert.IsTrue(realOpenApiInfo != null);
+            Assert.IsTrue(realOpenApiInfo.Title == appSettings.Settings.Name);
+            Assert.IsTrue(realOpenApiInfo.Description == appSettings.Settings.Description);
+            Assert.IsTrue(realOpenApiInfo.Version == appSettings.Settings.Version);
+            Assert.IsTrue(realOpenApiInfo.TermsOfService == null);
         }
         catch (Exception ex)
         {

MainProject/Controllers/AuthController.cs

@@ -6,7 +6,6 @@ using BasicDotnetTemplate.MainProject.Models.Api.Request.Auth;
 using BasicDotnetTemplate.MainProject.Models.Api.Response;
 using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
 using BasicDotnetTemplate.MainProject.Services;
-using BasicDotnetTemplate.MainProject.Core.Filters;
 
 namespace BasicDotnetTemplate.MainProject.Controllers
 {
@@ -22,17 +21,30 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             this._authService = authService;
         }
 
-        [ModelStateValidationHandledByFilterAttribute]
         [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) //NOSONAR
+        public async Task<IActionResult> AuthenticateAsync([FromBody] AuthenticateRequest request)
         {
             try
             {
-                var data = await this._authService.AuthenticateAsync(request!.Data!);
+                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)
                 {
@@ -43,9 +55,14 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             }
             catch (Exception exception)
             {
-                return InternalServerError(exception);
+                var message = this._somethingWentWrong;
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
             }
 
         }
     }
-}
+}

MainProject/Controllers/BaseController.cs

@@ -12,6 +12,7 @@ namespace BasicDotnetTemplate.MainProject.Controllers
         protected readonly IMapper? _mapper;
         protected readonly IConfiguration _configuration;
         protected readonly AppSettings _appSettings;
+        protected readonly string _requestNotWellFormed = "Request is not well formed";
         protected readonly string _somethingWentWrong = "Something went wrong";
 
         protected BaseController(
@@ -66,16 +67,12 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             return StatusCode((int)HttpStatusCode.BadRequest, CreateResponse(HttpStatusCode.BadRequest, message, data));
         }
 
-        protected IActionResult InternalServerError(Exception exception)
+        protected IActionResult InternalServerError(string message)
         {
-            var message = this._somethingWentWrong;
-            if (!String.IsNullOrEmpty(exception.Message))
-            {
-                message += $". {exception.Message}";
-            }
+            message = String.IsNullOrEmpty(message) ? "Internal server error" : message;
             return StatusCode((int)HttpStatusCode.InternalServerError, CreateResponse(HttpStatusCode.InternalServerError, message, new object()));
         }
 
 #nullable disable
     }
-}
+}

MainProject/Controllers/RoleController.cs

@@ -7,7 +7,6 @@ using BasicDotnetTemplate.MainProject.Models.Api.Response;
 using BasicDotnetTemplate.MainProject.Models.Api.Response.Role;
 using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
 using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
-using BasicDotnetTemplate.MainProject.Core.Filters;
 
 namespace BasicDotnetTemplate.MainProject.Controllers
 {
@@ -24,7 +23,6 @@ namespace BasicDotnetTemplate.MainProject.Controllers
         }
 
         [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
         [HttpGet("get/{guid}")]
         [ProducesResponseType<GetRoleResponse>(StatusCodes.Status200OK)]
         [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status404NotFound)]
@@ -34,6 +32,15 @@ namespace BasicDotnetTemplate.MainProject.Controllers
         {
             try
             {
+                if (!ModelState.IsValid)
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+
+                if (String.IsNullOrEmpty(guid))
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
                 var role = await this._roleService.GetRoleByGuidAsync(guid);
 
                 if (role == null || String.IsNullOrEmpty(role.Guid))
@@ -47,24 +54,39 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             }
             catch (Exception exception)
             {
-                return InternalServerError(exception);
+                var message = this._somethingWentWrong;
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
             }
 
         }
 
         [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
         [HttpPost("create")]
         [ProducesResponseType<GetRoleResponse>(StatusCodes.Status201Created)]
         [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
         [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> CreateRoleAsync([FromBody] CreateRoleRequest request) //NOSONAR
+        public async Task<IActionResult> CreateRoleAsync([FromBody] CreateRoleRequest request)
         {
             try
             {
-                if (await this._roleService.CheckIfNameIsValid(request!.Data!.Name))
+                if (!ModelState.IsValid)
                 {
-                    var role = await this._roleService.CreateRoleAsync(request!.Data);
+                    return BadRequest(_requestNotWellFormed);
+                }
+
+                if (request == null || request.Data == null || String.IsNullOrEmpty(request.Data.Name)
+                )
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+
+                if (await this._roleService.CheckIfNameIsValid(request.Data.Name))
+                {
+                    var role = await this._roleService.CreateRoleAsync(request.Data);
 
                     if (role == null || String.IsNullOrEmpty(role.Guid))
                     {
@@ -83,21 +105,40 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             }
             catch (Exception exception)
             {
-                return InternalServerError(exception);
+                var message = this._somethingWentWrong;
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
             }
 
         }
 
         [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
         [HttpPut("update/{guid}")]
-        [ProducesResponseType<GetRoleResponse>(StatusCodes.Status200OK)]
+        [ProducesResponseType<GetRoleResponse>(StatusCodes.Status201Created)]
         [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
         [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> UpdateRoleAsync([FromBody] CreateRoleRequest request, string guid) //NOSONAR
+        public async Task<IActionResult> UpdateRoleAsync([FromBody] CreateRoleRequest request, string guid)
         {
             try
             {
+                if (!ModelState.IsValid)
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+
+                if (
+                    request == null ||
+                    request.Data == null ||
+                    String.IsNullOrEmpty(request.Data.Name) ||
+                    String.IsNullOrEmpty(guid)
+                )
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+
                 var role = await this._roleService.GetRoleByGuidAsync(guid);
 
                 if (role == null || String.IsNullOrEmpty(role.Guid))
@@ -111,8 +152,8 @@ namespace BasicDotnetTemplate.MainProject.Controllers
                 }
 
                 if (
-                    await this._roleService.CheckIfNameIsValid(request!.Data!.Name) ||
-                    await this._roleService.CheckIfNameIsValid(request!.Data!.Name, guid)
+                    await this._roleService.CheckIfNameIsValid(request.Data.Name) ||
+                    await this._roleService.CheckIfNameIsValid(request.Data.Name, guid)
                 )
                 {
                     role = await this._roleService.UpdateRoleAsync(request.Data, role);
@@ -129,13 +170,17 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             }
             catch (Exception exception)
             {
-                return InternalServerError(exception);
+                var message = this._somethingWentWrong;
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
             }
 
         }
 
         [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
         [HttpDelete("{guid}")]
         [ProducesResponseType<GetRoleResponse>(StatusCodes.Status200OK)]
         [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status404NotFound)]
@@ -145,6 +190,15 @@ namespace BasicDotnetTemplate.MainProject.Controllers
         {
             try
             {
+                if (!ModelState.IsValid)
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
+
+                if (String.IsNullOrEmpty(guid))
+                {
+                    return BadRequest(_requestNotWellFormed);
+                }
                 var role = await this._roleService.GetRoleByGuidAsync(guid);
 
                 if (role == null || String.IsNullOrEmpty(role.Guid))
@@ -158,11 +212,16 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             }
             catch (Exception exception)
             {
-                return InternalServerError(exception);
+                var message = this._somethingWentWrong;
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
             }
 
         }
 
 
     }
-}
+}

MainProject/Controllers/RootController.cs

@@ -15,4 +15,4 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             return Ok();
         }
     }
-}
+}

MainProject/Controllers/UserController.cs

@@ -7,7 +7,6 @@ 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;
-using BasicDotnetTemplate.MainProject.Core.Filters;
 
 namespace BasicDotnetTemplate.MainProject.Controllers
 {
@@ -26,9 +25,7 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             this._roleService = roleService;
         }
 
-
         [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
         [HttpGet("get/{guid}")]
         [ProducesResponseType<GetUserResponse>(StatusCodes.Status200OK)]
         [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status404NotFound)]
@@ -38,6 +35,15 @@ namespace BasicDotnetTemplate.MainProject.Controllers
         {
             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))
@@ -51,30 +57,49 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             }
             catch (Exception exception)
             {
-                return InternalServerError(exception);
+                var message = this._somethingWentWrong;
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
             }
 
         }
 
         [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
         [HttpPost("create")]
         [ProducesResponseType<GetUserResponse>(StatusCodes.Status201Created)]
         [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
         [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> CreateUserAsync([FromBody] CreateUserRequest request) //NOSONAR
+        public async Task<IActionResult> CreateUserAsync([FromBody] CreateUserRequest request)
         {
             try
             {
-                if (await this._userService.CheckIfEmailIsValid(request!.Data!.Email))
+                if (!ModelState.IsValid)
                 {
-                    var role = await this._roleService.GetRoleForUser(request!.Data!.RoleGuid);
+                    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);
+                    var user = await this._userService.CreateUserAsync(request.Data, role);
 
                     if (user == null || String.IsNullOrEmpty(user.Guid))
                     {
@@ -93,135 +118,17 @@ namespace BasicDotnetTemplate.MainProject.Controllers
             }
             catch (Exception exception)
             {
-                return InternalServerError(exception);
+                var message = this._somethingWentWrong;
+                if (!String.IsNullOrEmpty(exception.Message))
+                {
+                    message += $". {exception.Message}";
+                }
+                return InternalServerError(message);
             }
 
         }
 
-        [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
-        [HttpPut("update/{guid}")]
-        [ProducesResponseType<GetUserResponse>(StatusCodes.Status200OK)]
-        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> UpdateUserAsync([FromBody] UpdateUserRequest request, string guid) //NOSONAR
-        {
-            try
-            {
-                var user = await this._userService.GetUserByGuidAsync(guid);
-                if (user == null)
-                {
-                    return NotFound();
-                }
 
-                user = await this._userService.UpdateUserAsync(request!.Data!, user);
-
-                var userDto = _mapper?.Map<UserDto>(user);
-
-                return Success(String.Empty, userDto);
-
-            }
-            catch (Exception exception)
-            {
-                return InternalServerError(exception);
-            }
-
-        }
-
-        [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
-        [HttpPut("update/{guid}/password")]
-        [ProducesResponseType<GetUserResponse>(StatusCodes.Status200OK)]
-        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> UpdateUserPasswordAsync(string guid, string newPassword)
-        {
-            try
-            {
-                var user = await this._userService.GetUserByGuidAsync(guid);
-                if (user == null)
-                {
-                    return NotFound();
-                }
-
-                user = await this._userService.UpdateUserPasswordAsync(user, newPassword);
-
-                var userDto = _mapper?.Map<UserDto>(user);
-
-                return Success(String.Empty, userDto);
-
-            }
-            catch (Exception exception)
-            {
-                return InternalServerError(exception);
-            }
-
-        }
-
-        [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
-        [HttpPut("update/{guid}/role")]
-        [ProducesResponseType<GetUserResponse>(StatusCodes.Status200OK)]
-        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> UpdateUserRoleAsync(string guid, string roleGuid)
-        {
-            try
-            {
-                var role = await this._roleService.GetRoleByGuidAsync(roleGuid);
-                if (role == null)
-                {
-                    return BadRequest("Role not found");
-                }
-
-                var user = await this._userService.GetUserByGuidAsync(guid);
-                if (user == null)
-                {
-                    return NotFound();
-                }
-
-                user = await this._userService.UpdateUserRoleAsync(user, role);
-
-                var userDto = _mapper?.Map<UserDto>(user);
-
-                return Success(String.Empty, userDto);
-
-            }
-            catch (Exception exception)
-            {
-                return InternalServerError(exception);
-            }
-
-        }
-
-        [JwtAuthorization()]
-        [ModelStateValidationHandledByFilterAttribute]
-        [HttpDelete("{guid}")]
-        [ProducesResponseType<GetUserResponse>(StatusCodes.Status200OK)]
-        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status404NotFound)]
-        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType<BaseResponse<object>>(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> DeleteUserByGuidAsync(string guid)
-        {
-            try
-            {
-                var user = await this._userService.GetUserByGuidAsync(guid);
-
-                if (user == null || String.IsNullOrEmpty(user.Guid))
-                {
-                    return NotFound();
-                }
-
-                await this._userService.DeleteUserAsync(user);
-
-                return Success(String.Empty);
-            }
-            catch (Exception exception)
-            {
-                return InternalServerError(exception);
-            }
-
-        }
 
     }
-}
+}

MainProject/Controllers/VersionController.cs

@@ -11,6 +11,9 @@ namespace BasicDotnetTemplate.MainProject.Controllers
         ) : base(configuration) { }
 
         [HttpGet("get")]
-        public IActionResult GetVersion() => Success(String.Empty, _appSettings?.Settings?.Version);
+        public IActionResult GetVersion()
+        {
+            return Success(String.Empty, _appSettings?.Settings?.Version);
+        }
     }
-}
+}

MainProject/Core/Attributes/ValidateModelStateAutomaticallyAttribute.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace BasicDotnetTemplate.MainProject.Core.Attributes
-{
-    /// <summary>
-    /// Indicates that ModelState validation is handled automatically by an Action Filter.
-    /// Used to suppress SonarCloud warnings about missing ModelState.IsValid checks.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
-    public class ModelStateValidationHandledByFilterAttribute : Attribute
-    { }
-}

MainProject/Core/Database/SqlServerContext.cs

@@ -18,7 +18,7 @@ namespace BasicDotnetTemplate.MainProject.Core.Database
         public DbSet<PermissionOperation> PermissionOperations { get; set; }
         public DbSet<PermissionSystem> PermissionSystems { get; set; }
         public DbSet<PermissionSystemModule> PermissionSystemModules { get; set; }
-        public DbSet<PermissionSystemModuleOperation> PermissionSystemModuleOperations { get; set; }
+        public DbSet<PermissionSystemModuleOperation> PermissionSystemModuleOperations { get; set; }        
         public DbSet<RolePermissionSystemModuleOperation> RolePermissionSystemModuleOperations { get; set; }
         public DbSet<Role> Roles { get; set; }
         public DbSet<User> Users { get; set; }

MainProject/Core/Filters/ValidationActionFilter.cs

@@ -1,43 +0,0 @@
-using BasicDotnetTemplate.MainProject.Models.Api.Base;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.Filters;
-using System.Threading.Tasks;
-
-namespace BasicDotnetTemplate.MainProject.Core.Filters
-{
-    public class ValidationActionFilter : IAsyncActionFilter
-    {
-        private readonly string _requestNotWellFormedMessage = "Request is not well formed";
-
-        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
-        {
-            if (!context.ModelState.IsValid)
-            {
-                context.Result = new BadRequestObjectResult(new ValidationError
-                {
-                    Message = _requestNotWellFormedMessage,
-                    Errors = context.ModelState.Where(m =>
-                        m.Value != null && m.Value.Errors.Any())
-                        .ToDictionary(
-                            m => m.Key,
-                            m => m.Value!.Errors.Select(e => e.ErrorMessage).ToList()
-                        )
-                });
-                return;
-            }
-
-            var requestBody = context.ActionArguments.Values.FirstOrDefault(arg => arg != null && !arg.GetType().IsPrimitive && arg is not string);
-
-            if (requestBody == null)
-            {
-                context.Result = new BadRequestObjectResult(new ValidationError
-                {
-                    Message = _requestNotWellFormedMessage
-                });
-                return;
-            }
-
-            await next();
-        }
-    }
-}

MainProject/Enum/PasswordValidationEnum.cs

@@ -1,10 +0,0 @@
-namespace BasicDotnetTemplate.MainProject.Enum;
-public static class PasswordValidationEnum
-{
-    public const string MIN_LENGTH = "Password must be at least 8 characters long";
-    public const string MIN_UPPER = "Password must have at least 2 uppercase letters";
-    public const string MIN_LOWER = "Password must have at least 2 lowercase letters";
-    public const string MIN_NUMBER = "Password must be at least 2 numbers";
-    public const string MIN_SPECIAL = "Password must be at least 2 special characters";
-    public const string IDENTICAL_CHARS = "Password cannot have 3 or more consecutive identical characters";
-}

MainProject/MainProject.csproj

@@ -15,36 +15,36 @@
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.AspNetCore" Version="2.3.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.17" />
-    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.17" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.6" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="9.0.6" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.6">
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.16" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.16" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="9.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.5">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.6" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.6" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.6">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.5">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.6" />
-    <PackageReference Include="Microsoft.Identity.Web" Version="3.9.3" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.5" />
+    <PackageReference Include="Microsoft.Identity.Web" Version="3.9.2" />
     <PackageReference Include="MongoDB.Driver" Version="3.4.0" />
     <PackageReference Include="MongoDB.EntityFrameworkCore" Version="9.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="NLog" Version="5.5.0" />
-    <PackageReference Include="NLog.Extensions.Logging" Version="5.5.0" />
+    <PackageReference Include="NLog" Version="5.4.0" />
+    <PackageReference Include="NLog.Extensions.Logging" Version="5.4.0" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="9.0.1" />
-    <PackageReference Include="Swashbuckle.AspNetCore.Annotations" Version="9.0.1" />
-    <PackageReference Include="Swashbuckle.AspNetCore.Filters" Version="9.0.0" />
-    <PackageReference Include="Swashbuckle.AspNetCore.Filters.Abstractions" Version="9.0.0" />
-    <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" Version="9.0.1" />
-    <PackageReference Include="Swashbuckle.AspNetCore.Swagger" Version="9.0.1" />
-    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="9.0.1" />
-    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="9.0.1" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="8.1.2" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Annotations" Version="8.1.2" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Filters" Version="8.0.3" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Filters.Abstractions" Version="8.0.3" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" Version="8.1.2" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Swagger" Version="8.1.2" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="8.1.2" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="8.1.2" />
   </ItemGroup>
 
 </Project>

MainProject/Migrations/20240904211920_InitialCreate.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable

MainProject/Migrations/20241129231345_Try.cs

@@ -1,4 +1,4 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable
 

MainProject/Migrations/20250311195750_AlterTableUser.cs

@@ -1,4 +1,4 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable
 

MainProject/Migrations/20250312234517_AlterTableUserMaxLengthIndexes.cs

@@ -1,4 +1,4 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable
 

MainProject/Migrations/20250316014620_AlterTablesUsersAndRoles.cs

@@ -1,4 +1,4 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable
 

MainProject/Migrations/20250316212343_AlterBaseUpdateTimeDeletionTimeNullable.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable

MainProject/Migrations/20250316212722_AlterTableRoleAddedIsNotEditable.cs

@@ -1,4 +1,4 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable
 

MainProject/Migrations/20250426183010_AddingPermissionsTables.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable

MainProject/Migrations/20250617183212_AlterTableUsersForPasswordEncryption.Designer.cs

@@ -1,542 +0,0 @@
-// <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("20250617183212_AlterTableUsersForPasswordEncryption")]
-    partial class AlterTableUsersForPasswordEncryption
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasAnnotation("ProductVersion", "9.0.5")
-                .HasAnnotation("Relational:MaxIdentifierLength", 128);
-
-            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
-
-            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionModule", 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<bool>("Enabled")
-                        .HasColumnType("bit");
-
-                    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[] { "Enabled" }, "IX_Enabled")
-                        .HasFilter("[Enabled] = 1");
-
-                    b.HasIndex(new[] { "IsDeleted" }, "IX_IsDeleted")
-                        .HasFilter("[IsDeleted] = 0");
-
-                    b.HasIndex(new[] { "IsDeleted", "Name", "Enabled" }, "IX_IsDeleted_Name_Enabled")
-                        .HasFilter("[IsDeleted] = 0");
-
-                    b.ToTable("PermissionModules");
-                });
-
-            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionOperation", 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", "Name" }, "IX_IsDeleted_Name");
-
-                    b.ToTable("PermissionOperations");
-                });
-
-            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionSystem", 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<bool>("Enabled")
-                        .HasColumnType("bit");
-
-                    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[] { "Enabled" }, "IX_Enabled")
-                        .HasFilter("[Enabled] = 1");
-
-                    b.HasIndex(new[] { "IsDeleted" }, "IX_IsDeleted")
-                        .HasFilter("[IsDeleted] = 0");
-
-                    b.HasIndex(new[] { "IsDeleted", "Name", "Enabled" }, "IX_IsDeleted_Name_Enabled")
-                        .HasFilter("[IsDeleted] = 0");
-
-                    b.ToTable("PermissionSystems");
-                });
-
-            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionSystemModule", 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<bool>("Enabled")
-                        .HasColumnType("bit");
-
-                    b.Property<string>("Guid")
-                        .IsRequired()
-                        .HasMaxLength(45)
-                        .HasColumnType("nvarchar(45)");
-
-                    b.Property<bool>("IsDeleted")
-                        .HasColumnType("bit");
-
-                    b.Property<int>("PermissionModuleId")
-                        .HasColumnType("int");
-
-                    b.Property<int>("PermissionSystemId")
-                        .HasColumnType("int");
-
-                    b.Property<DateTime?>("UpdateTime")
-                        .HasColumnType("datetime2");
-
-                    b.Property<int?>("UpdateUserId")
-                        .HasColumnType("int");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("PermissionModuleId");
-
-                    b.HasIndex("PermissionSystemId");
-
-                    b.ToTable("PermissionSystemModules");
-                });
-
-            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionSystemModuleOperation", 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<bool>("Enabled")
-                        .HasColumnType("bit");
-
-                    b.Property<string>("Guid")
-                        .IsRequired()
-                        .HasMaxLength(45)
-                        .HasColumnType("nvarchar(45)");
-
-                    b.Property<bool>("IsDeleted")
-                        .HasColumnType("bit");
-
-                    b.Property<int>("PermissionOperationId")
-                        .HasColumnType("int");
-
-                    b.Property<int>("PermissionSystemModuleId")
-                        .HasColumnType("int");
-
-                    b.Property<DateTime?>("UpdateTime")
-                        .HasColumnType("datetime2");
-
-                    b.Property<int?>("UpdateUserId")
-                        .HasColumnType("int");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("PermissionOperationId");
-
-                    b.HasIndex("PermissionSystemModuleId");
-
-                    b.HasIndex(new[] { "IsDeleted", "Enabled", "Guid" }, "IX_IsDeleted_Enabled_Guid");
-
-                    b.ToTable("PermissionSystemModuleOperations");
-                });
-
-            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.RolePermissionSystemModuleOperation", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("int");
-
-                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
-
-                    b.Property<bool>("Active")
-                        .HasColumnType("bit");
-
-                    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<int>("PermissionSystemModuleOperationId")
-                        .HasColumnType("int");
-
-                    b.Property<int>("RoleId")
-                        .HasColumnType("int");
-
-                    b.Property<DateTime?>("UpdateTime")
-                        .HasColumnType("datetime2");
-
-                    b.Property<int?>("UpdateUserId")
-                        .HasColumnType("int");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("PermissionSystemModuleOperationId");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("RolePermissionSystemModuleOperations");
-                });
-
-            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")
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<int>("PasswordIterations")
-                        .HasColumnType("int");
-
-                    b.Property<string>("PasswordPepper")
-                        .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.PermissionSystemModule", b =>
-                {
-                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionModule", "PermissionModule")
-                        .WithMany()
-                        .HasForeignKey("PermissionModuleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionSystem", "PermissionSystem")
-                        .WithMany()
-                        .HasForeignKey("PermissionSystemId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("PermissionModule");
-
-                    b.Navigation("PermissionSystem");
-                });
-
-            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionSystemModuleOperation", b =>
-                {
-                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionOperation", "PermissionOperation")
-                        .WithMany()
-                        .HasForeignKey("PermissionOperationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionSystemModule", "PermissionSystemModule")
-                        .WithMany()
-                        .HasForeignKey("PermissionSystemModuleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("PermissionOperation");
-
-                    b.Navigation("PermissionSystemModule");
-                });
-
-            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.RolePermissionSystemModuleOperation", b =>
-                {
-                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.PermissionSystemModuleOperation", "PermissionSystemModuleOperation")
-                        .WithMany()
-                        .HasForeignKey("PermissionSystemModuleOperationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", "Role")
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("PermissionSystemModuleOperation");
-
-                    b.Navigation("Role");
-                });
-
-            modelBuilder.Entity("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.User", b =>
-                {
-                    b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", "Role")
-                        .WithMany()
-                        .HasForeignKey("RoleId");
-
-                    b.Navigation("Role");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

MainProject/Migrations/20250617183212_AlterTableUsersForPasswordEncryption.cs

@@ -1,109 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace MainProject.Migrations
-{
-    /// <inheritdoc />
-    public partial class AlterTableUsersForPasswordEncryption : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropForeignKey(
-                name: "FK_Users_Roles_RoleId",
-                table: "Users");
-
-            migrationBuilder.DropColumn(
-                name: "PasswordHash",
-                table: "Users");
-
-            migrationBuilder.AlterColumn<int>(
-                name: "RoleId",
-                table: "Users",
-                type: "int",
-                nullable: true,
-                oldClrType: typeof(int),
-                oldType: "int");
-
-            migrationBuilder.AlterColumn<string>(
-                name: "Password",
-                table: "Users",
-                type: "nvarchar(max)",
-                nullable: true,
-                oldClrType: typeof(string),
-                oldType: "nvarchar(max)");
-
-            migrationBuilder.AddColumn<int>(
-                name: "PasswordIterations",
-                table: "Users",
-                type: "int",
-                nullable: false,
-                defaultValue: 0);
-
-            migrationBuilder.AddColumn<string>(
-                name: "PasswordPepper",
-                table: "Users",
-                type: "nvarchar(max)",
-                nullable: true);
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_Users_Roles_RoleId",
-                table: "Users",
-                column: "RoleId",
-                principalTable: "Roles",
-                principalColumn: "Id");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropForeignKey(
-                name: "FK_Users_Roles_RoleId",
-                table: "Users");
-
-            migrationBuilder.DropColumn(
-                name: "PasswordIterations",
-                table: "Users");
-
-            migrationBuilder.DropColumn(
-                name: "PasswordPepper",
-                table: "Users");
-
-            migrationBuilder.AlterColumn<int>(
-                name: "RoleId",
-                table: "Users",
-                type: "int",
-                nullable: false,
-                defaultValue: 0,
-                oldClrType: typeof(int),
-                oldType: "int",
-                oldNullable: true);
-
-            migrationBuilder.AlterColumn<string>(
-                name: "Password",
-                table: "Users",
-                type: "nvarchar(max)",
-                nullable: false,
-                defaultValue: "",
-                oldClrType: typeof(string),
-                oldType: "nvarchar(max)",
-                oldNullable: true);
-
-            migrationBuilder.AddColumn<string>(
-                name: "PasswordHash",
-                table: "Users",
-                type: "nvarchar(max)",
-                nullable: false,
-                defaultValue: "");
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_Users_Roles_RoleId",
-                table: "Users",
-                column: "RoleId",
-                principalTable: "Roles",
-                principalColumn: "Id",
-                onDelete: ReferentialAction.Cascade);
-        }
-    }
-}

MainProject/Migrations/SqlServerContextModelSnapshot.cs

@@ -17,7 +17,7 @@ namespace MainProject.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("ProductVersion", "9.0.2")
                 .HasAnnotation("Relational:MaxIdentifierLength", 128);
 
             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
@@ -435,19 +435,18 @@ namespace MainProject.Migrations
                         .HasColumnType("nvarchar(200)");
 
                     b.Property<string>("Password")
+                        .IsRequired()
                         .HasColumnType("nvarchar(max)");
 
-                    b.Property<int>("PasswordIterations")
-                        .HasColumnType("int");
-
-                    b.Property<string>("PasswordPepper")
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
                         .HasColumnType("nvarchar(max)");
 
                     b.Property<string>("PasswordSalt")
                         .IsRequired()
                         .HasColumnType("nvarchar(max)");
 
-                    b.Property<int?>("RoleId")
+                    b.Property<int>("RoleId")
                         .HasColumnType("int");
 
                     b.Property<DateTime?>("UpdateTime")
@@ -529,7 +528,9 @@ namespace MainProject.Migrations
                 {
                     b.HasOne("BasicDotnetTemplate.MainProject.Models.Database.SqlServer.Role", "Role")
                         .WithMany()
-                        .HasForeignKey("RoleId");
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
 
                     b.Navigation("Role");
                 });

MainProject/Models/Api/Base/ValidationError.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace BasicDotnetTemplate.MainProject.Models.Api.Base;
-
-public class ValidationError
-{
-    public string? Message { get; set; }
-    public Dictionary<string, List<string>>? Errors { get; set; }
-}

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

@@ -9,7 +9,7 @@ public class UserRole
     public string? Name { get; set; }
 #nullable disable
 
-    public UserRole() { }
+    public UserRole() {}
 
     public UserRole(DatabaseSqlServer.Role role)
     {

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

@@ -19,7 +19,7 @@ public class AuthenticatedUser
         FirstName = user.FirstName;
         LastName = user.LastName;
         Email = user.Email;
-        Role = new UserRole(user.Role!);
+        Role = new UserRole();
     }
 }
 

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

@@ -1,13 +1,11 @@
-using System.ComponentModel.DataAnnotations;
-
 namespace BasicDotnetTemplate.MainProject.Models.Api.Data.Auth;
 
 public class AuthenticateRequestData
 {
-    [Required(ErrorMessage = "Email is required")]
-    public required string Email { get; set; }
-    [Required(ErrorMessage = "Password is required")]
-    public required string Password { get; set; }
+#nullable enable
+    public string? Email { get; set; }
+    public string? Password { get; set; }
+#nullable disable
 }
 
 

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

@@ -1,11 +1,8 @@
-using System.ComponentModel.DataAnnotations;
-
 namespace BasicDotnetTemplate.MainProject.Models.Api.Data.Role;
 
 public class CreateRoleRequestData
 {
-    [Required(ErrorMessage = "Name is required")]
-    public required string Name { get; set; }
+    public string Name { get; set; } = String.Empty;
     public required bool IsNotEditable { get; set; }
 
-}
+}

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

@@ -1,16 +1,11 @@
-using System.ComponentModel.DataAnnotations;
-
 namespace BasicDotnetTemplate.MainProject.Models.Api.Data.User;
 
-public class CreateUserRequestData : UpdateUserRequestData
+public class CreateUserRequestData
 {
-    [Required(ErrorMessage = "Email is required")]
-    [StringLength(200, ErrorMessage = "Email's maxLength: 200")]
-    public required string Email { get; set; }
-
-    [Required(ErrorMessage = "Password is required")]
-    public required string Password { get; set; }
-
+    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/Data/User/UpdateUserRequestData.cs

@@ -1,19 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace BasicDotnetTemplate.MainProject.Models.Api.Data.User;
-
-public class UpdateUserRequestData
-{
-    [Required(ErrorMessage = "FirstName is required")]
-    [StringLength(200, ErrorMessage = "FirstName's maxLength: 200")]
-    public required string FirstName { get; set; }
-
-    [Required(ErrorMessage = "LastName is required")]
-    [StringLength(200, ErrorMessage = "LastName's maxLength: 200")]
-    public required string LastName { get; set; }
-
-}
-
-
-
-

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

@@ -1,12 +1,12 @@
-using System.ComponentModel.DataAnnotations;
 using BasicDotnetTemplate.MainProject.Models.Api.Data.Auth;
 
 namespace BasicDotnetTemplate.MainProject.Models.Api.Request.Auth;
 
 public class AuthenticateRequest
 {
-    [Required(ErrorMessage = "Data is required")]
-    public required AuthenticateRequestData Data { get; set; }
+#nullable enable
+    public AuthenticateRequestData? Data { get; set; }
+#nullable disable
 }
 
 

MainProject/Models/Api/Request/Role/CreateRoleRequest.cs

@@ -1,10 +1,10 @@
-using System.ComponentModel.DataAnnotations;
 using BasicDotnetTemplate.MainProject.Models.Api.Data.Role;
 
 namespace BasicDotnetTemplate.MainProject.Models.Api.Request.Role;
 
 public class CreateRoleRequest
 {
-    [Required(ErrorMessage = "Data is required")]
-    public required CreateRoleRequestData? Data { get; set; }
-}
+#nullable enable
+    public CreateRoleRequestData? Data { get; set; }
+#nullable disable
+}

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

@@ -1,12 +1,12 @@
-using System.ComponentModel.DataAnnotations;
 using BasicDotnetTemplate.MainProject.Models.Api.Data.User;
 
 namespace BasicDotnetTemplate.MainProject.Models.Api.Request.User;
 
 public class CreateUserRequest
 {
-    [Required(ErrorMessage = "Data is required")]
-    public required CreateUserRequestData Data { get; set; }
+#nullable enable
+    public CreateUserRequestData? Data { get; set; }
+#nullable disable
 }
 
 

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

@@ -1,14 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using BasicDotnetTemplate.MainProject.Models.Api.Data.User;
-
-namespace BasicDotnetTemplate.MainProject.Models.Api.Request.User;
-
-public class UpdateUserRequest
-{
-    [Required(ErrorMessage = "Data is required")]
-    public required UpdateUserRequestData Data { get; set; }
-}
-
-
-
-

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

@@ -5,4 +5,4 @@ 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

@@ -16,4 +16,4 @@ public class BaseResponse<T>
 
     public virtual dynamic? Data { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Api/Response/Role/GetRoleResponse.cs

@@ -5,4 +5,4 @@ namespace BasicDotnetTemplate.MainProject.Models.Api.Response.Role;
 public class GetRoleResponse : BaseResponse<RoleDto>
 {
     public GetRoleResponse(int status, string? message, RoleDto? data) : base(status, message, data) { }
-}
+}

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

@@ -5,4 +5,4 @@ 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/Common/OperationInfo.cs

@@ -4,6 +4,6 @@ public class OperationInfo
 {
 #nullable enable
     public string? Operation { get; set; }
-    public List<string>? Roles { get; set; }
+    public List<string>? Roles {get; set; }
 #nullable disable
-}
+}

MainProject/Models/Common/PermissionInfo.cs

@@ -4,6 +4,6 @@ public class PermissionInfo
 {
 #nullable enable
     public string? System { get; set; }
-    public List<RolePermissionModuleOperation>? RolePermissionModuleOperations { get; set; }
+    public List<RolePermissionModuleOperation>? RolePermissionModuleOperations {get; set; }
 #nullable disable
-}
+}

MainProject/Models/Common/PermissionsFile.cs

@@ -5,4 +5,4 @@ public class PermissionsFile
 #nullable enable
     public List<PermissionInfo>? PermissionInfos { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Common/RolePermissionModuleOperation.cs

@@ -6,4 +6,4 @@ public class RolePermissionModuleOperation
     public string? Module { get; set; }
     public List<OperationInfo>? Operations { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Database/Mongo/Log.cs

@@ -8,4 +8,4 @@ namespace BasicDotnetTemplate.MainProject.Models.Database.Mongo
         [BsonId]
         public ObjectId Id { get; set; }
     }
-}
+}

MainProject/Models/Database/SqlServer/PermissionModule.cs

@@ -8,4 +8,4 @@ namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer
         public required string Name { get; set; }
         public required bool Enabled { get; set; }
     }
-}
+}

MainProject/Models/Database/SqlServer/PermissionOperation.cs

@@ -7,4 +7,4 @@ namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer
         [MaxLength(100)]
         public required string Name { get; set; }
     }
-}
+}

MainProject/Models/Database/SqlServer/PermissionSystem.cs

@@ -8,4 +8,4 @@ namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer
         public required string Name { get; set; }
         public required bool Enabled { get; set; }
     }
-}
+}

MainProject/Models/Database/SqlServer/PermissionSystemModule.cs

@@ -10,4 +10,4 @@ namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer
         public required PermissionModule PermissionModule { get; set; }
         public required bool Enabled { get; set; }
     }
-}
+}

MainProject/Models/Database/SqlServer/PermissionSystemModuleOperation.cs

@@ -10,4 +10,4 @@ namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer
         public required PermissionSystemModule PermissionSystemModule { get; set; }
         public required PermissionOperation PermissionOperation { get; set; }
     }
-}
+}

MainProject/Models/Database/SqlServer/RolePermissionSystemModuleOperation.cs

@@ -10,4 +10,4 @@ namespace BasicDotnetTemplate.MainProject.Models.Database.SqlServer
         public required Role Role { get; set; }
         public required PermissionSystemModuleOperation PermissionSystemModuleOperation { get; set; }
     }
-}
+}

MainProject/Models/Database/SqlServer/User.cs

@@ -13,10 +13,7 @@ public class User : Base
     [MaxLength(200)]
     public required string Email { get; set; }
     public required string PasswordSalt { get; set; }
-#nullable enable
-    public string? PasswordPepper { get; set; }
-#nullable disable
-    public required int PasswordIterations { get; set; }
+    public required string PasswordHash { get; set; }
     public required Role Role { get; set; }
     public required bool IsTestUser { get; set; }
 

MainProject/Models/Settings/AppSettings.cs

@@ -11,4 +11,4 @@ public class AppSettings
     public EncryptionSettings? EncryptionSettings { get; set; }
     public PermissionsSettings? PermissionsSettings { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Settings/DatabaseConnection.cs

@@ -7,4 +7,4 @@ public class DatabaseConnection
     public string? Postgres { get; set; }
     public string? Mongodb { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Settings/DatabaseSettings.cs

@@ -7,4 +7,4 @@ public class DatabaseSettings
     public string? MongoDbConnectionString { get; set; }
     public string? PostgreSQLConnectionString { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Settings/EncryptionSettings.cs

@@ -3,8 +3,7 @@ namespace BasicDotnetTemplate.MainProject.Models.Settings;
 public class EncryptionSettings
 {
 #nullable enable
-    public string? SaltKey { get; set; }
     public string? Salt { get; set; }
-    public int? Iterations { get; set; }
+    public string? Pepper { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Settings/JwtSettings.cs

@@ -9,4 +9,4 @@ public class JwtSettings
     public int? ExpiredAfterMinsOfInactivity { get; set; }
 
 #nullable disable
-}
+}

MainProject/Models/Settings/OpenApiSettings.cs

@@ -7,4 +7,4 @@ public class OpenApiSettings
     public OpenApiSettingsDetails? OpenApiContact { get; set; }
     public OpenApiSettingsDetails? OpenApiLicense { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Settings/OpenApiSettingsDetails.cs

@@ -6,4 +6,4 @@ public class OpenApiSettingsDetails
     public string? Name { get; set; }
     public string? Url { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Settings/PermissionsSettings.cs

@@ -5,4 +5,4 @@ public class PermissionsSettings
 #nullable enable
     public string? FilePath { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Settings/PrivateSettings.cs

@@ -5,4 +5,4 @@ public class PrivateSettings
 #nullable enable
     public DatabaseConnection? DatabaseConnection { get; set; }
 #nullable disable
-}
+}

MainProject/Models/Settings/Settings.cs

@@ -7,4 +7,4 @@ public class Settings
     public string? Version { get; set; }
     public string? Description { get; set; }
 #nullable disable
-}
+}

MainProject/Program.cs

@@ -1,4 +1,4 @@
-using NLog;
+using NLog;
 using BasicDotnetTemplate.MainProject.Models.Settings;
 using System.Reflection;
 using BasicDotnetTemplate.MainProject.Utils;
@@ -60,4 +60,4 @@ internal static class Program
         NLog.LogManager.Shutdown(); // Flush and close down internal threads and timers
     }
 
-}
+}

MainProject/Services/PermissionService.cs

@@ -1275,4 +1275,4 @@ public class PermissionService : BaseService, IPermissionService
 
 
 
-}
+}

MainProject/Services/UserService.cs

@@ -4,7 +4,6 @@ using BasicDotnetTemplate.MainProject.Core.Database;
 using BasicDotnetTemplate.MainProject.Models.Api.Common.Exceptions;
 using BasicDotnetTemplate.MainProject.Models.Api.Data.User;
 using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
-using BasicDotnetTemplate.MainProject.Utils;
 using Microsoft.EntityFrameworkCore;
 
 namespace BasicDotnetTemplate.MainProject.Services;
@@ -16,10 +15,7 @@ public interface IUserService
     Task<User?> GetUserByUsernameAndPassword(string email, string password);
     Task<bool> CheckIfEmailIsValid(string email, string? guid = "");
     Task<User?> CreateUserAsync(CreateUserRequestData data, Role role);
-    Task<User?> UpdateUserAsync(UpdateUserRequestData data, User user);
     Task<bool?> DeleteUserAsync(User user);
-    Task<User?> UpdateUserPasswordAsync(User user, string newPassword);
-    Task<User?> UpdateUserRoleAsync(User user, Role newRole);
 }
 
 public class UserService : BaseService, IUserService
@@ -46,9 +42,6 @@ public class UserService : BaseService, IUserService
 
     private User CreateUserData(CreateUserRequestData data, Role role)
     {
-        var salt = _appSettings.EncryptionSettings?.Salt ?? String.Empty;
-        var pepper = CryptUtils.GeneratePepper();
-        var iterations = _appSettings.EncryptionSettings?.Iterations ?? 10;
         User user = new()
         {
             CreationTime = DateTime.UtcNow,
@@ -58,10 +51,9 @@ public class UserService : BaseService, IUserService
             FirstName = data.FirstName,
             LastName = data.LastName,
             Email = data.Email,
-            PasswordSalt = salt,
-            PasswordPepper = pepper,
-            PasswordIterations = iterations,
-            Password = CryptUtils.GeneratePassword(data.Password, salt, iterations, pepper),
+            PasswordSalt = "",
+            PasswordHash = "",
+            Password = "",
             Role = role,
             IsTestUser = false
         };
@@ -85,9 +77,7 @@ public class UserService : BaseService, IUserService
         User? user = await this.GetUserByEmailQueryable(email).FirstOrDefaultAsync();
         if (user != null)
         {
-            var valid = CryptUtils.VerifyPassword(user.Password, password, user.PasswordSalt, user.PasswordIterations, user.PasswordPepper);
-            if (!valid)
-                user = null;
+            var encryptedPassword = user.PasswordHash;
         }
 
         return user;
@@ -137,31 +127,6 @@ public class UserService : BaseService, IUserService
         return user;
     }
 
-    public async Task<User?> UpdateUserAsync(UpdateUserRequestData data, User user)
-    {
-        using var transaction = await _sqlServerContext.Database.BeginTransactionAsync();
-
-        try
-        {
-            user.FirstName = data.FirstName ?? user.FirstName;
-            user.LastName = data.LastName ?? user.LastName;
-            user.UpdateTime = DateTime.UtcNow;
-            user.UpdateUserId = this.GetCurrentUserId();
-
-            _sqlServerContext.Users.Update(user);
-            await _sqlServerContext.SaveChangesAsync();
-            await transaction.CommitAsync();
-        }
-        catch (Exception exception)
-        {
-            Logger.Error(exception, $"[UserService][UpdateUserAsync] | {transaction.TransactionId}");
-            await transaction.RollbackAsync();
-            throw new UpdateException($"An error occurred while updating the user for transaction ID {transaction.TransactionId}.", exception);
-        }
-
-        return user;
-    }
-
     public async Task<bool?> DeleteUserAsync(User user)
     {
         bool? deleted = false;
@@ -179,59 +144,6 @@ public class UserService : BaseService, IUserService
         return deleted;
     }
 
-    public async Task<User?> UpdateUserPasswordAsync(User user, string newPassword)
-    {
-        using var transaction = await _sqlServerContext.Database.BeginTransactionAsync();
 
-        try
-        {
-            var salt = _appSettings.EncryptionSettings?.Salt ?? String.Empty;
-            var pepper = CryptUtils.GeneratePepper();
-            var iterations = _appSettings.EncryptionSettings?.Iterations ?? 10;
-
-            user.PasswordSalt = salt;
-            user.PasswordPepper = pepper;
-            user.PasswordIterations = iterations;
-            user.Password = CryptUtils.GeneratePassword(newPassword, salt, iterations, pepper);
-            user.UpdateTime = DateTime.UtcNow;
-            user.UpdateUserId = this.GetCurrentUserId();
-
-            _sqlServerContext.Users.Update(user);
-            await _sqlServerContext.SaveChangesAsync();
-            await transaction.CommitAsync();
-        }
-        catch (Exception exception)
-        {
-            Logger.Error(exception, $"[UserService][UpdateUserPasswordAsync] | {transaction.TransactionId}");
-            await transaction.RollbackAsync();
-            throw new UpdateException($"An error occurred while updating the user for transaction ID {transaction.TransactionId}.", exception);
-        }
-
-        return user;
-    }
-
-    public async Task<User?> UpdateUserRoleAsync(User user, Role newRole)
-    {
-        using var transaction = await _sqlServerContext.Database.BeginTransactionAsync();
-
-        try
-        {
-            user.Role = newRole;
-            user.UpdateTime = DateTime.UtcNow;
-            user.UpdateUserId = this.GetCurrentUserId();
-
-            _sqlServerContext.Users.Update(user);
-            await _sqlServerContext.SaveChangesAsync();
-            await transaction.CommitAsync();
-        }
-        catch (Exception exception)
-        {
-            Logger.Error(exception, $"[UserService][UpdateUserRoleAsync] | {transaction.TransactionId}");
-            await transaction.RollbackAsync();
-            throw new UpdateException($"An error occurred while updating the user for transaction ID {transaction.TransactionId}.", exception);
-        }
-
-        return user;
-    }
 }
 

MainProject/Utils/CryptoUtils.cs

@@ -4,17 +4,24 @@ using System.Text;
 using BasicDotnetTemplate.MainProject.Models.Settings;
 
 namespace BasicDotnetTemplate.MainProject.Utils;
-public class CryptUtils(AppSettings appSettings)
+public class CryptUtils
 {
-    private readonly string _saltKey = appSettings.EncryptionSettings?.SaltKey ?? String.Empty;
+    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._saltKey) || this._saltKey.Length < _M)
+        if (String.IsNullOrEmpty(this._secretKey) || this._secretKey.Length < _M)
         {
             throw new ArgumentException("Unable to proceed with decryption due to invalid settings");
         }
@@ -28,7 +35,7 @@ public class CryptUtils(AppSettings appSettings)
 
             using (var aes = Aes.Create())
             {
-                aes.Key = Encoding.UTF8.GetBytes(this._saltKey);
+                aes.Key = Encoding.UTF8.GetBytes(this._secretKey);
                 aes.IV = Encoding.UTF8.GetBytes(iv);
 
                 using (var decryptor = aes.CreateDecryptor(aes.Key, aes.IV))
@@ -50,21 +57,21 @@ public class CryptUtils(AppSettings appSettings)
         return decrypted;
     }
 
-    public static string GeneratePepper()
+    public static string GenerateSalt()
     {
         using var rng = RandomNumberGenerator.Create();
-        var bytePepper = new byte[16];
-        rng.GetBytes(bytePepper);
-        var pepper = Convert.ToBase64String(bytePepper);
-        return pepper;
+        var byteSalt = new byte[16];
+        rng.GetBytes(byteSalt);
+        var salt = Convert.ToBase64String(byteSalt);
+        return salt;
     }
 
-    public static string GeneratePassword(string password, string salt, int iterations, string? pepper = "")
+    public string GeneratePassword(string password, string salt, int iteration)
     {
         string hashedPassword = password;
-        for (var i = 0; i <= iterations; i++)
+        for(var i = 0; i <= iteration; i++)
         {
-            var passwordSaltPepper = $"{hashedPassword}{salt}{pepper}";
+            var passwordSaltPepper = $"{hashedPassword}{salt}{this._pepper}";
             var byteValue = Encoding.UTF8.GetBytes(passwordSaltPepper);
             var byteHash = SHA256.HashData(byteValue);
             hashedPassword = Convert.ToBase64String(byteHash);
@@ -73,9 +80,9 @@ public class CryptUtils(AppSettings appSettings)
         return hashedPassword;
     }
 
-    public static bool VerifyPassword(string userPassword, string password, string salt, int iterations, string? pepper = "")
+    public bool VerifyPassword(string password, string salt, int iteration, string userPassword)
     {
-        string hashedPassword = GeneratePassword(password, salt, iterations, pepper);
+        string hashedPassword = this.GeneratePassword(password, salt, iteration);
         return hashedPassword.Equals(userPassword, StringComparison.OrdinalIgnoreCase);
     }
 

MainProject/Utils/FileUtils.cs

@@ -39,4 +39,4 @@ public static class FileUtils
         }
     }
 
-}
+}

MainProject/Utils/PasswordUtils.cs

@@ -1,64 +0,0 @@
-using System;
-using System.ComponentModel.DataAnnotations;
-using System.Security.Cryptography;
-using System.Text;
-using System.Text.RegularExpressions;
-using BasicDotnetTemplate.MainProject.Enum;
-using BasicDotnetTemplate.MainProject.Models.Settings;
-
-namespace BasicDotnetTemplate.MainProject.Utils;
-
-public static partial class PasswordUtils
-{
-    private const int MIN_LENGTH = 8;
-    private const int MIN_UPPER = 2;
-    private const int MIN_LOWER = 2;
-    private const int MIN_NUMBER = 2;
-    private const int MIN_SPECIAL = 2;
-
-    [GeneratedRegex("[A-Z]")]
-    private static partial Regex RegexUpper();
-
-    [GeneratedRegex("[a-z]")]
-    private static partial Regex RegexLower();
-
-    [GeneratedRegex("[0-9]")]
-    private static partial Regex RegexNumber();
-
-    [GeneratedRegex("[^a-zA-Z0-9]")]
-    private static partial Regex RegexSpecial();
-
-    private static readonly Regex RegexIdenticalChars = new(
-        @"(\S)\1{2,}",
-        RegexOptions.IgnoreCase | RegexOptions.Compiled,
-        TimeSpan.FromMilliseconds(100)
-    );
-
-    public static List<string> ValidatePassword(string password)
-    {
-        List<string> errors = [];
-
-        if (password.Length < MIN_LENGTH)
-            errors.Add(PasswordValidationEnum.MIN_LENGTH);
-
-        if (RegexUpper().Matches(password).Count < MIN_UPPER)
-            errors.Add(PasswordValidationEnum.MIN_UPPER);
-
-        if (RegexLower().Matches(password).Count < MIN_LOWER)
-            errors.Add(PasswordValidationEnum.MIN_LOWER);
-
-        if (RegexNumber().Matches(password).Count < MIN_NUMBER)
-            errors.Add(PasswordValidationEnum.MIN_NUMBER);
-
-        if (RegexSpecial().Matches(password).Count < MIN_SPECIAL)
-            errors.Add(PasswordValidationEnum.MIN_SPECIAL);
-
-        if (RegexIdenticalChars.IsMatch(password))
-            errors.Add(PasswordValidationEnum.IDENTICAL_CHARS);
-
-        return errors;
-    }
-
-
-}
-

MainProject/Utils/ProgramUtils.cs

@@ -8,7 +8,7 @@ using BasicDotnetTemplate.MainProject.Models.Settings;
 using BasicDotnetTemplate.MainProject.Services;
 using BasicDotnetTemplate.MainProject.Models.Api.Data.Role;
 using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
-using BasicDotnetTemplate.MainProject.Core.Filters;
+
 
 
 namespace BasicDotnetTemplate.MainProject.Utils;
@@ -140,10 +140,7 @@ public static class ProgramUtils
 
         builder.Services.AddAuthentication();
         builder.Services.AddAuthorization();
-        builder.Services.AddControllers(options =>
-        {
-            options.Filters.Add<ValidationActionFilter>();
-        });
+        builder.Services.AddControllers();
         builder.Services.AddEndpointsApiExplorer();
 
         Logger.Info("[ProgramUtils][AddServices] Done services");
@@ -295,4 +292,4 @@ public static class ProgramUtils
         }
     }
 
-}
+}

MainProject/appsettings.json

@@ -35,9 +35,8 @@
             "ExpiredAfterMinsOfInactivity": 15
         },
         "EncryptionSettings": {
-            "SaltKey": "S7VIidfXQf1tOQYX",
-            "Salt": "u5CZAwq9vLGysC",
-            "Iterations": 10
+            "Salt": "S7VIidfXQf1tOQYX",
+            "Pepper": ""
         },
         "PermissionsSettings": {
             "FilePath": "Config/permissions.json"