phronCare/phronCare.API/Controllers/AccountController.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Authorization;
using phronCare.API.Models.Account;

namespace phronCare.API.Controllers
{
    [Authorize(Roles = "Admin")]
    [Route("api/[controller]")]
    [ApiController]
    public class AccountController : ControllerBase
    {
        private readonly RoleManager<IdentityRole> _roleManager;
        private readonly UserManager<IdentityUser> _userManager;

        public AccountController(RoleManager<IdentityRole> roleManager, UserManager<IdentityUser> userManager)
        {
            _roleManager = roleManager;
            _userManager = userManager;
        }

        // Endpoint para obtener todos los roles
        [HttpGet("GetAllRoles")]
        public IActionResult GetAllRoles()
        {
            var roles = _roleManager.Roles.ToList();
            return Ok(roles);
        }
        [HttpGet("GetRoleById/{id}")]
        public IActionResult GetRoleById(string id)
        {
            var role = _roleManager.Roles
                .Where(_ => _.Id == id.TrimStart('{').TrimEnd('}'))
                .FirstOrDefault();
            return Ok(role);
        }
        [HttpPut("UpdateRole/{id}")]
        public async Task<IActionResult> UpdateRole(string id, Role model)
        {
            var role = await _roleManager.FindByIdAsync(id);
            if (role == null)
            {
                return NotFound("Rol no encontrado");
            }

            // Actualizar propiedades del rol
            role.Name = model.Name;
            role.NormalizedName = model.NormalizedName;

            // Actualizar el rol en la base de datos
            var result = await _roleManager.UpdateAsync(role);

            if (result.Succeeded)
            {
                return Ok("Rol actualizado exitosamente");
            }
            else
            {
                return BadRequest("Error al actualizar el rol");
            }
        }
        [HttpPost("CreateRole")]
        public async Task<IActionResult> CreateRole(Role model)
        {
            // Verifica si el rol ya existe
            var existingRole = await _roleManager.FindByNameAsync(model.Name);
            if (existingRole != null)
            {
                return BadRequest("El rol ya existe.");
            }

            // Crea un nuevo rol
            var newRole = new IdentityRole
            {
                Name = model.Name,
                NormalizedName = model.Name.ToUpper(), // Normaliza el nombre, generalmente a mayúsculas
                ConcurrencyStamp = Guid.NewGuid().ToString()
            };

            var result = await _roleManager.CreateAsync(newRole);

            if (result.Succeeded)
            {
                return Ok("Rol creado exitosamente.");
            }
            else
            {
                // Manejar errores en la creación del rol
                var errors = result.Errors.Select(e => e.Description);
                return BadRequest("Error al crear el rol: " + string.Join(", ", errors));
            }
        }
        // Endpoint para eliminar un rol
        [HttpDelete("DeleteRole/{roleId}")]
        public IActionResult DeleteRole(string roleId)
        {
            // Verifica si el rol existe
            var existingRole = _roleManager.FindByIdAsync(roleId).Result;
            if (existingRole == null)
            {
                return NotFound("El rol no se encontró.");
            }

            // Evita la eliminación del rol "Admin"
            if (existingRole.Name.ToLower() == "admin")
            {
                return BadRequest("No se puede eliminar el rol 'Admin'.");
            }

            // Realiza la eliminación del rol en la base de datos
            var result = _roleManager.DeleteAsync(existingRole).Result;
            if (result.Succeeded)
            {
                return Ok("El rol se eliminó exitosamente.");
            }
            else
            {
                return BadRequest("Error al eliminar el rol.");
            }
        }
        // Endpoint para obtener todos los usuarios
        [HttpGet("GetAllUsers")]
        public IActionResult GetAllUsers()
        {
            var users = _userManager.Users.ToList();
            return Ok(users);
        }
        [HttpGet("GetUserById/{id}")]
        public IActionResult GetUserById(string id)
        {
            var user = _userManager.Users
                .Where(_ => _.Id == id.TrimStart('{').TrimEnd('}'))
                .FirstOrDefault();
            return Ok(user);
        }
        [HttpPut("UpdateUser/{id}")]
        public async Task<IActionResult> UpdateUser(string id, UserUpdate? model)
        {
            var user = await _userManager.FindByIdAsync(id);
            if (user == null)
            {
                return NotFound("Usuario no encontrado");
            }
            // Actualizar propiedades del rol
            user.UserName = model.UserName;
            user.NormalizedUserName = model.UserName.ToLower();
            user.Email = model.Email;
            user.NormalizedEmail = model.Email.ToLower();
            user.TwoFactorEnabled = model.TwoFactorEnabled;
            user.LockoutEnabled = model.LockoutEnabled;

            // Actualizar el usuario en la base de datos
            var result = await _userManager.UpdateAsync(user);

            if (result.Succeeded)
            {
                return Ok("usuario actualizado exitosamente");
            }
            else
            {
                return BadRequest("Error al actualizar el usuario");
            }
        }

        // Endpoint para eliminar un usuario
        [HttpDelete("DeleteUser/{userId}")]
        public IActionResult DeleteUser(string UserId)
        {
            // Verifica si el usuario existe
            var existingUser = _userManager.FindByIdAsync(UserId).Result;
            if (existingUser == null)
            {
                return NotFound("El usuario no se encontró.");
            }

            // Evita la eliminación del usuario "SuperAdmin"
            if (existingUser.UserName.ToLower() == "superdmin")
            {
                return BadRequest("No se puede eliminar el usuario 'SuperAdmin'.");
            }

            // Realiza la eliminación del rol en la base de datos
            var result = _userManager.DeleteAsync(existingUser).Result;
            if (result.Succeeded)
            {
                return Ok("El usuario se eliminó exitosamente.");
            }
            else
            {
                return BadRequest("Error al eliminar el usuario.");
            }
        }
    }
}