Core.Thalos.Service.API/Core.Cerberos.Service.API/Controllers/ModuleController.cs

using Asp.Versioning;
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Attributes;
using Core.Cerberos.Adapters.Common.Constants;
using Core.Cerberos.Application.UseCases.Modules.Input;
using Core.Cerberos.Application.UseCases.Modules.Ports;
using Lib.Architecture.BuildingBlocks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Core.Cerberos.Service.API.Controllers
{
    /// <summary>
    /// Handles all services and business rules related to <see cref="ModuleController"/>.
    /// </summary>
    [ApiVersion("1.0")]
    [Route("api/v{api-version:apiVersion}/[controller]")]
    [Produces("application/json")]
    [ApiController]
    public class ModuleController : ControllerBase
    {
        private readonly IComponentHandler<GetModuleRequest> getModuleHandler;
        private readonly IComponentHandler<GetAllModulesRequest> getAllModulesHandler;
        private readonly IComponentHandler<GetAllModulesByListRequest> getAllModulesByListHandler;
        private readonly IComponentHandler<CreateModuleRequest> createModuleHandler;
        private readonly IComponentHandler<UpdateModuleRequest> updateModuleHandler;
        private readonly IComponentHandler<ChangeModuleStatusRequest> changeModuleStatusHandler;
        private readonly IModulePort port;

        /// <summary>
        /// Handles all services and business rules related to <see cref="ModuleController"/>.
        /// </summary>
        public ModuleController(
            IComponentHandler<GetModuleRequest> getModuleHandler,
            IComponentHandler<GetAllModulesRequest> getAllModulesHandler,
            IComponentHandler<GetAllModulesByListRequest> getAllModulesByListHandler,
            IComponentHandler<CreateModuleRequest> createModuleHandler,
            IComponentHandler<UpdateModuleRequest> updateModuleHandler,
            IComponentHandler<ChangeModuleStatusRequest> changeModuleStatusHandler,
            IModulePort port
            )
        {
            this.createModuleHandler = createModuleHandler;
            this.updateModuleHandler = updateModuleHandler;
            this.changeModuleStatusHandler = changeModuleStatusHandler;
            this.getAllModulesHandler = getAllModulesHandler;
            this.getModuleHandler = getModuleHandler;
            this.getAllModulesByListHandler = getAllModulesByListHandler;
            this.port = port;
        }

        /// <summary>
        /// Gets all the modules.
        /// </summary>
        [HttpGet("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("ModuleManagement.Read, RoleManagement.Read")]
        public async Task<IActionResult> GetAllModulesAsync(CancellationToken cancellationToken)
        {
            await getAllModulesHandler.ExecuteAsync(new GetAllModulesRequest { }, cancellationToken).ConfigureAwait(false);

            return port.ViewModel;
        }

        /// <summary>
        /// Gets all the modules by module identifiers.
        /// </summary>
        /// <param name="request">The request containing the list of module identifiers.</param>
        /// <param name="cancellationToken">Cancellation token for the asynchronous operation.</param>
        /// <returns>The <see cref="IActionResult"/> representing the result of the service call.</returns>
        /// <response code="200">The modules found.</response>
        /// <response code="204">No content if no modules are found.</response>
        /// <response code="400">Bad request if the module identifiers are missing or invalid.</response>
        /// <response code="401">Unauthorized if the user is not authenticated.</response>
        /// <response code="412">Precondition failed if the request does not meet expected conditions.</response>
        /// <response code="422">Unprocessable entity if the request cannot be processed.</response>
        /// <response code="500">Internal server error if an unexpected error occurs.</response>
        [HttpPost]
        [Route(Routes.GetModuleList)]
        [ProducesResponseType(typeof(IEnumerable<ModuleAdapter>), 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("ModuleManagement.Read")]
        public async Task<IActionResult> GetAllModulesByListAsync([FromBody] GetAllModulesByListRequest request, CancellationToken cancellationToken)
        {

            if (request == null || request.Modules == null || !request.Modules.Any())
            {
                return BadRequest("Module identifiers are required.");
            }

            await getAllModulesByListHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);

            return port.ViewModel;
        }

        /// <summary>
        /// Gets the module 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("ModuleManagement.Read")]
        public async Task<IActionResult> GetModuleById([FromBody] GetModuleRequest request, CancellationToken cancellationToken)
        {

            if (request.Id == null || !request.Id.Any())
            {
                return BadRequest("Invalid Module Id");
            }

            await getModuleHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);

            return port.ViewModel;
        }

        /// <summary>
        /// Creates a new module.
        /// </summary>
        [HttpPost("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("ModuleManagement.Write")]
        public async Task<IActionResult> CreateModuleAsync([FromBody] CreateModuleRequest newModule, CancellationToken cancellationToken = default)
        {
            await createModuleHandler.ExecuteAsync(newModule, cancellationToken).ConfigureAwait(false);

            return port.ViewModel;
        }

        /// <summary>
        /// Updates a full module 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("ModuleManagement.Write")]
        public async Task<IActionResult> UpdateModuleAsync([FromBody] UpdateModuleRequest request, CancellationToken cancellationToken = default)
        {
            await updateModuleHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);

            return port.ViewModel;
        }

        /// <summary>
        /// Changes the status of the module.
        /// </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("ModuleManagement.Write")]
        public async Task<IActionResult> ChangeModuleStatusAsync([FromBody] ChangeModuleStatusRequest request,
                                                                     CancellationToken cancellationToken)
        {
            if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid module identifier"); }

            await changeModuleStatusHandler.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);

            return port.ViewModel;
        }
    }
}