AlquilaFacil/Aspnet/Controllers/UsuarioController.cs

using AlquilaFacil.Builder;
using Microsoft.AspNetCore.Mvc;
using Modelo;
using Entidades;
using AlquilaFacil.Emailer.Sender;

namespace AlquilaFacil.Controllers;

[ApiController]
public class UsuarioController : ControllerBase
{
    [HttpGet("/api/usuario")]
    public IActionResult ObtenerInfoUsuario([FromHeader(Name = "Auth")] string Auth)
    {
        Cliente? cli = RepositorioUsuarios.Singleton.ObtenerClientePorToken(Auth);
        if (cli == null) return BadRequest(new { message = "No hay un usuari por ese token" });

        var usu = new UsuarioDtoBuilder()
            .SetNombre(cli.Nombre).SetApellido(cli.Apellido)
            .SetEmail(cli.Email).SetCelular(cli.Celular)
            .SetDni(cli.Dni).SetDomicilio(cli.Domicilio)
            .SetEmailRecuperacion(cli.EmailRecuperacion)
            .Build();
        return Ok(usu);
    }

    public class bodyCambiarContraseña
    {
        public string contraseña { get; set; } = "";
    }

    [HttpPatch("/api/usuario")]
    public IActionResult CambiarPass([FromHeader(Name = "Auth")] string Auth, [FromBody] bodyCambiarContraseña body)
    {
        Cliente? cli = RepositorioUsuarios.Singleton.ObtenerClientePorToken(Auth);
        if (cli == null) return BadRequest(new { message = "No hay un usuario por ese token" });

        if (body.contraseña.Length < 8) return BadRequest(new { message = "Tiene que tener por lo menos 8 caracteres" });

        bool ret = RepositorioUsuarios.Singleton.CambiarContraseña(body.contraseña, cli);
        return ret ? Ok(new { message = "Contraseña cambiada con éxito" }) : BadRequest(new { message = "No se pudo cambiar la contraseña" });
    }

    public class bodyCambiarContraAdmin : bodyCambiarContraseña
    {
        public long Dni { get; set; }
    }

    [HttpPatch("/api/admin/contraseña")]
    public IActionResult CambiarPassAdmin([FromHeader(Name = "Auth")] string Auth, [FromBody] bodyCambiarContraAdmin body)
    {
        var ret = RepositorioPermisos.Singleton.CheckPermisos(Auth, 9);
        if (!ret) return BadRequest(new { message = "No tienes permisos para cambiar contraseñas de usuario" });

        if (body.contraseña.Length < 8 || string.IsNullOrWhiteSpace(body.contraseña)) return BadRequest(new { message = "La contraseña debe tener al menos 8 caracteres y no puede estar vacía" });

        if (body.Dni <= 0) return BadRequest(new { message = "El DNI no puede estar vacío" });

        Cliente? usu = RepositorioUsuarios.Singleton.ObtenerClientePorDni(body.Dni);
        if (usu == null) return BadRequest(new { message = "No existe un usuario con ese DNI" });

        ret = RepositorioUsuarios.Singleton.CambiarContraseña(body.contraseña, usu);
        return ret ? Ok(new { message = "Contraseña cambiada con éxito" }) : BadRequest(new { message = "No se pudo cambiar la contraseña" });

    }

    public record SetEmail(string EmailRecuperacion);
    [HttpPut("/api/usuario/emailrecuperacion")]
    public IActionResult CambiarPass([FromHeader(Name = "Auth")] string Auth, [FromBody] SetEmail setemail)
    {
        Cliente? cli = RepositorioUsuarios.Singleton.ObtenerClientePorToken(Auth);
        if (cli == null) return BadRequest(new { message = "No hay un usuario por ese token" });

        string emailrecuperacion = setemail.EmailRecuperacion;
        if (!emailrecuperacion.Contains("@")) return BadRequest(new { message = "Tiene que ser un email" });

        bool ret = RepositorioUsuarios.Singleton.SetEmailRecuperacion(emailrecuperacion, cli);
        if (ret == false) return BadRequest(new { message = "No se pudo actualizar el email de recuperación" });

        Task.Run(() =>
        {
            AvisoEmailSender s = new();
            s.Send(cli.Email, setemail.EmailRecuperacion);
        });

        return Ok(new { message = "Email de recuperación actualizado con éxito" });
    }

    public record RecuperarUsuarioDto(string Email, string EmailRecuperacion);
    [HttpPost("/api/recuperarUsuario")]
    public IActionResult RecuperarUsuario([FromBody] RecuperarUsuarioDto mails)
    {
        bool check = RepositorioUsuarios.Singleton.CheckEmailRecuperacion(mails.Email, mails.EmailRecuperacion);
        if (check == false) return BadRequest(new { message = "El email no corresponde al email de recuperacion" });

        string pin = "";
        var ran = new Random();
        for (int i = 0; i < 6; i++) pin += ran.Next(0, 10);

        bool ret = RepositorioUsuarios.Singleton.SetF2aPin(pin, mails.Email);
        if (ret == false) return BadRequest(new { message = "no se pudo generar/guardar el codigo 2fa" });

        Task.Run(() =>
        {
            OtpEmailSender s = new();
            s.Send(mails.EmailRecuperacion, mails.Email, pin);
        });

        return Ok(new { message = $"Se envio un email de recuperacion a {mails.EmailRecuperacion}" });
    }

    public record ingreso2fa(string Pin, string Email);
    [HttpPost("/api/ingresar2fa")]
    public IActionResult IngresarUsuario([FromBody] ingreso2fa data)
    {
        if (!data.Email.Contains("@")) return BadRequest(new { message = "Tiene que ser un email" });
        if (data.Pin.Length != 6) return BadRequest(new { message = "el pin tiene que tener 6 digitos" });

        (bool check, long Dni) = RepositorioUsuarios.Singleton.Check2fa(data.Email, data.Pin);
        if (check == false) return BadRequest(new { message = "El pin es incorrecto" });

        var cli = RepositorioUsuarios.Singleton.ObtenerClientePorDni(Dni);

        //esto literalmente no se puede triggerear pero lo pongo para evitar una warning
        if (cli == null) return BadRequest(new { message = "El usuario no existe" });

        return Ok(new { token = cli.Token });
    }

    public record Crearusuario(long Dni, string Nombre, string Apellido, string Domicilio, string Celular,
                               string Email, string Contraseña, string? EmailRecuperacion, List<int> grupos);
    [HttpPost("api/crearusuario")]
     public IActionResult CrearUsuario([FromHeader(Name ="Auth")] string Auth, [FromBody] Crearusuario cu)
     {
         var ret = RepositorioPermisos.Singleton.CheckPermisos(Auth, 19);
         if (!ret) return BadRequest(new { message = "No tienes permisos para Crear un usuario" });

         Cliente? cli = RepositorioUsuarios.Singleton.ObtenerClientePorToken(Auth);
         if (cli == null) return BadRequest(new { message = "No hay un usuario por ese token" });

         string rett = "";

         if (cu.Dni <= 0)
             rett += "No puede haber un documento con numero menor o igual a 0";
         if (cu.Apellido.Length > 20)
             rett += "Apellido excede los 20 caracteres. ";
         if (cu.Nombre.Length > 20)
             rett += "Nombre excede los 20 caracteres. ";
         if (cu.Celular.Length > 40)
             rett += "Celular excede los 40 caracteres. ";
         if (cu.Domicilio.Length > 40)
             rett += "Domicilio excede los 40 caracteres. ";
         if (cu.Email.Length > 50)
             rett += "Email excede los 50 caracteres. ";
         if (cu.EmailRecuperacion?.Length > 50)
             rett += "Email de recuperación excede los 50 caracteres. ";

         if (rett != "") return BadRequest(new { message = rett });

        Cliente clii = new Cliente
        {
            Habilitado = 1,
            Dni = cu.Dni,
            Nombre = cu.Nombre,
            Apellido = cu.Apellido,
            Celular = cu.Celular,
            Email = cu.Email,
            EmailRecuperacion = ((cu.EmailRecuperacion ?? "").Length == 0) ? cu.Email : cu.EmailRecuperacion,
            Domicilio = cu.Domicilio
        };

         var rettt = RepositorioUsuarios.Singleton.AltaUsuario(cli.Dni, clii, cu.Contraseña, cu.grupos);

        return rettt
            ? Ok(new { message = "Usuario creado exitosamente." })
            : BadRequest(new { message = "Hubo un error al crear el usuario." });     }
}