Beispiel #1
0
        //=========================================================================================================
        //=========================================================================================================
        //BUSQUEDA DE USUARIOS (CONSUMO DE SERVICIOS WEB)
        public async Task <List <ResponseQueryAdmin> > ListaPersonasHttpClient(int SeleccionBusqueda, string Dato)
        {
            //SE CREA E INICIALIZA LA VARIABLE QUE CONTENDRA EL URL
            string url = App.BaseUrl + "/queryadmin";

            //SE CREA E INICIALIZA LA VARIABLE QUE RECIBIRA LA LISTA DE USUARIOS ENCONTRADOS
            List <ResponseQueryAdmin> lista = null;

            //SE CREA E INICIALIZA LA VARIABLE QUE SERVIRA DE MODELO PARA EL OBJETO JSON ENVIADO EN LA SOLICITUD
            var model = new RequestQueryAdmin()
            {
                Parametro = Dato, UserId = Persona.Cedula,
            };

            //SE CREA E INICIALIZA LA VARIABLE QUE RECIBIRA LA RESPUESTA DE LA SOLICITUD HTTP
            HttpResponseMessage response = new HttpResponseMessage();

            //SE CREA E INICIALIZA LA VARIABLE QUE VERIFICARA EL ESTADO DE CONEXION A INTERNET
            var current = Connectivity.NetworkAccess;

            //SE VERIFICA SI EL DISPOSITIVO SE ENCUENTRA CONECTADO A INTERNET
            if (current == NetworkAccess.Internet)
            {
                //EL EQUIPO SE ENCUENTRA CONECTADO A INTERNET
                //SE INICIA EL CICLO TRY...CATCH
                try
                {
                    //INICIAMOS EL SEGMENTO DEL CODIGO EN EL CUAL REALIZAREMOS EL CONSUMO DE SERVICIOS WEB MEDIANTE
                    //LA INICIALIZACION Y CREACION DE UNA VARIABLE QUE FUNCIONARA COMO CLIENTE EN LAS SOLICITUDES
                    //Y RESPUESTAS ENVIADAS Y RECIBIDAS POR EL SERVIDOR (WEB API)
                    //----------------------------------------------------------------------------------------------
                    //NOTA: CUANDO SE REALIZA LA CREACION E INICIALIZACION DE LA VARIABLE DEL TIPO HttpClient SE
                    //HACE UN LLAMADO A UN METODO ALOJADO EN LA CLASE "App" Y QUE ES ENVIADO COMO PARAMETRO DEL
                    //TIPO HttpClientHandler =>
                    //----------------------------------------------------------------------------------------------
                    using (HttpClient client = new HttpClient(App.GetInsecureHandler()))
                    {
                        //SE DA SET AL TIEMPO MAXIMO DE ESPERA PARA RECIBIR UNA RESPUESTA DEL SERVIDOR
                        client.Timeout = TimeSpan.FromSeconds(App.TimeInSeconds);
                        //SE REALIZA LA CONVERSION A OBJETO JSON
                        var json = JsonConvert.SerializeObject(model);
                        //SE AÑADE EL OBJETO JSON RECIEN CREADO COMO CONTENIDO BODY DEL NUEVO REQUEST
                        HttpContent httpContent = new StringContent(json, Encoding.UTF8, "application/json");
                        //SE HACE LA CONFIGURACION DE LOS HEADERS DEL REQUEST
                        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                        //--------------------------------------------------------------------------------------------------------
                        //DEPENDIENDO DEL VALOR QUE POSEA SeleccionBusqueda:
                        //(EN ESTE CASO SOLO PUEDE TENER 4, QUE SON: 0-ID, 1-NUMERO DE FICHA, 2-NOMBRES, 3-APELLIDOS, 4-USERNAME)
                        //--------------------------------------------------------------------------------------------------------
                        switch (SeleccionBusqueda)
                        {
                        //CASO BUSQUEDA POR CEDULA
                        case 0:
                            //SE TERMINA DE ESPECIFICAR EL URL AL CUAL SE DEBE REALIZAR LA SOLICITUD CUANDO ES BUSQUEDA POR CEDULA
                            url = url + "/cedula";
                            //SE HACE EL ENVIO DE LA SOLICITUD
                            response = await client.PostAsync(url, httpContent);

                            break;

                        //CASO BUSQUEDA POR NUMERO DE FICHA
                        case 1:
                            //SE TERMINA DE ESPECIFICAR EL URL AL CUAL SE DEBE REALIZAR LA SOLICITUD CUANDO ES BUSQUEDA POR CEDULA
                            url = url + "/ficha";
                            //SE HACE EL ENVIO DE LA SOLICITUD
                            response = await client.PostAsync(url, httpContent);

                            break;

                        //CASO BUSQUEDA POR NOMBRE
                        case 2:
                            //SE TERMINA DE ESPECIFICAR EL URL AL CUAL SE DEBE REALIZAR LA SOLICITUD CUANDO ES BUSQUEDA POR CEDULA
                            url = url + "/nombres";
                            //SE HACE EL ENVIO DE LA SOLICITUD
                            response = await client.PostAsync(url, httpContent);

                            break;

                        //CASO BUSQUEDA POR APELLIDO
                        case 3:
                            //SE TERMINA DE ESPECIFICAR EL URL AL CUAL SE DEBE REALIZAR LA SOLICITUD CUANDO ES BUSQUEDA POR CEDULA
                            url = url + "/apellidos";
                            //SE HACE EL ENVIO DE LA SOLICITUD
                            response = await client.PostAsync(url, httpContent);

                            break;

                        //CASO BUSQUEDA POR USERNAME
                        case 4:
                            //SE TERMINA DE ESPECIFICAR EL URL AL CUAL SE DEBE REALIZAR LA SOLICITUD CUANDO ES BUSQUEDA POR CEDULA
                            url = url + "/username";
                            //SE HACE EL ENVIO DE LA SOLICITUD
                            response = await client.PostAsync(url, httpContent);

                            break;
                        }
                    }
                }
                //SECCION DE CODIGO QUE SE EJECUTA CUANDO EL COMANDO DE SOLICITUD HTTP FALLE
                catch (Exception ex) when(ex is HttpRequestException ||
                                          ex is Javax.Net.Ssl.SSLException ||
                                          ex is Javax.Net.Ssl.SSLHandshakeException ||
                                          ex is System.Threading.Tasks.TaskCanceledException)
                {
                    //SE RETORNA LA LISTA NULA
                    return(await Task.FromResult(lista));
                }
            }

            //SE VERIFICA SI EL CODIGO DE ESTATUS DEL CONSUMO DEL SERVICIO WEB ES POSITIVO
            if (response.IsSuccessStatusCode)
            {
                //DE SER POSITIVO, SE DESERILIZA EL OBJETO JSON (List<>)CONTENIDO EN LA RESPUESTA RECIBIDA LUEGO DEL CONSUMO DEL SERVICIO WEB
                lista = JsonConvert.DeserializeObject <List <ResponseQueryAdmin> >(await response.Content.ReadAsStringAsync());
            }
            else
            {
                //DE SER NEGATIVO, SE DESERIALIZA EL OBJETO JSON (STRING)
                errormessage = JsonConvert.DeserializeObject <string>(await response.Content.ReadAsStringAsync());
            }

            //SE RETORNA LA LISTA DE USUARIOS ENCONTRADOS
            return(await Task.FromResult(lista));
        }
        //--------------------------------------------------------------------------------------------------
        //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"));
                }
            }
        }