Apigateway/Microservicios/MsUsuarios/Controllers/UsuariosController.cs

using MSAdminUsuarios.Context;
using Microsoft.AspNetCore.Mvc;
using MSAdminUsuarios.Dto;
using Security;
using MSAdminUsuarios.Models;
using Microsoft.AspNetCore.Components.Forms;
using Microsoft.EntityFrameworkCore;
using System.Configuration;

namespace MSAdminUsuarios.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class UsuariosController : ControllerBase
    {
        private readonly ModelContext _context;
        private readonly Encripter _encript = new();

        public UsuariosController(ModelContext context)
        {
            _context = context;
        }

        [HttpPost("UserBene")]
        public async Task<IActionResult> PostUserBeneficiario(string TX_IDENTIFICACION_AFIL)
        {
            ErrorModel _errorModel = new ErrorModel();
            try
            {
                if (TX_IDENTIFICACION_AFIL == null)
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("Ingrese un dato");
                    return Ok(_errorModel);
                }

                USUARIO user = new USUARIO();

                user.TX_PKDOC_USUMS = TX_IDENTIFICACION_AFIL;
                user.TX_LOGINNAME_USUMS = TX_IDENTIFICACION_AFIL;
                user.TX_PASSWORD_USUMS = _encript.EncryptPwd(TX_IDENTIFICACION_AFIL);

                _context.USUARIOSMs.Add(user);
                await _context.SaveChangesAsync();

                _errorModel.error = false;
                _errorModel.cuerpo.Add("Usuario creado");
                return Ok(_errorModel);

            }
            catch (Exception)
            {
                _errorModel.error = true;
                _errorModel.cuerpo.Add("Problemas con la base de datos");
                return BadRequest(_errorModel);

            }
        }

        [HttpGet("Iniciales")]
        public async Task<IActionResult> GetIniciales(string TX_PKDOC_USUMS)
        {
            try
            {
                var consulta = _context.USUARIOSMs.FirstOrDefault(x => x.TX_PKDOC_USUMS == TX_PKDOC_USUMS);

                var ininame = consulta.TX_PRIMERNOM_USUMS.ToCharArray();
                var iniape = consulta.TX_PRIMERAPELL_USUMS.ToCharArray();

                NameObject nombreObjeto = new NameObject()
                {
                    iniciales = ininame[0].ToString() + iniape[0].ToString(),
                    nombre = consulta.TX_PRIMERNOM_USUMS.ToString() + " " + consulta.TX_PRIMERAPELL_USUMS.ToString(),
                    pk = consulta.NU_PK_USUMS,
                };

                return Ok(nombreObjeto);
            }
            catch (Exception ex)
            {
                return BadRequest(ex);
            }
        }

        [HttpGet]
        public async Task<IActionResult> GetUsuarios()
        {
            try
            {
                List<UsuarioDTO> consulta = new List<UsuarioDTO>();

                consulta = (from dm in _context.USUARIOSMs
                            where dm.NU_ESTADO_USUMS >= 0
                            select new UsuarioDTO(dm)).ToList();

                return Ok(consulta);
            }
            catch (Exception ex)
            {
                return BadRequest(ex);
            }
        }

        /**
         * identificacion public string TX_PKDOC_USUMS { get; set; } = null!;
         * pk public int? NU_PK_USUMS { get; set; }
         */
        [HttpGet("/Usuario")]
        public async Task<IActionResult> GetUsuario(int? clave, string? documento)
        {
            ErrorModel _errorModel = new ErrorModel();
            try
            {
                if (clave == null && documento == null) 
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("Sin datos de busqueda.");
                    return Conflict(_errorModel);
                }
                if (clave != null) {
                    var consulta = await _context.USUARIOSMs.FirstOrDefaultAsync(u => u.NU_PK_USUMS == clave);
                    if (consulta != null) return Ok(consulta);
                }
                if (documento != null) {
                
                    var consulta = await _context.USUARIOSMs.FirstOrDefaultAsync(u => u.TX_PKDOC_USUMS == documento);
                    if (consulta != null) return Ok(consulta);
                }
                _errorModel.error = true;
                _errorModel.cuerpo.Add("No se encontró coincidencia.");
                return Conflict(_errorModel);
            }
            catch (Exception ex)
            {
                _errorModel.error = true;
                _errorModel.cuerpo.Add("Problema con la base de datos.");
                return BadRequest(_errorModel);
            }
        }


        /*[HttpGet("ConsultaFirma")]
        public async Task<IActionResult> GetFirma(string TX_IDENTIFICACION_AFIL)
        {
            ErrorModel _errorModel = new ErrorModel();
            try
            {
                USUARIO usuario = await _context.USUARIOSMs.OrderBy(u => u.NU_PK_USUMS).FirstOrDefaultAsync(u => u.TX_PKDOC_USUMS == TX_IDENTIFICACION_AFIL); 

                if (usuario == null)
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("Usuario no existe");
                    return Conflict(_errorModel);
                }

                return Ok(usuario.CL_FIRMA_USUMS);
            }
            catch (Exception ex)
            {
                return BadRequest(ex);
            }
        }*/

        [HttpPost]
        public async Task<IActionResult> GuardarUsuarios(USUARIO usuario)
        {
            try
            {
                if (usuario == null) return Conflict();

                if (usuario.TX_CORREO_USUMS == null) return Conflict("Indique algún correo.");

                var login_name = usuario.TX_CORREO_USUMS.Split('@');

                var existe_login = _context.USUARIOSMs.Where(x => x.TX_LOGINNAME_USUMS == login_name[0]).Count();

                if (existe_login > 0) return Conflict("El login ya está en uso");

                usuario.TX_LOGINNAME_USUMS = login_name[0];

                if (usuario.TX_PKDOC_USUMS == null)
                {
                    var ult = _context.USUARIOSMs.Max(x => x.NU_PK_USUMS) + 1;
                    usuario.TX_PKDOC_USUMS = ult.ToString();
                }

                if (usuario.TX_PASSWORD_USUMS != null)
                {
                    usuario.TX_PASSWORD_USUMS = _encript.EncryptPwd(usuario.TX_PASSWORD_USUMS);
                }



                _context.USUARIOSMs.Add(usuario);
                await _context.SaveChangesAsync();
                return Ok();
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpPatch]
        public async Task<IActionResult> EditarUsuarios(USUARIO editado)
        {
            ErrorModel _errorModel = new ErrorModel();

            using (var dbContextTransaction = _context.Database.BeginTransaction())
            {
                try
                {
                    if (editado == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Ingrese datos");
                        return Conflict(_errorModel);
                    }

                    var existe = _context.USUARIOSMs.FirstOrDefault(x => x.NU_PK_USUMS == editado.NU_PK_USUMS);

                    if (existe == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("El usuario que desea editar no existe");
                        return Conflict(_errorModel);
                    }

                    existe.TX_PRIMERNOM_USUMS = editado.TX_PRIMERNOM_USUMS;
                    existe.TX_SEGUNDONOM_USUMS = editado.TX_SEGUNDONOM_USUMS;
                    existe.TX_PRIMERAPELL_USUMS = editado.TX_PRIMERAPELL_USUMS;
                    existe.TX_SEGUNDONOM_USUMS = editado.TX_SEGUNDONOM_USUMS;
                    existe.TX_CELULAR_USUMS = editado.TX_CELULAR_USUMS;
                    existe.TX_TELEFONO_USUMS = editado.TX_TELEFONO_USUMS;
                    existe.TX_CORREO_USUMS = editado.TX_CORREO_USUMS;
                    existe.TX_DIRECCION_USUMS = editado.TX_DIRECCION_USUMS;
                    existe.BL_PERTENCEIPS_USUMS = editado.BL_PERTENCEIPS_USUMS;
                    existe.TX_NOMBRE_PVD = editado.TX_NOMBRE_PVD;
                    existe.BL_VIENELDAP_USUMS = editado.BL_VIENELDAP_USUMS;
                    existe.NU_GRUPO_USUMS = editado.NU_GRUPO_USUMS;
                    existe.NU_CARGO_USUMS = editado.NU_CARGO_USUMS;
                    existe.NU_MODALIDADCTT_USUMS = editado.NU_MODALIDADCTT_USUMS;
                    existe.TX_SEDES_USUMS = editado.TX_SEDES_USUMS;


                    ErrorModel errorPFLxUSUMS = await ActualizarRelaciones(existe.TX_PKDOC_USUMS, editado.TX_PKDOC_USUMS);

                    if (errorPFLxUSUMS.error == true)
                    {
                        _errorModel.listaErrores.Add(errorPFLxUSUMS.cuerpo[0]);
                        //return Conflict(_errorModel);
                        throw new Exception();
                    }

                    _errorModel.listaErrores.Add(errorPFLxUSUMS.cuerpo[0]);

                    existe.NU_TIPODOC_USUMS = editado.NU_TIPODOC_USUMS;
                    existe.TX_PKDOC_USUMS = editado.TX_PKDOC_USUMS;

                    _context.USUARIOSMs.Update(existe);
                    _context.SaveChanges();

                    _errorModel.error = false;
                    _errorModel.cuerpo.Add("Usuario actualizado.");
                    dbContextTransaction.Commit();
                    return Ok(_errorModel);
                }
                catch
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("Problema con la base de datos.");
                    dbContextTransaction.Rollback();
                    return BadRequest(_errorModel);
                }
            }
        }
        
        [HttpPatch("NumeroDocumento")]
        public async Task<IActionResult> EditarNoDocumentoUsuarios(USUARIO editado)
        {
            ErrorModel _errorModel = new ErrorModel();

            using (var dbContextTransaction = _context.Database.BeginTransaction())
            {
                try
                {
                    if (editado == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Ingrese datos");
                        return Conflict(_errorModel);
                    }

                    var existe = _context.USUARIOSMs.FirstOrDefault(x => x.NU_PK_USUMS == editado.NU_PK_USUMS);

                    if (existe == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("El usuario que desea editar no existe");
                        return Conflict(_errorModel);
                    }

                    if (existe.TX_PKDOC_USUMS != editado.TX_PKDOC_USUMS || existe.NU_TIPODOC_USUMS != editado.NU_TIPODOC_USUMS)
                    {
                        ErrorModel errorPFLxUSUMS = await ActualizarRelaciones(existe.TX_PKDOC_USUMS, editado.TX_PKDOC_USUMS);

                        if(errorPFLxUSUMS.error == true) {
                            _errorModel.listaErrores.Add(errorPFLxUSUMS.cuerpo[0]);
                            return Conflict(_errorModel);
                        }

                        _errorModel.listaErrores.Add(errorPFLxUSUMS.cuerpo[0]);

                        existe.NU_TIPODOC_USUMS = editado.NU_TIPODOC_USUMS;
                        existe.TX_PKDOC_USUMS = editado.TX_PKDOC_USUMS;
                    }

                    _context.USUARIOSMs.Update(existe);
                    await _context.SaveChangesAsync();

                    _errorModel.error = false;
                    _errorModel.cuerpo.Add("Documento y tipo actualizados.");
                    dbContextTransaction.Commit();
                    return Ok(_errorModel);
                }
                catch
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("Problema con la base de datos.");
                    dbContextTransaction.Rollback();
                    return BadRequest(_errorModel);
                }
            }
        }

        [HttpPatch("Perfil_usu")]    
        public async Task<ErrorModel> ActualizarRelaciones(string TX_PKDOC_USUMS_anterior, string TX_PKDOC_USUMS_nuevo)
        {
            var _errorModel = new ErrorModel();
            try
            {
                var existe_any = _context.PERFILESPORUSUARIOs.FirstOrDefault(x => x.TX_FKDOC_USUMS == TX_PKDOC_USUMS_anterior);

                if (existe_any == null)
                {
                    _errorModel.error = false;
                    _errorModel.cuerpo.Add($"No existen Perfiles para {TX_PKDOC_USUMS_anterior}");
                    return _errorModel;
                }

                List<PERFILPORUSUARIO> existe = _context.PERFILESPORUSUARIOs.Where(x => x.TX_FKDOC_USUMS == TX_PKDOC_USUMS_anterior).ToList();

                foreach (var r in existe)
                {
                    r.TX_FKDOC_USUMS = TX_PKDOC_USUMS_nuevo;
                    _context.PERFILESPORUSUARIOs.Update(r);
                }

                await _context.SaveChangesAsync();
                _errorModel.error = false;
                _errorModel.cuerpo.Add("Perfiles Actualizados.");
                return _errorModel;

            }
            catch
            {
                _errorModel.error = true;
                _errorModel.cuerpo.Add("Problema con la base de datos PERFILES POR USUARIO.");
                return _errorModel;
            }
        }

        [HttpPatch("Firma")]
        public async Task<IActionResult> EditarFirma(USUARIO inputData)
        {
            ErrorModel _errorModel = new();
            using (var dbContextTransaction = _context.Database.BeginTransaction())
            {
                try
                {

                    #region Validaciones

                    if ((inputData == null || inputData.CL_FIRMA_USUMS == null) ||
                        (String.IsNullOrEmpty(inputData.CL_FIRMA_USUMS.Trim()) ||
                            String.IsNullOrWhiteSpace(inputData.CL_FIRMA_USUMS.Trim())))
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("No se recibió la información requerida.");
                        return Conflict(_errorModel);
                    }

                    #endregion

                    // Busco el usuario
                    var found = _context.USUARIOSMs.FirstOrDefault(x => x.NU_PK_USUMS == inputData.NU_PK_USUMS);

                    if (found == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("El usuario seleccionado no existe.");
                        return Conflict(_errorModel);
                    }

                    found.CL_FIRMA_USUMS = inputData.CL_FIRMA_USUMS;

                    _context.USUARIOSMs.Update(found);
                    await _context.SaveChangesAsync();

                    await dbContextTransaction.CommitAsync();

                    _errorModel.cuerpo.Add("Firma actualizada correctamente.");
                    return Ok(_errorModel);
                }
                catch (Exception e)
                {
                    dbContextTransaction.Rollback();

                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("Ocurrió un error en la base de datos.");
                    _errorModel.cuerpo.Add("Por favor intente de nuevo más tarde");

                    //_errorModel.debugInfo(e.InnerException.ToString());

                    return BadRequest(_errorModel);
                }

            }

        }

        [HttpGet("Firma")]
        public async Task<IActionResult> Get(int PK)
        {
            ErrorModel _errorModel = new ErrorModel();
            try
            {
                var result = await _context.USUARIOSMs.FirstOrDefaultAsync(dt => dt.NU_PK_USUMS == PK);

                if(result == null)
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("Usuario no encontrado");
                    return BadRequest(_errorModel);
                }

                if (String.IsNullOrEmpty(result.CL_FIRMA_USUMS) || 
                    String.IsNullOrWhiteSpace(result.CL_FIRMA_USUMS.Trim()))
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("El usuario no tiene firma.");
                    return Conflict(_errorModel);
                }

                return Ok(result.CL_FIRMA_USUMS);
            }
            catch (Exception e)
            {
                _errorModel.error = true;
                _errorModel.cuerpo.Add("Problema con la base de datos.");

                return BadRequest(_errorModel);
            }
        }

    }
}