simona/dotnet-template
Template
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

Sprint 8 #43

Merged
csimonapastore merged 20 commits from sprints/8 into main 2025-06-21 01:11:03 +02:00
Conversation 1 Commits 20 Files Changed 83 +2238 -972
83 changed files with 2238 additions and 972 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
.editorconfig Normal file
View File

@@ -0,0 +1,15 @@
# 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

87
MainProject.Tests/Controllers/AuthController_Tests.cs
View File

@@ -61,12 +61,12 @@ public class AuthController_Tests
ObjectResult response = (ObjectResult)(await controller.AuthenticateAsync(request));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, result.Status);
Assert.IsInstanceOfType(result.Data, typeof(AuthenticatedUser));
}
else
@@ -81,42 +81,6 @@ 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()
{
@@ -140,46 +104,7 @@ public class AuthController_Tests
if (response != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status404NotFound);
}
else
{
Assert.Fail($"Response is null");
}
}
[TestMethod]
public async Task AuthenticateAsync_ModelInvalid()
{
IConfiguration configuration = TestUtils.CreateConfiguration();
var authServiceMock = new Mock<IAuthService>();
var controller = new AuthController(configuration, authServiceMock.Object);
var request = new AuthenticateRequest
{
Data = null
};
AuthenticatedUser? authenticatedUser = null;
authServiceMock.Setup(s => s.AuthenticateAsync(It.IsAny<AuthenticateRequestData>())).ReturnsAsync(authenticatedUser);
controller.ModelState.AddModelError("Data", "Invalid data");
ObjectResult response = (ObjectResult)(await controller.AuthenticateAsync(request));
Assert.IsInstanceOfType(response, typeof(ObjectResult));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
Assert.IsTrue(result.Message == "Request is not well formed");
}
else
{
Assert.Fail($"Result value is null");
}
Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
}
else
{
@@ -207,13 +132,13 @@ public class AuthController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
}
else
{

401
MainProject.Tests/Controllers/RoleController_Tests.cs
View File

@@ -70,12 +70,12 @@ public class RoleController_Tests
ObjectResult response = (ObjectResult)(await _roleController.GetRoleByGuidAsync(guid));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, result.Status);
Assert.IsInstanceOfType(result.Data, typeof(RoleDto));
}
else
@@ -89,41 +89,6 @@ 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()
{
@@ -141,44 +106,7 @@ public class RoleController_Tests
if (response != null)
{
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");
}
Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
}
else
{
@@ -202,13 +130,13 @@ public class RoleController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
}
else
{
@@ -255,12 +183,12 @@ public class RoleController_Tests
ObjectResult response = (ObjectResult)(await _roleController.CreateRoleAsync(request));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, result.Status);
Assert.IsInstanceOfType(result.Data, typeof(RoleDto));
}
else
@@ -297,57 +225,13 @@ public class RoleController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
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");
Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
Assert.AreEqual("Invalid name", result.Message);
}
else
{
@@ -391,13 +275,13 @@ public class RoleController_Tests
ObjectResult response = (ObjectResult)(await _roleController.CreateRoleAsync(request));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
Assert.IsTrue(result.Message == "Not created");
Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
Assert.AreEqual("Not created", result.Message);
}
else
{
@@ -410,56 +294,6 @@ 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()
{
@@ -494,13 +328,13 @@ public class RoleController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
}
else
{
@@ -531,42 +365,7 @@ public class RoleController_Tests
ObjectResult response = (ObjectResult)(await _roleController.DeleteRoleByGuidAsync(guid));
if (response != null && response.Value != null)
{
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");
}
Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
}
else
{
@@ -591,44 +390,7 @@ public class RoleController_Tests
if (response != null)
{
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");
}
Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
}
else
{
@@ -652,13 +414,13 @@ public class RoleController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
}
else
{
@@ -673,8 +435,6 @@ public class RoleController_Tests
#endregion
#region "UPDATE"
[TestMethod]
@@ -708,12 +468,12 @@ public class RoleController_Tests
ObjectResult response = (ObjectResult)(await _roleController.UpdateRoleAsync(request, role.Guid));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, result.Status);
Assert.IsInstanceOfType(result.Data, typeof(RoleDto));
}
else
@@ -752,7 +512,7 @@ public class RoleController_Tests
if (response != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status404NotFound);
Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
}
else
{
@@ -786,13 +546,13 @@ public class RoleController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
Assert.IsTrue(result.Message == "Invalid name");
Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
Assert.AreEqual("Invalid name", result.Message);
}
else
{
@@ -832,13 +592,13 @@ public class RoleController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
Assert.IsTrue(result.Message == "This role is not editable");
Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
Assert.AreEqual("This role is not editable", result.Message);
}
else
{
@@ -851,96 +611,6 @@ 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()
{
@@ -971,18 +641,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.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
}
else
{
@@ -996,4 +666,5 @@ public class RoleController_Tests
}
#endregion
}

690
MainProject.Tests/Controllers/UserController_Tests.cs
View File

@@ -66,6 +66,7 @@ public class UserController_Tests
}
#region "GET"
[TestMethod]
public async Task GetUserByGuidAsync_Should_Return_200_When_Successful()
{
@@ -80,12 +81,12 @@ public class UserController_Tests
ObjectResult response = (ObjectResult)(await _userController.GetUserByGuidAsync(guid));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, result.Status);
Assert.IsInstanceOfType(result.Data, typeof(UserDto));
}
else
@@ -99,41 +100,6 @@ 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()
{
@@ -151,44 +117,7 @@ public class UserController_Tests
if (response != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status404NotFound);
}
else
{
Assert.Fail($"Response is null");
}
}
[TestMethod]
public async Task GetUserByGuidAsync_ModelInvalid()
{
if (_userController == null)
{
Assert.Fail($"_userController is null");
}
var guid = Guid.NewGuid().ToString();
DatabaseSqlServer.User? user = null;
_userServiceMock?.Setup(s => s.GetUserByGuidAsync(It.IsAny<string>())).ReturnsAsync(user);
_userController.ModelState.AddModelError("Data", "Invalid data");
ObjectResult response = (ObjectResult)(await _userController.GetUserByGuidAsync(guid));
Assert.IsInstanceOfType(response, typeof(ObjectResult));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
Assert.IsTrue(result.Message == "Request is not well formed");
}
else
{
Assert.Fail($"Result value is null");
}
Assert.AreEqual(StatusCodes.Status404NotFound, response.StatusCode);
}
else
{
@@ -212,13 +141,13 @@ public class UserController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
}
else
{
@@ -231,6 +160,10 @@ public class UserController_Tests
}
}
#endregion
#region "CREATE"
[TestMethod]
public async Task CreateUserAsync_Success()
{
@@ -265,12 +198,12 @@ public class UserController_Tests
ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status200OK);
Assert.AreEqual(StatusCodes.Status200OK, result.Status);
Assert.IsInstanceOfType(result.Data, typeof(UserDto));
}
else
@@ -311,13 +244,13 @@ public class UserController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
Assert.IsTrue(result.Message == "Invalid email");
Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
Assert.AreEqual("Invalid email", result.Message);
}
else
{
@@ -362,58 +295,13 @@ public class UserController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
Assert.IsTrue(result.Message == "Role not found");
}
else
{
Assert.Fail($"Result value is null");
}
}
else
{
Assert.Fail($"Response value is null");
}
}
[TestMethod]
public async Task CreateUserAsync_CreateUserRequestDataNull()
{
if (_userController == null)
{
Assert.Fail($"_userController is null");
}
DatabaseSqlServer.User user = ModelsInit.CreateUser();
CreateUserRequest request = new CreateUserRequest()
{
Data = null
};
_userServiceMock?.Setup(s => s.CheckIfEmailIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
_userServiceMock?.Setup(s => s.CreateUserAsync(
It.IsAny<CreateUserRequestData>(),
It.IsAny<Role>()
)).ReturnsAsync(user);
ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
Assert.IsTrue(result.Message == "Request is not well formed");
Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
Assert.AreEqual("Role not found", result.Message);
}
else
{
@@ -462,13 +350,13 @@ public class UserController_Tests
ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
Assert.AreEqual(StatusCodes.Status400BadRequest, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
Assert.IsTrue(result.Message == "Not created");
Assert.AreEqual(StatusCodes.Status400BadRequest, result.Status);
Assert.AreEqual("Not created", result.Message);
}
else
{
@@ -481,59 +369,6 @@ 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()
{
@@ -576,13 +411,13 @@ public class UserController_Tests
if (response != null && response.Value != null)
{
Assert.IsTrue(response.StatusCode == StatusCodes.Status500InternalServerError);
Assert.AreEqual(StatusCodes.Status500InternalServerError, response.StatusCode);
var result = (BaseResponse<object>)response.Value;
if (result != null)
{
Assert.IsTrue(result.Status == StatusCodes.Status500InternalServerError);
Assert.IsTrue(result.Message == "Something went wrong. Unexpected error");
Assert.AreEqual(StatusCodes.Status500InternalServerError, result.Status);
Assert.AreEqual("Something went wrong. Unexpected error", result.Message);
}
else
{
@@ -594,4 +429,479 @@ 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
}

135
MainProject.Tests/Core/Filters/ValidationActionFilter_Tests.cs Normal file
View File

@@ -0,0 +1,135 @@
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; }
}
}

5
MainProject.Tests/JsonData/appsettings.json
View File

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

5
MainProject.Tests/JsonData/invalidCryptAppsettings.json
View File

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

13
MainProject.Tests/MainProject.Tests.csproj
View File

@@ -10,12 +10,15 @@
</PropertyGroup>
<ItemGroup>
<PackageReference Include="coverlet.collector" Version="6.0.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.3" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
<PackageReference Include="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="Moq" Version="4.20.72" />
<PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
<PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
<PackageReference Include="MSTest.TestAdapter" Version="3.9.3" />
<PackageReference Include="MSTest.TestFramework" Version="3.9.3" />
<PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
</ItemGroup>

4
MainProject.Tests/Models/Api/Common/Role/UserRole_Tests.cs
View File

@@ -23,9 +23,9 @@ public class UserRole_Tests
try
{
DatabaseSqlServer.Role role = ModelsInit.CreateRole();
UserRole userRole = new UserRole(role);
UserRole userRole = new(role);
Assert.IsTrue(userRole.Name == role.Name);
Assert.AreEqual(role.Name, userRole.Name);
}
catch (Exception ex)
{

6
MainProject.Tests/Models/Api/Common/User/AuthenticatedUser_Tests.cs
View File

@@ -25,9 +25,9 @@ public class AuthenticatedUser_Tests
DatabaseSqlServer.User user = ModelsInit.CreateUser();
AuthenticatedUser authenticatedUser = new AuthenticatedUser(user);
Assert.IsTrue(authenticatedUser.FirstName == user.FirstName);
Assert.IsTrue(authenticatedUser.LastName == user.LastName);
Assert.IsTrue(authenticatedUser.Email == user.Email);
Assert.AreEqual(user.FirstName, authenticatedUser.FirstName);
Assert.AreEqual(user.LastName, authenticatedUser.LastName);
Assert.AreEqual(user.Email, authenticatedUser.Email);
Assert.IsInstanceOfType(authenticatedUser.Role, typeof(UserRole));
}
catch (Exception ex)

270
MainProject.Tests/Services/UserService_Tests.cs
View File

@@ -36,29 +36,6 @@ 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()
{
@@ -93,7 +70,8 @@ public class UserService_Tests
{
FirstName = expectedUser.FirstName ?? String.Empty,
LastName = expectedUser.LastName ?? String.Empty,
Email = expectedUser.Email ?? String.Empty
Email = expectedUser.Email ?? String.Empty,
Password = "Password"
};
Role role = new()
@@ -106,10 +84,14 @@ public class UserService_Tests
var user = await _userService.CreateUserAsync(data, role);
Assert.IsInstanceOfType(user, typeof(User));
Assert.IsNotNull(user);
Assert.IsTrue(expectedUser.FirstName == user.FirstName);
Assert.IsTrue(expectedUser.LastName == user.LastName);
Assert.IsTrue(expectedUser.Email == user.Email);
Assert.IsTrue(expectedUser.Role?.Name == user.Role?.Name);
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);
_user = user;
}
@@ -120,6 +102,51 @@ 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()
{
@@ -131,7 +158,8 @@ public class UserService_Tests
{
FirstName = expectedUser.FirstName ?? String.Empty,
LastName = expectedUser.LastName ?? String.Empty,
Email = expectedUser.Email ?? String.Empty
Email = expectedUser.Email ?? String.Empty,
Password = expectedUser.Password ?? String.Empty
};
Role role = new()
@@ -223,7 +251,7 @@ public class UserService_Tests
{
var user = await _userService.GetUserByIdAsync(_user.Id);
Assert.IsNotNull(user);
Assert.IsTrue(user.Id == _user?.Id);
Assert.AreEqual(user.Id, _user?.Id);
}
else
{
@@ -247,7 +275,7 @@ public class UserService_Tests
{
var user = await _userService.GetUserByGuidAsync(_user.Guid ?? String.Empty);
Assert.IsNotNull(user);
Assert.IsTrue(user.Guid == _user?.Guid);
Assert.AreEqual(user.Guid, _user?.Guid);
}
else
{
@@ -261,6 +289,186 @@ 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()
{

3
MainProject.Tests/TestsUtils/ModelsInit.cs
View File

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

21
MainProject.Tests/Utils/CryptoUtils_Tests.cs → MainProject.Tests/Utils/CryptUtils_Tests.cs
View File

@@ -102,12 +102,12 @@ public class CryptoUtils_Tests
}
[TestMethod]
public void GenerateSalt()
public void GeneratePepper()
{
try
{
var salt = CryptUtils.GenerateSalt();
Assert.IsTrue(!String.IsNullOrEmpty(salt));
var salt = CryptUtils.GeneratePepper();
Assert.IsFalse(String.IsNullOrEmpty(salt));
}
catch (Exception ex)
{
@@ -122,14 +122,14 @@ public class CryptoUtils_Tests
try
{
var password = "P4ssw0rd@1!";
var salt = CryptUtils.GenerateSalt();
Assert.IsTrue(!String.IsNullOrEmpty(salt));
var pepper = CryptUtils.GeneratePepper();
Assert.IsFalse(String.IsNullOrEmpty(pepper));
WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
CryptUtils cryptoUtils = new CryptUtils(appSettings);
var encryptedPassword = cryptoUtils.GeneratePassword(password, salt, 0);
Assert.IsTrue(password != encryptedPassword);
var salt = appSettings?.EncryptionSettings?.Salt ?? String.Empty;
var encryptedPassword = CryptUtils.GeneratePassword(password, salt, 0, pepper);
Assert.AreNotEqual(encryptedPassword, password);
}
catch (Exception ex)
{
@@ -147,10 +147,7 @@ public class CryptoUtils_Tests
var salt = "Afi7PQYgEL2sPbNyVzduvg==";
var hashedPassword = "2lMeySZ9ciH1KtSg1Z7oSJRmJEjHMeDvdaNRcJcGutM=";
WebApplicationBuilder builder = WebApplication.CreateBuilder(Array.Empty<string>());
AppSettings appSettings = ProgramUtils.AddConfiguration(ref builder, System.AppDomain.CurrentDomain.BaseDirectory + "/JsonData");
CryptUtils cryptoUtils = new CryptUtils(appSettings);
var verified = cryptoUtils.VerifyPassword(password, salt, 0, hashedPassword);
var verified = CryptUtils.VerifyPassword(hashedPassword, password, salt, 0);
Assert.IsTrue(verified);
}
catch (Exception ex)

62
MainProject.Tests/Utils/PasswordUtils_Test.cs Normal file
View File

@@ -0,0 +1,62 @@
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}");
}
}
}

27
MainProject/Controllers/AuthController.cs
View File

@@ -6,6 +6,7 @@ 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
{
@@ -21,30 +22,17 @@ 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)
public async Task<IActionResult> AuthenticateAsync([FromBody] AuthenticateRequest request) //NOSONAR
{
try
{
if (!ModelState.IsValid)
{
return BadRequest(_requestNotWellFormed);
}
if (
request == null ||
request.Data == null ||
String.IsNullOrEmpty(request.Data.Email) ||
String.IsNullOrEmpty(request.Data.Password)
)
{
return BadRequest(_requestNotWellFormed);
}
var data = await this._authService.AuthenticateAsync(request.Data);
var data = await this._authService.AuthenticateAsync(request!.Data!);
if (data == null)
{
@@ -55,12 +43,7 @@ namespace BasicDotnetTemplate.MainProject.Controllers
}
catch (Exception exception)
{
var message = this._somethingWentWrong;
if (!String.IsNullOrEmpty(exception.Message))
{
message += $". {exception.Message}";
}
return InternalServerError(message);
return InternalServerError(exception);
}
}

9
MainProject/Controllers/BaseController.cs
View File

@@ -12,7 +12,6 @@ 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(
@@ -67,9 +66,13 @@ namespace BasicDotnetTemplate.MainProject.Controllers
return StatusCode((int)HttpStatusCode.BadRequest, CreateResponse(HttpStatusCode.BadRequest, message, data));
}
protected IActionResult InternalServerError(string message)
protected IActionResult InternalServerError(Exception exception)
{
message = String.IsNullOrEmpty(message) ? "Internal server error" : message;
var message = this._somethingWentWrong;
if (!String.IsNullOrEmpty(exception.Message))
{
message += $". {exception.Message}";
}
return StatusCode((int)HttpStatusCode.InternalServerError, CreateResponse(HttpStatusCode.InternalServerError, message, new object()));
}

91
MainProject/Controllers/RoleController.cs
View File

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

173
MainProject/Controllers/UserController.cs
View File

@@ -7,6 +7,7 @@ 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
{
@@ -25,7 +26,9 @@ namespace BasicDotnetTemplate.MainProject.Controllers
this._roleService = roleService;
}
[JwtAuthorization()]
[ModelStateValidationHandledByFilterAttribute]
[HttpGet("get/{guid}")]
[ProducesResponseType<GetUserResponse>(StatusCodes.Status200OK)]
[ProducesResponseType<BaseResponse<object>>(StatusCodes.Status404NotFound)]
@@ -35,15 +38,6 @@ 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))
@@ -57,49 +51,30 @@ namespace BasicDotnetTemplate.MainProject.Controllers
}
catch (Exception exception)
{
var message = this._somethingWentWrong;
if (!String.IsNullOrEmpty(exception.Message))
{
message += $". {exception.Message}";
}
return InternalServerError(message);
return InternalServerError(exception);
}
}
[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)
public async Task<IActionResult> CreateUserAsync([FromBody] CreateUserRequest request) //NOSONAR
{
try
{
if (!ModelState.IsValid)
if (await this._userService.CheckIfEmailIsValid(request!.Data!.Email))
{
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);
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))
{
@@ -118,17 +93,135 @@ namespace BasicDotnetTemplate.MainProject.Controllers
}
catch (Exception exception)
{
var message = this._somethingWentWrong;
if (!String.IsNullOrEmpty(exception.Message))
{
message += $". {exception.Message}";
}
return InternalServerError(message);
return InternalServerError(exception);
}
}
[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);
}
}
}
}

5
MainProject/Controllers/VersionController.cs
View File

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

12
MainProject/Core/Attributes/ValidateModelStateAutomaticallyAttribute.cs Normal file
View File

@@ -0,0 +1,12 @@
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
{ }
}

43
MainProject/Core/Filters/ValidationActionFilter.cs Normal file
View File

@@ -0,0 +1,43 @@
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();
}
}
}

10
MainProject/Enum/PasswordValidationEnum.cs Normal file
View File

@@ -0,0 +1,10 @@
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";
}

40
MainProject/MainProject.csproj
View File

@@ -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.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">
<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">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<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">
<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">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.5" />
<PackageReference Include="Microsoft.Identity.Web" Version="3.9.2" />
<PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.6" />
<PackageReference Include="Microsoft.Identity.Web" Version="3.9.3" />
<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.4.0" />
<PackageReference Include="NLog.Extensions.Logging" Version="5.4.0" />
<PackageReference Include="NLog" Version="5.5.0" />
<PackageReference Include="NLog.Extensions.Logging" Version="5.5.0" />
<PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
<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" />
<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" />
</ItemGroup>
</Project>

2
MainProject/Migrations/20240904211920_InitialCreate.cs
View File

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

2
MainProject/Migrations/20241129231345_Try.cs
View File

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

2
MainProject/Migrations/20250311195750_AlterTableUser.cs
View File

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

2
MainProject/Migrations/20250312234517_AlterTableUserMaxLengthIndexes.cs
View File

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

2
MainProject/Migrations/20250316014620_AlterTablesUsersAndRoles.cs
View File

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

2
MainProject/Migrations/20250316212343_AlterBaseUpdateTimeDeletionTimeNullable.cs
View File

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

2
MainProject/Migrations/20250316212722_AlterTableRoleAddedIsNotEditable.cs
View File

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

2
MainProject/Migrations/20250426183010_AddingPermissionsTables.cs
View File

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

542
MainProject/Migrations/20250617183212_AlterTableUsersForPasswordEncryption.Designer.cs generated Normal file
View File

@@ -0,0 +1,542 @@
// <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
}
}
}

109
MainProject/Migrations/20250617183212_AlterTableUsersForPasswordEncryption.cs Normal file
View File

@@ -0,0 +1,109 @@
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);
}
}
}

15
MainProject/Migrations/SqlServerContextModelSnapshot.cs
View File

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

9
MainProject/Models/Api/Base/ValidationError.cs Normal file
View File

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

2
MainProject/Models/Api/Common/Role/UserRole.cs
View File

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

2
MainProject/Models/Api/Common/User/AuthenticatedUser.cs
View File

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

10
MainProject/Models/Api/Data/Auth/AuthenticateRequestData.cs
View File

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

5
MainProject/Models/Api/Data/Role/CreateRoleRequestData.cs
View File

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

15
MainProject/Models/Api/Data/User/CreateUserRequestData.cs
View File

@@ -1,11 +1,16 @@
using System.ComponentModel.DataAnnotations;
namespace BasicDotnetTemplate.MainProject.Models.Api.Data.User;
public class CreateUserRequestData
public class CreateUserRequestData : UpdateUserRequestData
{
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;
[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? RoleGuid { get; set; }
}

19
MainProject/Models/Api/Data/User/UpdateUserRequestData.cs Normal file
View File

@@ -0,0 +1,19 @@
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; }
}

6
MainProject/Models/Api/Request/Auth/AuthenticateRequest.cs
View File

@@ -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
{
#nullable enable
public AuthenticateRequestData? Data { get; set; }
#nullable disable
[Required(ErrorMessage = "Data is required")]
public required AuthenticateRequestData Data { get; set; }
}

6
MainProject/Models/Api/Request/Role/CreateRoleRequest.cs
View File

@@ -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
{
#nullable enable
public CreateRoleRequestData? Data { get; set; }
#nullable disable
[Required(ErrorMessage = "Data is required")]
public required CreateRoleRequestData? Data { get; set; }
}

6
MainProject/Models/Api/Request/User/CreateUserRequest.cs
View File

@@ -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
{
#nullable enable
public CreateUserRequestData? Data { get; set; }
#nullable disable
[Required(ErrorMessage = "Data is required")]
public required CreateUserRequestData Data { get; set; }
}

14
MainProject/Models/Api/Request/User/UpdateUserRequest.cs Normal file
View File

@@ -0,0 +1,14 @@
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; }
}

2
MainProject/Models/Common/OperationInfo.cs
View File

@@ -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
}

2
MainProject/Models/Common/PermissionInfo.cs
View File

@@ -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
}

5
MainProject/Models/Database/SqlServer/User.cs
View File

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

3
MainProject/Models/Settings/EncryptionSettings.cs
View File

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

2
MainProject/Program.cs
View File

@@ -1,4 +1,4 @@
using NLog;
using NLog;
using BasicDotnetTemplate.MainProject.Models.Settings;
using System.Reflection;
using BasicDotnetTemplate.MainProject.Utils;

96
MainProject/Services/UserService.cs
View File

@@ -4,6 +4,7 @@ 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;
@@ -15,7 +16,10 @@ 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
@@ -42,6 +46,9 @@ 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,
@@ -51,9 +58,10 @@ public class UserService : BaseService, IUserService
FirstName = data.FirstName,
LastName = data.LastName,
Email = data.Email,
PasswordSalt = "",
PasswordHash = "",
Password = "",
PasswordSalt = salt,
PasswordPepper = pepper,
PasswordIterations = iterations,
Password = CryptUtils.GeneratePassword(data.Password, salt, iterations, pepper),
Role = role,
IsTestUser = false
};
@@ -77,7 +85,9 @@ public class UserService : BaseService, IUserService
User? user = await this.GetUserByEmailQueryable(email).FirstOrDefaultAsync();
if (user != null)
{
var encryptedPassword = user.PasswordHash;
var valid = CryptUtils.VerifyPassword(user.Password, password, user.PasswordSalt, user.PasswordIterations, user.PasswordPepper);
if (!valid)
user = null;
}
return user;
@@ -127,6 +137,31 @@ 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;
@@ -144,6 +179,59 @@ 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;
}
}

35
MainProject/Utils/CryptoUtils.cs → MainProject/Utils/CryptUtils.cs
View File

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

64
MainProject/Utils/PasswordUtils.cs Normal file
View File

@@ -0,0 +1,64 @@
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;
}
}

7
MainProject/Utils/ProgramUtils.cs
View File

@@ -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,7 +140,10 @@ public static class ProgramUtils
builder.Services.AddAuthentication();
builder.Services.AddAuthorization();
builder.Services.AddControllers();
builder.Services.AddControllers(options =>
{
options.Filters.Add<ValidationActionFilter>();
});
builder.Services.AddEndpointsApiExplorer();
Logger.Info("[ProgramUtils][AddServices] Done services");

5
MainProject/appsettings.json
View File

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