Add project files.

2025-04-29 18:56:29 -06:00
parent ad652bc070
commit 7d760b589e
91 changed files with 4366 additions and 0 deletions
--- a/Core.Cerberos.Service.API/Controllers/UserController.cs
+++ b/Core.Cerberos.Service.API/Controllers/UserController.cs
@@ -0,0 +1,432 @@
+using Asp.Versioning;
+using Core.Cerberos.Adapters;
+using Core.Cerberos.Adapters.Attributes;
+using Core.Cerberos.Adapters.Common.Constants;
+using Core.Cerberos.Application.UseCases.Users.Input;
+using Core.Cerberos.Application.UseCases.Users.Ports;
+using Lib.Architecture.BuildingBlocks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Core.Cerberos.Service.API.Controllers
+{
+    /// <summary>
+    /// Handles all requests for user.
+    /// </summary>
+    [ApiVersion("1.0")]
+    [Route("api/v{api-version:apiVersion}/[controller]")]
+    [Produces("application/json")]
+    [ApiController]
+    public class UserController : ControllerBase
+    {
+        private readonly IComponentHandler<GetUserRequest> getUserHandler;
+        private readonly IComponentHandler<GetUserByEmailRequest> getUserByEmailHandler;
+        private readonly IComponentHandler<GetAllUsersRequest> getAllUsersHandler;
+        private readonly IComponentHandler<CreateUserRequest> createUserHandler;
+        private readonly IComponentHandler<UpdateUserRequest> updateUserHandler;
+        private readonly IComponentHandler<ChangeUserStatusRequest> ChangeUserStatusHandler;
+        private readonly IComponentHandler<AddCompanyToUserRequest> addCompanyToUserHandler;
+        private readonly IComponentHandler<RemoveCompanyFromUserRequest> removeCompanyFromUserHandler;
+        private readonly IComponentHandler<AddProjectToUserRequest> addProjectToUserHandler;
+        private readonly IComponentHandler<RemoveProjectFromUserRequest> removeProjectFromUserHandler;
+        private readonly IComponentHandler<LoginUserRequest> loginUserHandler;
+        private readonly IComponentHandler<LogoutUserRequest> logoutUserHandler;
+        private readonly IComponentHandler<ValidateUserExistenceRequest> validateUserHandler;
+        private readonly IComponentHandler<GetTokenAdapterRequest> getTokenAdapterHandler;
+        private readonly IComponentHandler<GetConsentFormPDFRequest> getConsentFormPDFHandler;
+        private readonly IComponentHandler<AcceptUserConsentFormRequest> acceptUserConsentFormHandler;
+        private readonly IUserPort port;
+
+        /// <summary>
+        /// Creates a new instance of UserController.
+        /// </summary>
+        public UserController(
+            IComponentHandler<GetUserRequest> getUserHandler,
+            IComponentHandler<GetUserByEmailRequest> getUserByEmailHandler,
+            IComponentHandler<GetAllUsersRequest> getAllUsersHandler,
+            IComponentHandler<CreateUserRequest> createUserHandler,
+            IComponentHandler<UpdateUserRequest> updateUserHandler,
+            IComponentHandler<ChangeUserStatusRequest> changeUserStatusHandler,
+            IComponentHandler<AddCompanyToUserRequest> addCompanyToUserHandler,
+            IComponentHandler<RemoveCompanyFromUserRequest> removeCompanyFromUserHandler,
+            IComponentHandler<AddProjectToUserRequest> addProjectToUserHandler,
+            IComponentHandler<RemoveProjectFromUserRequest> removeProjectFromUserHandler,
+            IComponentHandler<LoginUserRequest> loginUserHandler,
+            IComponentHandler<LogoutUserRequest> logoutUserHandler,
+            IComponentHandler<ValidateUserExistenceRequest> validateUserHandler,
+            IComponentHandler<GetTokenAdapterRequest> getTokenAdapterHandler,
+            IComponentHandler<GetConsentFormPDFRequest> getConsentFormPDFHandler,
+            IComponentHandler<AcceptUserConsentFormRequest> acceptUserConsentFormHandler,
+            IUserPort port
+            )
+        {
+            this.createUserHandler = createUserHandler;
+            this.updateUserHandler = updateUserHandler;
+            this.ChangeUserStatusHandler = changeUserStatusHandler;
+            this.getAllUsersHandler = getAllUsersHandler;
+            this.getUserHandler = getUserHandler;
+            this.getUserByEmailHandler = getUserByEmailHandler;
+            this.addCompanyToUserHandler = addCompanyToUserHandler;
+            this.removeCompanyFromUserHandler = removeCompanyFromUserHandler;
+            this.addProjectToUserHandler = addProjectToUserHandler;
+            this.removeProjectFromUserHandler = removeProjectFromUserHandler;
+            this.loginUserHandler = loginUserHandler;
+            this.logoutUserHandler = logoutUserHandler;
+            this.validateUserHandler = validateUserHandler;
+            this.getTokenAdapterHandler = getTokenAdapterHandler;
+            this.getConsentFormPDFHandler = getConsentFormPDFHandler;
+            this.acceptUserConsentFormHandler = acceptUserConsentFormHandler;
+            this.port = port;
+        }
+        /// <summary>
+        /// Gets all the users.
+        /// </summary>
+        [HttpGet]
+        [Route("GetAll")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Read")]
+        public async Task<IActionResult> GetAllUsersAsync(CancellationToken cancellationToken)
+        {
+            await getAllUsersHandler.ExecuteAsync(new GetAllUsersRequest { }, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Gets the user by identifier.
+        /// </summary>
+        [HttpPost]
+        [Route("GetById")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Read")]
+        public async Task<IActionResult> GetUserById([FromBody] GetUserRequest request, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid user identifier"); }
+
+            await getUserHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Gets the user by email.
+        /// </summary>
+        [HttpPost]
+        [Route("GetByEmail")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Authorize(AuthenticationSchemes = $"{Schemes.HeathScheme}, {Schemes.AzureScheme}")]
+        public async Task<IActionResult> GetUserByEmail([FromBody] GetUserByEmailRequest request, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.Email)) { return BadRequest("Invalid user email"); }
+
+            await getUserByEmailHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Creates a new user.
+        /// </summary>
+        [HttpPost]
+        [Route("Create")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Write")]
+        public async Task<IActionResult> CreateUserAsync([FromBody] CreateUserRequest newUser, CancellationToken cancellationToken = default)
+        {
+            await createUserHandler.ExecuteAsync(newUser, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Updates a full user by identifier.
+        /// </summary>
+        [HttpPut("Update")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Write")]
+        public async Task<IActionResult> UpdateUserAsync([FromBody] UpdateUserRequest request,
+                                                         CancellationToken cancellationToken = default)
+        {
+            await updateUserHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Logs in the user.
+        /// </summary>
+        [HttpPatch("LoginUser")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Authorize(AuthenticationSchemes = $"{Schemes.HeathScheme}, {Schemes.AzureScheme}")]
+        public async Task<IActionResult> LoginUserAsync([FromBody] LoginUserRequest request, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.Email)) { return BadRequest("Invalid user email"); }
+
+            await loginUserHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Logs in the user.
+        /// </summary>
+        [HttpPatch("LogOutUser")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> LogOutUserSessionAsync([FromBody] LogoutUserRequest request, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.Email)) { return BadRequest("Invalid user email"); }
+
+            await logoutUserHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Changes the status of the user.
+        /// </summary>
+        [HttpPatch]
+        [Route("ChangeStatus")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Write")]
+        public async Task<IActionResult> ChangeUserStatusAsync([FromBody] ChangeUserStatusRequest request, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid user identifier"); }
+
+            await ChangeUserStatusHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Adds a company to the user's list of companies.
+        /// </summary>
+        [HttpPost]
+        [Route("AddCompany")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Write")]
+        public async Task<IActionResult> AddCompanyToUserAsync([FromBody] AddCompanyToUserRequest request,
+                                                               CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.UserId)) { return BadRequest("Invalid user identifier"); }
+            if (string.IsNullOrEmpty(request.CompanyId)) { return BadRequest("Invalid company identifier"); }
+
+            await addCompanyToUserHandler.ExecuteAsync(request, cancellationToken);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Removes a company from the user's list of companies.
+        /// </summary>
+        [HttpDelete]
+        [Route("RemoveCompany")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Write")]
+        public async Task<IActionResult> RemoveCompanyFromUserAsync([FromBody] RemoveCompanyFromUserRequest request,
+                                                                   CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.UserId)) { return BadRequest("Invalid user identifier"); }
+            if (string.IsNullOrEmpty(request.CompanyId)) { return BadRequest("Invalid company identifier"); }
+
+            await removeCompanyFromUserHandler.ExecuteAsync(request, cancellationToken);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Adds a project to the user's list of projects.
+        /// </summary>
+        [HttpPost]
+        [Route("AddProject")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Write")]
+        public async Task<IActionResult> AddProjectToUserAsync([FromBody] AddProjectToUserRequest request,
+                                                              CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.UserId)) { return BadRequest("Invalid user identifier"); }
+            if (string.IsNullOrEmpty(request.ProjectId)) { return BadRequest("Invalid project identifier"); }
+
+            await addProjectToUserHandler.ExecuteAsync(request, cancellationToken);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Removes a project from the user's list of projects.
+        /// </summary>
+        [HttpDelete]
+        [Route("RemoveProject")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Write")]
+        public async Task<IActionResult> RemoveProjectFromUserAsync([FromBody] RemoveProjectFromUserRequest request,
+                                                                   CancellationToken cancellationToken)
+        {
+
+            if (string.IsNullOrEmpty(request.UserId)) { return BadRequest("Invalid user identifier"); }
+            if (string.IsNullOrEmpty(request.ProjectId)) { return BadRequest("Invalid project identifier"); }
+
+            await removeProjectFromUserHandler.ExecuteAsync(request, cancellationToken);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Validates if a user exists on the database.
+        /// </summary>
+        [HttpPost]
+        [Route("ValidateExistence")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [AllowAnonymous]
+        public async Task<IActionResult> ValidateUserExistenceAsync([FromBody] ValidateUserExistenceRequest request, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.Email)) { return BadRequest("Invalid user email"); }
+
+            await validateUserHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Gets a token for the user, including roles, permissions, and modules.
+        /// </summary>
+        [HttpPost]
+        [Route("GetTokenAdapter")]
+        [ProducesResponseType(typeof(TokenAdapter), StatusCodes.Status200OK)]
+        [Authorize(AuthenticationSchemes = $"{Schemes.HeathScheme}, {Schemes.AzureScheme}")]
+        public async Task<IActionResult> GetTokenAdapter([FromBody] GetTokenAdapterRequest request, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(request.Email)) { return BadRequest("Invalid user email"); }
+
+            await getTokenAdapterHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Get Consent Form PDF.
+        /// </summary>
+        [HttpGet]
+        [Route("GetConsentFormPDF")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
+        [Permission("UserManagement.Read")]
+        public async Task<IActionResult> GetConsentFormPDFAsync(CancellationToken cancellationToken)
+        {
+            await getConsentFormPDFHandler.ExecuteAsync(new GetConsentFormPDFRequest { }, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+
+        /// <summary>
+        /// Accept user consent form.
+        /// </summary>
+        [HttpPatch("AcceptUserConsentForm")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Authorize(AuthenticationSchemes = $"{Schemes.HeathScheme}, {Schemes.AzureScheme}")]
+        public async Task<IActionResult> AcceptUserConsentFormAsync(CancellationToken cancellationToken)
+        {
+            await acceptUserConsentFormHandler.ExecuteAsync(new AcceptUserConsentFormRequest { }, cancellationToken).ConfigureAwait(false);
+
+            return port.ViewModel;
+        }
+    }
+}