//--------------------------------------------------------------------------------------------------
//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"));
}
//--------------------------------------------------------------------------------------------------
//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));
}
//--------------------------------------------------------------------------------------------------
//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"));
}
//--------------------------------------------------------------------------------------------------
//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));
}