Esempio n. 1
0
        //--------------------------------------------------------------------------------------------------
        //FUNCION QUE REGISTRA LA INFORMACION DE UN NUEVO USUARIO EN LA BASE DE DATOS
        //--------------------------------------------------------------------------------------------------
        public async Task <ActionResult <string> > RegistroUsuario([FromBody] RequestRegistroUsuario newuser)
        {
            //SE EVALUA SI LOS SIGUIENTES CAMPOS YA SE ENCUENTRAN REGISTRADOS DENTRO DE LA TABLA PERSONAS
            if (!MatchCedula(newuser.NewUser.Persona.Cedula) &&             //TRUE: SE ENCONTRO UN REGISTRO CON LA MISMA CEDULA (ID)
                !MatchNumeroFicha(newuser.NewUser.Persona.NumeroFicha) &&   //TRUE: SE ENCONTRO UN REGISTRO CON EL MISMO NUMERO DE FICHA
                !MatchUsername(newuser.NewUser.Usuario.Username))           //TRUE: SE ENCONTRO UN REGISTRO CON EL MISMO NOMBRE DE USUARIO
            {
                //SE INICIA EL CICLO TRY... CATCH
                try
                {
                    using (var transaction = this._context.Database.BeginTransaction())
                    {
                        //--------------------------------------------------------------------------------------------------------
                        //SE CREAN LOS OBJETOS DEL TIPO "Personas" Y "Usuarios" QUE CONTENDRAN LA NUEVA INFORMACION
                        Personas persona = Personas.NewPersonas(newuser.NewUser.Persona);
                        Usuarios usuario = Usuarios.NewUsuarios(newuser.NewUser.Usuario);

                        //--------------------------------------------------------------------------------------------------------
                        //SE REGISTRA LA INFORMACION NUEVA
                        this._context.Add(persona);
                        this._context.Entry(persona).State = EntityState.Added;

                        this._context.Add(usuario);
                        this._context.Entry(usuario).State = EntityState.Added;

                        //--------------------------------------------------------------------------------------------------------
                        //SE CREA E INICIALIZA UN NUEVO OBJETO "HistorialSolicitudesWeb"
                        Historialsolicitudesweb solicitudweb =
                            Historialsolicitudesweb.NewHistorialSolocitudesWeb(newuser.UserId, 5);

                        //--------------------------------------------------------------------------------------------------------
                        //SE AÑADE EL NUEVO REGISTRO A LA BASE DE DATOS
                        this._context.Historialsolicitudesweb.Add(solicitudweb);      //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialSolicitudesWeb.
                        this._context.Entry(solicitudweb).State = EntityState.Added;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA.

                        //--------------------------------------------------------------------------------------------------------
                        //SE COMPRUEBAN QUE LAS TABLAS "Personas" Y "Usuarios" TENGAN LA MISMA CANTIDAD DE REGISTROS
                        //NOTA: ESTO DEBIDO A QUE ESTAS DOS TABLAS LLEVAN REGISTROS PARALELOS QUE SE CORRESPONDEN
                        if (this._context.Personas.Count() != this._context.Usuarios.Count()) //=> true => LAS DOS TABLAS TIENEN CANTIDAD DE REGISTROS DISTINTOS
                        {
                            //SE RETORNA UNA RESPUESTA A LA SOLICITUD Y SE PROCEDE A INFORMAR AL USUARIO
                            return(BadRequest("Error al intentar regitrar datos. Intente nuevente"));
                        }

                        //--------------------------------------------------------------------------------------------------------
                        //SE GUARDAN LOS CAMBIOS
                        await this._context.SaveChangesAsync();

                        //SE CIERRA LA TRANSACCION
                        await transaction.CommitAsync();
                    }
                }
                //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                catch (Exception ex) when(ex is DbUpdateException ||
                                          ex is DbUpdateConcurrencyException)
                {
                    Console.WriteLine("\n=================================================");
                    Console.WriteLine("=================================================");
                    Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                    Console.WriteLine("=================================================");
                    Console.WriteLine("=================================================\n");
                    //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                    return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                }
            }
            //NO SE CUMPLIO ALGUNA DE LAS TRES CONDICIONES, SE RETORNA UN MENSAJE INFORMANDO CUAL CONDICION FALLO.
            else
            {
                //===============================================================================================
                //SI ALGUNA DE LOS CONDICIONALES EN LA EVALUACION ANTERIOR ES FALSA SE PROCEDE A INFORMAR CUAL
                //DE LOS CAMPOS EVALUADOS YA SE ENCUENTRA REGISTRADO

                //SE EVALUA SI EXISTE ALGUN REGISTRO DE USUARIO CON EL MISMO ID (CEDULA) DEL USUARIO QUE DESEA REGISTRAR
                if (MatchCedula(newuser.NewUser.Persona.Cedula))
                {
                    return(BadRequest("Numero de cedula ya registrado: " + newuser.NewUser.Persona.Cedula.ToString()));
                }

                //SE EVALUA SI EXISTE ALGUN REGISTRO DE USUARIO CON EL MISMO NUMERO DE FICHA DEL USUARIO QUE DESEA REGISTRAR
                if (MatchNumeroFicha(newuser.NewUser.Persona.NumeroFicha))
                {
                    return(BadRequest("Numero de ficha ya registrado: " + newuser.NewUser.Persona.NumeroFicha.ToString()));
                }

                //SE EVALUA SI EXISTE ALGUN REGISTRO DE USUARIO CON EL NOMBRE DE USUARIO DEL USUARIO QUE DESEA REGISTRAR
                if (MatchUsername(newuser.NewUser.Usuario.Username))
                {
                    return(BadRequest("Nombre de usuario" + newuser.NewUser.Usuario.Username + "ya se encuentra registrado"));
                }
            }

            //SI TODAS LAS CONDICIONES SE CUMPLEN SE REGISTRA EL USUARIO, SE RETORNA EL CODIGO DE ESTATUS 200
            //OK Y SE INFORMA MEDIANTE UN MENSAJE QUE SE REGISTRO CON EXITO EL TABLERO.
            return(Ok("Registro Exitoso"));
        }
Esempio n. 2
0
        //--------------------------------------------------------------------------------------------------
        //FUNCION QUE ACTUALIZARA LA INFORMACION DE UN USUARIO CUANDO SE REALICE EL LLAMADO DESDE
        //LA PAGINA "PaginaConsultaTableros" DE LA APLICACION "Mtto App". EN ESTA FUNCION SE RECIBEN
        //LOS PARAMETROS:
        // -username: PARAMETRO ENVIADO EN EL URL DE LA SOLICITUD (username=<username> || USERNAME=<username>)
        // -password: PARAMETRO ENVIADO EN EL URL DE LA SOLICITUD (password=<password> || PASSWORD=<password>)
        //--------------------------------------------------------------------------------------------------
        public async Task <IActionResult> LogInRequest([FromBody] LogInRequest request)
        {
            //SE CREA E INICIALIZA LA VARIABLE QUE SE RETORNARA SI TODAS LAS CONDICIONES SE CUMPLEN
            LogInResponse response = null;

            //SE EVALUA QUE EXISTA UN NOMBRE DE USUARIO QUE OBEDESCA AL NOMBRE DE USUARIO
            if (this._context.Usuarios.Any
                    (x => x.Username.ToLower() == request.Username.ToLower())) //=> true => EXISTE UN REGISTRO EN LA TABLA USUARIOS QUE RESPONDE AL
            //           NOMBRE DE USUARIO ENVIADO COMO PARAMETRO.
            {
                //SI EXISTE, SE OBTIENE TODA LA INFORMACION DE DICHO REGISTRO Y SE ALMACENA EN UNA VARIABLE DEL TIPO USUARIO
                Usuarios usuario = this._context.Usuarios.First                                   //=> METODO QUE RETORNA EL PRIMER REGISTRO QUE COINCIDA
                                       (x => x.Username.ToLower() == request.Username.ToLower()); //CON LA COMPARACION DE NOMBRE DE USUARIOS

                //SE COMPARA QUE LA PROPIEDAD DEL OBJETO usuario (OBJETO QUE CONTIENE TODA LA INFORMACION DE USUARIO
                //QUE DESEA INGRESAR) CON EL PARAMETRO "password"
                if (usuario.Password == request.Password) //=> true => LA CONTRASEÑA ENVIADA ES CORRECTA
                {
                    //SE INICIA LA TRANSACCION CON LA BASE DE DATOS
                    using (var transaction = this._context.Database.BeginTransaction())
                    {
                        //SE INICIA LA TRANSACCIONES CON LA BASE DE DATOS
                        try
                        {
                            //--------------------------------------------------------------------------------------------
                            //SE BUSCA LA INFORMACION PERSONAL DEL USUARIO QUE DESEA INGRESAR
                            var persona = await this._context.Personas.FindAsync(usuario.Cedula);

                            //--------------------------------------------------------------------------------------------
                            //SE EVALUA SI SE OBTUVO UN REGISTRO DE LA BUSQUEDA ANTERIOR
                            if (persona != null)
                            {
                                //DE EXISTIR SE DESECHA LA ENTIDAD RETENIDA
                                this._context.Entry(persona).State = EntityState.Detached;
                            }

                            //--------------------------------------------------------------------------------------------
                            //SE CREA E INICIALIZA UN OBJETO DEL TIPO "InformacionGeneral" (OBJETO QUE RETORNARA TODA LA
                            //INFORMACION DEL USUARIO QUE DESEA INGRESAR)
                            var fullinfo = InformacionGeneral.NewInformacionGeneral(persona, usuario);

                            //--------------------------------------------------------------------------------------------
                            //SE CREA E INICALIZA UN OBJETO DEL TIPO "UltimaConexion"
                            var ultimaconexion = new Ultimaconexion().NewUltimaConexion(persona, usuario);

                            //--------------------------------------------------------------------------------------------
                            //SE AÑADE A LA TABLAS "UltimaConexion" EL NUEVO REGISTRO
                            this._context.Ultimaconexion.Add(ultimaconexion);               //SE REGISTRA/AÑADE EN LA BASE DE DATOS
                            this._context.Entry(ultimaconexion).State = EntityState.Added;  //SE CAMBIA EL ESTADO DE LA ENTIDAD RETENIDA

                            //--------------------------------------------------------------------------------------------
                            //SE CREA E INICIALIZA UNA LISTA DE OBJETOS "UltimaConexion"
                            List <Ultimaconexion> lista = new List <Ultimaconexion>();
                            //SE LLENA LA LISTA PREVIAMENTE CREADA CON TODOS LOS REGISTROS DE CONEXION DEL USUARIO QUE DESEA INGRESAR
                            foreach (Ultimaconexion y in this._context.Ultimaconexion.ToList())
                            {
                                //SE EVAUA CADA UNO DE LOS REGISTROS DE LA LISTA Y SE COMPARA SI EL PARAMETRO UserId
                                //DEL REGISTRO ES IGUAL AL ID (CEDULA) DEL USUARIO QUE ESTA INGRESANDO
                                if (y.UserId == persona.Cedula)
                                {
                                    //SE AÑADE A LA LISTA EL REGISTRO.
                                    lista.Add(y);
                                }
                            }

                            //--------------------------------------------------------------------------------------------
                            //SE CREA UN NUEVO REGISTRO DE SOLICITUDES WEB Y SE AÑADE A LA TABLA "HistorialSolicitudesWeb"
                            Historialsolicitudesweb solicitudweb =
                                Historialsolicitudesweb.NewHistorialSolocitudesWeb(fullinfo.Usuario.Cedula, 0);

                            //--------------------------------------------------------------------------------------------
                            //SE REGISTRA/AÑADE UN NUEVO REGISTRO DE SOLICITUDES WEB
                            this._context.Historialsolicitudesweb.Add(solicitudweb);
                            this._context.Entry(solicitudweb).State = EntityState.Added;

                            //--------------------------------------------------------------------------------------------
                            //SE RETORNA EL TOKEN GENERADO LUEGO DE LA AUTENTICACION
                            string token = jwtauthenticationManager.Authenticate(request);

                            //--------------------------------------------------------------------------------------------
                            //SE EVALUA CUANTOS REGISTROS SE ACUMULARON EN LA LISTA "lista"
                            //MAS DE UN REGISTRO
                            if (lista.Count > 0)
                            {
                                //SE ENVIA LA INFORMACION DEL USUARIO Y EL PENULTIMO REGISTRO (ULTIMA CONEXION PREVIA A LA ACTUAL)
                                response = LogInResponse.NewLogInResponse(fullinfo, lista[lista.Count - 1].UltimaConexion1, token);
                            }
                            if (lista.Count == 0)
                            {
                                //SE ENVIA LA INFORMACION DEL USUARIO Y EL ULTIMO REGISTRO (CONEXION ACTUAL)
                                response = LogInResponse.NewLogInResponse(fullinfo, ultimaconexion.UltimaConexion1, token);
                            }
                            //--------------------------------------------------------------------------------------------
                            //SE GUARDAN LOS CAMBIOS REALIZADOS SOBRE LA BASE DE DATOS
                            await this._context.SaveChangesAsync();

                            //SE CULMINA LA TRANSACCION CON LA BASE DE DATOS
                            await transaction.CommitAsync();
                        }
                        //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                        //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                        catch (Exception ex) when(ex is DbUpdateException ||
                                                  ex is DbUpdateConcurrencyException)
                        {
                            Console.WriteLine("\n=================================================");
                            Console.WriteLine("=================================================");
                            Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                            Console.WriteLine("=================================================");
                            Console.WriteLine("=================================================\n");
                            //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                            return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                        }
                    }
                }
                else
                {
                    //SI EL NOMBRE DE USUARIO CONICIDE PERO LA CONTRASEÑA NO SE RETORNA UN BADREQUEST
                    return(BadRequest("Contraseña incorrecta"));
                }
            }
            else
            {
                //SI EL NOMBRE DE USUARIO NO CONIDIDE SE RETORNA UN NOT FOUND
                return(NotFound("Nombre de usuario no encontrado"));
            }

            //SE RETORNA EL CODIGO 200 OK JUNTO CON TODA LA INFORMACION DEL USUARIO
            return(Ok(response));
        }
        //--------------------------------------------------------------------------------------------------
        //FUNCION QUE REGISTRA LA INFORMACION DE UN NUEVO TABLERO EN LA BASE DE DATOS
        //--------------------------------------------------------------------------------------------------
        public async Task <IActionResult> NewTablero([FromBody] RegistroTablero newtablero)
        {
            //SE VERIFICA SI LOS SIGUIENTES DATOS YA SE ENCUENTRAN REGISTRADOS DENTRO DE LA TABLA:
            if (!MatchTableroID(newtablero.tableroInfo.TableroId) &&                //TRUE: SE ENCONTRO UN REGISTRO CON EL MISMO ID DE TABLERO
                !MatchTableroID(newtablero.tableroInfo.SapId) &&                    //TRUE: SE ENCONTRO UN REGISTRO CON EL MISMO ID DE SAP
                !MatchTableroCodigoQRData(newtablero.tableroInfo.CodigoQrdata))     //TRUE: SE ENCONTRO UN REGISTRO CON EL MIDMO CodigoQRData
            {
                //SE INICIA EL CICLO TRY... CATCH
                try
                {
                    //SE INICIA LA TRANSACCION
                    using (var transaction = this._context.Database.BeginTransaction())
                    {
                        //--------------------------------------------------------------------------------------------------------
                        //SE AÑADE EL OBJETO "newtablero"
                        this._context.Tableros.Add(newtablero.tableroInfo);

                        //--------------------------------------------------------------------------------------------------------
                        //SE CAMBIA EL ESTADO DE LA ENTIDAD QUE ESTA RETENIDA POR EF
                        this._context.Entry(newtablero.tableroInfo).State = EntityState.Added;

                        //--------------------------------------------------------------------------------------------------------
                        //SE RECORRE LA LISTA DE ITEMS ENVIADA JUNTO CON LA INFORMACION DEL TABLERO
                        foreach (Items x in newtablero.itemsTablero)
                        {
                            //SE AÑADE EL OBJETO "Items"
                            this._context.Items.Add(x);

                            //SE CAMBIA EL ESTADO DE LA ENTIDAD QUE ESTA SIENDO RETENIDA POR EF
                            this._context.Entry(x).State = EntityState.Added;
                        }

                        //--------------------------------------------------------------------------------------------------------
                        //CREACION E INICIALIZACION DEL OBJETO solicitudweb
                        Historialsolicitudesweb solicitudweb =
                            Historialsolicitudesweb.NewHistorialSolocitudesWeb(newtablero.tableroInfo.Idcreador, 4);

                        //--------------------------------------------------------------------------------------------------------
                        //SE AÑADE EL NUEVO REGISTRO A LA BASE DE DATOS
                        this._context.Historialsolicitudesweb.Add(solicitudweb);      //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialSolicitudesWeb.
                        this._context.Entry(solicitudweb).State = EntityState.Added;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA.

                        //--------------------------------------------------------------------------------------------------------
                        //SE GUARDAN LOS CAMBIOS
                        await this._context.SaveChangesAsync();

                        //SE CULMINA LA TRANSACCION
                        await transaction.CommitAsync();
                    }
                }
                //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                catch (Exception ex) when(ex is DbUpdateException ||
                                          ex is DbUpdateConcurrencyException)
                {
                    Console.WriteLine("\n=================================================");
                    Console.WriteLine("=================================================");
                    Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                    Console.WriteLine("=================================================");
                    Console.WriteLine("=================================================\n");
                    //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                    return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                }
            }
            //NO SE CUMPLIO ALGUNA DE LAS TRES CONDICIONES, SE RETORNA UN MENSAJE INFORMANDO CUAL CONDICION FALLO.
            else
            {
                //SE EVALUA CUAL DE LAS PROPIEDADES DEL OBJETO "newtablero" ENVIADO COINCIDE CON EL LA INFORMACION DE REGISTRO DE
                //ALGUN OTRO TABLERO

                //SE EVALUA SI EXISTE ALGUN TABLERO CON EL ID DEL TABLERO QUE SE DESEA REGISTRAR
                if (MatchTableroSAPID(newtablero.tableroInfo.TableroId))
                {
                    return(BadRequest("El ID del tablero que intenta registrar ya se encuentra registrado: " + newtablero.tableroInfo.TableroId));
                }

                //SE EVALUA SI EXISTE ALGUN TABLERO CON EL ID DE SAP DEL TABLERO QUE SE DESEA REGISTRAR
                if (MatchTableroSAPID(newtablero.tableroInfo.SapId))
                {
                    return(BadRequest("El ID de SAP del tablero que intenta registrar ya se encuentra registrado: " + newtablero.tableroInfo.SapId));
                }

                //SE EVALUA SI EXISTE ALGUN TABLERO QUE POSEA EL CODIGOQR (IMAGEN) QUE SE DESEA REGISTRAR
                if (MatchTableroCodigoQRData(newtablero.tableroInfo.CodigoQrdata))
                {
                    return(BadRequest("El codigo QR del tablero que intenta registrar ya se encuentra asignado a otro tablero"));
                }
            }

            //SI TODAS LAS CONDICIONES SE CUMPLEN SE REGISTRA EL TABLERO, SE RETORNA EL CODIGO DE ESTATUS 200
            //OK Y SE INFORMA MEDIANTE UN MENSAJE QUE SE REGISTRO CON EXITO EL TABLERO.
            return(Ok("Registro exitoso"));
        }
        //--------------------------------------------------------------------------------------------------
        //FUNCION QUE RETORNARA UNA LISTA DE USUARIOS, LOS CUALES DEBEN CUMPLIR CON EL PARAMETRO DE BUSQUEDA
        //ENVIADO. EL LLAMADO SE HACE DESDE LA PAGINA "PaginaQueryAdmin" DE LA APLICACION "Mtto App".
        //EN ESTA FUNCION SE RECIBEN LOS PARAMETROS:
        // -request:  OBJETO DEL TIPO "RequestQueryAdmin" EL CUAL CONTENDRA EL PARAMETRO ENVIADO Y EL NUMERO
        // DE OPCION DE BUSQUEDA (0 => Consulta por cedula; 1=> Consulta por Ficha; 2=> Consulta por Nombr(s)
        // 3=> Consulta por Apellido(s); 4=> Consulta por Username)
        //--------------------------------------------------------------------------------------------------
        public async Task <ActionResult <List <QueryAdmin> > > QueryCedula([FromBody] RequestQueryAdmin request)
        {
            //CREACION E INICIALIZACION DE VARIABLES
            List <QueryAdmin> result = new List <QueryAdmin>();   //=> LISTA DE USUARIOS QUE COINCIDEN CON EL PARAMETRO ENVIADO

            //CREACION E INICIALIZACION DE LA LISTA DE USUARIOS REGISTRADOS EN LA PLATAFORMA
            List <Personas> registros = await this._context.Personas.ToListAsync();

            //SE RECORRE CADA UNO DE LOS REGISTROS ("Personas")
            foreach (Personas x in registros)
            {
                //SE EVALUAN TODOS LOS REGISTROS MENOS EL REGISTRO DEL USUARIO ADMINISTRATOR
                if (x.Cedula != 0) //=> true => EL REGISTRO EVALUADO NO ES EL USUARIO ADMINISTRATOR
                {
                    //SE EVALUA QUE EL DATO ENVIADO SE ENCUENTRE DENTRO DE LA LISTA REGISTROS.

                    /*------------------------------------------------------------------------
                    *  NOTA: LA EVALUACION SE HACE TOMANDO EN CUENTA EL TAMAÑO (CANTIDAD DE
                    *  CARACTERES) DEL PARAMETRO ENVIADO. PUESTO QUE SE CONSIDERA QUE NO SIEMPRE
                    *  SE ENVIARA TODO EL NUMERO DE CEDULA COMPLETO SE HACE UNA BUSQUEDA DE LOS
                    *  REGISTROS EXISTENTES ENVIANDO EL NUMERO DE CEDULA COMPLETO O PARCIAL
                    *  (TODO DEPENDE DE COMO SEA ENVIADO EL PARAMETRO) Y SE RETORNARAN EL
                    *  REGISTRO O LOS REGISTROS QUE COINCIDAN
                    *  ------------------------------------------------------------------------*/
                    if (request.Parametro.ToString() == x.Cedula.ToString().Substring(0, request.Parametro.ToString().Length))
                    {
                        //SE AGREGA A LA LISTA EL REGISTRO DE DICHA PERSONA
                        result?.Add(QueryAdmin.NewQueryAdmin(x));
                    }
                }
            }

            //SE EVALUA CUANTOS ELEMENTOS HAY EN LA LISTA "result"
            if (result.Count == 0)
            {
                //CERO ELEMTENTOS: SE RETORNA EL CORIGO DE ESTATUS 404 NOTFOUND (NO HAY REGISTROS QUE CUMPLAN CON EL PARAMETRO ENVIADO)
                return(NotFound(NotFoundMessage));
            }
            else
            {
                //SE INICIA EL CICLO TRY...CATCH
                try
                {
                    //DIFERENTE DE CERO: SE RETORNA EL CODIGO DE ESTATUS 200 OK JUNTO CON LA LISTA DE USUARIOS OBTENIDOS
                    using (var transaction = this._context.Database.BeginTransaction())
                    {
                        //--------------------------------------------------------------------------------------------------------
                        //SE CREA E INICIALIZA UN OBJETO DEL TIPO "HistorialSolicitudesWeb" CON LA INFORMACION DEL NUEVO REGISTRO
                        //DE LA TABLA "HistorialSolicitudesWeb".
                        Historialsolicitudesweb solicitudesweb =
                            Historialsolicitudesweb.NewHistorialSolocitudesWeb(request.UserId, 6);

                        //--------------------------------------------------------------------------------------------------------
                        //SE ALMACENA EL REGISTRO DENTRO DE LA BASE DE DATOS
                        this._context.Historialsolicitudesweb.Add(solicitudesweb);      //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialSolicitudesWeb.
                        this._context.Entry(solicitudesweb).State = EntityState.Added;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA.

                        //--------------------------------------------------------------------------------------------------------
                        //SE GUARDAN LOS CAMBIOS REALIZADOS SOBRE LA BASE DE DATOS
                        await this._context.SaveChangesAsync();

                        //SE CULMINA LA TRANSACCION CON LA BASE DE DATOS
                        await transaction.CommitAsync();
                    }

                    //SE RETORNA EL CODIGO 200 OK JUNTO CON LA LISTA DE USUARIOS QUE COINCIDEN
                    return(Ok(result));
                }
                //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                catch (Exception ex) when(ex is DbUpdateException ||
                                          ex is DbUpdateConcurrencyException)
                {
                    Console.WriteLine("\n=================================================");
                    Console.WriteLine("=================================================");
                    Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                    Console.WriteLine("=================================================");
                    Console.WriteLine("=================================================\n");
                    //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                    return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                }
            }
        }
        //--------------------------------------------------------------------------------------------------
        //FUNCION QUE RETORNARA LA INFORMACION GENERAL DEL USUARIO SELECCIONADO EN LA LISTA DE USUARIOS
        //QUE COINCIDEN CON EL PARAMETRO DE BUSQUEDA Y LA OPCION SE CONSULTA SELECCIONADA
        //--------------------------------------------------------------------------------------------------
        public async Task <ActionResult <InformacionGeneral> > GetUserSelectedInfo([FromBody] UserSelectedRequest userselected)
        {
            //SE CREA E INICIALIZA LA VARIABLE QUE
            var fullinfo = new InformacionGeneral();

            //SE VERIFICA QUE EL OBJETO DEL TIPO "UserSelectedRequest" ENVIADO NO SEA NULO O VACIO
            if (userselected == null)   //=> true => EL OBJETO ES NULO
            {
                //SE RETORNA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMATIVO
                return(BadRequest("Error, vuelva a intentarlo nuevamente"));
            }
            else if (userselected != null)   //=> true => EL OBJETO NO ES NULO
            {
                //INICIAMOS EL CICLO TRY... CATCH
                try
                {
                    //SE INICIA LA TRANSACCION DE DATA CON LA BASE DE DATOS
                    using (var transaction = this._context.Database.BeginTransaction())
                    {
                        //--------------------------------------------------------------------------------------------------------
                        //SE BUSCA EL REGISTRO DENTRO DE LA TABLA DE USUARIOS QUE COINDICA CON EL ID DEL OBJETO ENVIADO
                        fullinfo.Persona = await this._context.Personas.FindAsync(userselected.UserIdSelected);

                        //SE VERIFICA SI EL OBJETO QUE RECIBIO LA INFORMACION SE ENCUENTRA NULO O NO
                        if (fullinfo.Persona != null)
                        {
                            //SI NO SE ENCUENTRA NULO SE DESECHA AL OBJETO RETENIDO POR LA CLASE CONTEXTO
                            this._context.Entry(fullinfo.Persona).State = EntityState.Detached;
                        }

                        //--------------------------------------------------------------------------------------------------------
                        //SE REPITE EL MISMO PROCESO EN LA BUSQUEDA DEL REGISTRO DENTRO DE LA TABLA USUARIOS
                        fullinfo.Usuario = await this._context.Usuarios.FindAsync(userselected.UserIdSelected);

                        //SE VERIFICA SI EL OBJETO QUE RECIBIO LA INFORMACION SE ENCUENTRA NULO O NO
                        if (fullinfo.Usuario != null)
                        {
                            //SI NO SE ENCUENTRA NULO SE DESECHA AL OBJETO RETENIDO POR LA CLASE CONTEXTO
                            this._context.Entry(fullinfo.Usuario).State = EntityState.Detached;
                        }

                        //--------------------------------------------------------------------------------------------------------
                        //SE VUELVE A VERISICAR EL ESTADO DE LOS OBJTOS QUE CONTIENEN LA INFORMACION SOLICITADA DE LA BASE DE DATOS
                        if (fullinfo.Persona == null && fullinfo.Usuario == null)
                        {
                            //SE RETORNA LA RESPUESTA DE ESTATUS BAD REQUEST 400
                            return(BadRequest("Error, vuelva a intentarlo nuevamente"));
                        }

                        //--------------------------------------------------------------------------------------------------------
                        //SE CREA E INICIALIZA UN OBJETO DEL TIPO "HistorialSolicitudesWeb" CON LA INFORMACION DEL NUEVO REGISTRO
                        //DE LA TABLA "HistorialSolicitudesWeb".
                        Historialsolicitudesweb solicitudesweb =
                            Historialsolicitudesweb.NewHistorialSolocitudesWeb(userselected.UserIdRequested, 11);

                        //--------------------------------------------------------------------------------------------------------
                        //SE ALMACENA EL REGISTRO DENTRO DE LA BASE DE DATOS
                        this._context.Historialsolicitudesweb.Add(solicitudesweb);      //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialSolicitudesWeb.
                        this._context.Entry(solicitudesweb).State = EntityState.Added;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA.

                        //--------------------------------------------------------------------------------------------------------
                        //SE GUARDAN LOS CAMBIOS REALIZADOS SOBRE LA BASE DE DATOS
                        await this._context.SaveChangesAsync();

                        //SE CULMINA LA TRANSACCION CON LA BASE DE DATOS
                        await transaction.CommitAsync();
                    }
                }
                //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                catch (Exception ex) when(ex is DbUpdateException ||
                                          ex is DbUpdateConcurrencyException)
                {
                    Console.WriteLine("\n=================================================");
                    Console.WriteLine("=================================================");
                    Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                    Console.WriteLine("=================================================");
                    Console.WriteLine("=================================================\n");
                    //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                    return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                }
            }

            return(Ok(fullinfo));
        }
Esempio n. 6
0
        //--------------------------------------------------------------------------------------------------
        //FUNCION QUE ACTUALIZARA LA INFORMACION DE UN USUARIO CUANDO SE REALICE EL LLAMADO DESDE
        //LA PAGINA "PaginaConfiguracion" DE LA APLICACION "Mtto App". EN ESTA FUNCION SE RECIBEN
        //LOS PARAMETROS:
        // -cedula => DATO DEFINIDO EN EL URL DE LA SOLICITUD (POR ESTA RAZON EL ROUTING "Route"
        //CONTIENE LA PALABRA "{cedula}")
        // -newinfo => OBJETO ENVIADO EN EL BODY DE LA SOLICITUD HTTP EL CUAL CONTIENE TODA LA
        //INFORMACION (VIEJA Y ACTUALIZADA) DEL USUARIO A ACTUALIZAR/CONFIGURAR
        //--------------------------------------------------------------------------------------------------
        public async Task <IActionResult> ActualizarUsuario(double cedula, [FromBody] ConfiguracionU newinfo)
        {
            //SE EVALUA SI PARAMETRO "cedula" Y LA PROPIEDAD "cedula" DEL OBJETO "newinfo" SON DIFERENTES
            if (cedula != newinfo.Cedula) //=> LAS PROPIEDADES SON DISTINTAS
            {
                //SE DA RETORNO A LA SOLICITUD CON LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO AL USUARIO
                return(BadRequest("La cedula no coincide con la informacion del objeto enviado"));
            }

            //SI EL PARAMETRO "cedula" Y LA PROPIEDAD "cedula" DEL OBJETO "newinfo" SON SIMILARES
            //SE INICIA LA TRASACCION
            using (var transaction = this._context.Database.BeginTransaction())
            {
                //SE INICIA EL CICLO TRY... CATCH
                try
                {
                    //CON LA INFORMACION ENVIADA SE PROCEDE A BUSCAR LA INFORMACION DE USUARIO DENTRO DE LA BASE DE DATOS
                    //SE CREA EL OBJETO "persona", Y SE INICIALIZA CON EL METODO DE BUSQUEDA PROPIO DEL OBJETO "Context"
                    //DECRITO AL INICIO DE LA CLASE
                    Personas persona = await this._context.Personas.FindAsync(newinfo.Cedula);

                    //SE EVALUA SI EL OBJETO "persona" NO SE ENCUENTRA NULO
                    if (persona != null)
                    {
                        //EL OBJETO "persona" NO SE ENCUENTRA NULO.
                        //PUESTO QUE SE UTILIZO LA CLASE "Context" PARA REALIZAR LA BUSQUEDA DE INFORMACION DE UN REGISTRO
                        //EN UNA TABLA ESPECIFICA SE DEBE "desechar" EL OBJETO QUE ACABA DE SER BUSCADO.
                        this._context.Entry(persona).State = EntityState.Detached;
                    }

                    //CON LA INFORMACION ENVIADA SE PROCEDE A BUSCAR LA INFORMACION DE USUARIO DENTRO DE LA BASE DE DATOS
                    //SE CREA EL OBJETO "usuario", Y SE INICIALIZA CON EL METODO DE BUSQUEDA PROPIO DEL OBJETO "Context"
                    //DECRITO AL INICIO DE LA CLASE
                    Usuarios usuario = await this._context.Usuarios.FindAsync(newinfo.Cedula);

                    if (usuario != null)
                    {
                        //EL OBJETO "persona" NO SE ENCUENTRA NULO.
                        //PUESTO QUE SE UTILIZO LA CLASE "Context" PARA REALIZAR LA BUSQUEDA DE INFORMACION DE UN REGISTRO
                        //EN UNA TABLA ESPECIFICA SE DEBE "desechar" EL OBJETO QUE ACABA DE SER BUSCADO.
                        this._context.Entry(usuario).State = EntityState.Detached;
                    }

                    //SE VERIFICA SI LOS OBJETOS "personas" Y "usuarios" CREADOS E INICIALIZADOS PREVIAMENTE
                    //SE ENCUENTRAN NULOS (SE EVALUA LA "NULIDAD" DE AMBOS)
                    if (persona == null && usuario == null)
                    {
                        //SI LOS OBJETOS (AMBOS O SOLO UNO) SE ENCUENTRAN NULOS ESTO IMPLICA QUE LA CLASE "Context" NO
                        //ENCONTRO NINGUN REGISTRO QUE RESPONDIERA AL NUMERO DE CEDULA ENVIADO COMO PARAMETRO.
                        //SE RETORNA LA RESPUESTA "NotFound" JUNTO CON UN MENSAJE INFORMANDO AL USUARIO.
                        return(NotFound("Numero de cedula no registrado: " + cedula));
                    }

                    //--------------------------------------------------------------------------------------------------------
                    //SE CREA E INICIALIZA UN OBJETO DEL TIPO "ModificacionesUsuario" QUE SERVIRA PARA CONTENER
                    //LA INFORMACION DEL NUEVO REGISTRO DENTRO DE LA TABLA "Modificacionesusuario"
                    Modificacionesusuario newmodificacionesiusuario =
                        Modificacionesusuario.NewModificacionesUsuarios(persona, Personas.NewPersonaInfo(persona, newinfo),
                                                                        usuario, Usuarios.NewUsuarioInfo(usuario, newinfo),
                                                                        DateTime.Now, newinfo.Cedula);

                    //--------------------------------------------------------------------------------------------------------
                    //SE ACTUALIZA LA INFORMACION DENTRO DE LOS OBJETOS "persona" Y "usuario"
                    persona = Personas.NewPersonaInfo(persona, newinfo);
                    usuario = Usuarios.NewUsuarioInfo(usuario, newinfo);

                    //--------------------------------------------------------------------------------------------------------
                    //SE ACTUALIZA LA INFORMACION DE LAS RESPECTIVAS TABLAS DENTRO DE LA BASE DE DATOS
                    this._context.Personas.Update(persona);                     //=> SE ACTUALIZA LA INFORMACION EN LA TABLA PERSONA
                    this._context.Entry(persona).State = EntityState.Modified;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA
                    //_____________________________________________________________________________________________________________
                    //NOTA: CAMBIAR EL ESTADO DE LOS OBJETOS CREADO COMO REFERENCIA PERMITE A LA CLASE CONTEXTO SEPARAR OBJETOS
                    //MODIFICADOS, AÑADIDOS, DESECHADOS. DE ESTA MANERA CADA QUE SE EJECUTE UN CAMBIO EN LA BASE DE DATOS CON ALGUN
                    //OBJETO DE REFERENCIA LUEGO DE SU USO SE DEBE REFERENCIAR QUE SE HIZO CON DICHO OBJETO.
                    //_____________________________________________________________________________________________________________
                    this._context.Usuarios.Update(usuario);                                   //=> SE ACTUALIZA LA INFORMACION EN LA TABLA USUARIO
                    this._context.Entry(usuario).State = EntityState.Modified;                //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA

                    this._context.Modificacionesusuario.Add(newmodificacionesiusuario);       //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA MODIFICACIONESUSUARIOS
                    this._context.Entry(newmodificacionesiusuario).State = EntityState.Added; //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA

                    //--------------------------------------------------------------------------------------------------------
                    //SE CREA E INICIALIZA UN OBJETO DEL TIPO "HistorialSolicitudesWeb" CON LA INFORMACION DEL NUEVO REGISTRO
                    //DE LA TABLA "HistorialSolicitudesWeb".
                    Historialsolicitudesweb solicitudesweb =
                        Historialsolicitudesweb.NewHistorialSolocitudesWeb(cedula, 12);

                    //SE ALMACENA EL REGISTRO DENTRO DE LA BASE DE DATOS
                    this._context.Historialsolicitudesweb.Add(solicitudesweb);      //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialSolicitudesWeb
                    this._context.Entry(solicitudesweb).State = EntityState.Added;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA
                    //-------------------------------------------------------------------------------------------------------

                    //SE GUARDAN LOS CAMBIOS
                    await this._context.SaveChangesAsync();

                    //SE TERMINA LA TRANSACCION
                    await transaction.CommitAsync();
                }
                //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                catch (Exception ex) when(ex is DbUpdateException ||
                                          ex is DbUpdateConcurrencyException)
                {
                    Console.WriteLine("\n=================================================");
                    Console.WriteLine("=================================================");
                    Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                    Console.WriteLine("=================================================");
                    Console.WriteLine("=================================================\n");
                    //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                    return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                }
            }

            //SI NO EXISTIERON ERRORES O EXCEPCIONES EN EL PROCESO DE LECTURA Y ESCRITURA, Y LA INFORMACION
            //FUE ACTUALIZADA SATISFACTORIAMENTE SE RETORNA LA RESPUESTA "Ok" JUNTO CON UN MENSAJE INFORMANDO
            //SOBRE LA ACTUALIZACION EXITOSA.
            return(Ok("Datos actualizados"));
        }
Esempio n. 7
0
        //--------------------------------------------------------------------------------------------------
        //FUNCION QUE ACTUALIZARA LA INFORMACION DE UN USUARIO CUANDO SE REALICE EL LLAMADO DESDE
        //LA PAGINA "PaginaConfiguracionAdmin" DE LA APLICACION "Mtto App". EN ESTA FUNCION SE RECIBEN
        //LOS PARAMETROS:
        // -cedula => DATO DEFINIDO EN EL URL DE LA SOLICITUD (POR ESTA RAZON EL ROUTING "Route"
        //CONTIENE LA PALABRA "{cedula}")
        // -newinfo => OBJETO ENVIADO EN EL BODY DE LA SOLICITUD HTTP EL CUAL CONTIENE TODA LA
        //INFORMACION (VIEJA Y ACTUALIZADA) DEL USUARIO A ACTUALIZAR/CONFIGURAR
        //--------------------------------------------------------------------------------------------------
        public async Task <IActionResult> ActualizarUsuarioAdm(double cedula, [FromBody] ConfiguracionA newinfo)
        {
            //SE EVALUA SI PARAMETRO "cedula" Y LA PROPIEDAD "cedula" DEL OBJETO "newinfo" SON DIFERENTES
            if (cedula != newinfo.Cedula)
            {
                //SE DA RETORNO A LA SOLICITUD CON LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO AL USUARIO
                return(BadRequest("La cedula no coincide con la información del objeto enviado"));
            }

            //SI EL PARAMETRO "cedula" Y LA PROPIEDAD "cedula" DEL OBJETO "newinfo" SON SIMILARES
            //SE INICIA LA TRASACCION
            using (var transaction = this._context.Database.BeginTransaction())
            {
                //SE INICIA EL CICLO TRY... CATCH
                try
                {
                    //SE RECIBE INFORMACION QUE SE TIENE ACTUALMENTE EN LA BASE DE DATOS
                    Personas persona = await this._context.Personas.FindAsync(newinfo.Cedula);

                    if (persona != null)
                    {
                        this._context.Entry(persona).State = EntityState.Detached;
                    }

                    Usuarios usuario = await this._context.Usuarios.FindAsync(newinfo.Cedula);

                    if (usuario != null)
                    {
                        this._context.Entry(usuario).State = EntityState.Detached;
                    }

                    //SE VERIFICA QUE LOS OBJETOS ENVIADOS NO SEAN NULOS
                    if (persona == null && usuario == null)
                    {
                        return(NotFound("Número de cedula no registrado: " + cedula));
                    }

                    //SE CREA E INICIALIZA UN OBJETO DEL TIPO "ModificacionesUsuario" QUE SERVIRA PARA CONTENER
                    //LA INFORMACION DEL NUEVO REGISTRO DENTRO DE LA TABLA "Modificacionesusuario"
                    //----------------------------------------------------------------------------------------------
                    //NOTA: SE ENVIA EL NUMERO CERO (0) COMO ULTIMO PARAMETRO EN EL METODO NewModificacionesUsuarios
                    //DEBIDO A QUE EL USUARIO ADMINISTRATOR ES EL UNICO CON ACCESO A DICHO METODO
                    //----------------------------------------------------------------------------------------------
                    Modificacionesusuario newmodificacionesiusuario =
                        Modificacionesusuario.NewModificacionesUsuarios(persona, Personas.NewPersonaInfo(persona, newinfo),
                                                                        usuario, Usuarios.NewUsuarioInfo(usuario, newinfo),
                                                                        DateTime.Now, 0);

                    //--------------------------------------------------------------------------------------------------------
                    //SE ACTUALIZA LA INFORMACION DENTRO DE LOS OBJETOS PERSONAS
                    persona = Personas.NewPersonaInfo(persona, newinfo);
                    usuario = Usuarios.NewUsuarioInfo(usuario, newinfo);

                    //--------------------------------------------------------------------------------------------------------
                    //SE ACTUALIZA LA INFORMACION DENTRO DE LA BASE DE DATOS
                    //SE ACTUALIZA LA INFORMACION DE LAS RESPECTIVAS TABLAS DENTRO DE LA BASE DE DATOS
                    this._context.Personas.Update(persona);                     //=> SE ACTUALIZA LA INFORMACION EN LA TABLA PERSONA
                    this._context.Entry(persona).State = EntityState.Modified;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA

                    this._context.Usuarios.Update(usuario);                     //=> SE ACTUALIZA LA INFORMACION EN LA TABLA USUARIO
                    this._context.Entry(usuario).State = EntityState.Modified;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA

                    //SE AÑADE A LA TABLA "ModificacionesUsuarios" UN NUEVO REGISTRO
                    this._context.Modificacionesusuario.Add(newmodificacionesiusuario);         //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA MODIFICACIONESUSUARIOS
                    this._context.Entry(newmodificacionesiusuario).State = EntityState.Added;   //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA
                    //--------------------------------------------------------------------------------------------------------
                    //SE CREA E INICIALIZA UN OBJETO DEL TIPO "HistorialSolicitudesWeb" CON LA INFORMACION DEL NUEVO REGISTRO
                    //DE LA TABLA "HistorialSolicitudesWeb".
                    Historialsolicitudesweb solicitudesweb =
                        Historialsolicitudesweb.NewHistorialSolocitudesWeb(0, 13);

                    //SE ALMACENA EL REGISTRO DENTRO DE LA BASE DE DATOS
                    this._context.Historialsolicitudesweb.Add(solicitudesweb);      //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialSolicitudesWeb
                    this._context.Entry(solicitudesweb).State = EntityState.Added;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA
                    //-------------------------------------------------------------------------------------------------------

                    //SE GUARDAN LOS CAMBIOS
                    await this._context.SaveChangesAsync();

                    //SE TERMINA LA TRANSACCION
                    await transaction.CommitAsync();
                }
                //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                catch (Exception ex) when(ex is DbUpdateException ||
                                          ex is DbUpdateConcurrencyException)
                {
                    Console.WriteLine("\n=================================================");
                    Console.WriteLine("=================================================");
                    Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                    Console.WriteLine("=================================================");
                    Console.WriteLine("=================================================\n");
                    //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                    return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                }
            }

            //SI NO EXISTIERON ERRORES O EXCEPCIONES EN EL PROCESO DE LECTURA Y ESCRITURA, Y LA INFORMACION
            //FUE ACTUALIZADA SATISFACTORIAMENTE SE RETORNA LA RESPUESTA "Ok" JUNTO CON UN MENSAJE INFORMANDO
            //SOBRE LA ACTUALIZACION EXITOSA.
            return(Ok("Datos Actualizados"));
        }
        //--------------------------------------------------------------------------------------------------
        //FUNCION QUE ACTUALIZARA LA INFORMACION DE UN USUARIO CUANDO SE REALICE EL LLAMADO DESDE
        //LA PAGINA "PaginaConsultaTableros" DE LA APLICACION "Mtto App". EN ESTA FUNCION SE RECIBEN
        //LOS PARAMETROS:
        // -info => OBJETO DEL TIPO "RequestConsultaTablero" ENVIADO EN EL BODY DE LA SOLICITUD HTTP
        // JUNTO CON LA INFORMACION NECESARIA PARA PROCESAR LA CONSULTA DE TABLEROS.
        //--------------------------------------------------------------------------------------------------
        public async Task <ActionResult <RegistroTablero> > ConsultaTableroId([FromBody] RequestConsultaTablero info)
        {
            //SE CREA E INICIALIZA EL OBJETO DEL TIPO "RegistroTablero" QUE CONTENDRA Y RETORNARA
            //TODA LA INFORMACION DEL TABLERO CONSULTADO.
            RegistroTablero tablero = null;

            //SE EVALUA SI EXISTE ALGUN TABLERO DENTRO DE LA BASE DE DATOS QUE POSEEA EL ID ENVIADO COMO PARAMETRO
            if (this._context.Tableros.Any
                    (x => x.TableroId.ToLower() == info.TableroId.ToLower())) //=> true => EXISTE UN REGISTRO DENTRO DE LA CLASE TABLERO CON DICHO DATO
            {
                //SE INICIA LA TRANSACCIONES CON LA BASE DE DATOS
                using (var transaction = this._context.Database.BeginTransaction())
                {
                    //SE INICIA EL CICLO TRY... CATCH
                    try
                    {
                        //--------------------------------------------------------------------------------------------------------
                        //CON LA INFORMACION ENVIADA SE PROCEDE A BUSCAR LA INFORMACION DE USUARIO DENTRO DE LA BASE DE DATOS
                        //SE CREA EL OBJETO "tableroinfo", Y SE INICIALIZA CON EL METODO DE BUSQUEDA PROPIO DEL OBJETO "Context"
                        //DECRITO AL INICIO DE LA CLASE.
                        Tableros tableroinfo = await this._context.Tableros.FirstAsync
                                                   (x => x.TableroId.ToLower() == info.TableroId.ToLower()); //=> METODO QUE INSPECCIONA TODOS LOS REGISTROS DE

                        //LA TABLA "Tableros" Y COMPARA EL ID DE CADA REGISTRO
                        //CON EL ID DEL OBJETO ENVIADO COMO PARAMETRO DE FUNCION

                        //--------------------------------------------------------------------------------------------------------
                        //SE EVALUA QUE EL OBJETO NO SEA NULO
                        if (tableroinfo != null)
                        {
                            //SI ES DIFERENTE DE NULO DESECHAMOS LA ENTIDAD RETENIDA POR EF (ENTITYFRAMEWORK)
                            this._context.Entry(tableroinfo).State = EntityState.Detached;
                        }

                        //--------------------------------------------------------------------------------------------------------
                        //CREAMOS E INICIALIZAMOS UNA LISTA DE OBJETOS "Items" CON LOS ITEMS QUE POSEE DICHO TABLERO
                        List <Items> itemstablero =
                            await this._context.Items.Where(x => x.TableroId.ToLower() == info.TableroId.ToLower()).ToListAsync();

                        //--------------------------------------------------------------------------------------------------------
                        //SE CREA E INICIALIZA UN OBJETO DEL TIPO "HistorialConsultaTableros" QUE SERVIRA PARA CONTENER
                        //LA INFORMACION DEL NUEVO REGISTRO DENTRO DE LA TABLA "Modificacionesusuario"
                        Historialconsultatableros newregistro =
                            Historialconsultatableros.NewHistorialConsultaTableros(tableroinfo.TableroId, "CONSULTA_POR_TABLERO_ID", info.UserId);

                        //--------------------------------------------------------------------------------------------------------
                        //SE AÑADE A LA TABLAS "HistorialConsultaTableros" EL NUEVO REGISTRO
                        this._context.Historialconsultatableros.Add(newregistro);   //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialConsultaTableros.
                        this._context.Entry(newregistro).State = EntityState.Added; //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA.

                        //--------------------------------------------------------------------------------------------------------
                        //SE CREA E INICIALIZA UN OBJETO DEL TIPO "HistorialSolicitudesWeb" CON LA INFORMACION DEL NUEVO REGISTRO
                        //DE LA TABLA "HistorialSolicitudesWeb".
                        Historialsolicitudesweb solicitudweb =
                            Historialsolicitudesweb.NewHistorialSolocitudesWeb(info.UserId, 2);

                        //--------------------------------------------------------------------------------------------------------
                        //SE AÑADE A LA TABLA "HistorialSolicitudesWeb" EL NUEVO REGISTRO
                        this._context.Historialsolicitudesweb.Add(solicitudweb);     //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialSolicitudesWeb.
                        this._context.Entry(solicitudweb).State = EntityState.Added; //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA.

                        //--------------------------------------------------------------------------------------------------------
                        //INICIALIZAMOS EL OBJETO "RegistroTablero" (CREADO AL INICIO DE LA FUNCION) CON TODA LA
                        //INFORMACION DEL TABLERO SOLICITADO
                        tablero = RegistroTablero.NewRegistroTablero(tableroinfo, itemstablero);

                        //--------------------------------------------------------------------------------------------------------
                        //SE GUARDAN LOS CAMBIOS REALIZADOS SOBRE LA BASE DE DATOS
                        await this._context.SaveChangesAsync();

                        //SE CULMINA LA TRANSACCION CON LA BASE DE DATOS
                        await transaction.CommitAsync();
                    }
                    //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                    //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                    catch (Exception ex) when(ex is DbUpdateException ||
                                              ex is DbUpdateConcurrencyException)
                    {
                        Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                        //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                        return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                    }
                }
            }
            //NO SE CONSIGUIO NINGUN REGISTRO QUE POSEEA EL ID ENVIADO COMO PARAMETRO
            else
            {
                //SE RETORNA EL CODIGO 404 NOT FOUND (NO ENCONTRADO)
                return(NotFound("No se encontro registro de tableros con el siguiente Id: " + info.TableroId));
            }

            //SE RETORNA EL CODIGO 200 OK JUNTO CON TODA LA INFORMACION DEL TABELRO SOLICITADO
            return(Ok(tablero));
        }