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.Linq;
using Microsoft.IdentityModel.Tokens;
using RabbitMQ.Client;
using Newtonsoft.Json;
using System.Threading.Channels;
using MSAdminUsuarios.Dto.Externos.MsAgendaMedica;
using static MSAdminUsuarios.Utils.RabbitMQService;
using MSAdminUsuarios.Utils;
using Microsoft.EntityFrameworkCore.Storage;

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

        public UsuariosController(ModelContext context)
        {
            _context = context;            
        }
        //public UsuariosController(ModelContext context, IModel channel)
        //{
        //    _context = context;
        //    _channel = channel;
        //}


        [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
                            orderby dm.NU_PK_USUMS
                            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)
        {
            using (var dbContextTransaction = _context.Database.BeginTransaction())
            {
                try
                {
                    if (usuario == null) return Conflict();

                    string[] login_name = { "" };
                    if (usuario.TX_CORREO_USUMS == null && usuario.TX_LOGINNAME_USUMS == null) return Conflict("Indique algún correo.");

                    if (usuario.TX_CORREO_USUMS != null)
                        login_name = usuario.TX_CORREO_USUMS.Split('@');

                    usuario.TX_LOGINNAME_USUMS ??= login_name[0];

                    var existe_login = _context.USUARIOSMs.Where(x => x.TX_LOGINNAME_USUMS == usuario.TX_LOGINNAME_USUMS).Count();

                    if (existe_login > 0) return Conflict($"El login \"{usuario.TX_LOGINNAME_USUMS}\" ya está en uso");

                    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 = usuario.TX_PKDOC_USUMS;
                    }

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

                    if (usuario.TX_UUID_USUMS == null)
                    {
                        Guid uuid = Guid.NewGuid();
                        var UUID = uuid.ToString();
                        usuario.TX_UUID_USUMS = UUID;
                    }

                    // TODO: Validacion agregada mientras se aclara el proceso
                    if (usuario.TX_SEDES_USUMS == null || usuario.TX_SEDES_USUMS.Length == 0) 
                    {
                        usuario.TX_SEDES_USUMS = "[0]";
                    }                   

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

                    dbContextTransaction.Commit();
                    return Ok();
                }
                catch (Exception ex)
                {
                    dbContextTransaction.Rollback();
                    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);
                    var existe = _context.USUARIOSMs.FirstOrDefault(x => x.TX_UUID_USUMS == editado.TX_UUID_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_SEGUNDOAPELL_USUMS = editado.TX_SEGUNDOAPELL_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;
                    existe.NU_BLOQUEO_USUMS = editado.NU_BLOQUEO_USUMS;
                    existe.NU_TIPOUSUARIO_USUMS = editado.NU_TIPOUSUARIO_USUMS;
                    existe.TX_REGPROF_MDC = editado.TX_REGPROF_MDC;
                    existe.FE_INICIOACTIVACION_USUTMP = editado.FE_INICIOACTIVACION_USUTMP;
                    existe.FE_FINACTIVACION_USUTMP = editado.FE_FINACTIVACION_USUTMP;

                    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();

                    /*
                     * 1. Perfiles del usuario
                     * 2. Buscar el perfil de medico
                     * 3. Si existe la relacion
                     * 3.1. Se hace la actualizacion de datos
                     * 
                     */

                    List<PERFILPORUSUARIO> perfilesUsuario = this._context.PERFILESPORUSUARIOs.Where(pxu => pxu.TX_UUID_USUMS == existe.TX_UUID_USUMS).ToList();

                    if (perfilesUsuario.Count > 0 && perfilesUsuario.Exists(pxu => pxu.NU_FK_PFL == 1)) 
                    {
                        /*using (_channel)
                        {
                            var medico = new MedicoDto()
                            {
                                TX_UUID_MDC = existe.TX_UUID_USUMS,
                                TX_LUGARESATEN_MDC = existe.TX_SEDES_USUMS
                            };

                            string jsonMedico = JsonConvert.SerializeObject(medico);

                            string exchange = MQExchanges.AgendaMedica;

                            // Publish Usuario
                            RabbitMQMessages.PublishToMessageQueue(
                                channel: _channel,
                                exchange: exchange,
                                routingKey: $"{exchange}.{MQueues.medico}.patch",
                                message: jsonMedico
                            );
                        }*/

                    }

                    _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.TX_UUID_USUMS == inputData.TX_UUID_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);
            }
        }

        [HttpPost("UsuarioPerfiles")]
        public async Task<IActionResult> PostUsuarioPerfiles(UsuarioPerfilesDTO nuevo)
        {
            ErrorModel _errorModel = new ErrorModel();
            using (var transaccion = _context.Database.BeginTransaction())
            {
                try
                {
                    if (nuevo == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Sin datos a guardar.");
                        return Conflict(_errorModel);
                    }

                    transaccion.CreateSavepoint("InicioCreacionUsuarioPerfiles");

                    if (nuevo.usuario == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Sin usuario a guardar.");
                        return Conflict(_errorModel);
                    }

                    if (nuevo.usuario.TX_CORREO_USUMS == null && nuevo.usuario.TX_LOGINNAME_USUMS == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Indique algún correo.");
                        return Conflict(_errorModel);
                    }

                    if (nuevo.usuario.TX_UUID_USUMS == null)
                    {
                        Guid uuid = Guid.NewGuid();
                        var UUID = uuid.ToString();
                        nuevo.usuario.TX_UUID_USUMS = UUID;

                        if (nuevo.usuario.TX_PASSWORD_USUMS == null)
                        {
                            nuevo.usuario.TX_PASSWORD_USUMS = nuevo.usuario.TX_PKDOC_USUMS;
                        }

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

                        if (nuevo.usuario.TX_SEDES_USUMS == null || nuevo.usuario.TX_SEDES_USUMS.Length == 0)
                        {
                            nuevo.usuario.TX_SEDES_USUMS = "[0]";
                        }

                        nuevo.usuario.NU_INICIO_PRIMERAVEZ_USUMS = 0;

                        _context.USUARIOSMs.Add(nuevo.usuario);
                        await _context.SaveChangesAsync();

                    }
                    else 
                    {
                        USUARIO? existe = _context.USUARIOSMs.FirstOrDefault(usu => usu.TX_UUID_USUMS == nuevo.usuario.TX_UUID_USUMS);
                        if (existe == null) 
                        {
                            _errorModel.error = true;
                            _errorModel.cuerpo.Add("Sin usuario no existe.");
                            return Conflict(_errorModel);
                        }

                        existe.NU_TIPODOC_USUMS = nuevo.usuario.NU_TIPODOC_USUMS;
                        existe.TX_PRIMERNOM_USUMS = nuevo.usuario.TX_PRIMERNOM_USUMS;
                        existe.TX_SEGUNDONOM_USUMS = nuevo.usuario.TX_SEGUNDONOM_USUMS;
                        existe.TX_PRIMERAPELL_USUMS = nuevo.usuario.TX_PRIMERAPELL_USUMS;
                        existe.TX_SEGUNDOAPELL_USUMS = nuevo.usuario.TX_SEGUNDOAPELL_USUMS;
                        existe.TX_CELULAR_USUMS = nuevo.usuario.TX_CELULAR_USUMS;
                        existe.TX_TELEFONO_USUMS = nuevo.usuario.TX_TELEFONO_USUMS;
                        existe.TX_CORREO_USUMS = nuevo.usuario.TX_CORREO_USUMS;
                        existe.TX_DIRECCION_USUMS = nuevo.usuario.TX_DIRECCION_USUMS;
                        existe.BL_PERTENCEIPS_USUMS = nuevo.usuario.BL_PERTENCEIPS_USUMS;
                        existe.TX_NOMBRE_PVD = nuevo.usuario.TX_NOMBRE_PVD;
                        existe.BL_VIENELDAP_USUMS = nuevo.usuario.BL_VIENELDAP_USUMS;
                        existe.NU_GRUPO_USUMS = nuevo.usuario.NU_GRUPO_USUMS;
                        existe.NU_CARGO_USUMS = nuevo.usuario.NU_CARGO_USUMS;
                        existe.NU_MODALIDADCTT_USUMS = nuevo.usuario.NU_MODALIDADCTT_USUMS;
                        existe.TX_SEDES_USUMS = nuevo.usuario.TX_SEDES_USUMS;
                        existe.NU_BLOQUEO_USUMS = nuevo.usuario.NU_BLOQUEO_USUMS;
                        existe.NU_TIPOUSUARIO_USUMS = nuevo.usuario.NU_TIPOUSUARIO_USUMS;
                        existe.TX_REGPROF_MDC = nuevo.usuario.TX_REGPROF_MDC;
                        existe.FE_INICIOACTIVACION_USUTMP = nuevo.usuario.FE_INICIOACTIVACION_USUTMP;
                        existe.FE_FINACTIVACION_USUTMP = nuevo.usuario.FE_FINACTIVACION_USUTMP;

                        if (existe.TX_PASSWORD_USUMS == null || existe.TX_PASSWORD_USUMS == "")
                        {
                            existe.TX_PASSWORD_USUMS = _encript.EncryptPwd(nuevo.usuario.TX_PKDOC_USUMS!);
                        }

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

                    USUARIO? creado = await _context.USUARIOSMs.FirstOrDefaultAsync(us => us.TX_UUID_USUMS == nuevo.usuario.TX_UUID_USUMS);

                    if (nuevo.perfiles != null && creado!=null)
                    {
                        // Se cambia a estado 0 todos los perfiles por usuario existentes
                        var existe_plfxusu = _context.PERFILESPORUSUARIOs.Where(x => x.BL_ESTADO_PFLXUSU == 1 && x.TX_UUID_USUMS == creado.TX_UUID_USUMS).ToList();

                        foreach (var pu in existe_plfxusu)
                        {
                            pu.BL_ESTADO_PFLXUSU = 0;
                        }
                        _context.PERFILESPORUSUARIOs.UpdateRange(existe_plfxusu);
                        await _context.SaveChangesAsync();

                        foreach (PERFILPORUSUARIO pxu in nuevo.perfiles)
                        {
                            if (pxu != null)
                            {
                                PERFILPORUSUARIO? existe = _context.PERFILESPORUSUARIOs.FirstOrDefault(pu => pu.TX_UUID_PFL == pxu.TX_UUID_PFL && pu.TX_UUID_USUMS == pxu.TX_UUID_USUMS);
                                if (existe != null)
                                {
                                    existe.BL_ESTADO_PFLXUSU = 1;
                                    _context.Update(existe);
                                    await _context.SaveChangesAsync();
                                }
                                else
                                {
                                    pxu.BL_ESTADO_PFLXUSU = 1;
                                    pxu.TX_UUID_USUMS = nuevo.usuario.TX_UUID_USUMS;
                                    _context.PERFILESPORUSUARIOs.Add(pxu);
                                    await _context.SaveChangesAsync();

                                }
                            }
                        }

                        /*List<PERFILPORUSUARIO> perUsuEliminiado = _context.PERFILESPORUSUARIOs.Where(pu => pu.TX_UUID_USUMS == creado.TX_UUID_USUMS && pu.BL_ESTADO_PFLXUSU == 0).ToList();
                        _context.PERFILESPORUSUARIOs.RemoveRange(perUsuEliminiado);
                        await _context.SaveChangesAsync();*/

                    }

                    transaccion.Commit();

                    _errorModel.error = false;
                    _errorModel.cuerpo.Add("Usuario creado correctamente");
                    return Ok(_errorModel);
                }
                catch (Exception e)
                {
                    transaccion.RollbackToSavepoint("InicioCreacionUsuarioPerfiles");
                    return BadRequest(e.Message);
                }
            }
        }

        [HttpPost("UsuarioPerfilesRetorno")]
        public async Task<IActionResult> PostUsuarioPerfilesRetorno(UsuarioPerfilesDTO nuevo)
        {
            ErrorModel _errorModel = new ErrorModel();
            using (var transaccion = _context.Database.BeginTransaction())
            {
                try
                {
                    if (nuevo == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Sin datos a guardar.");
                        return Conflict(_errorModel);
                    }

                    transaccion.CreateSavepoint("InicioCreacionUsuarioPerfiles");

                    if (nuevo.usuario == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Sin usuario a guardar.");
                        return Conflict(_errorModel);
                    }

                    if (nuevo.usuario.TX_CORREO_USUMS == null && nuevo.usuario.TX_LOGINNAME_USUMS == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Indique algún correo.");
                        return Conflict(_errorModel);
                    }

                    if (nuevo.usuario.TX_UUID_USUMS == null)
                    {

                    if (nuevo.usuario.TX_CORREO_USUMS != null )
                    {
                        USUARIO? existe = _context.USUARIOSMs.FirstOrDefault(usu => usu.TX_CORREO_USUMS == nuevo.usuario.TX_CORREO_USUMS);
                        if (existe != null)
                        {
                            _errorModel.error = true;
                            _errorModel.cuerpo.Add($"Usuario con correo {existe.TX_CORREO_USUMS} ya existe.");
                            return Conflict(_errorModel);

                        }
                    }

                        Guid uuid = Guid.NewGuid();
                        var UUID = uuid.ToString();
                        nuevo.usuario.TX_UUID_USUMS = UUID;

                        if (nuevo.usuario.TX_PASSWORD_USUMS == null)
                        {
                            nuevo.usuario.TX_PASSWORD_USUMS = nuevo.usuario.TX_PKDOC_USUMS;
                        }

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

                        if (nuevo.usuario.TX_SEDES_USUMS == null || nuevo.usuario.TX_SEDES_USUMS.Length == 0)
                        {
                            nuevo.usuario.TX_SEDES_USUMS = "[0]";
                        }

                        _context.USUARIOSMs.Add(nuevo.usuario);
                        await _context.SaveChangesAsync();

                    }
                    else 
                    {
                        USUARIO? existe = _context.USUARIOSMs.FirstOrDefault(usu => usu.TX_UUID_USUMS == nuevo.usuario.TX_UUID_USUMS);
                        if (existe == null) 
                        {
                            _errorModel.error = true;
                            _errorModel.cuerpo.Add("Sin usuario no existe.");
                            return Conflict(_errorModel);
                        }

                        existe.NU_TIPODOC_USUMS = nuevo.usuario.NU_TIPODOC_USUMS;
                        existe.TX_PRIMERNOM_USUMS = nuevo.usuario.TX_PRIMERNOM_USUMS;
                        existe.TX_SEGUNDONOM_USUMS = nuevo.usuario.TX_SEGUNDONOM_USUMS;
                        existe.TX_PRIMERAPELL_USUMS = nuevo.usuario.TX_PRIMERAPELL_USUMS;
                        existe.TX_SEGUNDOAPELL_USUMS = nuevo.usuario.TX_SEGUNDOAPELL_USUMS;
                        existe.TX_CELULAR_USUMS = nuevo.usuario.TX_CELULAR_USUMS;
                        existe.TX_TELEFONO_USUMS = nuevo.usuario.TX_TELEFONO_USUMS;
                        existe.TX_CORREO_USUMS = nuevo.usuario.TX_CORREO_USUMS;
                        existe.TX_DIRECCION_USUMS = nuevo.usuario.TX_DIRECCION_USUMS;
                        existe.BL_PERTENCEIPS_USUMS = nuevo.usuario.BL_PERTENCEIPS_USUMS;
                        existe.TX_NOMBRE_PVD = nuevo.usuario.TX_NOMBRE_PVD;
                        existe.BL_VIENELDAP_USUMS = nuevo.usuario.BL_VIENELDAP_USUMS;
                        existe.NU_GRUPO_USUMS = nuevo.usuario.NU_GRUPO_USUMS;
                        existe.NU_CARGO_USUMS = nuevo.usuario.NU_CARGO_USUMS;
                        existe.NU_MODALIDADCTT_USUMS = nuevo.usuario.NU_MODALIDADCTT_USUMS;
                        existe.TX_SEDES_USUMS = nuevo.usuario.TX_SEDES_USUMS;
                        existe.NU_BLOQUEO_USUMS = nuevo.usuario.NU_BLOQUEO_USUMS;
                        existe.NU_TIPOUSUARIO_USUMS = nuevo.usuario.NU_TIPOUSUARIO_USUMS;
                        existe.TX_REGPROF_MDC = nuevo.usuario.TX_REGPROF_MDC;
                        existe.FE_INICIOACTIVACION_USUTMP = nuevo.usuario.FE_INICIOACTIVACION_USUTMP;
                        existe.FE_FINACTIVACION_USUTMP = nuevo.usuario.FE_FINACTIVACION_USUTMP;

                        if (existe.TX_PASSWORD_USUMS == null || existe.TX_PASSWORD_USUMS == "")
                        {
                            existe.TX_PASSWORD_USUMS = _encript.EncryptPwd(nuevo.usuario.TX_PKDOC_USUMS!);
                        }

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

                    USUARIO? creado = await _context.USUARIOSMs.FirstOrDefaultAsync(us => us.TX_UUID_USUMS == nuevo.usuario.TX_UUID_USUMS);

                    if (nuevo.perfiles != null && creado!=null)
                    {
                        // Se cambia a estado 0 todos los perfiles por usuario existentes
                        var existe_plfxusu = _context.PERFILESPORUSUARIOs.Where(x => x.BL_ESTADO_PFLXUSU == 1 && x.TX_UUID_USUMS == creado.TX_UUID_USUMS).ToList();

                        foreach (var pu in existe_plfxusu)
                        {
                            pu.BL_ESTADO_PFLXUSU = 0;
                        }
                        _context.PERFILESPORUSUARIOs.UpdateRange(existe_plfxusu);
                        await _context.SaveChangesAsync();

                        foreach (var pxu in nuevo.perfiles)
                        {
                            if (pxu != null)
                            {
                                PERFILPORUSUARIO? existe = _context.PERFILESPORUSUARIOs.FirstOrDefault(pu => pu.TX_UUID_PFL == pxu.TX_UUID_PFL && pu.TX_UUID_USUMS == pxu.TX_UUID_USUMS);

                                if (existe != null)
                                {
                                    //Si existe activamos estado 1 del perfil
                                    existe.BL_ESTADO_PFLXUSU = 1;
                                    _context.Update(existe);
                                    await _context.SaveChangesAsync();
                                }
                                else
                                {
                                    pxu.BL_ESTADO_PFLXUSU = 1;
                                    pxu.TX_UUID_USUMS = nuevo.usuario.TX_UUID_USUMS;
                                    _context.PERFILESPORUSUARIOs.Add(pxu);
                                    await _context.SaveChangesAsync();
                                }
                            }
                        }

                        /*List<PERFILPORUSUARIO> perUsuEliminiado = _context.PERFILESPORUSUARIOs.Where(pu => pu.TX_UUID_USUMS == creado.TX_UUID_USUMS && pu.BL_ESTADO_PFLXUSU == 0).ToList();
                        _context.PERFILESPORUSUARIOs.RemoveRange(perUsuEliminiado);
                        await _context.SaveChangesAsync();*/

                    }

                    transaccion.Commit();

                    _errorModel.error = false;
                    _errorModel.cuerpo.Add("Usuario creado correctamente");
                    return Ok(creado);
                }
                catch (Exception e)
                {
                    transaccion.RollbackToSavepoint("InicioCreacionUsuarioPerfiles");
                    return BadRequest(e.Message);
                }
            }
        }

    }
}