Exemple #1
0
        private void siguiente_Click(object sender, EventArgs e)
        {
            if (flowLayoutPanel1.Controls.OfType <RadioButton>().FirstOrDefault(r => r.Checked) != null)
            {
                int respuestaId = Int32.Parse(flowLayoutPanel1.Controls.OfType <RadioButton>().FirstOrDefault(r => r.Checked).Name);

                this.iExamen = ControladorExamen.GuardarRespuesta(iExamen, obtienePregunta(iNumeroPregunta), respuestaId);

                LimpiaControles(); // Limpia todos los controles

                iNumeroPregunta++;

                if (iNumeroPregunta >= iExamen.CantidadPreguntas)
                {
                    this.Hide();

                    examenTerminado = ControladorExamen.FinalizarExamen(iExamen);

                    Ventana_Examen_Terminado finalizado = new Ventana_Examen_Terminado(examenTerminado);
                    finalizado.ShowDialog();
                    this.Close();
                }
                else
                {
                    obtienePregunta(iNumeroPregunta);
                }
            }
            else
            {
                MessageBox.Show("Debe seleccionar una resupuesta");
            }
        }
        protected void btnIngreso_Click(object sender, EventArgs e)
        {
            IngresoDTO  ingresoDTO  = (IngresoDTO)Session["ingreso_ADM_DTO"];
            PacienteDTO pacienteDTO = (PacienteDTO)Session["paciente_ADM_DTO"];

            ExamenNEG examenNEG   = new ExamenNEG();
            ExamenDTO examenDTOIN = new ExamenDTO();
            int       retorno     = 0;

            examenDTOIN.nombre_examen = txtNombreExamen.Text;
            examenDTOIN.fecha_examen  = Convert.ToDateTime(datepicker.Text);
            examenDTOIN.ingresoID     = ingresoDTO.ingresoID;
            examenDTOIN.resultado     = "";

            retorno = examenNEG.create(examenDTOIN);

            if (retorno == 1)
            {
                //Mensaje OK
                divok.Visible = true;
            }
            else
            {
                //Mensaje OK
                diverror.Visible = true;
            }
        }
Exemple #3
0
 public Ventana_Preguntas(ExamenDTO pExamenDto)
 {
     InitializeComponent();
     iExamen         = pExamenDto;
     iNumeroPregunta = 0;
     iPreguntas      = ControladorExamen.GetPreguntasDeExamen(iExamen.Id).ToList();
 }
        public int create(ExamenDTO examenDTO)
        {
            int           retorno = 0;
            SqlConnection conn    = new SqlConnection(connectionString);

            string sql = "INSERT INTO Examen ( nombre_examen, fecha_examen, resultado, ingresoID ) values( @nombre_examen, @fecha_examen, @resultado, @ingresoID)";

            SqlCommand sqlcmd = new SqlCommand(sql, conn);

            sqlcmd.Parameters.AddWithValue("@nombre_examen", examenDTO.nombre_examen);
            sqlcmd.Parameters.AddWithValue("@fecha_examen", examenDTO.fecha_examen);
            sqlcmd.Parameters.AddWithValue("@resultado", examenDTO.resultado);
            sqlcmd.Parameters.AddWithValue("@ingresoID", examenDTO.ingresoID);


            sqlcmd.CommandType = CommandType.Text;
            conn.Open();

            try
            {
                retorno = sqlcmd.ExecuteNonQuery();
            }
            catch
            {
                retorno = 0;
            }
            finally
            {
                conn.Close();
            }

            return(retorno);
        }
        public DataTable read(ExamenDTO examenDTO)
        {
            //List<ExamenDTO> retornoDTO = new List<ExamenDTO>();

            DataTable     dataTable = new DataTable();
            SqlConnection conn      = new SqlConnection(connectionString);

            string sql = "select * from Examen where examenID = @examenID";

            SqlCommand sqlcmd = new SqlCommand(sql, conn);

            sqlcmd.Parameters.Add(new SqlParameter("@examenID", SqlDbType.Int));
            sqlcmd.Parameters["@examenID"].Value = examenDTO.ingresoID;

            try
            {
                conn.Open();
                SqlDataReader rdr = sqlcmd.ExecuteReader();
                dataTable.Load(rdr);
                rdr.Close();
            }
            catch
            {
                dataTable = null;
            }
            finally
            {
                conn.Close();
            }
            return(dataTable);
        }
Exemple #6
0
        public List <ExamenDTO> readxIngreso(ExamenDTO examenDTO)
        {
            DataTable dt = new DataTable();

            ExamenDAO examenDAO = new ExamenDAO();

            dt = examenDAO.readxIngreso(examenDTO);

            List <ExamenDTO> retornoDTO = new List <ExamenDTO>();

            ExamenDTO exDTO = null;

            foreach (DataRow row in dt.Rows)
            {
                exDTO = new ExamenDTO();

                exDTO.examenID      = Convert.ToInt64(row["examenID"].ToString());
                exDTO.nombre_examen = row["nombre_examen"].ToString();
                exDTO.fecha_examen  = Convert.ToDateTime(row["fecha_examen"].ToString());
                exDTO.resultado     = row["resultado"].ToString();
                exDTO.ingresoID     = Convert.ToInt64(row["ingresoID"].ToString());

                retornoDTO.Add(exDTO);
            }

            return(retornoDTO);
        }
        public int delete(ExamenDTO examenDTO)
        {
            int retorno = 0;

            string        sql = "DELETE FROM Examen WHERE examenID=@examenID";
            SqlConnection con = new SqlConnection(connectionString);
            SqlCommand    cmd = new SqlCommand(sql, con);

            cmd.Parameters.AddWithValue("@examenID", examenDTO.examenID);
            cmd.CommandType = CommandType.Text;
            con.Open();

            try
            {
                retorno = cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                retorno = 0;
            }
            finally
            {
                con.Close();
            }
            return(retorno);
        }
Exemple #8
0
        public int create(ExamenDTO examenDTO)
        {
            int       retorno   = 0;
            ExamenDAO examenDAO = new ExamenDAO();

            retorno = examenDAO.create(examenDTO);

            return(retorno);
        }
Exemple #9
0
 public Examen(ExamenDTO examenDTO)
 {
     this.Id              = examenDTO.Id;
     this.Puntaje         = examenDTO.Puntaje;
     this.TiempoLimite    = examenDTO.TiempoLimite;
     this.TiempoUsado     = examenDTO.TiempoUsado;
     this.Fecha           = examenDTO.Fecha;
     this.UsuarioId       = examenDTO.UsuarioId;
     this.ExamenPreguntas = Examen.DTOaExamenPregunta(examenDTO.ExamenPreguntas);
 }
Exemple #10
0
        protected void Page_Load(object sender, EventArgs e)
        {
            cargardatospaciente();

            IngresoDTO  ingresoDTO  = (IngresoDTO)Session["ingresoDTO"];
            PacienteDTO pacienteDTO = (PacienteDTO)Session["pacienteDTO"];

            List <ExamenDTO> listExamenDTO = new List <ExamenDTO>();
            ExamenNEG        examenNEG     = new ExamenNEG();
            ExamenDTO        examenDTOIN   = new ExamenDTO();

            examenDTOIN.ingresoID = ingresoDTO.ingresoID;

            listExamenDTO = examenNEG.readxIngreso(examenDTOIN);

            gvExamenes.DataSource = listExamenDTO;
            gvExamenes.DataBind();


            List <ImagenDTO> listImagenDTO = new List <ImagenDTO>();
            ImagenNEG        imagenNEG     = new ImagenNEG();
            ImagenDTO        imagenDTOIN   = new ImagenDTO();

            imagenDTOIN.ingresoID = ingresoDTO.ingresoID;

            listImagenDTO = imagenNEG.readxIngreso(imagenDTOIN);

            gvImagenes.DataSource = listImagenDTO;
            gvImagenes.DataBind();

            //List<ImagenesDTO> listExamenDTO = new List<ImagenesDTO>();
            //ExamenNEG examenNEG = new ExamenNEG();
            //ExamenDTO examenDTOIN = new ExamenDTO();

            //gvImagenes.DataSource = dtImagenes;
            //gvImagenes.DataBind();

            //DataTable dtImagenes = new DataTable();

            //dtImagenes.Clear();
            //dtImagenes.Columns.Add("nombre_imagen");
            //dtImagenes.Columns.Add("fecha_imagen");
            //dtImagenes.Columns.Add("diagnostico");

            //DataRow rowImagenes = dtImagenes.NewRow();
            //rowImagenes["nombre_imagen"] = "Radiografia Pierna Derecha";
            //rowImagenes["fecha_imagen"] = "26/11/2016";
            //rowImagenes["diagnostico"] = "Diagnostico 1";
            //dtImagenes.Rows.Add(rowImagenes);

            //gvImagenes.DataSource = dtImagenes;
            //gvImagenes.DataBind();
        }
        private void btnComenzarExamen_Click(object sender, EventArgs e)
        {
            if ((categoria.SelectedItem == null) || (dificultad.SelectedItem == null) || (conjunto.SelectedItem == null) || (cantidadPreguntas.Value == null))
            {
                MessageBox.Show("Debe completar todos los campos para iniciar el examen");
            }
            else
            {
                string categoriaSeleccionada  = categoria.SelectedItem.ToString();
                string dificultadSeleccionada = dificultad.SelectedItem.ToString();
                string conjuntoSeleccionado   = conjunto.SelectedItem.ToString();
                int    cantidadSeleccionada   = Convert.ToInt32(cantidadPreguntas.Value);

                var categoriaPreguntas = ControladorPreguntas.GetCategoriasConMasDeNPreguntas(conjuntoSeleccionado, cantidadSeleccionada);


                //Si la categoria no tiene mas de N preguntas
                if (categoriaPreguntas.FirstOrDefault(c => c.Id == categoriaSeleccionada) == null)
                {
                    int cantidadDePreguntasParaCategoria = ControladorPreguntas.CantidadDePreguntasParaCategoria(categoriaSeleccionada);

                    MessageBoxButtons mensaje = MessageBoxButtons.YesNo;
                    DialogResult      result  = MessageBox.Show($"Solo hay {cantidadDePreguntasParaCategoria} preguntas de {categoriaSeleccionada}. " +
                                                                $"Quiere hacer el examen aunque no haya la cantidad de preguntas seleccionadas?", "Advertencia", mensaje);


                    if (result == DialogResult.Yes)
                    {
                        ExamenDTO nuevoExamen = ControladorExamen.InicializarExamen(cantidadSeleccionada.ToString(), conjuntoSeleccionado, categoriaSeleccionada, dificultadSeleccionada);
                        nuevoExamen = ControladorExamen.IniciarExamen(iNombreUsuario, nuevoExamen);

                        this.Hide();

                        using (Ventana_Preguntas Vpreguntas = new Ventana_Preguntas(nuevoExamen))
                            Vpreguntas.ShowDialog();
                        this.Close();
                    }
                }
                else
                {
                    ExamenDTO nuevoExamen = ControladorExamen.InicializarExamen(cantidadSeleccionada.ToString(), conjuntoSeleccionado, categoriaSeleccionada, dificultadSeleccionada);
                    nuevoExamen = ControladorExamen.IniciarExamen(iNombreUsuario, nuevoExamen);

                    this.Hide();

                    using (Ventana_Preguntas Vpreguntas = new Ventana_Preguntas(nuevoExamen))
                        Vpreguntas.ShowDialog();
                    this.Close();
                }
            }
        }
Exemple #12
0
 public ActionResult <ExamenDTO> Add([FromBody] ExamenDTO examen)
 {
     try
     {
         examen.IdExamen = _examenAppService.GenerarCodigo();
         _examenAppService.Add(examen);
         _examenAppService.Save();
         return(CreatedAtAction(nameof(Add), new { id = examen.IdExamen }, examen));
     }
     catch (Exception)
     {
         return(BadRequest());
     }
 }
        public List<ExamenDTO> GetExamen(long idperiodo, string tipo_evaluado)
        {
            List<ExamenDTO> examenes = new List<ExamenDTO>();
            try
            {
                // consultas
                periodos periodo = db.periodos.Where(x => x.id == idperiodo && x.estado != 0).FirstOrDefault();
                List<evaluacion> evaluacionlst = db.evaluacion.Where(x => x.id == periodo.id_evaluacion && x.estado != 0).ToList();
                if (evaluacionlst.Count() > 0)
                {
                    evaluacion e = evaluacionlst.FirstOrDefault();
                    // algoritmo para filtrar las competencias por rango
                    List<competencias> competenciaslst = tipo_evaluado.Equals("Jefe") ? 
                        competenciaslst = db.competencias.Where(x => x.idevaluacion == e.id).ToList() 
                        : 
                        competenciaslst = db.competencias.Where(x => x.idevaluacion == e.id && x.rango_evaluacion == tipo_evaluado).ToList();

                    foreach(competencias c in competenciaslst){
                        ExamenDTO examen = new ExamenDTO();
                        examen.competencia = new CompetenciaDTO();
                    
                        // añado la competencia
                        examen.competencia.id = c.id;
                        examen.competencia.idevaluacion = c.idevaluacion;
                        examen.competencia.nombre = c.nombre;
                        examen.competencia.rango_evaluacion = c.rango_evaluacion;
                        // añado preguntas
                        examen.preguntas = from p in db.preguntas
                                           where p.idcompetencia == c.id
                                           select new PreguntaDTO()
                                           {
                                               id = p.id,
                                               idcompetencia = p.idcompetencia,
                                               nombre = p.nombre,
                                           };
                        // añado a la lista de examenes
                        examenes.Add(examen);
                    }
                }
                else
                {
                    examenes.Add(new ExamenDTO());
                }
            }
            catch (Exception e)
            {
                throw e;
            }
            return examenes;
        }
Exemple #14
0
 public ActionResult <ExamenDTO> Update(string id, [FromBody] ExamenDTO examen)
 {
     try
     {
         if (examen == null)
         {
             return(NotFound());
         }
         _examenAppService.Update(examen);
         _examenAppService.Save();
         return(examen);
     }
     catch (Exception)
     {
         return(BadRequest());
     }
 }
Exemple #15
0
        private void timer_Tick(object sender, EventArgs e) //Tiempo agotado
        {
            if (tiempo > 0)
            {
                tiempo--;
                this.time.Text = "Tiempo Restante: " + tiempo.ToString();
            }
            else if (examenTerminado == null)
            {
                this.timer.Enabled = false;
                this.Hide();

                examenTerminado = ControladorExamen.FinalizarExamen(iExamen);

                using (Ventana_Examen_Terminado finalizado = new Ventana_Examen_Terminado(examenTerminado)) //Paso el examen a la proxima ventana
                    finalizado.ShowDialog();
                this.Close();
            }
        }
Exemple #16
0
        /// <summary>
        /// Guarda el resultado de un examen para una pregunta y su respuesta
        /// Almacena el resultado de la respuesta
        /// </summary>
        /// <exception cref="ArgumentException"></exception>
        /// <param name="pExamen"></param>
        /// <param name="pPregunta"></param>
        /// <param name="pRespuesta"></param>
        /// <returns>Examen actualizado</returns>
        public static ExamenDTO GuardarRespuesta(ExamenDTO pExamen, PreguntaDTO pPregunta, int idRespuesta)
        {
            Examen examen;

            using (var db = new TrabajoDbContext())
            {
                using (var UoW = new UnitOfWork(db))
                {
                    examen = UoW.ExamenRepository.Get(pExamen.Id);
                    var respuesta = UoW.RepositorioPreguntas.Get(pPregunta.Id).Respuestas.Where(r => r.Id == idRespuesta);
                    if (!respuesta.Any())
                    {
                        throw new ArgumentException(String.Format("Respuesta {0} no existe", idRespuesta));
                    }
                    examen.ExamenPreguntas.First(e => e.PreguntaId == pPregunta.Id).RespuestaElegidaId = idRespuesta;
                    UoW.Complete();
                }
            }
            return(new ExamenDTO(examen));
        }
Exemple #17
0
        /// <summary>
        /// Asocia un usuario a un examen y llama a examen.iniciar()
        /// </summary>
        /// <param name="pUsuario"></param>
        /// <param name="pExamen"></param>
        /// <returns>Examen con datos actualiados</returns>
        public static ExamenDTO IniciarExamen(string pNombreUsuario, ExamenDTO pExamen)
        {
            Examen examen = new Examen(pExamen);

            using (var db = new TrabajoDbContext())
            {
                using (var UoW = new UnitOfWork(db))
                {
                    Usuario usuario = UoW.RepositorioUsuarios.Get(pNombreUsuario);
                    if (usuario == null)
                    {
                        throw new UsrNoEncontradoException("Usuario no existe");
                    }
                    examen.UsuarioId = usuario.Id;
                    examen.Iniciar();
                    UoW.ExamenRepository.Add(examen);
                }
            }
            return(new ExamenDTO(examen));
        }
Exemple #18
0
        /// <summary>
        /// Da fin a un examen y lo guarda en la DB
        /// </summary>
        /// <param name="pExamen"></param>
        public static ExamenDTO FinalizarExamen(ExamenDTO pExamen)
        {
            Examen examen           = new Examen(pExamen);
            int    n                = ControladorExamen.CantidadRespuestasCorrectas(examen);
            double factorDificultad = ControladorExamen.GetFactorDificultad(examen);

            examen.Finalizar(n, factorDificultad);

            using (var db = new TrabajoDbContext())
            {
                using (var UoW = new UnitOfWork(db))
                {
                    var ex = UoW.ExamenRepository.Get(examen.Id);
                    ex.Puntaje     = examen.Puntaje;
                    ex.TiempoUsado = examen.TiempoUsado;
                    UoW.Complete();
                }
            }
            return(new ExamenDTO(examen));
        }
Exemple #19
0
        public ExamenDTO read(ExamenDTO examenDTO)
        {
            DataTable dt = new DataTable();

            ExamenDAO examenDAO = new ExamenDAO();

            dt = examenDAO.read(examenDTO);

            ExamenDTO exDTO = new ExamenDTO();

            foreach (DataRow row in dt.Rows)
            {
                exDTO.examenID      = Convert.ToInt64(row["examenID"].ToString());
                exDTO.nombre_examen = row["nombre_examen"].ToString();
                exDTO.fecha_examen  = Convert.ToDateTime(row["fecha_examen"].ToString());
                exDTO.resultado     = row["resultado"].ToString();
                exDTO.ingresoID     = Convert.ToInt64(row["ingresoID"].ToString());
            }

            return(exDTO);
        }
        public ExamenDTO update(ExamenDTO examenDTO)
        {
            ExamenDTO retornoDTO = new ExamenDTO();

            return(retornoDTO);
        }
        public List <ExamenDTO> readAll(ExamenDTO examenDTO)
        {
            List <ExamenDTO> listDTO = new List <ExamenDTO>();

            return(listDTO);
        }
Exemple #22
0
 public Ventana_Examen_Terminado(ExamenDTO unExamen)
 {
     InitializeComponent();
     iExamen = unExamen;
 }