Core.Thalos.DAL.API/Core.Thalos.DAL.API/Controllers/ModuleController.cs

// ***********************************************************************
// <copyright file="ModuleController.cs">
//     AgileWebs
// </copyright>
// ***********************************************************************

using Asp.Versioning;
using Core.Blueprint.Mongo;
using Core.Thalos.Adapters;
using Core.Thalos.Adapters.Attributes;
using Core.Thalos.Adapters.Common.Constants;
using Core.Thalos.Provider.Contracts;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Graph;
using ModuleRequest = Core.Thalos.Domain.Contexts.Onboarding.Request.ModuleRequest;

namespace LSA.Core.Thalos.API.Controllers
{
    /// <summary>
    /// Handles all requests for module authentication.
    /// </summary>
    [ApiVersion(MimeTypes.ApplicationVersion)]
    [Route("api/v{api-version:apiVersion}/[controller]")]
    [Produces(MimeTypes.ApplicationJson)]
    [Consumes(MimeTypes.ApplicationJson)]
    [ApiController]
    [AllowAnonymous]
    public class ModuleController(IModuleProvider service) : ControllerBase
    {
        /// <summary>
        /// Gets all the modules.
        /// </summary>
        /// <returns>The <see cref="IEnumerable{ModuleAdapter}"/> found entities.</returns>
        /// <response code="200">The roles found.</response>
        /// <response code="404">The roles not found error.</response>
        /// <response code="500">The service internal error.</response>
        [HttpGet]
        [Consumes(MimeTypes.ApplicationJson)]
        [Produces(MimeTypes.ApplicationJson)]
        [ProducesResponseType(typeof(IEnumerable<ModuleAdapter>), StatusCodes.Status200OK)]
        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        //[Permission("ModuleManagement.Read, RoleManagement.Read")]
        public async Task<IActionResult> GetAllModulesAsync(CancellationToken cancellationToken)
        {
            var result = await service.GetAllModules(cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }

        /// <summary>
        /// Gets all the modules by module identifiers.
        /// </summary>
        /// <param name="modules">The list of module identifiers.</param>
        /// <returns>The <see cref="IEnumerable{ModuleAdapter}"/> found entities.</returns>
        /// <response code="200">The modules found.</response>
        /// <response code="404">The modules not found error.</response>
        /// <response code="500">The service internal error.</response>
        [HttpPost]
        [Route(Routes.GetModuleList)]
        [Consumes(MimeTypes.ApplicationJson)]
        [Produces(MimeTypes.ApplicationJson)]
        [ProducesResponseType(typeof(IEnumerable<ModuleAdapter>), StatusCodes.Status200OK)]
        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        //[Permission("ModuleManagement.Read")]
        public async Task<IActionResult> GetAllModulesByList([FromBody] string[] modules, CancellationToken cancellationToken)
        {
            if (modules == null || !modules.Any())
            {
                return BadRequest("Module identifiers are required.");
            }

            var result = await service.GetAllModulesByList(modules, cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }


        /// <summary>
        /// Gets the module by identifier.
        /// </summary>
        /// <param name="id">The module identifier.</param>
        /// <returns>The <see cref="ModuleAdapter"/> found entity.</returns>
        /// <response code="200">The module found.</response>
        /// <response code="404">The module not found error.</response>
        /// <response code="500">The service internal error.</response>
        [HttpGet]
        [Route(Routes.Id)]
        [Consumes(MimeTypes.ApplicationJson)]
        [Produces(MimeTypes.ApplicationJson)]
        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        //[Permission("ModuleManagement.Read")]
        public async Task<IActionResult> GetModuleByIdAsync([FromRoute] string id, CancellationToken cancellationToken)
        {
            var result = await service.GetModuleById(id, cancellationToken).ConfigureAwait(false);

            if (result == null)
            {
                return NotFound("Entity not found");
            }

            return Ok(result);
        }

        /// <summary>
        /// Creates a new module.
        /// </summary>
        /// <param name="newModule">The module to be added.</param>
        /// <returns>The <see cref="ModuleAdapter"/> created entity.</returns>
        /// <response code="201">The module created.</response>
        /// <response code="422">The module could not be created.</response>
        /// <response code="500">The service internal e|ror.</response>
        [HttpPost]
        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status201Created)]
        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        //[Permission("ModuleManagement.Write")]
        public async Task<IActionResult> CreateModuleAsync([FromBody] ModuleRequest newModule, CancellationToken cancellationToken)
        {
            var result = await service.CreateModule(newModule, cancellationToken).ConfigureAwait(false);
            return Created("CreatedWithIdAsync", result);
        }

        /// <summary>
        /// Updates a full module by identifier.
        /// </summary>
        /// <param name="entity">The module to update.</param>
        /// <param name="id">The module identifier.</param>
        /// <returns>The <see cref="ModuleAdapter"/> updated entity.</returns>
        /// <response code="200">The module updated.</response>
        /// <response code="404">The module not found.</response>
        /// <response code="422">The module could not be updated.</response>
        /// <response code="500">The service internal error.</response>
        [HttpPut]
        [Route(Routes.Id)]
        [Consumes(MimeTypes.ApplicationJson)]
        [Produces(MimeTypes.ApplicationJson)]
        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        //[Permission("ModuleManagement.Write")]
        public async Task<IActionResult> UpdateModuleAsync([FromRoute] string id, ModuleAdapter entity, CancellationToken cancellationToken)
        {
            if (id != entity._Id?.ToString())
            {
                return BadRequest("Module ID mismatch");
            }

            var result = await service.UpdateModule(entity, cancellationToken).ConfigureAwait(false);

            return Ok(result);
        }

        /// <summary>
        /// Changes the status of the module.
        /// </summary>
        /// <param name="id">The module identifier.</param>
        /// <param name="newStatus">The new status of the module.</param>
        /// <returns>The <see cref="ModuleAdapter"/> updated entity.</returns>
        /// <response code="200">The module updates.</response>
        /// <response code="404">The module not found.</response>
        /// <response code="422">The module could not be deleted.</response>
        /// <response code="500">The service internal error.</response>
        [HttpPatch]
        [Route(Routes.ChangeStatus)]
        [Consumes(MimeTypes.ApplicationJson)]
        [Produces(MimeTypes.ApplicationJson)]
        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        //[Permission("ModuleManagement.Write")]
        public async Task<IActionResult> ChangeModuleStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
        {
            var result = await service.ChangeModuleStatus(id, newStatus, cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }
    }
}