Exemplo n.º 1
0
        // GET: Admin/Contenidos
        public ActionResult Index(int id, int gramaticaId)
        {
            if (id == null || gramaticaId == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var subtema   = SubTemaDataAccess.ObtenerSubTemas(db).Include(s => s.Tema).SingleOrDefault(s => s.SubTemaId == id);
            var gramatica = GramaticaDataAccess.ObtenerGramaticas(db).FirstOrDefault(g => g.GramaticaId == gramaticaId);

            if (subtema == null || gramatica == null)
            {
                return(HttpNotFound());
            }
            if (!ComprobarAccesoSubTema(id))
            {
                return(RedirectToAction("SinAcceso", "Home", new { Area = "Alumno" }));
            }



            var userId = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;
            var frases = db.Frases.Where(fr => fr.GramaticaId == gramaticaId).OrderBy(v => v.Palabra_en).ToList();


            FrasesIndexViewModel viewModel = new FrasesIndexViewModel();

            viewModel.glosario  = db.FraseGlosarios.Where(vg => vg.AlumnoId == userId).Select(vg => vg.FraseId).ToList();
            viewModel.frases    = frases;
            viewModel.Subtema   = subtema;
            viewModel.Gramatica = gramatica;

            return(View(viewModel));
        }
        // GET: Alumno/Juegos/Categoria
        public ActionResult Categoria(int id, int subtemaId)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(ex => ex.Tema).FirstOrDefault(b => b.SubTemaId == subtemaId);

            if (subtema == null)
            {
                return(HttpNotFound());
            }
            var categoriaJuego = db.CategoriaJuegos.FirstOrDefault(b => b.CategoriaJuegoId == id);

            if (categoriaJuego == null)
            {
                return(HttpNotFound());
            }
            var juegos = JuegoDataAccess.ObtenerJuegos(db).Include(ex => ex.CategoriaJuego).Where(b => b.SubTemaId == subtemaId && b.CategoriaJuegoId == id).ToList();
            JuegosCategoriaViewModel viewModel = new JuegosCategoriaViewModel();

            viewModel.SubTema        = subtema;
            viewModel.Juegos         = juegos;
            viewModel.CategoriaJuego = categoriaJuego;
            return(View(viewModel));
        }
Exemplo n.º 3
0
        // GET: Usuario/Home
        public ActionResult Index()
        {
            var temas     = TemaDataAccess.ObtenerTemas(db).ToList();
            var temasHome = new List <TemaHome>();

            AuthRepository  authRepository = new AuthRepository();
            ApplicationUser user           = authRepository.FindByName(User.Identity.Name);

            foreach (var tema in temas)
            {
                var subtemas = SubTemaDataAccess.ObtenerSubTemas(db).Where(st => st.TemaId == tema.TemaId).Select(st => st.SubTemaId);

                var subtemasAprobados = db.Examenes.Where(e => e.AlumnoId == user.Id && e.Aprobado &&
                                                          subtemas.Contains(e.SubTemaId)).Select(e => e.SubTemaId).Distinct().Count();

                double porcentaje = (double)subtemasAprobados / subtemas.Count() * 100;

                temasHome.Add(new TemaHome()
                {
                    Porcentaje = (int)porcentaje,
                    Tema       = tema
                });
            }



            var _examenes = db.Examenes.Include(e => e.SubTema).Include(e => e.SubTema.Tema).Where(e => e.AlumnoId == user.Id).OrderByDescending(e => e.FechaExamen).Take(3).ToList();


            HomeIndexViewModel viewModel = new HomeIndexViewModel();

            viewModel.temasHome = temasHome;



            viewModel.NRealizados = db.BloqueRealizados.Count(br => br.AlumnoId == user.Id);
            viewModel.NExtras     = db.ExtraDesbloqueados.Count(br => br.AlumnoId == user.Id);


            var GrupoUsuarioID = ((ClaimsIdentity)User.Identity).FindFirst("GrupoUsuario").Value;

            if (GrupoUsuarioID == "")
            {
                viewModel.Noticias = NoticiaDataAccess.ObtenerNoticia().OrderByDescending(not => not.Fecha).Take(3).ToList();
            }
            else
            {
                viewModel.Noticias = db.NoticiaGrupos.Where(ng => ng.GrupoUsuarioId.ToString() == GrupoUsuarioID)
                                     .Select(gu => gu.Noticia).OrderByDescending(not => not.Fecha).Take(3).ToList();
            }

            viewModel.Hilos = ForoHiloDataAccess.ObtenerForoHilo().Take(3).ToList();


            viewModel.Puntos = user.PuntosActual;

            viewModel.Examenes = _examenes;

            return(View(viewModel));
        }
Exemplo n.º 4
0
        // GET: Admin/SubTemas
        public ActionResult Index(int id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            var tema = TemaDataAccess.ObtenerTemas(db).FirstOrDefault(te => te.TemaId == id);

            if (tema == null)
            {
                return(HttpNotFound());
            }


            var userId = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;

            var subTemas        = SubTemaDataAccess.ObtenerSubTemas(db).Include(s => s.Tema).Where(subtema => subtema.TemaId == id).OrderBy(d => d.Orden).ToList();
            var listaSubtemaIds = subTemas.Select(st => st.SubTemaId).ToList();

            var subtemasDesbloqueados = db.SubTemaDesbloqueados.Where(sd => sd.AlumnoId == userId &&
                                                                      listaSubtemaIds.Contains(sd.SubTemaId)).Select(sd => sd.SubTemaId).ToList();

            SubTemasIndexViewModel viewModel = new SubTemasIndexViewModel();

            viewModel.Tema = tema;


            viewModel.listadoSubTemasBloqueados    = subTemas.Where(st => !subtemasDesbloqueados.Contains(st.SubTemaId)).ToList();
            viewModel.listadoSubTemasDesbloqueados = subTemas.Where(st => subtemasDesbloqueados.Contains(st.SubTemaId)).ToList();
            if (User.IsInRole("Admin"))
            {
                viewModel.listadoSubTemasBloqueados    = new List <SubTema>();
                viewModel.listadoSubTemasDesbloqueados = subTemas.ToList();
            }


            var gramaticas    = GramaticaDataAccess.ObtenerGramaticas(db).Include(gt => gt.Vocabularios).Where(gr => listaSubtemaIds.Contains(gr.SubTemaId));
            var gramaticasIds = gramaticas.Select(gr => gr.GramaticaId).ToList();

            viewModel.NUnidades    = gramaticasIds.Count;
            viewModel.NFrases      = db.Frases.Count(f => gramaticasIds.Contains(f.GramaticaId));
            viewModel.NVocabulario = gramaticas.SelectMany(gr => gr.Vocabularios).Count();
            viewModel.NPracticas   = BloqueDataAccess.ObtenerBloques(db).Count(b => listaSubtemaIds.Contains(b.SubTemaId));
            viewModel.NLecciones   = listaSubtemaIds.Count;

            viewModel.TemaSuperado = (db.Examenes.Count(e => e.AlumnoId == userId && e.Aprobado && e.SubTema.TemaId == id) == listaSubtemaIds.Count);

            viewModel.examenesDesbloqueados = db.ExamenDesbloqueados.Where(ex => ex.AlumnoId == userId).Select(ex => ex.SubTemaId).ToList();
            viewModel.listadoSubTemasAcceso = db.SubTemaAccesoUsuarios.Where(sau => sau.AlumnoId == userId).Select(sau => sau.SubTemaId).ToList();

            return(View(viewModel));
        }
Exemplo n.º 5
0
        // GET: Alumno/Vocabularios/Gramatica
        public ActionResult Gramatica(int id, int gramaticaId, string idioma)
        {
            if (id == null || gramaticaId == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var subtema   = SubTemaDataAccess.ObtenerSubTemas(db).Include(s => s.Tema).SingleOrDefault(s => s.SubTemaId == id);
            var gramatica = GramaticaDataAccess.ObtenerGramaticas(db).Include(gt => gt.Vocabularios.Select(v => v.CategoriaVocabulario)).FirstOrDefault(g => g.GramaticaId == gramaticaId);

            if (subtema == null || gramatica == null)
            {
                return(HttpNotFound());
            }

            if (!ComprobarAccesoSubTema(id))
            {
                return(RedirectToAction("SinAcceso", "Home", new { Area = "Alumno" }));
            }

            if (string.IsNullOrEmpty(idioma))
            {
                idioma = "en";
            }


            var vocabulario = new List <Vocabulario>();

            if (idioma == "en")
            {
                vocabulario = gramatica.Vocabularios.OrderBy(v => v.Palabra_en).ToList();
            }
            else
            {
                vocabulario = gramatica.Vocabularios.OrderBy(v => v.Palabra_es).ToList();
            }

            VocabulariosGramaticaViewModel viewModel = new VocabulariosGramaticaViewModel();

            viewModel.vocabulario = vocabulario;
            viewModel.Subtema     = subtema;
            viewModel.Gramatica   = gramatica;
            viewModel.Idioma      = idioma;

            var userId = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;

            viewModel.glosario = db.VocabularioGlosarios.Where(vg => vg.AlumnoId == userId).Select(vg => vg.VocabularioId).ToList();

            return(View(viewModel));
        }
        public ActionResult Examen(int id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(st => st.Tema).FirstOrDefault(b => b.SubTemaId == id);

            if (subtema == null)
            {
                return(HttpNotFound());
            }

            if (!ComprobarAccesoExamen(id))
            {
                return(RedirectToAction("SinAcceso", "Home", new { Area = "Alumno" }));
            }

            List <PreguntaExamen> contenidos = db.Tests.Include(t => t.TipoEjercicio).Where(sk => sk.SubTemaId == subtema.SubTemaId && sk.PreguntaExamen.HasValue ? sk.PreguntaExamen.Value : false).Select(t => new PreguntaExamen()
            {
                id = t.Id, tipo = t.TipoEjercicio.Controlador
            }).ToList();

            contenidos.AddRange(db.FillTheGaps.Include(t => t.TipoEjercicio).Where(sk => sk.SubTemaId == subtema.SubTemaId && sk.PreguntaExamen.HasValue ? sk.PreguntaExamen.Value : false).Select(t => new PreguntaExamen()
            {
                id = t.Id, tipo = t.TipoEjercicio.Controlador
            }).ToList());
            contenidos.AddRange(db.TrueFalses.Include(t => t.TipoEjercicio).Where(sk => sk.SubTemaId == subtema.SubTemaId && sk.PreguntaExamen.HasValue ? sk.PreguntaExamen.Value : false).Select(t => new PreguntaExamen()
            {
                id = t.Id, tipo = t.TipoEjercicio.Controlador
            }).ToList());
            contenidos.AddRange(db.AudioSentenceExercises.Include(t => t.TipoEjercicio).Where(sk => sk.SubTemaId == subtema.SubTemaId && sk.PreguntaExamen.HasValue ? sk.PreguntaExamen.Value : false).Select(t => new PreguntaExamen()
            {
                id = t.Id, tipo = t.TipoEjercicio.Controlador
            }).ToList());


            contenidos.Shuffle();

            ExamenIndexViewModel _modelTest = new ExamenIndexViewModel();

            _modelTest.subTema    = subtema;
            _modelTest.contenidos = contenidos.Take(30).ToList();
            _modelTest.examenId   = id;

            return(View("Examen", _modelTest));
        }
        // GET: Alumno/Juegos/Seleccion
        public ActionResult Seleccion(int id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(ex => ex.Tema).FirstOrDefault(b => b.SubTemaId == id);

            if (subtema == null)
            {
                return(HttpNotFound());
            }
            JuegosIndexViewModel viewModel = new JuegosIndexViewModel();

            viewModel.SubTema = subtema;
            return(View(viewModel));
        }
        // GET: Alumno/Extras
        public ActionResult Index(int id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(s => s.Tema).SingleOrDefault(s => s.SubTemaId == id);

            if (subtema == null)
            {
                return(HttpNotFound());
            }
            if (!ComprobarAccesoSubTema(id))
            {
                return(RedirectToAction("SinAcceso", "Home", new { Area = "Alumno" }));
            }

            ExtrasIndexViewModel viewModel = new ExtrasIndexViewModel();

            viewModel.categorias = db.CategoriaExtras.ToList();
            viewModel.Subtema    = subtema;

            viewModel.ExtraDesbloqueadoEstadisticas = new List <ExtraDesbloqueadoEstadistica>();
            foreach (var categoria in viewModel.categorias)
            {
                var extras  = ExtraDataAccess.ObtenerExtras(db).Where(ex => ex.CategoriaExtraId == categoria.CategoriaExtraId && ex.SubTemaId == id).Select(ex => ex.ExtraId).ToList();
                int nExtras = extras.Count;
                var userId  = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;
                int nExtrasDesbloqueados = db.ExtraDesbloqueados.Count(ex => ex.AlumnoId == userId && extras.Contains(ex.ExtraId));

                double porcentaje = (double)nExtrasDesbloqueados / nExtras * 100;
                ExtraDesbloqueadoEstadistica extraEstadistica = new ExtraDesbloqueadoEstadistica()
                {
                    CateGoriaExtraId = categoria.CategoriaExtraId,
                    NDesbloqueados   = nExtrasDesbloqueados,
                    NExtras          = nExtras,
                    Porcentaje       = (int)porcentaje
                };
                viewModel.ExtraDesbloqueadoEstadisticas.Add(extraEstadistica);
            }

            return(View(viewModel));
        }
        // GET: Alumno/Juegos
        public ActionResult Index(int id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(ex => ex.Tema).FirstOrDefault(b => b.SubTemaId == id);

            if (subtema == null)
            {
                return(HttpNotFound());
            }
            var categorias = JuegoDataAccess.ObtenerJuegos(db).Include(ex => ex.CategoriaJuego).Where(b => b.SubTemaId == id).Select(b => b.CategoriaJuego).Distinct().ToList();
            JuegosIndexViewModel viewModel = new JuegosIndexViewModel();

            viewModel.SubTema         = subtema;
            viewModel.CategoriaJuegos = categorias;
            return(View(viewModel));
        }
Exemplo n.º 10
0
        // GET: Admin/Contenidos
        public ActionResult Index(int id, int areaId)
        {
            if (id == null || areaId == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(s => s.Tema).SingleOrDefault(s => s.SubTemaId == id);
            var area    = db.Areas.SingleOrDefault(s => s.AreaId == areaId);

            if (subtema == null || area == null)
            {
                return(HttpNotFound());
            }
            if (!ComprobarAccesoSubTema(id))
            {
                return(RedirectToAction("SinAcceso", "Home", new { Area = "Alumno" }));
            }

            var realizados  = ContenidoHelper.ObtenerEjercicioHecho(id, areaId);
            var conMistakes = ContenidoHelper.ObtenerEjerciciosConMistakes(id, areaId);


            var bloques    = BloqueDataAccess.ObtenerBloques(db).Include(t => t.TipoEjercicio).Where(t => t.SubTemaId == id && t.AreaId == areaId).ToList();
            var bloquesIds = bloques.Select(bl => bl.BloqueId).ToList();


            BloquesIndexViewModel viewModel = new BloquesIndexViewModel();

            viewModel.listadoBloques = bloques;
            var userId = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;

            viewModel.bloquesDesbloqueados = db.BloqueDesbloqueados.Where(ex => ex.AlumnoId == userId && bloquesIds.Contains(ex.BloqueId)).Select(ex => ex.BloqueId).ToList();


            viewModel.Subtema     = subtema;
            viewModel.Area        = area;
            viewModel.realizados  = realizados.Select(br => br.BloqueId).ToList();
            viewModel.conMistakes = conMistakes.Select(br => br.BloqueId).ToList();


            return(View(viewModel));
        }
        // GET: Alumno/SubTemaVideos
        public ActionResult Index(int id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(ex => ex.Tema).FirstOrDefault(b => b.SubTemaId == id);

            if (subtema == null)
            {
                return(HttpNotFound());
            }
            var SubTemaVideos = SubTemaVideoDataAccess.ObtenerSubTemaVideos(db).Where(b => b.SubTemaId == id).ToList();
            SubTemaVideosIndexViewModel viewModel = new SubTemaVideosIndexViewModel();

            viewModel.SubTema       = subtema;
            viewModel.SubTemaVideos = SubTemaVideos;
            return(View(viewModel));
        }
Exemplo n.º 12
0
        // GET: Alumno/View/id
        public ActionResult View(int id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            var Juego = JuegoDataAccess.ObtenerJuegos(db).Include(ex => ex.CategoriaJuego).FirstOrDefault(b => b.JuegoId == id);

            if (Juego == null)
            {
                return(HttpNotFound());
            }
            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(ex => ex.Tema).FirstOrDefault(b => b.SubTemaId == Juego.SubTemaId);

            JuegosViewViewModel viewModel = new JuegosViewViewModel();

            viewModel.Juego   = Juego;
            viewModel.SubTema = subtema;
            return(View(viewModel));
        }
Exemplo n.º 13
0
        protected override void CargarAccesoSeleccionado(AuthContext db)
        {
            var temas = TemaDataAccess.ObtenerTemasCliente(db, Usuario.ClienteId).ToList();

            AccesoTemas = new List <AccesoTema>();

            var Accesos = db.SubTemaAccesoUsuarios.Where(sau => sau.AlumnoId == Usuario.Id).Select(sau => sau.SubTemaId).ToList();

            foreach (Tema tema in temas)
            {
                var accesoTema = new AccesoTema
                {
                    Tema     = tema,
                    SubTemas = SubTemaDataAccess.ObtenerSubTemasCliente(db, Usuario.ClienteId).Where(st => st.TemaId == tema.TemaId).OrderBy(st => st.Orden).Select(subt => new SelectListItem {
                        Text = subt.Descripcion, Value = subt.SubTemaId.ToString(), Selected = Accesos.Contains(subt.SubTemaId)
                    }).ToList()
                };
                AccesoTemas.Add(accesoTema);
            }
        }
Exemplo n.º 14
0
        // GET: Admin/Contenidos
        public ActionResult Index(int id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(s => s.Tema).SingleOrDefault(s => s.SubTemaId == id);

            if (subtema == null)
            {
                return(HttpNotFound());
            }
            if (!ComprobarAccesoSubTema(id))
            {
                return(RedirectToAction("SinAcceso", "Home", new { Area = "Alumno" }));
            }

            var realizados = JuegoOnlineHelper.ObtenerJuegoOnlineHecho(id);

            var JuegoOnlines    = JuegoOnlineDataAccess.ObtenerJuegoOnlines(db).Include(t => t.TipoJuegoOnline).Where(t => t.SubTemaId == id).ToList();
            var JuegoOnlinesIds = JuegoOnlines.Select(bl => bl.JuegoOnlineId).ToList();


            JuegoOnlinesIndexViewModel viewModel = new JuegoOnlinesIndexViewModel();

            viewModel.listadoJuegoOnlines = JuegoOnlines;
            var userId = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;

            viewModel.juegoOnlinesDesbloqueados = db.JuegoOnlineDesbloqueados.Where(ex => ex.AlumnoId == userId && JuegoOnlinesIds.Contains(ex.JuegoOnlineId)).Select(ex => ex.JuegoOnlineId).ToList();

            viewModel.Subtema = subtema;

            viewModel.realizados = realizados.Select(br => br.JuegoOnlineId).ToList();

            return(View(viewModel));
        }
Exemplo n.º 15
0
        // GET: Alumno/Documentos
        public ActionResult Index()
        {
            DocumentosIndexViewModel viewModel = new DocumentosIndexViewModel();

            var GrupoUsuarioID = ((ClaimsIdentity)User.Identity).FindFirst("GrupoUsuario").Value;

            var userId = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;

            var subtemasDesbloqueados = db.SubTemaDesbloqueados.Where(sd => sd.AlumnoId == userId
                                                                      ).Select(sd => sd.SubTemaId).ToList();

            if (GrupoUsuarioID == "")
            {
                viewModel.Documentos = db.Documentos.OrderByDescending(not => not.Fecha).ToList();
            }
            else
            {
                viewModel.Documentos = db.DocumentoGrupos.Where(ng => ng.GrupoUsuarioId.ToString() == GrupoUsuarioID)
                                       .Select(gu => gu.Documento).OrderByDescending(not => not.Fecha).ToList();
            }
            viewModel.Documentos = viewModel.Documentos.ToList();
            List <int> idsTemas    = viewModel.Documentos.Select(doc => doc.TemaId.HasValue? doc.TemaId.Value: -1).Distinct().ToList();
            List <int> idsSubTemas = viewModel.Documentos.Select(doc => doc.SubTemaId.HasValue ? doc.SubTemaId.Value : -1).Distinct().ToList();

            viewModel.Temas = TemaDataAccess.ObtenerTemas(db).Where(t => idsTemas.Contains(t.TemaId)).ToList();
            if (User.IsInRole("Admin"))
            {
                viewModel.Subtemas = SubTemaDataAccess.ObtenerSubTemas(db).Where(t => idsSubTemas.Contains(t.SubTemaId)).ToList();
            }
            else
            {
                viewModel.Subtemas = SubTemaDataAccess.ObtenerSubTemas(db).Where(t => idsSubTemas.Contains(t.SubTemaId) && subtemasDesbloqueados.Contains(t.SubTemaId)).ToList();
            }

            return(View(viewModel));
        }
Exemplo n.º 16
0
        public JsonResult FinExamenFillTheGap(int id, int aciertos, int errores, int totales, RespuestaIncorrectaFillTheGapExamen[] respuestasIncorrectas)
        {
            var userId = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;

            FillTheGap _fillTheGap = db.FillTheGaps.Find(id);

            bool _aprobado = (aciertos >= 28);

            FinExamenFillTheGap resultado = new FinExamenFillTheGap();

            resultado.Correctas          = aciertos;
            resultado.Aprobado           = _aprobado;
            resultado.Porcentaje         = (aciertos * 100 / totales);
            resultado.IdSiguienteLeccion = 0;
            resultado.SiguienteLeccion   = "";

            SubTema _tema          = SubTemaDataAccess.ObtenerSubTemas(db).Where(s => s.SubTemaId == _fillTheGap.SubTemaId).FirstOrDefault();
            SubTema _siguienteTema = SubTemaDataAccess.ObtenerSubTemas(db).Where(s => s.TemaId == _tema.TemaId && s.Orden > _tema.Orden).OrderBy(s => s.Orden).FirstOrDefault();

            resultado.UltimoExamen = true;
            if (_siguienteTema != null)
            {
                resultado.UltimoExamen = false;
                if (_aprobado)
                {
                    resultado.IdSiguienteLeccion = _siguienteTema.SubTemaId;
                    resultado.SiguienteLeccion   = _siguienteTema.Descripcion;

                    var  BloquearSubtemas = ((ClaimsIdentity)User.Identity).FindFirst("BloquearSubtemas").Value;
                    bool anyadir          = true;
                    if (Convert.ToBoolean(BloquearSubtemas))
                    {
                        var listaSubtemasAcceso = db.SubTemaAccesoUsuarios.Where(sau => sau.AlumnoId == userId).Select(sau => sau.SubTemaId).ToList();
                        if (!listaSubtemasAcceso.Contains(_siguienteTema.SubTemaId))
                        {
                            anyadir = false;
                        }
                    }
                    if (anyadir)
                    {
                        SubTemaDesbloqueado _desbloqueado = new SubTemaDesbloqueado
                        {
                            AlumnoId        = userId,
                            FechaDesbloqueo = DateTime.Now,
                            SubTemaId       = _siguienteTema.SubTemaId
                        };
                        db.SubTemaDesbloqueados.Add(_desbloqueado);
                        db.SaveChanges();
                    }
                }
            }

            var    NombreUsuario = ((ClaimsIdentity)User.Identity).FindFirst("NombreUsuario").Value;
            Examen _examen       = new Examen
            {
                Aciertos     = aciertos,
                AlumnoId     = userId,
                NombreAlumno = NombreUsuario,
                Aprobado     = _aprobado,
                Fallos       = errores,
                FechaExamen  = DateTime.Now,
                Total        = totales
            };

            List <RespuestaIncorrecta> respuestas = new List <RespuestaIncorrecta>();

            foreach (RespuestaIncorrectaFillTheGapExamen respuestaIncorrecta in respuestasIncorrectas)
            {
                FillTheGap          fillTheGap   = db.FillTheGaps.Find(respuestaIncorrecta.id);
                RespuestaIncorrecta respuestaInc = new RespuestaIncorrecta();
                respuestaInc.Pregunta              = fillTheGap.Enunciado;
                respuestaInc.RespuestaCorrecta     = fillTheGap.Respuestas.Replace('#', ' ');
                respuestaInc.RespuestaSeleccionada = respuestaIncorrecta.respuesta.Replace('#', ' ');
                respuestas.Add(respuestaInc);
            }
            _examen.RespuestasIncorrectas = respuestas;



            db.Examenes.Add(_examen);
            db.SaveChanges();

            return(Json(resultado, JsonRequestBehavior.AllowGet));
        }
Exemplo n.º 17
0
        // GET: Alumno/Categoria/id
        public ActionResult Categoria(int id, int subtemaId)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            var categoria = db.CategoriaExtras.FirstOrDefault(b => b.CategoriaExtraId == id);

            if (categoria == null)
            {
                return(HttpNotFound());
            }


            if (subtemaId == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var subtema = SubTemaDataAccess.ObtenerSubTemas(db).Include(s => s.Tema).SingleOrDefault(s => s.SubTemaId == subtemaId);

            if (subtema == null)
            {
                return(HttpNotFound());
            }
            if (!ComprobarAccesoSubTema(subtemaId))
            {
                return(RedirectToAction("SinAcceso", "Home", new { Area = "Alumno" }));
            }

            ExtrasCategoriaViewModel viewModel = new ExtrasCategoriaViewModel();

            viewModel.CategoriaExtra = categoria;
            viewModel.Subtema        = subtema;
            viewModel.extras         = ExtraDataAccess.ObtenerExtras(db).Where(ex => ex.CategoriaExtraId == id && ex.SubTemaId == subtemaId).OrderBy(ex => ex.Orden).ToList();

            var extras = viewModel.extras.Select(ex => ex.ExtraId).ToList();

            var userId = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;

            viewModel.extrasDesbloqueados = db.ExtraDesbloqueados.Where(ex => ex.AlumnoId == userId && extras.Contains(ex.ExtraId)).Select(ex => ex.ExtraId).ToList();

            var siguienteExtra = viewModel.extras.Where(ex => !viewModel.extrasDesbloqueados.Contains(ex.ExtraId)).OrderBy(ex => ex.Orden).FirstOrDefault();

            if (siguienteExtra != null)
            {
                int siguienteId = siguienteExtra.ExtraId;
                viewModel.siguienteId = siguienteId;
            }
            else
            {
                viewModel.siguienteId = 0;
            }

            int nExtras = extras.Count;
            int nExtrasDesbloqueados = viewModel.extrasDesbloqueados.Count;

            double porcentaje = (double)nExtrasDesbloqueados / nExtras * 100;
            ExtraDesbloqueadoEstadistica extraEstadistica = new ExtraDesbloqueadoEstadistica()
            {
                CateGoriaExtraId = categoria.CategoriaExtraId,
                NDesbloqueados   = nExtrasDesbloqueados,
                NExtras          = nExtras,
                Porcentaje       = (int)porcentaje
            };

            viewModel.ExtraDesbloqueadoEstadistica = extraEstadistica;


            return(View(viewModel));
        }
Exemplo n.º 18
0
        // GET: Admin/SubTemas
        public ActionResult View(int id, int?gramaticaId)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var subTema = SubTemaDataAccess.ObtenerSubTemas(db).FirstOrDefault(su => su.SubTemaId == id);

            if (subTema == null)
            {
                return(HttpNotFound());
            }

            if (!ComprobarAccesoSubTema(id))
            {
                return(RedirectToAction("SinAcceso", "Home", new { Area = "Alumno" }));
            }

            SubTemasViewViewModel viewModel = new SubTemasViewViewModel();

            viewModel.Tema = TemaDataAccess.ObtenerTemas(db).FirstOrDefault(te => te.TemaId == subTema.TemaId);
            if (viewModel.Tema == null)
            {
                return(HttpNotFound());
            }
            viewModel.SubTema = subTema;

            var bloques = BloqueDataAccess.ObtenerBloques(db).Include(t => t.Area).Include(t => t.TipoEjercicio).Where(t => t.SubTemaId == id);
            var areas   = db.Areas.Where(a => a.Orden.HasValue).OrderBy(a => a.Orden.Value).ToList();

            var listadoAreas = new List <AreaContenidos>();

            foreach (var area in areas)
            {
                listadoAreas.Add(new AreaContenidos
                {
                    Area          = area,
                    NumContenidos = bloques.Where(c => c.AreaId == area.AreaId).Count()
                });
            }
            viewModel.listadoAreas = listadoAreas;

            var Gramaticas = GramaticaDataAccess.ObtenerGramaticas(db).Include(gram => gram.GramaticaCuerpo).Where(gram => gram.SubTemaId == id).OrderBy(d => d.Orden).ToList();

            viewModel.Gramaticas = Gramaticas;
            if (gramaticaId.HasValue)
            {
                viewModel.GramaticaMostrar = GramaticaDataAccess.ObtenerGramaticas(db).Include(gram => gram.GramaticaCuerpo).FirstOrDefault(gr => gr.GramaticaId == gramaticaId.Value);
            }
            else
            {
                viewModel.GramaticaMostrar = Gramaticas.FirstOrDefault();
            }

            var userId = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;

            viewModel.MostrarExamen         = (db.Examenes.Where(e => e.AlumnoId == userId && e.SubTemaId == id && e.Aprobado).FirstOrDefault() == null);
            viewModel.examenesDesbloqueados = db.ExamenDesbloqueados.Where(ex => ex.AlumnoId == userId && ex.SubTemaId == id).Select(ex => ex.SubTemaId).ToList();


            return(View(viewModel));
        }
Exemplo n.º 19
0
        public JsonResult FinExamen(int id, PreguntaExamen[] respuestas)
        {
            var userId   = ((ClaimsIdentity)User.Identity).FindFirst("UserId").Value;
            int aciertos = 0;
            int totales  = respuestas.Length;

            List <RespuestaIncorrecta> respuestasIncorrectas = new List <RespuestaIncorrecta>();

            foreach (var pregunta in respuestas)
            {
                bool   acertada              = false;
                string enunciado             = "";
                string respuestaCorrecta     = "";
                string respuestaSeleccionada = "";


                if (pregunta.tipo == "Tests")
                {
                    Test test = db.Tests.Find(pregunta.id);
                    if (pregunta.respuesta != null && test.RespuestaCorrecta.ToString() == pregunta.respuesta)
                    {
                        aciertos++;
                        acertada = true;
                    }
                    else
                    {
                        enunciado             = test.Enunciado;
                        respuestaCorrecta     = ObtenerRespuestaTest(test, test.RespuestaCorrecta);
                        respuestaSeleccionada = ObtenerRespuestaTest(test, Convert.ToInt32(pregunta.respuesta));
                    }
                }
                if (pregunta.tipo == "FillTheGaps")
                {
                    if (pregunta.respuesta != null)
                    {
                        pregunta.respuesta = pregunta.respuesta.Replace(',', '#');
                    }
                    FillTheGap fillTheGap = db.FillTheGaps.Find(pregunta.id);
                    if (pregunta.respuesta != null && fillTheGap.Respuestas.ToLower() == pregunta.respuesta.ToLower())
                    {
                        aciertos++;
                        acertada = true;
                    }
                    else
                    {
                        enunciado         = fillTheGap.Enunciado;
                        respuestaCorrecta = fillTheGap.Respuestas.Replace('#', ' ');
                        if (pregunta.respuesta != null)
                        {
                            respuestaSeleccionada = pregunta.respuesta.Replace('#', ' ');
                        }
                    }
                }
                if (pregunta.tipo == "TrueFalses")
                {
                    TrueFalse TrueFalse = db.TrueFalses.Find(pregunta.id);
                    if (pregunta.respuesta != null && TrueFalse.RespuestaCorrecta.ToString() == pregunta.respuesta)
                    {
                        aciertos++;
                        acertada = true;
                    }
                    else
                    {
                        enunciado             = TrueFalse.Enunciado;
                        respuestaCorrecta     = TrueFalse.RespuestaCorrecta.ToString();
                        respuestaSeleccionada = pregunta.respuesta;
                    }
                }
                if (pregunta.tipo == "AudioSentenceExercises")
                {
                    if (pregunta.respuesta != null)
                    {
                        pregunta.respuesta = pregunta.respuesta.Replace(',', '#');
                    }
                    AudioSentenceExercise audioSentence = db.AudioSentenceExercises.Find(pregunta.id);
                    if (pregunta.respuesta != null && audioSentence.Respuestas.ToLower() == pregunta.respuesta.ToLower())
                    {
                        aciertos++;
                        acertada = true;
                    }
                    else
                    {
                        enunciado         = audioSentence.Enunciado;
                        respuestaCorrecta = audioSentence.Respuestas.Replace('#', ' ');
                        if (pregunta.respuesta != null)
                        {
                            respuestaSeleccionada = pregunta.respuesta.Replace('#', ' ');
                        }
                    }
                }

                if (!acertada)
                {
                    RespuestaIncorrecta respuestaInc = new RespuestaIncorrecta();
                    respuestaInc.Pregunta              = enunciado;
                    respuestaInc.RespuestaCorrecta     = respuestaCorrecta;
                    respuestaInc.RespuestaSeleccionada = respuestaSeleccionada;
                    respuestaInc.Tipo       = pregunta.tipo;
                    respuestaInc.PreguntaId = pregunta.id;
                    respuestasIncorrectas.Add(respuestaInc);
                }
            }


            bool _aprobado = (aciertos >= 28);



            FinExamenTest resultado = new Models.FinExamenTest();

            resultado.Correctas          = aciertos;
            resultado.Aprobado           = _aprobado;
            resultado.Porcentaje         = (aciertos * 100 / totales);
            resultado.IdSiguienteLeccion = 0;
            resultado.SiguienteLeccion   = "";


            SubTema _subtemaActual = SubTemaDataAccess.ObtenerSubTemas(db).FirstOrDefault(s => s.SubTemaId == id);
            SubTema _siguienteTema = SubTemaDataAccess.ObtenerSubTemas(db).Where(s => s.TemaId == _subtemaActual.TemaId && s.Orden > _subtemaActual.Orden).OrderBy(s => s.Orden).FirstOrDefault();

            resultado.UltimoExamen = true;
            if (_siguienteTema != null)
            {
                resultado.UltimoExamen = false;
                if (_aprobado)
                {
                    resultado.IdSiguienteLeccion = _siguienteTema.SubTemaId;
                    resultado.SiguienteLeccion   = _siguienteTema.Descripcion;



                    var  BloquearSubtemas = ((ClaimsIdentity)User.Identity).FindFirst("BloquearSubtemas").Value;
                    bool anyadir          = true;
                    if (Convert.ToBoolean(BloquearSubtemas))
                    {
                        var listaSubtemasAcceso = db.SubTemaAccesoUsuarios.Where(sau => sau.AlumnoId == userId).Select(sau => sau.SubTemaId).ToList();
                        if (!listaSubtemasAcceso.Contains(_siguienteTema.SubTemaId))
                        {
                            anyadir = false;
                        }
                    }
                    if (anyadir)
                    {
                        SubTemaDesbloqueado _desbloqueado = new SubTemaDesbloqueado
                        {
                            AlumnoId        = userId,
                            FechaDesbloqueo = DateTime.Now,
                            SubTemaId       = _siguienteTema.SubTemaId
                        };
                        db.SubTemaDesbloqueados.Add(_desbloqueado);
                        db.SaveChanges();
                    }
                }
            }

            var    NombreUsuario = ((ClaimsIdentity)User.Identity).FindFirst("NombreUsuario").Value;
            Examen _examen       = new Examen
            {
                Aciertos     = aciertos,
                AlumnoId     = userId,
                NombreAlumno = NombreUsuario,
                Aprobado     = _aprobado,
                SubTemaId    = id,
                Fallos       = totales - aciertos,
                FechaExamen  = DateTime.Now,
                Total        = totales
            };

            _examen.RespuestasIncorrectas = respuestasIncorrectas;

            db.Examenes.Add(_examen);
            db.SaveChanges();

            return(Json(resultado, JsonRequestBehavior.AllowGet));
        }