Development

.gitignore

@@ -4,6 +4,7 @@ obj/
 Debug/
 test/
 packages/
+Migrations/
 .vs
 *.ide-shm
 *.cache

ShockQuiz/DAL/EntityFramework/Mapping/PreguntaMap.cs

@@ -29,6 +29,16 @@ public PreguntaMap()
             this.HasRequired<Conjunto>(x => x.Conjunto)
                 .WithMany(x => x.Preguntas)
                 .HasForeignKey<int>(x => x.ConjuntoId);
+
+            /*this.HasRequired<Sesion>(x => x.SesionActual)
+                .WithMany(x => x.Preguntas)
+                .HasForeignKey<int>(x => x.SesionActualId);*/
+
+            this.Property(x => x.SesionActualId)
+                .IsRequired()
+                .HasColumnName("idSesionActual");
+
+            this.Ignore(x => x.ConjuntoNombre);
         }
     }
 }

ShockQuiz/DAL/EntityFramework/Mapping/SesionMap.cs

@@ -14,7 +14,7 @@ public SesionMap()
                 .HasDatabaseGeneratedOption(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Identity)
                 .HasColumnName("id");
 
-            this.Property(x => x.CantidadPreguntas)
+            this.Property(x => x.PreguntasRestantes)
                 .HasColumnName("cantidadPreguntas")
                 .IsRequired();
 
@@ -31,8 +31,7 @@ public SesionMap()
                 .IsRequired();
 
             this.Property(x => x.FechaFin)
-                .HasColumnName("fechaInicio")
-                .IsRequired();
+                .HasColumnName("fechaInicio");
 
             this.Property(x => x.FechaFin)
                 .HasColumnName("fechaFin")
@@ -46,8 +45,8 @@ public SesionMap()
                 .WithMany(x => x.Sesiones)
                 .HasForeignKey<int>(x => x.ConjuntoId);
 
-            this.Ignore(x => x.Preguntas);
-            this.Ignore(x => x.RespuestasCorrectas);
+            this.Property(x => x.RespuestasCorrectas);
+            this.Property(x => x.CantidadTotalPreguntas);
         }
     }
 }

ShockQuiz/DAL/EntityFramework/RepositorioPregunta.cs

@@ -44,21 +44,21 @@ public IEnumerable<Pregunta> ObtenerTodas()
         /// <param name="pConjunto">Conjunto</param>
         /// <param name="pCantidad">Cantidad de Preguntas</param>
         /// <returns></returns>
-        public IEnumerable<Pregunta> ObtenerPreguntas(Categoria pCategoria, Dificultad pDificultad, Conjunto pConjunto, int pCantidad = 10)
+        public IEnumerable<Pregunta> ObtenerPreguntas(int pCategoria, int pDificultad, int pConjunto, int pCantidad = 10)
         {
 
             var list = from t in iDbContext.Preguntas
                        .Include(x => x.Respuestas)
                        .Include(x => x.Categoria)
                        .Include(x => x.Dificultad)
                        .Include(x => x.Conjunto)
-                       where t.Categoria.Nombre == pCategoria.Nombre
-                       && t.Dificultad.Nombre == pDificultad.Nombre
-                       && t.Conjunto.Nombre == pConjunto.Nombre
+                       where t.Categoria.Id == pCategoria
+                       && t.Dificultad.Id == pDificultad
+                       && t.Conjunto.ConjuntoId == pConjunto
                        select t;
             if (list.Count() >= pCantidad)
             {
-                return list.ToList().OrderBy(x => rnd.Next()).Take(pCantidad);
+                return list;
             }
             else
             {
@@ -70,7 +70,8 @@ public string GetOrCreate(string pNombre, string pConjunto)
         {
             var manager = ((IObjectContextAdapter)iDbContext).ObjectContext;
 
-            var dbPregunta = iDbContext.Preguntas.ToList().Where(x => x.Nombre == pNombre && x.Conjunto.Nombre == pConjunto).Any();
+            var dbPregunta = iDbContext.Preguntas.Include(x => x.Conjunto).ToList()
+                .Where(x => x.Nombre == pNombre && x.Conjunto.Nombre == pConjunto).Any();
 
 
 
@@ -110,5 +111,34 @@ public IEnumerable<Categoria> ObtenerCategorias(int pConjunto)
             }
             return listaCategorias;
         }
+
+        /// <summary>
+        /// Este método se utiliza para obtener todas las instancias de la clase Pregunta
+        /// las cuales poseen una sesión activa, a partir de su ID.
+        /// </summary>
+        /// <param name="pIdSesion">El ID de la sesión activa</param>
+        /// <returns></returns>
+        public IEnumerable<Pregunta> ObtenerPreguntasPorSesion(int pIdSesion)
+        {
+            var preguntasFiltradas = (from p in iDbContext.Preguntas.Include(x => x.Respuestas)
+                                      where p.SesionActualId == pIdSesion
+                                      select p);
+            return preguntasFiltradas;
+        }
+
+        /// <summary>
+        /// Este método se utiliza para obtener una pregunta y sus respuestas
+        /// a partir de si ID.
+        /// </summary>
+        /// <param name="pIdPregunta">El ID de la pregunta a traer</param>
+        /// <returns></returns>
+        public Pregunta ObtenerPreguntaPorId(int pIdPregunta)
+        {
+            var pregunta = (from p in iDbContext.Preguntas.Include(x => x.Respuestas)
+                            where p.PreguntaId == pIdPregunta
+                            select p
+                            );
+            return pregunta.First();
+        }
     }
 }

ShockQuiz/DAL/EntityFramework/RepositorioSesion.cs

@@ -1,6 +1,7 @@
 using ShockQuiz.Dominio;
 using System.Collections.Generic;
 using System.Linq;
+using System;
 
 namespace ShockQuiz.DAL.EntityFramework
 {
@@ -36,5 +37,49 @@ public IEnumerable<Sesion> ObtenerTodas(string pUsuario)
         {
             return this.iDbContext.Set<Sesion>().Where(x => x.Usuario.Nombre == pUsuario);
         }
+
+        /// <summary>
+        /// Devuelve la sesion que se encuentre activa en la base de datos.
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerable<Sesion> ObtenerSesionActiva()
+        {
+            var sesionActiva = from s in iDbContext.Sesiones
+                               .Include("Conjunto")
+                               .Include("Categoria")
+                               .Include("Dificultad")
+                               where !s.SesionFinalizada
+                               select s;
+            return sesionActiva;
+        }
+
+        /// <summary>
+        /// Este método se utiliza para obtener la última sesión que se ha
+        /// subido a la base de datos.
+        /// </summary>
+        /// <returns></returns>
+        public Sesion ObtenerUltimaSesion()
+        {
+            var ultimaSesion = from s in iDbContext.Sesiones
+                               .Include("Conjunto")
+                               select s;
+            return ultimaSesion.OrderByDescending(x => x.SesionId).First();
+        }
+
+        /// <summary>
+        /// Este método se utiliza para obtener una sesión de la base de datos
+        /// a partir de su ID, así como su conjunto y dificultad.
+        /// </summary>
+        /// <param name="pIdSesion">El ID de la sesión a traer</param>
+        /// <returns></returns>
+        public Sesion ObtenerSesionId(int pIdSesion)
+        {
+            var sesionActiva = from s in iDbContext.Sesiones
+                               .Include("Conjunto")
+                               .Include("Dificultad")
+                               where s.SesionId == pIdSesion
+                               select s;
+            return sesionActiva.First();
+        }
     }
 }

ShockQuiz/DAL/EntityFramework/RepositorioUsuario.cs

@@ -35,7 +35,10 @@ public IEnumerable<Usuario> ObtenerTodos()
         /// <returns></returns>
         public Usuario ObtenerPorNombre(string pNombre)
         {
-            return this.iDbContext.Set<Usuario>().First(x => x.Nombre == pNombre);
+            var usuarios = (from u in iDbContext.Usuarios
+                            where u.Nombre == pNombre
+                            select u);
+            return usuarios.First();
         }
     }
 }

ShockQuiz/DAL/EntityFramework/ShockQuizDbContext.cs

@@ -8,7 +8,7 @@ public class ShockQuizDbContext : DbContext
     {
         public ShockQuizDbContext() : base("ShockQuiz")
         {
-            Database.SetInitializer(new MigrateDatabaseToLatestVersion<ShockQuizDbContext, Migrations.Configuration>());
+            //Database.SetInitializer(new MigrateDatabaseToLatestVersion<ShockQuizDbContext, Migrations.Configuration>());
         }
 
         public DbSet<Pregunta> Preguntas { get; set; }

ShockQuiz/DAL/IRepositorioPregunta.cs

@@ -7,9 +7,11 @@ public interface IRepositorioPregunta : IRepositorio<Pregunta>
 
     {
         void AgregarPreguntas(IEnumerable<Pregunta> pPreguntas);
-        IEnumerable<Pregunta> ObtenerPreguntas(Categoria pCategoria, Dificultad pDificultad, Conjunto pConjunto, int pCantidad);
+        IEnumerable<Pregunta> ObtenerPreguntas(int pCategoria, int pDificultad, int pConjunto, int pCantidad);
         IEnumerable<Pregunta> ObtenerTodas();
         string GetOrCreate(string pNombre, string pConjunto);
         IEnumerable<Categoria> ObtenerCategorias(int pConjunto);
+        IEnumerable<Pregunta> ObtenerPreguntasPorSesion(int pIdSesion);
+        Pregunta ObtenerPreguntaPorId(int pIdPregunta);
     }
 }

ShockQuiz/DAL/IRepositorioSesion.cs

@@ -7,5 +7,8 @@ public interface IRepositorioSesion : IRepositorio<Sesion>
     {
         IEnumerable<Sesion> ObtenerTodas(string pUsuario);
         IEnumerable<Sesion> ObtenerRanking(int pTop);
+        IEnumerable<Sesion> ObtenerSesionActiva();
+        Sesion ObtenerUltimaSesion();
+        Sesion ObtenerSesionId(int pIdSesion);
     }
 }

ShockQuiz/DAL/OpenTriviaDB/JsonMapper.cs

@@ -1,6 +1,7 @@
 using Newtonsoft.Json;
 using ShockQuiz.DAL.EntityFramework;
 using ShockQuiz.Dominio;
+using ShockQuiz.IO;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -55,7 +56,7 @@ public static string ObtenerToken()
         /// <param name="pToken">API Token</param>
         /// <param name="pNumber">Cantidad de Preguntas</param>
         /// <returns></returns>
-        public static List<Pregunta> AlmacenarPreguntas(string pToken = null, int pNumber = 10)
+        public static List<Pregunta> GetPreguntas(string pToken = null, int pNumber = 10)
         {
             List<Pregunta> listaPreguntas = new List<Pregunta>();
             string CONJUNTO = "OpenTDB";
@@ -82,56 +83,46 @@ public static List<Pregunta> AlmacenarPreguntas(string pToken = null, int pNumbe
                     // Se parsea la respuesta y se serializa a JSON a un objeto dynamic
                     dynamic mResponseJSON = JsonConvert.DeserializeObject(reader.ReadToEnd());
 
-                    using (var bDbContext = new ShockQuizDbContext())
+                    // Se iteran cada uno de los resultados.
+                    foreach (var bResponseItem in mResponseJSON.results)
                     {
-                        using (UnitOfWork bUoW = new UnitOfWork(bDbContext))
-                        {
-                            // Se iteran cada uno de los resultados.
-                            foreach (var bResponseItem in mResponseJSON.results)
-                            {
-
-                                string preguntaDesc = HttpUtility.HtmlDecode(bResponseItem.question.ToString());
-                                string categoria = HttpUtility.HtmlDecode(bResponseItem.category.ToString());
-                                string dificultad = HttpUtility.HtmlDecode(bResponseItem.difficulty.ToString());
+                        string preguntaDesc = HttpUtility.HtmlDecode(bResponseItem.question.ToString());
+                        string categoria = HttpUtility.HtmlDecode(bResponseItem.category.ToString());
+                        string dificultad = HttpUtility.HtmlDecode(bResponseItem.difficulty.ToString());
 
-                                List<Respuesta> respuestas = new List<Respuesta>();
-                                Respuesta respuestaCorrecta = new Respuesta()
-                                {
-                                    EsCorrecta = true,
-                                    DefRespuesta = HttpUtility.HtmlDecode(bResponseItem.correct_answer.ToString())
-                                };
-                                respuestas.Add(respuestaCorrecta);
+                        List<Respuesta> respuestas = new List<Respuesta>();
+                        Respuesta respuestaCorrecta = new Respuesta()
+                        {
+                            EsCorrecta = true,
+                            DefRespuesta = HttpUtility.HtmlDecode(bResponseItem.correct_answer.ToString())
+                        };
+                        respuestas.Add(respuestaCorrecta);
 
-                                for (int i = 0; i < 3; i++)
-                                {
-                                    Respuesta res = new Respuesta()
-                                    {
-                                        DefRespuesta = HttpUtility.HtmlDecode(bResponseItem.incorrect_answers[i].ToString()),
-                                        EsCorrecta = false
-                                    };
-                                    respuestas.Add(res);
-                                }
+                        for (int i = 0; i < 3; i++)
+                        {
+                            Respuesta res = new Respuesta()
+                            {
+                                DefRespuesta = HttpUtility.HtmlDecode(bResponseItem.incorrect_answers[i].ToString()),
+                                EsCorrecta = false
+                            };
+                            respuestas.Add(res);
+                        }
 
-                                Pregunta pregunta = new Pregunta()
-                                {
-                                    Nombre = bUoW.RepositorioPregunta.GetOrCreate(preguntaDesc, CONJUNTO),
-                                    Categoria = bUoW.RepositorioCategoria.GetOrCreate(categoria),
-                                    Dificultad = bUoW.RepositorioDificultad.GetOrCreate(dificultad),
-                                    Conjunto = bUoW.RepositorioConjunto.Get(CONJUNTO),
-                                    Respuestas = respuestas
-                                };
-                                if (pregunta.Nombre != string.Empty)
-                                {
-                                    bUoW.RepositorioPregunta.Agregar(pregunta);
-                                }
-                            }
-                            bUoW.GuardarCambios();
+                        Pregunta pregunta = new Pregunta()
+                        {
+                            Nombre = preguntaDesc,
+                            Categoria = new Categoria() { Nombre = categoria },
+                            Dificultad = new Dificultad() { Nombre = dificultad },
+                            ConjuntoNombre = CONJUNTO,
+                            Respuestas = respuestas
+                        };
+                        if (pregunta.Nombre != string.Empty)
+                        {
+                            listaPreguntas.Add(pregunta);
                         }
                     }
                 }
             }
-
-
             catch (WebException ex)
             {
                 WebResponse mErrorResponse = ex.Response;

ShockQuiz/Dominio/Categoria.cs

@@ -6,7 +6,6 @@ public class Categoria
     {
         public int Id { get; set; }
         public string Nombre { get; set; }
-
         public ICollection<Sesion> Sesiones { get; set; }
         public ICollection<Pregunta> Preguntas { get; set; }
     }

ShockQuiz/Dominio/ConjuntoOTDB.cs

@@ -1,10 +1,14 @@
 using ShockQuiz.DAL.OpenTriviaDB;
+using ShockQuiz.Forms;
 using System;
+using System.Collections.Generic;
 
 namespace ShockQuiz.Dominio
 {
     public class ConjuntoOTDB : Conjunto
     {
+        FachadaConfiguracionAdmin fachada = new FachadaConfiguracionAdmin();
+
         public override double CalcularPuntaje(Sesion pSesion)
         {
             int TIEMPO_LIMITE_1 = 5;
@@ -25,7 +29,7 @@ public override double CalcularPuntaje(Sesion pSesion)
                     break;
             }
             double FACTOR_TIEMPO = 1;
-            double tiempoPorPregunta = pSesion.Duracion().TotalSeconds / pSesion.CantidadPreguntas;
+            double tiempoPorPregunta = pSesion.SegundosTranscurridos / pSesion.CantidadTotalPreguntas;
             if (tiempoPorPregunta < TIEMPO_LIMITE_1)
             {
                 FACTOR_TIEMPO = 5;
@@ -38,7 +42,7 @@ public override double CalcularPuntaje(Sesion pSesion)
             {
                 FACTOR_TIEMPO = 3;
             }
-            double puntaje = ((double)pSesion.RespuestasCorrectas / (double)pSesion.CantidadPreguntas) * FACTOR_DIFICULTAD * FACTOR_TIEMPO;
+            double puntaje = ((double)pSesion.RespuestasCorrectas / (double)pSesion.CantidadTotalPreguntas) * FACTOR_DIFICULTAD * FACTOR_TIEMPO;
             return Math.Round(puntaje, 2);
         }
 
@@ -50,13 +54,15 @@ public override void AgregarPreguntas(int pCantidad, string pToken = null)
                 int aux = pCantidad;
                 while (aux > 0)
                 {
-                    JsonMapper.AlmacenarPreguntas(pToken, aux);
+                    List<Pregunta> preguntas = JsonMapper.GetPreguntas(pToken, aux);
+                    fachada.AlmacenarPreguntas(preguntas);
                     aux -= 50;
                 }
             }
             else
             {
-                JsonMapper.AlmacenarPreguntas(pToken, pCantidad);
+                List<Pregunta> preguntas = JsonMapper.GetPreguntas(pToken, pCantidad);
+                fachada.AlmacenarPreguntas(preguntas);
             }
         }
     }