/// <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);
}
}
}
}
