/// <summary> /// Devuevlve el ranking de los examenes de un usuario. /// </summary> /// <param name="pUsuario">Id del usuario</param> /// <returns></returns> public List <Examen> GetRanking(String pUsuario) { using (var db = new TrabajoDbContext()) { return(db.Examenes.Where(e => e.Usuario.Id == pUsuario).OrderBy(ex => ex.Puntaje).ToList <Examen>()); } }
/// <summary> /// Dada una lista de preguntas, las inserta en la base de datos /// Devuelve la cantidad de preguntas insertada con exito /// </summary> public static int CargarPreguntas(IEnumerable <Pregunta> pPreguntas) { /// Este metodo es horriblemente ineficiente /// Pero fue la unica forma que encontre de hacerlo andar int cantidad = 0; foreach (Pregunta pre in pPreguntas) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { // si la pregunta no existe if (UoW.RepositorioPreguntas.Get(pre.Id) == null) { cantidad++; ConjuntoPreguntas conjunto = UoW.RepositorioConjuntoPregunta.Get(pre.Conjunto.Id); pre.Conjunto = conjunto; UoW.RepositorioPreguntas.Add(pre); } UoW.Complete(); } } } return(cantidad); }
/// <summary> /// Guarda un examen la base de datos /// </summary> /// <param name="pExamen"></param> public void GuardarExamen(Examen pExamen) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { foreach (var ep in pExamen.ExamenPreguntas) { ep.Pregunta = UoW.RepositorioPreguntas.Get(ep.Pregunta.Id); } Usuario usr = UoW.RepositorioUsuarios.Get(pExamen.Usuario.Id); if (usr == null) { UoW.ExamenRepository.Add(pExamen); } else { pExamen.Usuario = usr; UoW.ExamenRepository.Add(pExamen); } UoW.Complete(); } } }
/// <summary> /// Metodo que devuelve todas las dificultades cargadas en base de datos de un determinado conjunto /// </summary> /// <returns></returns> public static IEnumerable <DificultadDTO> GetDificultades(String pNombreConjunto) { List <DificultadDTO> dificultadesDTO = new List <DificultadDTO>(); try { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { ICollection <Dificultad> dificultades = UoW.RepositorioConjuntoPregunta.DificultadesDeUnConjunto(pNombreConjunto); foreach (Dificultad dificultad in dificultades) { dificultadesDTO.Add(new DificultadDTO(dificultad)); } } } } catch (Exception ex) { var bitacora = new Bitacora.Bitacora(); bitacora.GuardarLog("ControladorPreguntas.GetDificultades" + ex.ToString()); } return(dificultadesDTO); }
/// <summary> /// Chequea si un usuario ya existe en la base de datos /// </summary> /// <param name="pUsuarioId"></param> /// <param name="pContrasenia"></param> /// <returns>Verdadero si usuario y contraseña existen </returns> public Boolean UsuarioValido(string pUsuarioId, string pContrasenia) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { Usuario usr = new Usuario(pUsuarioId, pContrasenia); Usuario usrDb = UoW.RepositorioUsuarios.Get(pUsuarioId); if (usrDb != null) { if (usrDb.Contrasenia == usr.Contrasenia) { return(true); } else { return(false); } } else { return(false); } } } }
/// <summary> /// Devuelve todas las categorias que tengan mas (o igual) de N preguntas /// </summary> /// <returns>Lista de categorias</returns> public static ICollection <CategoriaPreguntaDTO> GetCategoriasConMasDeNPreguntas(String pNombreConjunto, int n) { List <CategoriaPreguntaDTO> categoriasDTO = new List <CategoriaPreguntaDTO>(); try { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { var categorias = UoW.RepositorioPreguntas.CategoriasConMasDeNPreguntas(pNombreConjunto, n); foreach (CategoriaPregunta categoria in categorias) { categoriasDTO.Add(new CategoriaPreguntaDTO(categoria)); } return(categoriasDTO); } } } catch (Exception ex) { var bitacora = new Bitacora.Bitacora(); bitacora.GuardarLog("ControladorPreguntas.GetCategoriasConMasDeNPreguntas" + ex.ToString()); return(null); } }
/// <summary> /// Crea un nuevo examen no asociado a un usuario /// </summary> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentException"> Cuando no existe un conjunto para la categoria y dificultad</exception> /// <param name="pCantidad"></param> /// <param name="pConjunto"></param> /// <param name="pCategoria"></param> /// <param name="pDificultad"></param> public static ExamenDTO InicializarExamen(string pCantidad, string pConjunto, string pCategoria, string pDificultad) { if (string.IsNullOrEmpty(pCantidad) || string.IsNullOrEmpty(pConjunto) || string.IsNullOrEmpty(pCategoria) || string.IsNullOrEmpty(pDificultad)) { throw new ArgumentNullException(); } Examen examen = new Examen(); var preguntas = ControladorExamen.GetPreguntasRandom(pCantidad, pConjunto, pCategoria, pDificultad); examen = ControladorExamen.AsociarExamenPregunta(examen, preguntas); using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { var conjunto = UoW.RepositorioConjuntoPregunta.ObtenerConjuntoPorDificultadYCategoria(pConjunto, pDificultad, pCategoria); if (conjunto == null) { throw new ArgumentException(String.Format("No existe {0} para {1} y {2}", pConjunto, pCategoria, pDificultad)); } examen.TiempoLimite = (float)examen.CantidadPreguntas * conjunto.TiempoEsperadoRespuesta; } } return(new ExamenDTO(examen)); }
/// <summary> /// Obtiene un log de la base de datos /// </summary> /// <param name="pId">Id del log</param> /// <returns></returns> public Log Obtener(int pId) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { return(UoW.RepositorioLogs.Get(pId)); } } }
private static double GetFactorDificultad(Examen examen) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { return(UoW.RepositorioPreguntas.Get(examen.ExamenPreguntas.First().PreguntaId).Conjunto.Dificultad.FactorDificultad); } } }
public override void GuardarLog(Log pLog) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { UoW.RepositorioLogs.Add(pLog); } } }
/// <summary> /// Metodo que devuelve el tiempo limite de un examen /// </summary> /// <param name="unExamen"></param> /// <returns></returns> public float GetTiempoLimite(Examen unExamen) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { Examen ex = UoW.ExamenRepository.Get(unExamen.Id); return(ex.TiempoLimite); } } }
/// <summary> /// Metodo que modifica el tiempo esperado por respuesta de un conjunto pasado como parametro. /// </summary> /// <param name="pConjuntoPreguntas"></param> /// <param name="pTiempo"></param> public void ModificarTiempo(string pConjuntoPreguntas, float pTiempo) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { ConjuntoPreguntas conjunto = UoW.RepositorioConjuntoPregunta.Get(pConjuntoPreguntas); conjunto.Id = pConjuntoPreguntas; UoW.Complete(); } } }
/// <summary> /// Metodo que devuelve los examenes correspondientes a un usuario, ordenados por puntaje descendentemente /// </summary> /// <param name="pUsuario"></param> /// <returns></returns> public List <Examen> GetRanking(string pUsuario) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { List <Examen> examenes = UoW.ExamenRepository.SelectAll(pUsuario); examenes.Sort((a, b) => b.Puntaje.CompareTo(a.Puntaje)); return(examenes); } } }
/// <summary> /// Metodo que establece como admin a un usuario pasado como parametro /// </summary> /// <param name="pUsuario"></param> public void SetAdministrador(string pUsuario) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { Usuario dBUsuario = UoW.RepositorioUsuarios.Get(pUsuario); dBUsuario.Administrador = true; UoW.Complete(); } } }
/// <summary> /// Agrega un log a la base de datos /// </summary> /// <param name="pDescripcion"></param> public static void GuardarLog(String pDescripcion) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { Log log = new Log(); log.Descripcion = pDescripcion; log.Fecha = DateTime.Now; UoW.RepositorioLogs.Add(log); } } }
public override ICollection <Log> ObtenerTodos() { ICollection <Log> logs; using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { logs = UoW.RepositorioLogs.GetAll().ToArray(); } } return(logs); }
/// <summary> /// Obtiene preguntas random de la base de datos /// </summary> /// <param name="pCantidad"></param> /// <param name="pConjunto"></param> /// <param name="pCategoria"></param> /// <param name="pDificultad"></param> /// <returns></returns> private static IEnumerable <Pregunta> GetPreguntasRandom(string pCantidad, string pConjunto, string pCategoria, string pDificultad) { List <Pregunta> preguntas = new List <Pregunta>(); using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { preguntas = UoW.RepositorioPreguntas.GetRandom(pCantidad, pConjunto, pCategoria, pDificultad); } } return(preguntas); }
public override ICollection <Log> Obtener(DateTime pDesde, DateTime pHasta) { ICollection <Log> logs; using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { logs = UoW.RepositorioLogs.Obtener(pDesde, pHasta); } } return(logs); }
public List <Examen> GetExamenes() { List <Examen> listaExamenes = new List <Examen>(); using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { listaExamenes = (List <Examen>)UoW.ExamenRepository.GetAll(); } } return(listaExamenes); }
/// <summary> /// Obtiene todas las preguntas de la base de datos /// </summary> /// <returns></returns> public List <Pregunta> GetPreguntas() { List <Pregunta> listaPreguntas = new List <Pregunta>(); using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { listaPreguntas = (List <Pregunta>)UoW.RepositorioPreguntas.GetAll(); } } return(listaPreguntas); }
public List <Usuario> GetUsuarios() { List <Usuario> listaUsuarios = new List <Usuario>(); using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { listaUsuarios = (List <Usuario>)UoW.RepositorioUsuarios.GetAll(); } } return(listaUsuarios); }
/// <summary> /// Da comienzo a un examen. Asocia el examen a un usuario /// </summary> /// <param name="pUsuario"></param> /// <param name="pExamen"></param> public void InicarExamen(String pNombreUsuario, Examen pExamen) { Usuario usuario; using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { usuario = UoW.RepositorioUsuarios.Get(pNombreUsuario); } } controladorExamen.IniciarExamen(usuario, pExamen); }
public override Log Obtener(int pId) { Log log; using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { log = UoW.RepositorioLogs.Get(pId); } } return(log); }
/// <summary> /// Metodo que Agrega un usuario en la BD si este no existe. /// </summary> /// <param name="pUsuario"></param> /// <param name="pContrasenia"></param> public void GuardarUsuario(string pUsuario, string pContrasenia) { Usuario usuario = new Usuario(pUsuario, pContrasenia); using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { if (UoW.RepositorioUsuarios.Get(usuario.Id) == null) { UoW.RepositorioUsuarios.Add(usuario); } UoW.Complete(); } } }
/// <summary> /// Actualiza y autentica un usuario con los valores de la base de datos /// </summary> /// <param name="pUsuario"></param> /// <exception cref="UsrNoEncontradoException">pUsuario no esta en la bd</exception> /// <returns>Un usuario de la base de datos</returns> public static Usuario AutenticarUsuario(Usuario pUsuario) { Usuario usr = null; using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { usr = UoW.RepositorioUsuarios.AutenticarUsuario(pUsuario); } } if (usr == null) { throw new UsrNoEncontradoException("Credenciales incorrectas"); } return(usr); }
/// <summary> /// Obtiene un usuario de la bd /// </summary> /// <exception cref="UsrNoEncontradoException"> Si el usuario no existe</exception> /// <param name="pUsuario"></param> /// <returns></returns> public static Usuario GetUsuario(String pUsuario) { Usuario usr = null; using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { usr = UoW.RepositorioUsuarios.Get(pUsuario); } } if (usr == null) { throw new UsrNoEncontradoException(String.Format("{0} No registrado", pUsuario)); } return(usr); }
/// <summary> /// Metodo que crea un examen sin asociarlo a un usuario /// </summary> /// <param name="pCantidad">Cantidad de preguntas</param> /// <param name="pConjunto">OpentDb</param> /// <param name="pCategoria">Id Categoria</param> /// <param name="pDificultad">Id Dificultad</param> /// <returns></returns> /// public Examen InicializarExamen(int pCantidad, String pConjunto, string pCategoria, string pDificultad) { ConjuntoPreguntas conjunto; CategoriaPregunta categoria; Dificultad dificultad; using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { conjunto = UoW.RepositorioConjuntoPregunta.Get(pConjunto); categoria = UoW.RepositorioCategorias.Get(pCategoria); dificultad = UoW.RepositorioDificultades.Get(pDificultad); } } return(controladorExamen.InicializarExamen(pCantidad.ToString(), conjunto.Id, categoria.Id, dificultad.Id)); }
public static IEnumerable <PreguntaDTO> GetPreguntasDeExamen(int examenId) { List <PreguntaDTO> preguntas = new List <PreguntaDTO>(); using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { foreach (var examenPregunta in UoW.ExamenRepository.Get(examenId).ExamenPreguntas) { Pregunta pregunta = UoW.RepositorioPreguntas.Get(examenPregunta.PreguntaId); PreguntaDTO preguntaDTO = new PreguntaDTO(pregunta); preguntas.Add(preguntaDTO); } } } return(preguntas); }
public Boolean EsAdministrador(string nombreUsuario) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { Usuario usrDb = UoW.RepositorioUsuarios.Get(nombreUsuario); if (usrDb.Administrador == true) { return(true); } else { return(false); } } } }
public Boolean UsuarioValido(string pNombreUsuario) { using (var db = new TrabajoDbContext()) { using (var UoW = new UnitOfWork(db)) { Usuario usrDb = UoW.RepositorioUsuarios.Get(pNombreUsuario); if (usrDb.Id == pNombreUsuario) { return(true); } else { return(false); } } } }