//========================================================================================================
//========================================================================================================
//METODO ACTIVADO AL SELECCIONAR UN ITEM DE LA LISTA DE RESULTADOS DE BUSQUEDA
async private void OnItemSelected(object sender, ItemTappedEventArgs e)
{
//TOMAMOS LA INFORMACION DEL ITEM SELECCIONADO
var Item = e.Item as ResponseQueryAdmin;
//CREAMOS EL OBJETO QUE RECIBIRA LA RESPUESTA DEL METODO "OnUserSelected"
InformacionGeneral userinfo = null;
//REALIZAMOS LA PREGUNTA SOBRE SI SE DESEA MODIFICAR LA INFORMACION DEL USUARIO
bool response = await DisplayAlert("Mensaje", ConexionDatos.OnItemSelectedMethodMessage, ConexionDatos.AffirmativeText, ConexionDatos.NegativeText);
if (response)
{
//SE VUELVE VISIBLE EL ACTIVITYINDICATOR
ActivityIndicatorBusqueda.IsVisible = true;
//SE ACTIVA AL ACTIVITYINDICATOR MIENTRAS SE EJECUTA DE MANERA ASYNCORNA EL CONSUMO DEL METODO "OnUserSelected"
ActivityIndicatorBusqueda.IsRunning = true;
await Task.Run(async() =>
{
//SE HACE UN LLAMADO AL METODO "OnUserSelected"
userinfo = await ConexionDatos.OnUserSelected(Item);
//DESPUES DE RECIBIR LA RESPUESTA SE DESACTIVA EL ACTIVITY INDICATOR
ActivityIndicatorBusqueda.IsRunning = false;
});
//SE DESACTIVA LA VISIBILIDAD DEL ACTIVITYINDICATOR
ActivityIndicatorBusqueda.IsVisible = false;
//SE VERIFICA SI LA INFORMACION RETORNADA POR EL METODO "OnUserSelected" ES NULA O NO
if (userinfo == null)
{
//LA INFORMACION CONTENIDA EN EL OBJETO "userinfo" ES NULA
//SE PROCEDE A NOTIFICA AL USUARIO SOBRE EL ERROR
ConexionDatos.MensajePantalla(ConexionDatos.ErrorMessage);
}
else
{
//LA INFORMACION CONTENIDA EN EL OBJETO "userinfo" NO ES NULA
//SE PROCEDE A REALIZAR EL LLAMADO A LA PAGINA "PaginaConfiguracionAdmin"
await App.MasterDetail.Detail.Navigation.PushAsync(new PaginaConfiguracionAdmin(userinfo.Persona, userinfo.Usuario));
//SE BORRA LA INFORMACION SUMINISTRADA POR EL USUARIO
EntryDatos.Text = string.Empty;
//SE LIMPIA LA LISTA
ListViewPersonas.ItemsSource = null;
//SE ESCONDE LA LISTA
FrameListaBusqueda.IsVisible = false;
}
}
//SE LIBERA EL OBJETO SELECCIONADO DENTRO DE LA LISTA DE USUARIOS SOLICITADOS
((ListView)sender).SelectedItem = null;
}
public async Task <IEnumerable <InformacionGeneral> > GeneralParroquia(int?codigoCanton = null)
{
List <InformacionGeneral> generalesParroquia = null;
using (OracleConnection con = new OracleConnection(_conn))
{
using (OracleCommand cmd = new OracleCommand())
{
try
{
con.Open();
cmd.Connection = con;
//cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandType = CommandType.Text;
//cmd.CommandText = "PKG_CONTEO_RAPIDO.CONSULTA_USUARIO";
if (codigoCanton.HasValue)
{
sReporteGeneralParr += " WHERE COD_CANTON = " + codigoCanton.ToString();
}
sReporteGeneralParr += @"GROUP BY COD_PROVINCIA, NOM_PROVINCIA, COD_CANTON, NOM_CANTON, COD_PARROQUIA, NOM_PARROQUIA, NOM_ZONA, JUNTAS,
ASIGNADAS, DESCARGADAS, REPORTADAS, TRANSMITIDAS
ORDER BY COD_PROVINCIA, NOM_PROVINCIA,COD_CANTON,NOM_CANTON, COD_PARROQUIA, NOM_PARROQUIA, NOM_ZONA";
cmd.CommandText = string.Format(sReporteGeneralParr);
OracleDataReader odr = (OracleDataReader)await cmd.ExecuteReaderAsync();
if (odr.HasRows)
{
generalesParroquia = new List <InformacionGeneral>();
while (odr.Read())
{
InformacionGeneral generalParroquia = new InformacionGeneral
{
COD_PROVINCIA = Convert.ToInt32(odr["COD_PROVINCIA"]),
NOM_PROVINCIA = Convert.ToString(odr["NOM_PROVINCIA"]),
COD_CANTON = Convert.ToInt32(odr["COD_CANTON"]),
NOM_CANTON = Convert.ToString(odr["NOM_CANTON"]),
COD_PARROQUIA = Convert.ToInt32(odr["COD_PARROQUIA"]),
NOM_PARROQUIA = Convert.ToString(odr["NOM_PARROQUIA"]),
NOM_ZONA = Convert.ToString(odr["NOM_ZONA"]),
JUNTAS = Convert.ToInt32(odr["JUNTAS"]),
DESCARGADAS = Convert.ToInt32(odr["DESCARGADAS"]),
ASIGNADAS = Convert.ToInt32(odr["ASIGNADAS"]),
REPORTADAS = Convert.ToInt32(odr["REPORTADAS"]),
TRANSMITIDAS = Convert.ToInt32(odr["TRANSMITIDAS"])
};
generalesParroquia.Add(generalParroquia);
}
}
}
catch (Exception ex)
{
return(generalesParroquia);
}
finally
{
con.Close();
con.Dispose();
cmd.Dispose();
}
}
}
return(generalesParroquia);
}
//=========================================================================================================
//=========================================================================================================
//SELECCION DE USUARIO (CONSUMO DE SERVICIOS WEB)
public async Task <InformacionGeneral> OnUserSelected(ResponseQueryAdmin userselected)
{
//SE CREA E INICIALIZA LA VARIABLE QUE CONTENDRA EL URL
string url = App.BaseUrl + "/queryadmin/onuserselected";
//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 CREA LA CLASE MODELO QUE SERA CONVERTIDA A OBJETO JSON Y ENVIADA DENTRO DE LA SOLICITUD HTTP
var model = new UserSelectedRequest()
{
UserIdRequested = Usuario.Cedula, UserIdSelected = userselected.Cedula
};
//SE CREA E INICIALIZA LA VARIABLE QUE RECIBIRA EL OBJETO JSON RETORNADO POR LA SOLICITUD HTTP
InformacionGeneral informacion = null;
//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"));
//SE REALIZA LA SOLICITUD HTTP POST
response = await client.PostAsync(url, httpContent);
if (response.IsSuccessStatusCode)
{
//SE DESERIABLIZA EL OBJETO JSON CONTENIDO EN EL OBJETO "response" (<InformacionGeneral>)
informacion = JsonConvert.DeserializeObject <InformacionGeneral>(await response.Content.ReadAsStringAsync());
//SE DESENCRIPTA LA CONTRASEÑA
informacion.Usuario.Password = Metodos.DecryptString(informacion.Usuario.Password);
//====================================================================================
//====================================================================================
Console.WriteLine("\n\n====================================");
Console.WriteLine("====================================");
Console.WriteLine("La contraseña desencriptada es: " + informacion.Usuario.Password);
Console.WriteLine("====================================");
Console.WriteLine("====================================\n\n");
//====================================================================================
//====================================================================================
}
else
{
//SE DESEREALIZA EL OBJETO JSON CONTENIDO EN EL OBJETO "response" (<string>)
errormessage = JsonConvert.DeserializeObject <string>(await response.Content.ReadAsStringAsync());
}
}
}
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)
{
return(await Task.FromResult(informacion));
}
}
return(await Task.FromResult(informacion));
}
//--------------------------------------------------------------------------------------------------
//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 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));
}
