Core.Thalos.BFF/Core.Thalos.BFF.Api/Controllers/RoleController.cs

using Asp.Versioning;
using Core.Thalos.Application.UseCases.Roles.Input;
using Core.Thalos.BuildingBlocks;
using Lib.Architecture.BuildingBlocks;
using LSA.Dashboard.External.Clients.Dashboard;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Text.Json;

namespace Core.Thalos.BFF.Api.Controllers
{
    /// <summary>
    /// Handles all requests for role authentication.
    /// </summary>
    [ApiVersion("1.0")]
    [Route("api/v{version:apiVersion}/[controller]")]
    [Consumes("application/json")]
    [Produces("application/json")]
    [ApiController]
    [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
    public class RoleController(IThalosServiceClient thalosServiceClient, ILogger<RoleController> logger) : BaseController(logger)
    {
        /// <summary>
        /// Gets all roles.
        /// </summary>
        [HttpGet("GetAll")]
        [ProducesResponseType(typeof(IEnumerable<RoleAdapter>), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [Permission("RoleManagement.Read")]
        public async Task<IActionResult> GetAllRolesService(CancellationToken cancellationToken)
        {
            try
            {
                logger.LogInformation($"{nameof(GetAllRolesService)} - Request received - Payload: ");

                return await Handle(() => thalosServiceClient.GetAllRolesService(new GetAllRolesRequest { }, cancellationToken)).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                logger.LogError($"{nameof(GetAllRolesService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload");
                throw;
            }
        }

        /// <summary>
        /// Creates a new role.
        /// </summary>
        [HttpPost("Create")]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [Permission("RoleManagement.Write")]
        public async Task<IActionResult> CreateRoleService(CreateRoleRequest request, CancellationToken cancellationToken)
        {
            try
            {
                logger.LogInformation($"{nameof(CreateRoleService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");

                if (request == null) return BadRequest("Invalid role object");

                if (string.IsNullOrEmpty(request.Name)) return BadRequest("Invalid role name");

                if (string.IsNullOrEmpty(request.Description)) return BadRequest("Invalid role description");

                if (request.Applications?.Length <= 0) return BadRequest("Role must have at least one application");

                if (request.Modules?.Length <= 0) return BadRequest("Role must have at least one module");

                if (request.Permissions?.Length <= 0) return BadRequest("Role must have at least one permission");

                return await Handle(() => thalosServiceClient.CreateRoleService(request, cancellationToken)).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                logger.LogError($"{nameof(CreateRoleService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
                throw;
            }
        }

        /// <summary>
        /// Gets the role by identifier.
        /// </summary>
        [HttpPost("GetById")]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [Permission("RoleManagement.Read")]
        public async Task<IActionResult> GetRoleByIdService(GetRoleRequest request, CancellationToken cancellationToken)
        {
            try
            {
                logger.LogInformation($"{nameof(GetRoleByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");

                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid role identifier");

                return await Handle(() => thalosServiceClient.GetRoleByIdService(request, cancellationToken)).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                logger.LogError($"{nameof(GetRoleByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
                throw;
            }
        }

        /// <summary>
        /// Updates a full role by identifier.
        /// </summary>
        [HttpPut("Update")]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [Permission("RoleManagement.Write")]
        public async Task<IActionResult> UpdateRoleService(UpdateRoleRequest request, CancellationToken cancellationToken)
        {
            try
            {
                logger.LogInformation($"{nameof(UpdateRoleService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");

                if (request == null) return BadRequest("Invalid role object");

                if (string.IsNullOrEmpty(request.Name)) return BadRequest("Invalid role name");

                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid role identifier");

                if (string.IsNullOrEmpty(request.Description)) return BadRequest("Invalid role description");

                if (request.Applications?.Length <= 0) return BadRequest("Role must have at least one application");

                if (request.Modules?.Length <= 0) return BadRequest("Role must have at least one module");

                if (request.Permissions?.Length <= 0) return BadRequest("Role must have at least one permission");


                return await Handle(() => thalosServiceClient.UpdateRoleService(request, cancellationToken)).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                logger.LogError($"{nameof(UpdateRoleService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
                throw;
            }
        }

        /// <summary>
        /// Changes the status of the role.
        /// </summary>
        [HttpPatch]
        [Route("ChangeStatus")]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [Permission("RoleManagement.Write")]
        public async Task<IActionResult> ChangeRoleStatusService([FromBody] ChangeRoleStatusRequest request, CancellationToken cancellationToken)
        {
            try
            {
                logger.LogInformation($"{nameof(ChangeRoleStatusService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");

                if (string.IsNullOrEmpty(request._Id)) { return BadRequest("Invalid role identifier"); }

                return await Handle(() => thalosServiceClient.ChangeRoleStatusService(request, cancellationToken)).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                logger.LogError($"{nameof(ChangeRoleStatusService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
                throw;
            }
        }

        /// <summary>
        /// Adds an application to the role's list of applications.
        /// </summary>
        [HttpPost]
        [Route("AddApplication")]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [Permission("RoleManagement.Write")]
        public async Task<IActionResult> AddApplicationToRoleService([FromBody] AddApplicationToRoleRequest request, CancellationToken cancellationToken)
        {
            try
            {
                logger.LogInformation($"{nameof(AddApplicationToRoleService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");

                if (string.IsNullOrEmpty(request.RoleId)) { return BadRequest("Invalid role identifier"); }

                return await Handle(() => thalosServiceClient.AddApplicationToRoleService(request, cancellationToken)).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                logger.LogError($"{nameof(AddApplicationToRoleService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
                throw;
            }
        }

        /// <summary>
        /// Removes an application from the role's list of applications.
        /// </summary>
        [HttpDelete]
        [Route("RemoveApplication")]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [Permission("RoleManagement.Write")]
        public async Task<IActionResult> RemoveApplicationFromRoleService([FromBody] RemoveApplicationFromRoleRequest request, CancellationToken cancellationToken)
        {
            try
            {
                logger.LogInformation($"{nameof(RemoveApplicationFromRoleService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");

                if (string.IsNullOrEmpty(request.RoleId)) { return BadRequest("Invalid role identifier"); }

                return await Handle(() => thalosServiceClient.RemoveApplicationFromRoleService(request, cancellationToken)).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                logger.LogError($"{nameof(RemoveApplicationFromRoleService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
                throw;
            }
        }

        /// <summary>
        /// Deletes the Role by identifier.
        /// </summary>
        [HttpDelete("Delete")]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [Permission("RoleManagement.Write")]
        public async Task<IActionResult> DeleteRoleByIdService(DeleteRoleRequest request, CancellationToken cancellationToken)
        {
            try
            {
                logger.LogInformation($"{nameof(DeleteRoleByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");

                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid Role identifier");

                return await Handle(() => thalosServiceClient.DeleteRoleByIdService(request, cancellationToken)).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                logger.LogError($"{nameof(DeleteRoleByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
                throw;
            }
        }
    }
}