public int cantidad_De_Preguntas_Por_Competencia(string codigo_de_competencia, DateTime fecha_ev, string codigo_ev)
{
bool conexionExitosa;
GestorEvaluacion gestor_de_Evaluacion = new GestorEvaluacion();
List<CompetenciaEvaluada> listaCompetenciasEvaluadas = new List<CompetenciaEvaluada>();
string fecha_formateada = this.formatear_fecha(fecha_ev);
int cantidad_preguntas = -1;
string consultaSql = "SELECT COUNT(*) " +
" FROM `factor evaluado` fa " +
" JOIN `pregunta evaluada` pe on( `Factor Evaluado_idFactor Evaluado` = `idFactor Evaluado`) " +
" WHERE `Competencia Evaluada_idCompetencia Evaluada` = (SELECT DISTINCT `idCompetencia Evaluada` " +
" FROM `puesto evaluado_competencia evaluada` pe_ce " +
" JOIN `competencia evaluada` comp_ev on (codigo = '" + codigo_de_competencia +
"' AND `Competencia Evaluada_idCompetencia Evaluada` = `idCompetencia Evaluada`) " +
" WHERE `Puesto Evaluado_idPuesto Evaluado` = (SELECT DISTINCT `idPuesto Evaluado` " +
" FROM candidato cand " +
" JOIN cuestionario cuest on (idCandidato = Candidato_idCandidato) " +
" JOIN cuestionario_estado cuest_estado on (idCuestionario = Cuestionario_idCuestionario) " +
" JOIN `puesto evaluado` puesto_ev on (`idPuesto Evaluado` =`Puesto Evaluado_idPuesto Evaluado`)" +
" WHERE puesto_ev.codigo = '" + codigo_ev + "' AND fecha = '" + fecha_formateada + "'));";
//llamamos al metodo "iniciar conexion"
conexionExitosa = iniciarConexion();
//Evaluamos si la conexion se realizo con exito
if (!conexionExitosa)
{
MessageBox.Show("Fallo la conexion con la base de datos");
terminarConexion();
return -1;
}
//Creamos un adaptador llamado "comando" para realizar la consultaSql que definimos mas arriba
MySql.Data.MySqlClient.MySqlCommand comando;
comando = ObjConexion.CreateCommand();
comando.CommandText = consultaSql;//En el adaptador comando hacemos un asignacion en su atributo CommandText de la consultaSql
//Se hace la ejecucion del comando con el metodo ExecuterReader
//y se lo asigna a una variable reader que contendra los resultados de la busqueda en la base de datos
MySqlDataReader reader = comando.ExecuteReader();
if (!reader.HasRows)
{
//si el reader esta vacio, es que no se encontraron datos para la consulta realizada
MessageBox.Show("No existen preguntas asociadas a esta competencia de esta evaluacion[Imposible!]");
terminarConexion();
return -1;
}
while (reader.Read())
{
cantidad_preguntas = Int32.Parse(reader["COUNT(*)"].ToString());
}
terminarConexion();
return cantidad_preguntas;
}
/*
* retornarProximoBloque tiene la misión de recuperar el proximo bloque de un cuestionario a travez de su numero de bloque
*/
public Bloque retornarBloque(Cuestionario cuestAsociado, int nroBloque)
{
GestorCuestionario gestorCuestionario = new GestorCuestionario();
GestorEvaluacion gestorEvaluacion = new GestorEvaluacion();
if (cuestAsociado.PuestoEvaluado.Caracteristicas == null)
{
//Re-armamos las relaciones del cuestionario para tener todos los objetos en memoria
bool re_construido = this.reconstruirRelaciones(cuestAsociado);
if (!re_construido)
{
MessageBox.Show("No se pudo recuperar Todos los datos requeridos");
return null;
}
}
bool conexionExitosa;
List<PreguntaEvaluada> ListapregAsociadas = new List<PreguntaEvaluada>();
string consultaSql = "SELECT codigo " //Recupero el codigo de las preguntas evaluadas
+ "FROM item_bloque it_Bloq " //Desde la tabla de ITEM_BLOQUE de la base de datos
//CONDICIONO CON UN JOIN que el id que se encuentra en la tabla de `pregunta evaluada` sea igual al id de la tabla `item_bloque`
+ "JOIN `pregunta evaluada` pEv on (pEv.`idPregunta Evaluada` = it_Bloq.PreguntaEvaluada_idPreguntaEv) "
//CON UN SEGUNDO JOIN pido que me busque los datos del bloque que condice con el "nroBloque"
+ "JOIN bloque bq on (bq.nroBloque = " + nroBloque + ") "
//TERCER JOIN pido que me busque entre los cuestionarios los datos del que coincida con el cuestionario que le paso como parametro
+ "JOIN cuestionario cuest on (cuest.clave = '" + cuestAsociado.Clave + "') "
//Con el WHERE restrinjo que de los datos obtenidos:
//El id del bloque que se encuentra en la tabla `item_bloque` sea el mismo al del bloque seleccionado en el JOIN
+ "WHERE it_Bloq.Bloque_idBloque = bq.idBloque "
//Y que el id del cuestionario que esta en la tabla de `bloques` sea el mismo al obtenido del JOIN con la tabla cuestionario
+ "AND bq.Cuestionario_idCuestrionario = cuest.idCuestionario;";
conexionExitosa = iniciarConexion();
if (!conexionExitosa)
return null; //Error de conexion
MySql.Data.MySqlClient.MySqlCommand comando;
comando = ObjConexion.CreateCommand();
comando.CommandText = consultaSql;
MySqlDataReader reader = comando.ExecuteReader();
if (!reader.HasRows)//si el reader esta vacio, no se encontro el parametro buscado
return null;
while (reader.Read())
{
string codigo = reader["codigo"].ToString();
ListapregAsociadas.Add(gestorEvaluacion.retornarPreguntaDeLaRelacion(cuestAsociado.PuestoEvaluado, codigo));
}
terminarConexion();
bool esUltimoBloque = esUltimimoBloque(cuestAsociado, nroBloque);
Bloque bloque_R = gestorCuestionario.instanciarBloque(nroBloque, cuestAsociado);
bloque_R.EsUltimoNloque = esUltimoBloque;
bloque_R.ListaPreguntasEv = ListapregAsociadas;
terminarConexion();
return bloque_R;
}
/*
* - RecuperarPuestoEvaluado tiene la misión de recuperar un puesto evaluado puntual
* según su id de la tabla de la base de datos
*/
public PuestoEvaluado recuperarPuestoEvaluado(int idPuestoEv)
{
bool conexionExitosa;
GestorEvaluacion gestorEvaluados = new GestorEvaluacion();
PuestoEvaluado objPuesto = null;
DateTime fecha_evaluacion = this.recuperarFechadeComienzoEvaluacion(idPuestoEv);
string consultaSql = "SELECT * FROM `puesto evaluado` WHERE `idPuesto Evaluado` = " + idPuestoEv + " ;";
//llamamos al metodo "iniciar conexion"
conexionExitosa = iniciarConexion();
//Evaluamos si la conexion se realizo con exito
if (!conexionExitosa)
{
MessageBox.Show("Fallo la conexion con la base de datos");
terminarConexion();
return null;
}
MySql.Data.MySqlClient.MySqlCommand comando;
comando = ObjConexion.CreateCommand();
comando.CommandText = consultaSql;
MySqlDataReader reader = comando.ExecuteReader();
if (!reader.HasRows)
{
//Si el reader esta vacio, es qe no encontro a ese candidato
MessageBox.Show("No se encontro un candidato solicitado ");
terminarConexion();
return null;
}
else
{
while (reader.Read())
{
if (reader["eliminado"].ToString() == "")
{
string codigo = reader["codigo"].ToString();
string nombrePuestoEv = reader["nombre"].ToString();
string empresa = reader["empresa"].ToString();
//Usamos el gestor de evaluacion para instanciar el puesto evaludado con los datos encontrados en la base de datos
objPuesto = gestorEvaluados.instanciarPuestoEvaluado(codigo, nombrePuestoEv, empresa);
objPuesto.Fecha_Comienzo = fecha_evaluacion;
}
else
{
//Si el puesto evaludado fue eliminado se instanciara un puesto cuyo codigo sera "ELIMINADO"
objPuesto = gestorEvaluados.instanciarPuestoEvaluado("ELIMINADO", " ", " ");
}
}
}
terminarConexion();
return objPuesto;
}
public List<PuestoEvaluado> recuperarPuestos_ev(string codigo)
{
bool conexionExitosa;
GestorEvaluacion gestorPuestos = new GestorEvaluacion();
List<PuestoEvaluado> listaDePuestos_ev = new List<PuestoEvaluado>(); //para el retorno de datos
List<Int32> lista_de_ID_Puesto_ev = new List<Int32>();
string consultaSql = "SELECT DISTINCT `idPuesto Evaluado`, codigo, nombre, empresa, fecha " +
"FROM `puesto evaluado` pu_ev " +
"JOIN cuestionario cuest on (pu_ev.codigo = '" + codigo + "' AND pu_ev.`idPuesto evaluado` = cuest.`Puesto Evaluado_idPuesto Evaluado`) " +
"JOIN `cuestionario_estado` c_est on (cuest.idCuestionario = c_est.Cuestionario_idCuestionario) " +
"WHERE Estado_idEstado = 1 " +
"GROUP BY `idPuesto Evaluado`";
//llamamos al metodo "iniciar conexion"
conexionExitosa = iniciarConexion();
//Evaluamos si la conexion se realizo con exito
if (!conexionExitosa)
{
MessageBox.Show("No se pudo realizar la conexión con la Base de Datos");
terminarConexion();
return null;
}
//Creamos un adaptador llamado "comando" para realizar la consultaSql que definimos mas arriba
MySql.Data.MySqlClient.MySqlCommand comando;
comando = ObjConexion.CreateCommand();
//En el adaptador comando hacemos un asignacion en su atributo CommandText de la consultaSql
comando.CommandText = consultaSql;
//Se hace la ejecucion del comando con el metodo ExecuterReader
//y se lo asigna a una variable reader que contendra los resultados de la busqueda en la base de datos
MySqlDataReader reader = comando.ExecuteReader();
if (!reader.HasRows)
{
//si el reader esta vacio, es que no se encontraron datos para la consulta realizada
MessageBox.Show("No se encontro ningún puesto");
terminarConexion();
return null;
}
//Si el reader contiene datos, se realiza la lectura de todos los ellos.
while (reader.Read())
{
PuestoEvaluado objPuestoEv;
string id_puesto_ev = reader[0].ToString();
string cod = reader["codigo"].ToString();
string nomPuesto = reader["nombre"].ToString();
string emp = reader["empresa"].ToString();
DateTime fecha = (DateTime)reader["fecha"];
//Llamamos al gestor de puestos para instanciar el puesto que se obtuvo de la base de datos
objPuestoEv = gestorPuestos.instanciarPuestoEvaluado(cod, nomPuesto, emp);
objPuestoEv.Fecha_Comienzo = fecha;
//El retorno del metodo del gestor es introducido en la lista de puestos
listaDePuestos_ev.Add(objPuestoEv);
}
terminarConexion();
return listaDePuestos_ev;
}
/*
* - RecuperarPreguntas evaluadas tiene la misión de recuperar Las preguntas evaluadas para Un factor puntual
* de a la BASE DE DATOS
*/
public List<PreguntaEvaluada> recuperarPreguntasEvaluadas(FactorEvaluado factorAsociado)
{
bool conexionExitosa;
GestorEvaluacion gestorEvaluacion = new GestorEvaluacion();
List<PreguntaEvaluada> listaDePreguntas = new List<PreguntaEvaluada>();
string consultaSql = "SELECT p.nombre , p.codigo, p.pregunta, p.`Opcion de Respuesta Evaluada_idOpcion de Respuesta Evaluada` "
+ "FROM `pregunta evaluada` AS p "
+ "JOIN `factor evaluado` AS fac on (p.`Factor Evaluado_idFactor Evaluado` = fac.`idFactor Evaluado`) "
+ "WHERE fac.`codigo` = '" + factorAsociado.Codigo + "';";
conexionExitosa = iniciarConexion();
if (!conexionExitosa)
{
MessageBox.Show("No se realizo la conexion con la base de datos");
terminarConexion();
return null;
}
MySql.Data.MySqlClient.MySqlCommand comando;
comando = ObjConexion.CreateCommand();
comando.CommandText = consultaSql;
MySqlDataReader reader = comando.ExecuteReader();
if (!reader.HasRows)
{ //si el reader esta vacio, es qe no encontro a ese candidato
MessageBox.Show("El factor no posee preguntas para ser evaluado");
terminarConexion();
return null;
}
List<int> listaIdOpRespuesta = new List<int>();
while (reader.Read())
{
string cod = reader["codigo"].ToString();
string nomPreg = reader["nombre"].ToString();
string preg = reader["pregunta"].ToString();
int idOpRespuesta = Int32.Parse(reader["Opcion de Respuesta Evaluada_idOpcion de Respuesta Evaluada"].ToString());
PreguntaEvaluada preguntaEv = gestorEvaluacion.instanciarPreguntaEvaluda(cod, preg, nomPreg, factorAsociado);
listaDePreguntas.Add(preguntaEv);
listaIdOpRespuesta.Add(idOpRespuesta);
}
terminarConexion();
//Agregamos la listas de Opciones de respuesta y las opciones para cada una de las preguntas encontradas
for (int i = 0; i < listaDePreguntas.Count; i++)
{
//Se recuperan la opcion de respuesta de la pregunta
List<OpciondeRespuestaEvaluada> opcionesRespuesta = recuperarOpcionRespuestaEvaluada(listaIdOpRespuesta[i]);
if (opcionesRespuesta != null)
{
//Recuperamos la opcion que contiene la poneracion para esa pregunta
List<OpcionesEvaluadas> opciones = recuperarOpcionesEvaluadas(listaDePreguntas[i]);
//Completamos el objeto Opciones_de_respuestas_evaludas con la lista de opciones
opcionesRespuesta[0].ListaOpcionesEv = opciones;
//Realizamos la asignacion de la opcion de respuesta y las opciones corespondientes para la pregunta
listaDePreguntas[i].Op_respuestaEv = opcionesRespuesta[0];
listaDePreguntas[i].ListaOpcionesEv = opciones;
}
}
return listaDePreguntas;
}
/*
* - RecuperarOpcionRespuestaEvaluda tiene la misión de recuperar las opciones evaluadas para una pregunta puntual
* de a la BASE DE DATOS
*/
public List<OpciondeRespuestaEvaluada> recuperarOpcionRespuestaEvaluada(int idOpcionDeRespuesta)
{
bool conexionExitosa;
GestorEvaluacion gestorEvaluacion = new GestorEvaluacion();
List<OpciondeRespuestaEvaluada> listaDeOpRespuesta = new List<OpciondeRespuestaEvaluada>();//Para el retorno de datos
string consultaSql = "SELECT * FROM `opcion de respuesta evaluada` opcRes WHERE opcRes.`idOpcion de Respuesta Evaluada` = '" + idOpcionDeRespuesta + "';";
conexionExitosa = iniciarConexion();
if (!conexionExitosa)
{
MessageBox.Show("No se pudo realizar la conexion con la base de datos");
terminarConexion();
return null;
}
MySql.Data.MySqlClient.MySqlCommand comando;
comando = ObjConexion.CreateCommand();
comando.CommandText = consultaSql;
MySqlDataReader reader = comando.ExecuteReader();
if (!reader.HasRows)
{ //si el reader esta vacio, es qe no encontro a esa opcion de respuesta evaluada
MessageBox.Show("No se encontro la opcion de respuesta solicitada");
terminarConexion();
return null;
}
while (reader.Read())
{
string nomOpcionResp = reader["nombre"].ToString();
string codigo = reader["codigo"].ToString();
OpciondeRespuestaEvaluada OpcionResp = gestorEvaluacion.instanciarOpRespuestaEv(nomOpcionResp, codigo);
listaDeOpRespuesta.Add(OpcionResp);
}
terminarConexion();
return listaDeOpRespuesta;
}
/*
* - RecuperarOpcionesEvaludas tiene la misión de recuperar las opciones evaluadas para una pregunta puntual
* de a la BASE DE DATOS
*/
public List<OpcionesEvaluadas> recuperarOpcionesEvaluadas(PreguntaEvaluada pregAsociada)
{
bool conexionExitosa;
GestorEvaluacion gestionEvaluacion = new GestorEvaluacion();
List<OpcionesEvaluadas> listaDeOpciones = new List<OpcionesEvaluadas>();//Para el retorno de datos
string consultaSql = "SELECT op.nombre, pr_op.ponderacion, opr_op.ordenDeVisualizacion "
+ "FROM `pregunta evaluada_opcion evaluada` pr_op "
+ "JOIN `pregunta evaluada` pr on (pr_op.`Pregunta Evaluada_idPregunta Evaluada` = pr.`idPregunta Evaluada` AND pr.codigo = '" + pregAsociada.Codigo + "') "
+ "JOIN `opcion evaluada` op on (pr_op.`Opcion Evaluada_idOpcion` = op.idOpcion) "
+ "JOIN `opcion de respuesta evaluada_opcion evaluada` opr_op on (pr_op.`Opcion Evaluada_idOpcion` = opr_op.`Opcion Evaluada_idOpcion`) "
+ "GROUP BY nombre;";
//llamamos al metodo "iniciar conexion"
conexionExitosa = iniciarConexion();
//Evaluamos si la conexion se realizo con exito
if (!conexionExitosa)
{
MessageBox.Show("Fallo la conexion con la base de datos");
terminarConexion();
return null;
}
MySql.Data.MySqlClient.MySqlCommand comando;
comando = ObjConexion.CreateCommand();
comando.CommandText = consultaSql;
MySqlDataReader reader = comando.ExecuteReader();
if (!reader.HasRows)
{ //si el reader esta vacio, es qe no encontro a ese candidato
MessageBox.Show("No se entraron opciones para la pregunta solicitada");
terminarConexion();
return null;
}
while (reader.Read())
{
//opc.nombre, opR_opc.ordenDeVisualizacion, pr.`idPregunta Evaluada`
string nomOpcion = reader["nombre"].ToString();
int ponderacion = Int32.Parse(reader["ponderacion"].ToString());
int ordenVisualizacion = Int32.Parse(reader["ordenDeVisualizacion"].ToString());
OpcionesEvaluadas preguntaEv = gestionEvaluacion.instanciarOpcionEv(nomOpcion, ponderacion, ordenVisualizacion);
listaDeOpciones.Add(preguntaEv);
}
terminarConexion();
return listaDeOpciones;
}
/*
* - RecuperarFactoresEvaludos tiene la misión de recuperar los factores evaluados para una competencia puntual
* de a la BASE DE DATOS
*/
public List<FactorEvaluado> recuperarFactoresEvaluados(CompetenciaEvaluada competenciaAsociada)
{
bool conexionExitosa;
GestorEvaluacion gestorEvaluacion = new GestorEvaluacion();
List<FactorEvaluado> listaDeFactores = new List<FactorEvaluado>();//Para el retorno de datos
string consultaSql = "SELECT `factor evaluado`.nombre ,`factor evaluado`.codigo ,nroOrden " +
"FROM `factor evaluado` " +
"JOIN `competencia evaluada` comEv on (comEv.`codigo` = '" + competenciaAsociada.Codigo + "') " +
"WHERE `factor evaluado`.`Competencia Evaluada_idCompetencia Evaluada` = comEv.`idCompetencia Evaluada`;";
conexionExitosa = iniciarConexion();
if (!conexionExitosa)
{
MessageBox.Show("No se realizo la conexion con la base de datos");
terminarConexion();
return null;
}
MySql.Data.MySqlClient.MySqlCommand comando;
comando = ObjConexion.CreateCommand();
comando.CommandText = consultaSql;
MySqlDataReader reader = comando.ExecuteReader();
if (!reader.HasRows)
{ //si el reader esta vacio, es qe no encontro a ese candidato
MessageBox.Show("El puesto no posee competencias para ser evaluado");
terminarConexion();
return null;
}
while (reader.Read())
{
string cod = reader["codigo"].ToString();
string nomFactor = reader["nombre"].ToString();
int nrOrden = Int32.Parse(reader["nroOrden"].ToString());
//Ahora vamos a crear una instancia del objeto factor, a través del gestor de factores
FactorEvaluado factorEv = gestorEvaluacion.instanciarFactorEvaluado(cod, nomFactor, competenciaAsociada, nrOrden);
listaDeFactores.Add(factorEv);
}
terminarConexion();
//Agregamos la lista de Factores para cada una de las competencias encontradas
for (int i = 0; i < listaDeFactores.Count; i++)
{
List<PreguntaEvaluada> preguntasList = recuperarPreguntasEvaluadas(listaDeFactores[i]);
if (preguntasList != null)
{
for (int j = 0; j < preguntasList.Count; j++)
{
listaDeFactores[i].addPregunta(preguntasList[j]);
}
}
/*else
listaDeFactores.Add(preguntasList[i]);*/
}
return listaDeFactores;
}
/*
* - RecuperarCompetenciasEvaludas tiene la misión de recuperar una competencia evaluada según su ID
* que corresponde a la BASE DE DATOS
*/
public List<CompetenciaEvaluada> recuperarCompetenciasEvaluadas(int idCompetenciaEv)
{
bool conexionExitosa;
GestorEvaluacion gestorEvaluacion = new GestorEvaluacion();
List<CompetenciaEvaluada> listaDeCompetencias = new List<CompetenciaEvaluada>();//Para el retorno de datos
string consultaSql = "SELECT * FROM `competencia evaluada` WHERE `competencia evaluada`.`idCompetencia Evaluada` ='" + idCompetenciaEv + "';";
conexionExitosa = iniciarConexion();
if (!conexionExitosa)
{
MessageBox.Show("No se realizo la conexion con la base de datos");
terminarConexion();
return null;
}
MySql.Data.MySqlClient.MySqlCommand comando;
comando = ObjConexion.CreateCommand();
comando.CommandText = consultaSql;
MySqlDataReader reader = comando.ExecuteReader();
if (!reader.HasRows)
{ //si el reader esta vacio, es qe no encontro a ese candidato
MessageBox.Show("El puesto no posee competencias para ser evaluado");
terminarConexion();
return null;
}
while (reader.Read())
{
//Verificamos que la competencia no este eliminada
CompetenciaEvaluada competenciaEv;
if (reader["eliminado"].ToString() == "")
{
string cod = reader["codigo"].ToString();
string nomComp = reader["nombre"].ToString();
string descrip = reader["descripcion"].ToString();
//Si no fue eliminada, la instaciamos con el gestor de evaluacion con los datos obtenidos
competenciaEv = gestorEvaluacion.instanciarCompetenciaEvaluda(cod, nomComp, descrip);
}
else//Si fue eliminada, instanciamos una competencia con el atrubuto 'codigo' inicializado en ELIMINADA
competenciaEv = gestorEvaluacion.instanciarCompetenciaEvaluda("ELIMINADA", null, null);
listaDeCompetencias.Add(competenciaEv);
}
terminarConexion();
//Agregamos la lista de Factores para cada una de las competencias encontradas
for (int i = 0; i < listaDeCompetencias.Count; i++)
{
//Recuperamos los factores asociados a la competencia
List<FactorEvaluado> factoresList = recuperarFactoresEvaluados(listaDeCompetencias[i]);
if (factoresList != null)
{
for (int j = 0; j < factoresList.Count; j++)
{
//Para la competencia Evaluada que esta resguardada en la posición i
//le agregamos a su lista de factores, el factor evaluado que se encentre en la posición j
listaDeCompetencias[i].addFactor(factoresList[j]);
}
}
}
return listaDeCompetencias;
}