216 lines
10 KiB
C#
216 lines
10 KiB
C#
// ***********************************************************************
|
|
// <copyright file="UserController.cs">
|
|
// AgileWebs
|
|
// </copyright>
|
|
// ***********************************************************************
|
|
|
|
using Asp.Versioning;
|
|
using Core.Thalos.BuildingBlocks;
|
|
using Core.Thalos.Provider.Contracts;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
|
|
using UserRequest = Core.Thalos.Domain.Contexts.Onboarding.Request.UserRequest;
|
|
|
|
namespace LSA.Core.Thalos.API.Controllers
|
|
{
|
|
/// <summary>
|
|
/// Handles all requests for user authentication.
|
|
/// </summary>
|
|
[ApiVersion("1.0")]
|
|
[Route("api/v{api-version:apiVersion}/[controller]")]
|
|
[Produces(MimeTypes.ApplicationJson)]
|
|
[Consumes(MimeTypes.ApplicationJson)]
|
|
[ApiController]
|
|
public class UserController(IUserProvider service) : ControllerBase
|
|
{
|
|
/// <summary>
|
|
/// Gets all users.
|
|
/// </summary>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="IEnumerable{UserAdapter}"/> found entity.</returns>
|
|
[HttpGet]
|
|
[ProducesResponseType(typeof(IEnumerable<UserAdapter>), StatusCodes.Status200OK)]
|
|
[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
|
|
[Permission("UserManagement.Read")]
|
|
public async Task<IActionResult> GetAllUsers(CancellationToken cancellationToken)
|
|
{
|
|
var result = await service.GetAllUsers(cancellationToken).ConfigureAwait(false);
|
|
return Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the user by mongo identifier.
|
|
/// </summary>
|
|
/// <param name="_id">The user Mongo identifier.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="UserAdapter"/> found entity.</returns>
|
|
[HttpGet]
|
|
[Route(Routes.Id)]
|
|
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
|
|
[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
|
|
[Permission("UserManagement.Read")]
|
|
public async Task<IActionResult> GetUserById([FromRoute] string _id, CancellationToken cancellationToken)
|
|
{
|
|
var result = await service.GetUserById(_id, cancellationToken).ConfigureAwait(false);
|
|
return result == null ? NotFound("User not found") : Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the user by email.
|
|
/// </summary>
|
|
/// <param name="email">The user's email.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="UserAdapter"/> found entity.</returns>
|
|
[HttpGet]
|
|
[Route(Routes.Email)]
|
|
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
|
|
[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
|
|
public async Task<IActionResult> GetUserByEmail([FromRoute] string email, CancellationToken cancellationToken)
|
|
{
|
|
var result = await service.GetUserByEmail(email, cancellationToken).ConfigureAwait(false);
|
|
return result == null ? NotFound("User not found") : Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates if a user exists on the database.
|
|
/// </summary>
|
|
/// <param name="email">The user's email.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="UserExistenceAdapter"/> indicating existence.</returns>
|
|
[HttpGet]
|
|
[Route("{email}/ValidateExistence")]
|
|
[ProducesResponseType(typeof(UserExistenceAdapter), StatusCodes.Status200OK)]
|
|
[AllowAnonymous]
|
|
public async Task<IActionResult> ValidateUserExistence([FromRoute] string email, CancellationToken cancellationToken)
|
|
{
|
|
var result = await service.ValidateUserExistence(email, cancellationToken).ConfigureAwait(false);
|
|
return result == null ? NotFound("User not found") : Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new user.
|
|
/// </summary>
|
|
/// <param name="newUser">The user to be added.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="UserAdapter"/> created entity.</returns>
|
|
[HttpPost(Routes.Register)]
|
|
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status201Created)]
|
|
[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
|
|
[Permission("UserManagement.Write")]
|
|
public async Task<IActionResult> CreateUserAsync([FromBody] UserRequest newUser, CancellationToken cancellationToken)
|
|
{
|
|
var result = await service.CreateUser(newUser, cancellationToken).ConfigureAwait(false);
|
|
return Created("CreatedWithIdAsync", result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates a full user by mongo identifier.
|
|
/// </summary>
|
|
/// <param name="_id">The user Mongo identifier.</param>
|
|
/// <param name="entity">The user to update.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
|
|
[HttpPut]
|
|
[Route(Routes.Id)]
|
|
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
|
|
[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
|
|
[Permission("UserManagement.Write")]
|
|
public async Task<IActionResult> UpdateUserAsync([FromRoute] string _id, [FromBody] UserAdapter entity, CancellationToken cancellationToken)
|
|
{
|
|
if (_id != entity._Id)
|
|
return BadRequest("User ID mismatch");
|
|
|
|
var result = await service.UpdateUser(entity, cancellationToken).ConfigureAwait(false);
|
|
return Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Logs in the user.
|
|
/// </summary>
|
|
/// <param name="email">The user's email.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="UserAdapter"/> found entity.</returns>
|
|
[HttpPatch(Routes.LogIn)]
|
|
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
|
|
[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
|
|
public async Task<IActionResult> LoginUserAsync([FromRoute] string email, CancellationToken cancellationToken)
|
|
{
|
|
var result = await service.LogInUser(email, cancellationToken).ConfigureAwait(false);
|
|
return result == null ? NotFound($"The user with email: '{email}' was not found") : Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Logs out the user.
|
|
/// </summary>
|
|
/// <param name="email">The user's email.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
|
|
[HttpPatch(Routes.LogOut)]
|
|
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
|
|
[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
|
|
public async Task<IActionResult> LogOutUserSessionAsync([FromRoute] string email, CancellationToken cancellationToken)
|
|
{
|
|
var result = await service.LogOutUserSession(email, cancellationToken).ConfigureAwait(false);
|
|
return Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the status of the user.
|
|
/// </summary>
|
|
/// <param name="_id">The user Mongo identifier.</param>
|
|
/// <param name="newStatus">The new status of the user.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
|
|
[HttpPatch]
|
|
[Route(Routes.ChangeStatus)]
|
|
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
|
|
[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
|
|
[Permission("UserManagement.Write")]
|
|
public async Task<IActionResult> ChangeUserStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
|
|
{
|
|
var result = await service.ChangeUserStatus(_id, newStatus, cancellationToken).ConfigureAwait(false);
|
|
|
|
if (result == null)
|
|
return NotFound("User not found");
|
|
|
|
return Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a token for the user, including roles, permissions, and modules.
|
|
/// </summary>
|
|
/// <param name="email">The user's email.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The <see cref="TokenAdapter"/> with user details.</returns>
|
|
[HttpGet]
|
|
[Route("{email}/GetTokenAdapter")]
|
|
[ProducesResponseType(typeof(TokenAdapter), StatusCodes.Status200OK)]
|
|
[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
|
|
public async Task<IActionResult> GetTokenAdapter([FromRoute] string email, CancellationToken cancellationToken)
|
|
{
|
|
var tokenAdapter = await service.GetToken(email, cancellationToken).ConfigureAwait(false);
|
|
return tokenAdapter == null ? NotFound($"User with email: {email} not found") : Ok(tokenAdapter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes a user by mongo identifier.
|
|
/// </summary>
|
|
/// <param name="_id">The user Mongo identifier.</param>
|
|
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
|
|
/// <returns>The deleted <see cref="UserAdapter"/> entity.</returns>
|
|
/// <response code="200">The user deleted.</response>
|
|
/// <response code="404">The user not found.</response>
|
|
[HttpDelete]
|
|
[Route(Routes.Id)]
|
|
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
|
|
[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
|
|
[Permission("UserManagement.Write")]
|
|
public async Task<IActionResult> DeleteUserAsync([FromRoute] string _id, CancellationToken cancellationToken)
|
|
{
|
|
var result = await service.DeleteUser(_id, cancellationToken).ConfigureAwait(false);
|
|
return result == null ? NotFound("User not found") : Ok(result);
|
|
}
|
|
}
|
|
}
|