/// <summary>
/// Éste método se utiliza para persistir una lista de preguntas en la base de datos.
/// </summary>
/// <param name="pListaDePreguntas">La lista de preguntas a persistir.</param>
public static void AlmacenarPreguntas(List <Pregunta> pListaDePreguntas, int pConjunto)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
Conjunto conjunto = bUoW.RepositorioConjunto.Obtener(pConjunto);
foreach (Pregunta pregunta in pListaDePreguntas)
{
pregunta.Conjunto = conjunto;
string descripcion = pregunta.Nombre;
pregunta.Nombre = bUoW.RepositorioPregunta.GetOrCreate(descripcion, pregunta.ConjuntoNombre);
string categoria = pregunta.Categoria.Nombre;
pregunta.Categoria = bUoW.RepositorioCategoria.GetOrCreate(categoria);
string dificultad = pregunta.Dificultad.Nombre;
pregunta.Dificultad = bUoW.RepositorioDificultad.GetOrCreate(dificultad);
if (pregunta.Nombre != string.Empty)
{
bUoW.RepositorioPregunta.Agregar(pregunta);
}
}
bUoW.GuardarCambios();
}
}
}
/// <summary>
/// Este método se utiliza para obtener un conjunto presente en la base de datos a partir de
/// su ID.
/// </summary>
/// <param name="pIdConjunto">El ID del conjunto a obtener.</param>
/// <returns></returns>
public static Conjunto ObtenerConjunto(int pIdConjunto)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
return(bUoW.RepositorioConjunto.Obtener(pIdConjunto));
}
}
}
/// <summary>
/// Este método se utiliza para obtener todas las categorías presentes en la base de datos,
/// según un conjunto.
/// </summary>
/// <param name="pIdConjunto">El ID del conjunto cuyas categorías se obtendrán.</param>
/// <returns></returns>
public static IEnumerable <Categoria> ObtenerCategorias(int pIdConjunto)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
return(bUoW.RepositorioPregunta.ObtenerCategorias(pIdConjunto));
}
}
}
/// <summary>
/// Devuelve los conjuntos presentes en la base de datos de la aplicación
/// </summary>
/// <returns></returns>
public static IEnumerable <Conjunto> ObtenerConjuntos()
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
return(bUoW.RepositorioConjunto.ObtenerTodas());
}
}
}
/// <summary>
/// Este método se utiliza para obtener una sesión presente en la base de datos
/// a partir de su ID.
/// </summary>
/// <param name="pIdSesion">El ID de la sesión a obtener.</param>
/// <returns></returns>
public static Sesion ObtenerSesion(int pIdSesion)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
return(bUoW.RepositorioSesion.ObtenerSesionId(pIdSesion));
}
}
}
/// <summary>
/// Devuelve una lista de las <paramref name="pTop"/> mejores sesiones, ordenadas según puntaje
/// </summary>
/// <param name="pTop">Cantidad de sesiones a mostrar en el ranking</param>
/// <returns></returns>
public static List <Sesion> ObtenerTop(int pTop = 15)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
return(bUoW.RepositorioSesion.ObtenerRanking(pTop).ToList());
}
}
}
/// <summary>
/// Este método se utiliza para obtener una pregunta presente en la base de datos
/// a partir de su ID.
/// </summary>
/// <param name="pIdPregunta">El ID de la pregunta a obtener.</param>
/// <returns></returns>
public static Pregunta ObtenerPregunta(int pIdPregunta)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
return(bUoW.RepositorioPregunta.ObtenerPreguntaPorId(pIdPregunta));
}
}
}
/// <summary>
/// Este método se utiliza para obtener un usuario de la base de datos a partir de su ID.
/// </summary>
/// <param name="pIdUsuario">El ID del usuario a obtener.</param>
/// <returns></returns>
public static Usuario ObtenerUsuario(int pIdUsuario)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
return(bUoW.RepositorioUsuario.Obtener(pIdUsuario));
}
}
}
public void LimpiarRanking()
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
bDbContext.Set <Sesion>().RemoveRange(bDbContext.Set <Sesion>());
bUoW.GuardarCambios();
}
}
}
/// <summary>
/// Incrementa la autoridad de un usuario a administrador
/// </summary>
/// <param name="pUsuario">El usuario</param>
/// <returns></returns>
public static void UsuarioAAdmin(string pUsuario)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
bUoW.RepositorioUsuario.Ascender(pUsuario);
bUoW.GuardarCambios();
}
}
}
/// <summary>
/// Este método se utiliza para actualizar los datos de una sesión existente en la base
/// de datos al responder una pregunta.
/// </summary>
/// <param name="pIdSesion">El ID de la sesión.</param>
/// <param name="pSegundosTranscurridos">Los segundos transcurridos hasta la respuesta.</param>
/// <param name="pEsCorrecta">Si la respuesta fue correcta o no.</param>
/// <returns></returns>
public static bool Responder(int pIdSesion, double pSegundosTranscurridos, bool pEsCorrecta, int pIdPregunta)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
Sesion sesionActual = bUoW.RepositorioSesion.ObtenerSesionId(pIdSesion);
sesionActual.SegundosTranscurridos += pSegundosTranscurridos;
bool resultado = sesionActual.Responder(pEsCorrecta, pIdPregunta);
bUoW.GuardarCambios();
return(resultado);
}
}
}
/// <summary>
/// Este método se utiliza para obtener el resultado a la hora de responder una pregunta presente
/// en la base de datos.
/// </summary>
/// <param name="pIdPregunta">El ID de la pregunta a responder.</param>
/// <param name="pIdRespuesta">El ID de la respuesta seleccionada por el usuario.</param>
/// <returns></returns>
public static ResultadoRespuesta Responder(int pIdPregunta, int pIdRespuesta)
{
ResultadoRespuesta resultado = new ResultadoRespuesta();
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
Respuesta respuestaCorrecta = bUoW.RepositorioPregunta.ObtenerRespuestaCorrecta(pIdPregunta);
resultado.EsCorrecta = (respuestaCorrecta.RespuestaId == pIdRespuesta);
resultado.RespuestaCorrecta = respuestaCorrecta.DefRespuesta;
return(resultado);
}
}
}
/// <summary>
/// Este método se encarga de cancelar una sesión que se encuentre activa.
/// </summary>
/// <param name="pIdSesion">El ID de la sesión a cancelar.</param>
public static void CancelarSesion(int pIdSesion)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
Sesion sesionActiva = bUoW.RepositorioSesion.ObtenerSesionId(pIdSesion);
sesionActiva.FechaFin = DateTime.Now;
foreach (Pregunta pregunta in sesionActiva.Preguntas.ToList())
{
sesionActiva.Responder(false, pregunta.PreguntaId);
}
sesionActiva.SesionFinalizada = true;
bUoW.GuardarCambios();
}
}
}
/// <summary>
/// Este método se utiliza para obtener el ID de la sesión activa de un usuario.
/// </summary>
/// <param name="pIdUsuario">El ID del usuario.</param>
/// <returns></returns>
public static int ObtenerSesionActiva(int pIdUsuario)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
Sesion sesionActual = bUoW.RepositorioSesion.ObtenerSesionActiva(pIdUsuario);
if (sesionActual == null)
{
return(-1);
}
else
{
return(sesionActual.SesionId);
}
}
}
}
/// <summary>
/// Este método se utiliza para realizar un login, devolviendo el usuario si el nombre
/// y clave son correctos.
/// </summary>
/// <param name="pNombre">El nombre del usuario.</param>
/// <param name="pClave">Su contraseña.</param>
/// <returns></returns>
public static Usuario LoginUsuario(string pNombre, string pClave)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
Usuario usuario = bUoW.RepositorioUsuario.ObtenerPorNombre(pNombre);
if (usuario.ContraseñaCorrecta(pClave))
{
return(usuario);
}
else
{
throw new ContraseñaIncorrectaException();
}
}
}
}
/// <summary>
/// Crea una nueva instancia de ConjuntoOTDB y la guarda en la base de datos
/// </summary>
/// <param name="pNombre">Nombre del nuevo ConjuntoOTDB</param>
/// <param name="pTEPP">Cantidad de sengudos esperada por pregunta</param>
/// <param name="token">Si el checkbox del Token fue seleccionado o no</param>
/// <param name="pTipoConjunto">El tipo del conjunto a crear.</param>
public static void AñadirConjunto(string pNombre, int pTEPP, bool token, Type pTipoConjunto)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
string tokenString = null;
if (token)
{
tokenString = JsonMapper.ObtenerToken();
}
Conjunto conjunto = (Conjunto)Activator.CreateInstance(pTipoConjunto);
conjunto.Nombre = pNombre;
conjunto.TiempoEsperadoPorPregunta = pTEPP;
conjunto.Token = tokenString;
bUoW.RepositorioConjunto.Agregar(conjunto);
bUoW.GuardarCambios();
}
}
}
/// <summary>
/// Este método se utiliza para eliminar los datos almacenados actualmente
/// en la base de datos.
/// </summary>
public void LimpiarDB()
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
bDbContext.Set <Respuesta>().RemoveRange(bDbContext.Set <Respuesta>());
bUoW.GuardarCambios();
bDbContext.Set <Pregunta>().RemoveRange(bDbContext.Set <Pregunta>());
bUoW.GuardarCambios();
bDbContext.Set <Sesion>().RemoveRange(bDbContext.Set <Sesion>());
bUoW.GuardarCambios();
bDbContext.Set <Usuario>().RemoveRange(bDbContext.Set <Usuario>());
bUoW.GuardarCambios();
bDbContext.Set <Categoria>().RemoveRange(bDbContext.Set <Categoria>());
bUoW.GuardarCambios();
bDbContext.Set <Conjunto>().RemoveRange(bDbContext.Set <Conjunto>());
bUoW.GuardarCambios();
bDbContext.Set <Dificultad>().RemoveRange(bDbContext.Set <Dificultad>());
bUoW.GuardarCambios();
}
}
}
/// <summary>
/// Este método se utiliza para crear y persistir una nueva sesión en la base de datos,
/// devolviendo su ID.
/// </summary>
/// <param name="pUsuario">El ID del usuario correspondiente a la nueva sesión.</param>
/// <param name="pListaDePreguntas">Las preguntas asociadas a la nueva sesión.</param>
/// <returns></returns>
public static int IniciarSesion(int pUsuario, int pConjunto, int pDificultad, int pCategoria, int pCantidad)
{
Random random = new Random();
Sesion sesion = new Sesion();
sesion.FechaInicio = DateTime.Now;
sesion.CantidadTotalPreguntas = pCantidad;
sesion.UsuarioId = pUsuario;
sesion.FechaFin = DateTime.Parse("01-01-2399");
sesion.SesionFinalizada = false;
sesion.SegundosTranscurridos = 0;
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
sesion.Usuario = bUoW.RepositorioUsuario.Obtener(pUsuario);
sesion.Preguntas = bUoW.RepositorioPregunta.ObtenerPreguntas(pCategoria, pDificultad, pConjunto, pCantidad).ToList();
bUoW.RepositorioSesion.Agregar(sesion);
bUoW.GuardarCambios();
}
}
return(sesion.SesionId);
}
/// <summary>
/// Registra a un usuario en la base de datos de la aplicación.
/// </summary>
/// <param name="pNombre">Nombre del usuario</param>
/// <param name="pClave">Contraseña del usuario</param>
public static void AgregarUsuario(string pNombre, string pClave)
{
using (var bDbContext = new ShockQuizDbContext())
{
using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
{
bool admin = false;
if (bUoW.RepositorioUsuario.ObtenerTodos().Count() == 0)
{
admin = true;
}
Usuario user = new Usuario()
{
Nombre = pNombre,
Contraseña = pClave,
Admin = admin,
Sesiones = new List <Sesion>()
};
bUoW.RepositorioUsuario.Agregar(user);
bUoW.GuardarCambios();
}
}
}
