//constructor
public Bloque(int nro_Bloq, Cuestionario cuest)
{
nroBloque = nro_Bloq;
cuestAsociado = cuest;
esultimoBloque = false; //por defecto esta en falso
listaPreguntasEv = new List <PreguntaEvaluada>();
}
private int nroBloque; //numero de identificacion del bloque [ej: 1]
#endregion Fields
#region Constructors
//constructor
public Bloque(int nro_Bloq, Cuestionario cuest)
{
nroBloque = nro_Bloq;
cuestAsociado = cuest;
esultimoBloque = false; //por defecto esta en falso
listaPreguntasEv = new List<PreguntaEvaluada>();
}
public void cerrarCuestionario(Cuestionario cuestionario, string estado)
{
switch (estado)
{
case "ACTIVO":
this.cambiarEstado("SIN CONTESTAR", cuestionario);
break;
case "EN PROCESO":
this.cambiarEstado("INCOMPLETO", cuestionario);
break;
}
}
public bool cambiarEstado(string alEstado, Cuestionario cuest)
{
AdministradorBD admBD = new AdministradorBD(); //intanciacion del administrador base de datos
Estado nuevoEstado = new Estado(cuest, alEstado);
cuest.Estado = nuevoEstado;
bool seCambio_elEstado = admBD.guardarEstado(cuest.Estado); //se lo envia al Adm BD
if (seCambio_elEstado == true)
return true;
else
{
MessageBox.Show("\tNo se realizo el cambio de estado de su cuestionario\n\nPor favor reinicie su sesión", "ADVERTENCIA", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
}
/*
* La mision que justifica la existencia de los gestores es hacer de "interfaz" entre las ENTIDADES y el resto del sistema
* Por esto el gestor debe tener la responsabilidad de instanciar la/s que le corresponde gestionar
*/
public Cuestionario instanciarCuestionario(Candidato canditoAsociado, string claveCuestionario, PuestoEvaluado puestoEvAsociado, int accesos = 0)
{
int maxAccesos = admBD.darAccesosMaximos();
Cuestionario nuevoCuestionario = new Cuestionario(canditoAsociado, claveCuestionario, puestoEvAsociado, maxAccesos, accesos, null);
return nuevoCuestionario;
}
//Constructor de clase 2: se llamara si se esta instanciando un obj por primera vez.
public Estado(Cuestionario cuest, string est)
{
cuestionario = cuest;
estado_ = est;
fecha_hora = DateTime.Now;
}
//Constructor de clase 2: se llamara si se esta instanciando un obj por primera vez.
public Estado(Cuestionario cuest, string est)
{
cuestionario = cuest;
estado_ = est;
fecha_hora = DateTime.Now;
}
//Toma la decicion de que acción realizar para el cuestionario validado
public ArrayList crearCuestionario(Cuestionario nCuestionario)
{
ArrayList procesoFinalizado = new ArrayList();
int accesos = nCuestionario.NroAccesos;
int maxAccesos = nCuestionario.MaxAccesos;
string estadoCuestionario = nCuestionario.obtenerEstado();
switch (accesos < maxAccesos)
{
case true:
PuestoEvaluado puestoEv = nCuestionario.PuestoEvaluado;
DateTime fechaComienzoEvaluacion = gestorEvaluacion.obtenerFechaEvaluacion(puestoEv);
//tiempo del sistema es el tiempo en dias que se prevee para la evaluación
int tiempoSist = admBD.darTiempoEvaluacion();
//tiempo actual es el tiempo transcurrido en dias desde el se inicio de la evaluacion
int tiempoActual = this.determinarCantidad_DeDiasPasados(fechaComienzoEvaluacion);
switch (tiempoActual <= tiempoSist)
{
case true:
//tiempo maximo es el tiempo maximo para realizar el cuestionario desde que se comienza
int tiempoMax = admBD.darTiempoActivo();
DateTime fechaCuestionario = nCuestionario.obtenerFechaEstado();
//tiempo activo es el tiempo que transcurrio desde que se comenzo a realizar el cuestionario
int tiempoActivo = this.determinarCantidad_DeDiasPasados(fechaCuestionario);
switch (tiempoActivo <= tiempoMax)
{
case true:
{
if (Equals(estadoCuestionario, "EN PROCESO") == true)
{
Bloque bloq_retorno = this.levantarCuestionario(nCuestionario);
procesoFinalizado.Add(bloq_retorno);
}
else if (Equals(estadoCuestionario, "ACTIVO") == true)
{
procesoFinalizado.Add("instrucciones"); //va al objeto interfaz
break;
}
}
break;
case false:
cerrarCuestionario(nCuestionario, estadoCuestionario);
procesoFinalizado.Add("Se supero el tiempo para estar Activo establecido para completar el cuestionario");
break;
}
break;
case false:
cerrarCuestionario(nCuestionario, estadoCuestionario);
procesoFinalizado.Add("Supero el tiempo maximo permitido para completar el cuestionario");
break;
}
break;
case false:
cerrarCuestionario(nCuestionario, estadoCuestionario);
procesoFinalizado.Add("Supero la cantidad maxima de accesos permitida para completar el cuestionario");
break;
}
return procesoFinalizado;
}
private bool crearBloque(List<PreguntaEvaluada> listaPreguntas, int pregXbloque, Cuestionario cuest)
{
AdministradorBD admBD = new AdministradorBD(); //intanciacion del administrador base de datos
bool operacionRealizadaConExito = false;
int numBloq = 1, contadorDeBloqueCreados = 0;
int cantidadBloques = (listaPreguntas.Count / pregXbloque);
for (int i = 0; i < listaPreguntas.Count; )
{
Bloque nuevoBloque = new Bloque(numBloq, cuest);
for (int j = 0; j < pregXbloque; j++)
{
nuevoBloque.addPreguntaEv(listaPreguntas[i]);
i++;
}
contadorDeBloqueCreados += 1;
if (numBloq == 1)
{
cuest.UltimoBloque = nuevoBloque;
}
numBloq++;
switch (contadorDeBloqueCreados == cantidadBloques)
{
case true:
{
nuevoBloque.marcarUltimobloque();
bool echo = admBD.guardarBloque(nuevoBloque); // mensaje se envia al Adm de BD
if (echo)
operacionRealizadaConExito = true;
else
{
MessageBox.Show("\tNo se pudieron resguardar los datos de su evaluación\nComuniquese con su evaluador", "ADVERTENCIA", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
operacionRealizadaConExito = false;
}
}
break;
default:
{
bool echo = admBD.guardarBloque(nuevoBloque); // mensaje se envia al Adm de BD
if (echo)
operacionRealizadaConExito = true;
else
{
MessageBox.Show("\tNo se pudieron resguardar los datos de su evaluación\nComuniquese con su evaluador", "ADVERTENCIA", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
operacionRealizadaConExito = false;
}
}
break;
}
}
return operacionRealizadaConExito;
}
public bool resguardarCuestionario(Cuestionario cuest_)
{
AdministradorBD admBD = new AdministradorBD();
bool seGuardaronAtrubutos = admBD.guardarAtributosCuestionario(cuest_);
if (seGuardaronAtrubutos == true)
return true;
else
{
MessageBox.Show("Ocurrio un error al resguardar los datos del cuestionario\n\n\tReinicie su sesión\n\n\t\tDisculpe las molestias");
return false;
}
}
public Respuestas instanciarRespuesta(Cuestionario cuestAsociado, List<Caracteristica> listaRespuestas)
{
Respuestas nuevaRespuestas = new Respuestas(cuestAsociado, listaRespuestas);
return nuevaRespuestas;
}
/*
* 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;
}
/*
* - RecuperarUltimoEstado tiene la misión de recuperar los datos del ultimo Estado de un cuestionario puntual
*/
public List<Estado> recuperarUltimoEstado(Cuestionario cuestAsociado)
{
bool conexionExitosa;
GestorCuestionario gestorCuestionario = new GestorCuestionario();
List<Estado> listaEstado = new List<Estado>();//Para el retorno de datos
string consultaSql = "SELECT `Estado_idEstado`,`fecha` FROM `cuestionario` , `cuestionario_estado` WHERE `clave` = '" + cuestAsociado.Clave + "' AND `idCuestionario` = `Cuestionario_idCuestionario`;";
//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;
}
//Creamos un adaptador llamado "comando" para realizar la consultaSql que definimos 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 encontro el cuestionario
MessageBox.Show("No se encontro el estado para el cuestionario");
terminarConexion();
return null;
}
//Lista de caracteristicas auxiliar para contener la fecha y el ID ESTADO del estado que luego seran utilizados para
//definir el ultimo estado del cuestionario
List<Caracteristica> lista_fechaYid_Estado = new List<Caracteristica>();
while (reader.Read())
{
DateTime fecha = DateTime.Parse(reader["fecha"].ToString());
int idEstado = Int32.Parse(reader["Estado_idEstado"].ToString());
//Creamos un elemento del tipo caracteristica e inicializamos sus partes
Caracteristica elementoLista;
elementoLista.dato1 = fecha;
elementoLista.dato2 = idEstado;
//Agregamos el elemento a la lista
lista_fechaYid_Estado.Add(elementoLista);
}
terminarConexion();
//Seteado en esa fecha para hacer las comparaciones desde un punto fijo pero no posible
DateTime ultimaFecha = DateTime.Parse("1900-01-01");
int indice = 0; //Se utilizara para ubicar en la lista de las fechas y ID ESTADO al estado correspondiente
for (int i = 0; i < lista_fechaYid_Estado.Count; i++)
{
//Casteamos de la lista el dato1 que contiene la fecha
DateTime fechaLista = (DateTime)lista_fechaYid_Estado[i].dato1;
if (DateTime.Compare(ultimaFecha, fechaLista) == -1)
{
ultimaFecha = fechaLista;//actualizamos la variable como la ultima fecha
indice = i;//establecemos el indice donde se encuentra este ultimo estado
}
}
//Recuperamos los datos de Estado pasandole el id_estado que se encuentra en la lista
string estado = this.recuperarEstado((int)lista_fechaYid_Estado[indice].dato2);
//Instanciamos el estado de cuestionario
Estado objEstado = gestorCuestionario.instanciarEstado(cuestAsociado, estado, ultimaFecha);
listaEstado.Add(objEstado);
return listaEstado;
}
/*
* - RecuperarCaracteristicasPuesto tiene la misión de recuperar todas las competencias que estan activas (no eliminadas)
* y ponederaciones asociades a un puesto puntual de la base de datos
*/
public List<Caracteristica> recuperarCaracteristicasPuestoEv(PuestoEvaluado puestoEvAsociado, Cuestionario cuest_Asociado)
{
bool conexionExitosa;
//Lista que se retornara con los datos finales de la busqueda
List<Caracteristica> listaCaracteristicas = new List<Caracteristica>();
//Lista de caracteristicas auxiliar para realizar la busqueda (almacena los ID de las competencias y ponderaciones)
List<Caracteristica> listaRetornoBD = new List<Caracteristica>();
Caracteristica elementoLista = new Caracteristica();
//La consulta selecciona las competencias asociadas al puesto pasado como parametro con su correspondiente ponderacion
string consultaSql = "SELECT `Competencia Evaluada_idCompetencia Evaluada`, `ponderacion` "
+ "FROM `puesto evaluado_competencia evaluada` ponderaciones "
+ "JOIN `puesto evaluado` p on (p.`codigo` = '" + puestoEvAsociado.Codigo + "' AND p.`idPuesto Evaluado` = ponderaciones.`Puesto Evaluado_idPuesto Evaluado`) "
+ "JOIN cuestionario c ON (c.clave = '" + cuest_Asociado.Clave + "' AND c.`Puesto Evaluado_idPuesto Evaluado` = p.`idPuesto Evaluado`)";
conexionExitosa = iniciarConexion();
if (!conexionExitosa)
{
elementoLista.dato1 = "No se realizo la conexion con la base de datos";//Se informa el error
listaCaracteristicas.Add(elementoLista);
terminarConexion();
return listaCaracteristicas;
}
//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 qe no encontro a ese candidato
elementoLista.dato1 = "El puesto no posee competencias para ser evaluado";
listaCaracteristicas.Add(elementoLista);
terminarConexion();
return listaCaracteristicas;
}
while (reader.Read())
{
//Se recuperan los ID's de las competencias y los números correspondientes a las ponderaciones
int idCompetenciaEv = Int32.Parse(reader["Competencia Evaluada_idCompetencia Evaluada"].ToString());
int ponderacion = Int32.Parse(reader["ponderacion"].ToString());
//Los datos obtenidos se almacena en un elemento de la lista
elementoLista.dato1 = idCompetenciaEv;
elementoLista.dato2 = ponderacion;
listaRetornoBD.Add(elementoLista);//Agregamos el elemento a la lista
}
//Termanamos la conexion con la base de datos para evitar futuros conflictos con otras consultas
terminarConexion();
for (int i = 0; i < listaRetornoBD.Count; i++)
{
//Realizamos la busqueda de las competencias evaluadas por su ID (QUE ES UNICO)
List<CompetenciaEvaluada> competenciaAs = recuperarCompetenciasEvaluadas((int)listaRetornoBD[i].dato1);
if (competenciaAs[0] != null)
{
//Si hubo algun retorno, instanciamos un objeto del tipo ponderacion
Ponderacion pondeAs = new Ponderacion((int)listaRetornoBD[i].dato2);
//Agregamos la competencia y la poneración a un elemento de la lista
elementoLista.dato1 = competenciaAs[0];
elementoLista.dato2 = pondeAs;
listaCaracteristicas.Add(elementoLista);//Agregamos el elemento a la lista de caracteristicas del puesto evaluado
}
}
return listaCaracteristicas;
}
/*
* =======================================
* METODOS DE RECONSTRUCCION DE RELACIONES
* =======================================
* - Tiene la finalidad de re-establecer los objetos asociados del diagrama de clases
*/
public bool reconstruirRelaciones(Cuestionario cuestionarioAsociado)
{
bool seRealizoConExito = true;
PuestoEvaluado puestoEvAsociado = cuestionarioAsociado.PuestoEvaluado;
if (Equals(puestoEvAsociado.Caracteristicas, null) == true)
{
List<Caracteristica> caracteristicasPuesto = recuperarCaracteristicasPuestoEv(puestoEvAsociado, cuestionarioAsociado);
puestoEvAsociado.Caracteristicas = caracteristicasPuesto;
if (Equals(caracteristicasPuesto[0].dato1.GetType(), "stringEJEMPLO".GetType()) == false)
seRealizoConExito = true;
else
seRealizoConExito = false;
}
return seRealizoConExito;
}
public Estado instanciarEstado(Cuestionario cuestAsociado, string _estado, DateTime fecha)
{
Estado nuevoEstado = new Estado(cuestAsociado, _estado, fecha);
return nuevoEstado;
}
private bool esUltimimoBloque(Cuestionario cuestAsociado, int nroBloque)
{
bool esUltimoBloque_ = false;//POR DEFECTO ES FALSO
bool conexionExitosa;
conexionExitosa = iniciarConexion();
if (!conexionExitosa)
return false; //Error de conexion
string consultaSql = "SELECT bloq.esUltimoBloque "
+ "FROM bloque bloq "
+ "JOIN cuestionario cuest on (bloq.Cuestionario_idCuestrionario = cuest.idCuestionario) "
+ "WHERE cuest.clave = '" + cuestAsociado.Clave + "' AND bloq.nroBloque = " + nroBloque + ";";
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
MessageBox.Show("algo salio mal en el bloque ... ");
return false;
}
while (reader.Read())
{
if (reader["esUltimoBloque"].ToString() != "")
esUltimoBloque_ = Boolean.Parse(reader["esUltimoBloque"].ToString());
}
return esUltimoBloque_;
}
public Bloque levantarCuestionario(Cuestionario cuestionario)
{
cuestionario.aumentarAcceso();
cuestionario.Estado.Fecha_hora = DateTime.Now;
admBD.guardarEstado(cuestionario.Estado);
this.resguardarCuestionario(cuestionario);
Bloque bloq_ = cuestionario.UltimoBloque;
return bloq_;
}
public bool guardarAtributosCuestionario(Cuestionario cuest_)
{
MySql.Data.MySqlClient.MySqlTransaction transaccion;
bool conexionExitosa;
int cantDeFilasAfectadas = 0;
conexionExitosa = iniciarConexion();
MySql.Data.MySqlClient.MySqlCommand comando = new MySqlCommand();
comando.Connection = ObjConexion;
comando.CommandType = CommandType.Text;
comando.CommandTimeout = 0;
transaccion = ObjConexion.BeginTransaction();
try
{
if (!conexionExitosa)
return false;
else
{
//CONSULTA QUE ACTUALIZA LA TABLA ITEM_BLOQUE PARA RESGUARDAR LAS RESPUESTAS
string consultaSql = "UPDATE `cuestionario` SET `nroAccesos`=" + cuest_.NroAccesos + ", `ultimoBloque`=" + cuest_.UltimoBloque.NroBloque + " "
+ "WHERE clave='" + cuest_.Clave + "';";
comando.CommandText = consultaSql;
cantDeFilasAfectadas += comando.ExecuteNonQuery();
}
transaccion.Commit();
terminarConexion();
}
catch (MySqlException MysqlEx)
{
// si algo fallo deshacemos todo
transaccion.Rollback();
// mostramos el mensaje del error
MessageBox.Show("RESGUARDO DE DATOS CUESTIONARIO: La transaccion no se pudo realizar: " + MysqlEx.Message);
}
catch (DataException Ex)
{
// si algo fallo deshacemos todo
transaccion.Rollback();
// mostramos el mensaje del error
MessageBox.Show("RESGUARDO DE DATOS CUESTIONARIO: La transaccion no se pudo realizar: " + Ex.Message);
}
if (cantDeFilasAfectadas > 0)
{
return true;
}
else
{
return false;
}
}
//valida que el candidato poseea un cuestionario en algun estado valido
public bool validarAcceso(Cuestionario cuest, string claveUs)
{
bool retorno = false; //por defecto se lo dejo como falso.. MIRAR DESPUES
string estado = cuest.obtenerEstado();
switch(estado)
{
case "ACTIVO":
switch (Equals(cuest.Clave, claveUs))//se fija si la clave guardada en el cuestionario sea = a la pasada como parametro
{
case true:
retorno = true;
break;
case false:
retorno = false;
break;
}
break;
case "EN PROCESO":
switch (Equals(cuest.Clave, claveUs))//idem anterior ... FIJARSE SI NO HAY UNA MEJOR FORMA DE HACER ESTOS SWITCH EN GRAL
{
case true:
retorno = true;
break;
case false:
retorno = false;
break;
}
break;
default:
MessageBox.Show("El candidato no posee un cuestionario 'En proceso' o 'Activo'", "INFORMACION", MessageBoxButtons.OK, MessageBoxIcon.Information);
retorno = false;
break;
}
return retorno;
}
public Respuestas(Cuestionario cuestAsociado, List <Caracteristica> listasRespuestas)
{
cuestionarioAsociado = cuestAsociado;
preguntasMasOpciones = listasRespuestas;
}
public bool guardarRespuestas(Cuestionario cuestAsociado, List<Caracteristica> respuestaUsuario, int nroBloque_Asociado)
{
Respuestas Respuesta = this.instanciarRespuesta(cuestAsociado, respuestaUsuario);
bool procesoCompleto = admBD.guardarRespuesta(Respuesta, nroBloque_Asociado);
if (procesoCompleto == true)
return true;
else
return false;
}
public Bloque inicializarCuestionario(Cuestionario cuestionario)
{
PuestoEvaluado pEv = cuestionario.PuestoEvaluado;
List<PreguntaEvaluada> listaPreguntas = gestorEvaluacion.listarPreguntas(pEv);
if (listaPreguntas.Count != 0)
{
ordenarListaAleatorio(listaPreguntas);
int pregXbloque = admBD.preguntasPorBloque();
if (pregXbloque != -1 && pregXbloque != -2)
{
bool bloques_Creados = this.crearBloque(listaPreguntas, pregXbloque, cuestionario);
if (bloques_Creados)
{
this.cambiarEstado("EN PROCESO", cuestionario);
cuestionario.aumentarAcceso();
Bloque bloq_ = cuestionario.UltimoBloque;
this.resguardarCuestionario(cuestionario);
return bloq_;
}
else
return null;
}
else
return null;
}
else
return null;
}
//Contructor de clase 1: se lo llamara si se esta instanciando un obj para la clase que ya exista en la BD
public Estado(Cuestionario cuest, string est, DateTime fecha)
{
cuestionario = cuest;
estado_ = est;
fecha_hora = fecha;
}
public Bloque instanciarBloque(int nro_Bloq, Cuestionario cuest)
{
Bloque nuevoBloque = new Bloque(nro_Bloq, cuest);
return nuevoBloque;
}
public Respuestas(Cuestionario cuestAsociado, List<Caracteristica> listasRespuestas)
{
cuestionarioAsociado = cuestAsociado;
preguntasMasOpciones = listasRespuestas;
}
//Contructor de clase 1: se lo llamara si se esta instanciando un obj para la clase que ya exista en la BD
public Estado(Cuestionario cuest, string est, DateTime fecha)
{
cuestionario = cuest;
estado_ = est;
fecha_hora = fecha;
}
