public List <PacientesInterface> mostrarPacienteEvaluado(int rutPaciente)
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <PacientesInterface> queryPaciente = (from patients in dbEntity.Pacientes
from user in dbEntity.Usuarios
where patients.rut == rutPaciente
where patients.estado == "activo"
where patients.id_usuario == user.id_usuario
select new PacientesInterface
{
id_paciente = patients.id_paciente,
nombrePaciente = patients.nombre + " " + patients.apepat,
//apepatPaciente = patients.apepat,
//apematPaciente = patients.apemat,
rutPaciente = patients.rut,
edadPaciente = patients.edad,
SexoPaciente = patients.sexo,
diagnosticoPaciente = patients.diagnostico,
numFicha = patients.ficha_medica,
FechaCreacion = patients.fecha_creacion,
usuario = user.nombre + " " + user.apepat
}).ToList();
return(queryPaciente);
}
}
catch (Exception ex)
{
throw ex;
}
}
/**
* Page Load carga dropdownlist con los roles de usuario de la entidad roles de la base de datos
*/
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
lsdRol.DataSource = dbEntity.Roles.ToList();
lsdRol.DataTextField = "rol";
lsdRol.DataValueField = "id_rol";
lsdRol.DataBind();
}
}
txtNombreUsuario.Attributes.Add("class", "validate");
txtNombreUsuario.Attributes.Add("pattern", "^\\s*[a-zA-ZñÑ\\s]+\\s*$");
txtNombreUsuario.Attributes.Add("title", "Se admiten solo letras");
txtApepat.Attributes.Add("class", "validate");
txtApepat.Attributes.Add("pattern", "^\\s*[a-zA-ZñÑ\\s]+\\s*$");
txtApepat.Attributes.Add("title", "Se admiten solo letras");
txtApemat.Attributes.Add("class", "validate");
txtApemat.Attributes.Add("pattern", "^\\s*[a-zA-ZñÑ\\s]+\\s*$");
txtApemat.Attributes.Add("title", "Se admiten solo letras");
}
public String modificarPaciente(int idPaciente, String nombrePaciente, String apepat, String apemat, int edad, String sexo, String diagnostico)
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
Pacientes paciente = (from patients in dbEntity.Pacientes
where patients.id_paciente == idPaciente
select patients).First();
paciente.nombre = nombrePaciente;
paciente.apepat = apepat;
paciente.apemat = apemat;
paciente.edad = edad;
paciente.sexo = sexo;
paciente.diagnostico = diagnostico;
dbEntity.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
return("Paciente módificado");
}
// Metodo para mostrar los datos de composicion corporal del paciente
public List <EvaluacionesInterface> mostrarComposicion(int rutPaciente)
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <EvaluacionesInterface> queryComposicion = (from eval in dbEntity.Evaluaciones
from paciente in dbEntity.Pacientes
where paciente.rut == rutPaciente
where paciente.estado == "activo"
where eval.id_paciente == paciente.id_paciente
select new EvaluacionesInterface
{
id_evaluacion = eval.id_evaluacion,
cb_corp = eval.cb_corp,
pt_corp = eval.pt_corp,
pb_corp = eval.pb_corp,
psi_corp = eval.psi_corp,
pse_corp = eval.pse_corp,
pliegues_corp = eval.pliegues_corp,
cc_corp = eval.cc_corp,
carpo_corp = eval.carpo_corp,
cmb_corp = eval.cmb_corp,
amb_corp = eval.amb_corp,
agb_corp = eval.agb_corp,
}).ToList();
return(queryComposicion);
}
}
public List <RequerimientosInterface> mostrarReqFinal(int rutPaciente)
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <RequerimientosInterface> queryRequerimiento = (from req in dbEntity.Requerimientos
from pat in dbEntity.Pacientes
from eval in dbEntity.Evaluaciones
where pat.rut == rutPaciente
where pat.estado == "activo"
where eval.id_paciente == pat.id_paciente
where req.id_evaluacion == eval.id_evaluacion
where req.tipo == "Termino"
select new RequerimientosInterface
{
id_requerimiento = req.id_requerimiento,
tipo = req.tipo,
requerimiento = req.requerimiento,
energia = req.energia,
proteina = req.proteina,
factor_kcal = req.factor_kcal,
factor_prot = req.factor_prot,
cho_porc = req.cho_porc,
cho_gr = req.cho_gr,
lip_porc = req.lip_porc,
lip_gr = req.lip_gr,
id_evaluacion = req.id_evaluacion
}).ToList();
return(queryRequerimiento);
}
}
/**
* Metodo para modificar los datos de un usuario registrado.
*/
public String modificarUsuario(int id, String nombre, String apepat, String apemat, String login, int idRol)
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
Usuarios usuario = (from users in dbEntity.Usuarios
where users.id_usuario == id
select users).First();
usuario.nombre = nombre;
usuario.apepat = apepat;
usuario.apemat = apemat;
usuario.login = login;
usuario.id_rol = idRol;
dbEntity.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
return("Se ha modificado el Usuario");
}
/**Contador de cuentas de usuario activas en el sistema.
*/
public int cuentasUser()
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <int> cuentasAdmin = (from users in dbEntity.Usuarios
where users.estado == "activo"
select users.id_rol).ToList();
int contador = 0;
foreach (var find in cuentasAdmin)
{
// Recorremos la tabla Usuarios y los que tengan id_rol = 2 son user, aumenta el contador en 1.
if (find == 2)
{
contador++;
}
else
{
}
}
return(contador);
}
}
catch (Exception ex)
{
throw ex;
}
}
/**
* Contador de cuentas activas en el sistema.
*/
public int cuentasActivas()
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <String> cuentasActivas = (from users in dbEntity.Usuarios
select users.estado).ToList();
int contador = 0;
foreach (var find in cuentasActivas)
{
// Recorremos los la tabla usuarios y los que tengan estado "activo" aumentaran el contador en 1
if (find == "activo")
{
contador++;
}
else
{
}
}
return(contador);
}
}
catch (Exception ex)
{
throw ex;
}
}
// Metodo para mostrar los datos de los examenes del paciente
public List <EvaluacionesInterface> mostrarExamenes(int rutPaciente)
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <EvaluacionesInterface> queryExamenes = (from eval in dbEntity.Evaluaciones
from paciente in dbEntity.Pacientes
where paciente.rut == rutPaciente
where paciente.estado == "activo"
where eval.id_paciente == paciente.id_paciente
select new EvaluacionesInterface
{
id_evaluacion = eval.id_evaluacion,
albumina = eval.albumina,
creatinina = eval.creatinina,
balance_hidrico = eval.balance_hidrico,
pco2 = eval.pco2,
pafi = eval.pafi,
leucocitos = eval.leucocitos,
pc_reactiva = eval.pc_reactiva,
hemoglobina = eval.hemoglobina,
hematrocito = eval.hematrocito,
trigliceridos = eval.trigliceridos,
glicemia = eval.glicemia,
lactato = eval.lactato,
urea = eval.urea,
otros_examenes = eval.otros_examenes,
}).ToList();
return(queryExamenes);
}
}
/**
* Metodo para guardar un nuevo paciente en la Base de datos, devuelve un string como mensaje de exito.
*/
public string guardarPaciente(String nombrePaciente, String apepat, String apemat, int rut, int edad, String sexo,
String diagnostico, int fichaMedica, DateTime fecha, int idUsuario)
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
Pacientes paciente = new Pacientes
{
nombre = nombrePaciente,
apepat = apepat,
apemat = apemat,
rut = rut,
edad = edad,
sexo = sexo,
diagnostico = diagnostico,
ficha_medica = fichaMedica,
estado = "activo",
fecha_creacion = fecha,
id_usuario = idUsuario
};
dbEntity.Pacientes.Add(paciente);
dbEntity.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
return("Datos del Paciente Guardados exitosamente");
}
/**
* Metodo para listar los usuarios desde la base de datos,
* se utiliza para llenar el gridview de la capa de presentación
*/
public List <UsuariosInterface> mostrarUsuarios()
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <UsuariosInterface> queryUsuarios = (from users in dbEntity.Usuarios
from rol in dbEntity.Roles
where users.estado == "activo"
where users.id_rol == rol.id_rol
select new UsuariosInterface
{
id_usuario = users.id_usuario,
rut = users.rut,
nombre = users.nombre,
apepat = users.apepat,
apemat = users.apemat,
estado = users.estado,
fecha_creacion = users.fecha_creacion,
login = users.login,
rol = rol.rol
}).ToList();
return(queryUsuarios);
}
}
catch (Exception ex)
{
throw ex;
}
}
/**
* Page load carga el dropdownlist con los roles de usuario de la entidad roles de la base de datos.
* (El dropdownlist se encuentra en la ventana modal que muestra el formulario para modificar una cuenta de usuario).
*/
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
lsdRolMod.DataSource = dbEntity.Roles.ToList();
lsdRolMod.DataTextField = "rol";
lsdRolMod.DataValueField = "id_rol";
lsdRolMod.DataBind();
}
}
}
// Metodo para mostrar las observaciones registradas
public List <EvaluacionesInterface> mostrarObservaciones(int rutPaciente)
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <EvaluacionesInterface> queryObservaciones = (from eval in dbEntity.Evaluaciones
from paciente in dbEntity.Pacientes
where paciente.rut == rutPaciente
where paciente.estado == "activo"
where eval.id_paciente == paciente.id_paciente
select new EvaluacionesInterface
{
id_evaluacion = eval.id_evaluacion,
observaciones = eval.observaciones
}).ToList();
return(queryObservaciones);
}
}
// Metodo para mostrar el diagnostico
public List <EvaluacionesInterface> mostrarDiagNutr(int rutPaciente)
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <EvaluacionesInterface> queryDiagnostico = (from eval in dbEntity.Evaluaciones
from paciente in dbEntity.Pacientes
where paciente.rut == rutPaciente
where paciente.estado == "activo"
where eval.id_paciente == paciente.id_paciente
select new EvaluacionesInterface
{
id_evaluacion = eval.id_evaluacion,
diagnostico_nutricional = eval.diagnostico_nutricional
}).ToList();
return(queryDiagnostico);
}
}
/**
* Metodo para recuperar el id del usuario.
* parametro'login' lo obtenemos de la session["Usuario"] la cual contiene el username o login.
*/
public int idUsuario(String login)
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
int idUser = (from users in dbEntity.Usuarios
where users.login == login
select users.id_usuario).First();
return(idUser);
}
}
catch (Exception ex)
{
throw ex;
}
}
/**
* Metodo para guardar un usuario en el sistema, en primera instancia, valida si no
* hay un rut igual registrado previamente, si no es asi, guarda el registro del usuario.
* Se utiliza el procedimiento almacenado RegistrarUsuario para guardar la información
*/
public String guardarUsuario(String nombre, int rut, String apepat, String apemat, DateTime fecha,
String login, String contraseña, int id_rol)
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <int?> rutUsuario = (from users in dbEntity.Usuarios
select users.rut).ToList();
bool rutMatch = false;
foreach (var find in rutUsuario)
{
if (find == rut)
{
rutMatch = true;
break;
}
else
{
rutMatch = false;
}
}
if (rutMatch)
{
return("El rut ingresado ya existe");
}
else
{
dbEntity.RegistrarUsuario(nombre, rut, apepat, apemat, fecha, login, contraseña, id_rol);
return("Datos guardados exitosamente");
}
}
}
catch (Exception ex)
{
return("Error al guardar los datos");
throw ex;
}
}
public String desactivarPaciente(int idPaciente)
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
Pacientes paciente = (from patients in dbEntity.Pacientes
where patients.id_paciente == idPaciente
select patients).First();
paciente.estado = "inactivo";
dbEntity.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
return("Paciente dado de alta");
}
/**
* Metodo que modifica el estado del usuario de activo a inactivo (eliminacion logica).
*/
public String desactivarUsuario(int idUser)
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
Usuarios usuario = (from users in dbEntity.Usuarios
where users.id_usuario == idUser
select users).First();
usuario.estado = "inactivo";
dbEntity.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
return("Se ha desactivado la cuenta de usuario");
}
// Metodo para mostrar los datos de antropometria del paciente, como argumento se necesita el rut
public List <EvaluacionesInterface> mostrarAntropometria(int rutPaciente)
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
List <EvaluacionesInterface> queryEvaluacion = (from eval in dbEntity.Evaluaciones
from paciente in dbEntity.Pacientes
where paciente.rut == rutPaciente
where paciente.estado == "activo"
where eval.id_paciente == paciente.id_paciente
select new EvaluacionesInterface
{
id_evaluacion = eval.id_evaluacion,
fecha = eval.fecha,
peso_antr = eval.peso_antr,
talla_antr = eval.talla_antr,
imc_antr = eval.imc_antr,
peso_ideal_antr = eval.peso_ideal_antr,
factor_peso_antr = eval.factor_peso_antr
}).ToList();
return(queryEvaluacion);
}
}
/**
* Metodo para validar el ingreso del usuario al sistema, utiliza un procedimiento almacenado
* como funcion para validar el password y username, este devuelve, si hay coinsidencia, el rol del
* usuario.
*/
public int validarUsuario(String username, String password)
{
int numRol;
try
{
using (db_nutricionEntities db_entity = new db_nutricionEntities())
{
//parametro de objeto que pide el 'SP' como devolución de rol de usaurio
ObjectParameter result = new ObjectParameter("resultado", typeof(String));
db_entity.LoginUsuario(username, password, result);
/*Result es el parametro de devolucion dentro del 'SP',
* devuelve si el usuario es'administrador' o 'usuario'
* despues de validar el username y password*/
if (result.Value.ToString().Equals("administrador"))
{
numRol = 1;
}
else if (result.Value.ToString().Equals("usuario"))
{
numRol = 2;
}
else
{
numRol = 0;
}
}
}
catch (Exception ex)
{
throw ex;
}
return(numRol);
}
/**
* Metodo para guardar una evaluación nutricional, guarda la tabla evaluación
* y la tabla requerimientos (guarda dos requerimientos por evaluacion; de inicio y termino)
*/
public string guardarEvaluacion(/*antropometria =>*/ String fecha, String peso, String talla, String imc, String pesoIdeal, String factorPeso,
/*composición corporal =>*/ String cb, String pt, String pb, String psi, String pse, String pliegues, String cc, String carpo,
String cmb, String amb, String agb, /*Examenes =>*/ String albulimia, String creatinina, String balHidr, String pco2,
String pafi, String leucocitos, String pc_reactiva, String hemoglobina, String hematrocito, String triglic,
String glicemia, String lactato, String urea, String otrosEx, String diagnosticoNutr, String metaNutr,
String observaciones, int idPaciente, int idUsuario, /*Requerimientos iniciales==>*/ String reqPorcInicial,
String energiaInicial, String proteinaInicial, String factorKcalInicial, String factorProtInicial, String choPorcInicial,
String choGrInicial, String lipPorcInicial, String lipGrInicial, /*Requerimientos finales*/ String reqPorcFinal,
String energiaFinal, String proteinaFinal, String factorKcalFinal, String factorProtFinal, String choPorcFinal,
String choGrFinal, String lipPorcFinal, String lipGrFinal)
{
try
{
using (db_nutricionEntities dbEntity = new db_nutricionEntities())
{
Evaluaciones evaluacion = new Evaluaciones
{
fecha = fecha,
peso_antr = peso,
talla_antr = talla,
imc_antr = imc,
peso_ideal_antr = pesoIdeal,
factor_peso_antr = factorPeso,
cb_corp = cb,
pt_corp = pt,
pb_corp = pb,
psi_corp = psi,
pse_corp = pse,
pliegues_corp = pliegues,
cc_corp = cc,
carpo_corp = carpo,
cmb_corp = cmb,
amb_corp = amb,
agb_corp = agb,
albumina = albulimia,
creatinina = creatinina,
balance_hidrico = balHidr,
pco2 = pco2,
pafi = pafi,
leucocitos = leucocitos,
pc_reactiva = pc_reactiva,
hemoglobina = hemoglobina,
hematrocito = hematrocito,
trigliceridos = triglic,
glicemia = glicemia,
lactato = lactato,
urea = urea,
otros_examenes = otrosEx,
diagnostico_nutricional = diagnosticoNutr,
meta_nutricional = metaNutr,
observaciones = observaciones,
id_paciente = idPaciente,
id_usuario = idUsuario
};
Requerimientos requerimientoInicial = new Requerimientos
{
tipo = "Inicio",
requerimiento = reqPorcInicial,
energia = energiaInicial,
proteina = proteinaInicial,
factor_kcal = factorKcalInicial,
factor_prot = factorProtInicial,
cho_porc = choPorcInicial,
cho_gr = choGrInicial,
lip_porc = lipPorcInicial,
lip_gr = lipGrInicial,
Evaluaciones = evaluacion
};
Requerimientos requerimientoFinal = new Requerimientos
{
tipo = "Termino",
requerimiento = reqPorcFinal,
energia = energiaFinal,
proteina = proteinaFinal,
factor_kcal = factorKcalFinal,
factor_prot = factorProtFinal,
cho_porc = choPorcFinal,
cho_gr = choGrFinal,
lip_porc = lipPorcFinal,
lip_gr = lipGrFinal,
Evaluaciones = evaluacion
};
dbEntity.Evaluaciones.Add(evaluacion); // Guardamos Evaluación Nutricional
dbEntity.Requerimientos.Add(requerimientoInicial); // Guardamos Requerimiento inicial
dbEntity.Requerimientos.Add(requerimientoFinal); // Guardamos requerimiento final
dbEntity.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
return("Evaluación registrada exitosamente");
}
protected void btnRutFind_Click(object sender, EventArgs e)
{
clsPaciente paciente = new clsPaciente();
// guardamos en una variable el string que devuelve el metodo validar rut
String rut = paciente.validarRut(txtRutFind.Text);
if (rut.Equals("Rut invalido"))
{
lblRutInvalido.Text = rut;
}
else
{
lblRutInvalido.Text = "";
clsEvaluacion evaluacion = new clsEvaluacion();
clsRequerimiento requerimiento = new clsRequerimiento();
int rutPaciente = Convert.ToInt32(rut);
// Si el rut es valido validamos en la base de datos si esta registrado
try
{
using (
db_nutricionEntities dbentity = new db_nutricionEntities())
{
List <int?> rutPat = (from pat in dbentity.Pacientes
select pat.rut).ToList();
List <String> estadoPat = (from pat in dbentity.Pacientes
select pat.estado).ToList();
bool rutMatch = false;
bool estadoMatch = false;
foreach (var findRut in rutPat)
{
if (findRut == rutPaciente)
{
foreach (var findEstado in estadoPat)
{
if (findEstado == "activo")
{
rutMatch = true;
estadoMatch = true;
break;
}
}
}
}
if (rutMatch && estadoMatch)
{
grdPaciente.DataSource = paciente.mostrarPacienteEvaluado(rutPaciente);
grdPaciente.DataBind();
lblTitlePaciente.Visible = true;
btnExportPDF.Visible = true;
}
else
{
lblRutInvalido.Text = "Rut ingresado no existe";
}
}
}
catch (Exception ex)
{
throw ex;
}
// Si el rut esta registrado se llaman a los metodos mostrar de la clase evaluación para consultar la evaluación nutricional del paciente
grdAntropometria.DataSource = evaluacion.mostrarAntropometria(rutPaciente);
grdAntropometria.DataBind();
lblTitleAntr.Visible = true;
grdComposicion.DataSource = evaluacion.mostrarComposicion(rutPaciente);
grdComposicion.DataBind();
lblTitleCC.Visible = true;
grdExamenes.DataSource = evaluacion.mostrarExamenes(rutPaciente);
grdExamenes.DataBind();
lblTitleExamen.Visible = true;
grdDiagnostico.DataSource = evaluacion.mostrarDiagNutr(rutPaciente);
grdDiagnostico.DataBind();
lblTitleDiagn.Visible = true;
grdReqInicial.DataSource = requerimiento.mostrarReqInicial(rutPaciente);
grdReqInicial.DataBind();
lblTitleReqInicial.Visible = true;
grdReqFinal.DataSource = requerimiento.mostrarReqFinal(rutPaciente);
grdReqFinal.DataBind();
lblTitleReqFinal.Visible = true;
grdMetaNutr.DataSource = evaluacion.mostrarMetaNutr(rutPaciente);
grdMetaNutr.DataBind();
lblTitleMeta.Visible = true;
grdObservacion.DataSource = evaluacion.mostrarObservaciones(rutPaciente);
grdObservacion.DataBind();
lblTitleObs.Visible = true;
}
}
