コード例 #1
0
        public ActionResult ActividadesClase(string nombre)
        {
            var miCedula = (Int32)Session["cedula"];
            IRepositorio<ClaseEvaluacion> repositorioHorarioClase = new HorarioClaseRepositorio();
            var listCronograma = repositorioHorarioClase.GetAll().Where(alum => alum.Cedula == miCedula);

            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
            var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0);

            var misActClase = (from d in listCronograma
                               from c in listActividades
                               where c.Tipo.CompareTo("Clase") == 0 &&
                                     c.Periodo.CompareTo(_periodoActual) == 0 &&
                                     d.IdActividad == c.IdActividad
                               select c).ToList();
            IRepositorio<Materium> repositorioMateria = new MateriumRepositorio();
            foreach (var actividad in misActClase)
            {
                actividad.Materia = repositorioMateria.GetById(actividad.IdMateria);
            }
            if (String.IsNullOrEmpty(nombre) || String.IsNullOrWhiteSpace(nombre))
            {
                return View(misActClase.Where(actividad => actividad.Tipo.CompareTo("Clase") == 0 && actividad.HoraInicio.Date <= _fechaHoy.AddDays(_factor).Date && actividad.HoraInicio.Date >= _fechaHoy.Date).OrderBy(actividad => actividad.HoraInicio));
            }
            return View(misActClase.Where(actividad => actividad.Nombre.Contains(nombre)).OrderBy(actividad => actividad.HoraInicio));
        }
コード例 #2
0
 public ActionResult IndexProfesor()
 {
     var miCedula = (Int32)Session["cedula"];
     IRepositorio<Materium> repositorioMaterium = new MateriumRepositorio();
     IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
     var actividades = (from actividad in repositorioActividad.GetAll()
                        where actividad.Profesor == miCedula &&
                        actividad.Periodo == Helper.CalcularPeriodoActual() &&
                        actividad.Tipo.CompareTo("Clase") == 0
                        select actividad).ToList();
     var misAlumnos = new List<Alumno>();
     var misMaterias = new List<Materium>();
     IRepositorio<ClaseEvaluacion> repositorioClaseEvaluacion = new HorarioClaseRepositorio();
     var clase = repositorioClaseEvaluacion.GetAll();
     IRepositorio<Alumno> repositorioAlumno = new AlumnoRepositorio();
     foreach (var actividad in actividades)
     {
         foreach (var claseEvaluacion in clase)
         {
             if (claseEvaluacion.IdActividad == actividad.IdActividad)
             {
                 var alumno = repositorioAlumno.GetById(actividad.Cedula);
                 if (!misAlumnos.Contains(alumno))
                 {
                     misAlumnos.Add(alumno);
                 }
             }
         }
         var materia = repositorioMaterium.GetById(actividad.IdMateria);
         if (!misMaterias.Contains(materia))
         {
             misMaterias.Add(materia);
         }
     }
     IRepositorio<Profesor> repositorioProfesor = new ProfesorRepositorio();
     var miProfesor = repositorioProfesor.GetById(miCedula);
     miProfesor.Materiums = misMaterias;
     miProfesor.Alumnos = misAlumnos;
     return View(miProfesor);
 }
コード例 #3
0
        public ActionResult Register(Alumno alumno)
        {
            if (ModelState.IsValid)
            {
                if (alumno.Password == alumno.ConfirmPassword)
                {
                    IRepositorio<Profesor> repositorioProfesor = new ProfesorRepositorio();
                    var miProfesor = repositorioProfesor.GetByUniqueAtribute(alumno.Username);

                    IRepositorio<Alumno> repositorioAlumno = new AlumnoRepositorio();
                    var miAlumno = repositorioAlumno.GetByUniqueAtribute(alumno.Username);

                    if (miProfesor == null && miAlumno == null)
                    {
                        MembershipCreateStatus createStatus = MembershipService.CreateUser(alumno.Username,
                                                                                           alumno.Password,
                                                                                           alumno.CorreoUcab);

                        if (createStatus == MembershipCreateStatus.Success)
                        {
                            if (Roles.RoleExists("Estudiante"))
                            {
                                Roles.AddUserToRole(alumno.Username, "Estudiante");
                            }
                            else
                            {
                                Roles.CreateRole("Estudiante");
                                Roles.AddUserToRole(alumno.Username, "Estudiante");
                            }
                            alumno.CreationDate = DateTime.Today;
                            alumno.Sexo = alumno.Sexo == "Masculino" ? "M" : "F";
                            string resultado = repositorioAlumno.Save(alumno);

                            if (resultado.Equals("true"))
                            {
                                IRepositorio<ClaseEvaluacion> repositorioHorarioClase = new HorarioClaseRepositorio();
                                var listCronograma = repositorioHorarioClase.GetAll().Where(alum => alum.Cedula == alumno.Cedula).ToList();

                                IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
                                var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0).ToList();

                                var misMaterias = (from d in listCronograma
                                                   from c in listActividades
                                                   where c.Tipo.CompareTo("Clase") == 0 &&
                                                         d.IdActividad == c.IdActividad
                                                   select c.IdMateria).Distinct().ToList();

                                HorasPersonales(misMaterias, alumno);

                                Session["cedula"] = repositorioAlumno.GetByUniqueAtribute(alumno.Username).Cedula;
                                return RedirectToAction("Configuration", alumno);
                            }
                            else
                            {
                                ModelState.AddModelError("saveAlumno", "Oops! Ha ocurrido un error inesperado, vuelva a intentarlo.");
                            }
                        }
                        else
                        {
                            ModelState.AddModelError("passOrUsername", AccountValidation.ErrorCodeToString(createStatus));
                        }
                    }
                    else
                    {
                        ModelState.AddModelError("passOrUsername", "Oops!! El nombre de usuario ya existe, por favor intente con otro.");
                    }
                }
                else
                {
                    ModelState.AddModelError("contrasenia", "Las contraseñas no coinciden.");
                }

            }
            return View(alumno);
        }
コード例 #4
0
        public ActionResult LogOn(LogOnModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                if (MembershipService.ValidateUser(model.UserName, model.Password))
                {
                    FormsService.SignIn(model.UserName, model.RememberMe);
                    var roleEstudiante = Roles.GetUsersInRole("Estudiante");
                    bool flag = false;
                    foreach (var rol in roleEstudiante)
                    {
                        if (rol.CompareTo(model.UserName) == 0)
                        {
                            flag = true;
                        }
                    }
                    if (flag)
                    {
                        IRepositorio<Alumno> repoAlumno = new AlumnoRepositorio();
                        var miAlumno = repoAlumno.GetByUniqueAtribute(model.UserName);
                        if (miAlumno != null)
                        {
                            Session["cedula"] = miAlumno.Cedula;

                            /*
                             * Si no tengo actividades de clase
                             * invoco al trigger de Alumno
                             */
                            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
                            var misActividades = new List<Actividad>();

                            IRepositorio<ClaseEvaluacion> repositorioClaseE = new HorarioClaseRepositorio();
                            var listClaseEvaluacion = repositorioClaseE.GetAll().Where(cE => cE.Cedula == miAlumno.Cedula).ToList();

                            foreach (var claseEvaluacion in listClaseEvaluacion)
                            {
                                var actividad = repositorioActividad.GetById(claseEvaluacion.IdActividad);
                                if (actividad.Tipo.CompareTo("Clase") == 0 &&
                                    actividad.Periodo.CompareTo((_periodoActual)) == 0)
                                {
                                    misActividades.Add(actividad);
                                }
                            }
                            if (misActividades.Count == 0)
                            {
                                repoAlumno.Update(miAlumno);
                            }
                            /*
                             * Si no tengo actividades inteligentes
                             * en el periodo actual, se calculan
                             */
                            var actInteligentes =
                                repositorioActividad.GetAll().Where(a => a.Cedula == miAlumno.Cedula &&
                                                                         a.Tipo.CompareTo("Inteligente") == 0 &&
                                                                         a.Periodo.CompareTo(_periodoActual) == 0).ToList();
                            if (actInteligentes.Count() == 0)
                            {
                                IRepositorio<ClaseEvaluacion> repositorioHorarioClase = new HorarioClaseRepositorio();
                                var listCronograma = repositorioHorarioClase.GetAll().Where(alum => alum.Cedula == miAlumno.Cedula);

                                var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0);

                                var misMaterias = (from d in listCronograma
                                                   from c in listActividades
                                                   where c.Tipo.CompareTo("Clase") == 0 &&
                                                         d.IdActividad == c.IdActividad
                                                   select c.IdMateria).Distinct();

                                var misEvaluaciones = (from d in listCronograma
                                                       from c in listActividades
                                                       where c.Tipo.CompareTo("Evaluacion") == 0 &&
                                                             d.IdActividad == c.IdActividad
                                                       select c).ToList();

                                HorasPersonales(misMaterias, miAlumno);

                                IRepositorio<Materium> repositorioMateria = new MateriumRepositorio();
                                IRepositorio<AlumnoMaterium> repositorioAlumnoMat = new AlumnoMateriumRepositorio();
                                IRepositorio<PromedioFactor> repositorioPromedioFactor = new PromedioFactorRepositorio();
                                IList<PromedioFactor> listPromedioFactor = repositorioPromedioFactor.GetAll();

                                var mayorCredito = (from mat in repositorioMateria.GetAll()
                                                    select mat.Creditos).Max();

                                foreach (var miMateria in misMaterias)
                                {
                                    var alumnoMateria =
                                        repositorioAlumnoMat.GetAll().Where(aM => aM.IdMateria == miMateria &&
                                                                                  aM.Cedula == miAlumno.Cedula).First();
                                    if (alumnoMateria.Preferencia != 0.00)
                                    {
                                        var promedio = (from prom in listPromedioFactor
                                                        where prom.IdMateria == miMateria &&
                                                              prom.Factor.CompareTo("Promedio") == 0
                                                        select prom.Promedio).First();

                                        var porcentajeProm = (double)(((20 - promedio) * 100) / 20);

                                        var materia = repositorioMateria.GetById(miMateria);

                                        var uc = materia.Creditos;

                                        var porcentajeUC = (uc * 100) / mayorCredito;

                                        var porcentajePref = (alumnoMateria.Preferencia * 100) / 5.0;

                                        alumnoMateria.Prioridad = (porcentajePref + porcentajeProm + porcentajeUC) / 3;
                                    }
                                    else
                                    {
                                        var promedio = (from prom in listPromedioFactor
                                                        where prom.IdMateria == miMateria &&
                                                              prom.Factor.CompareTo("Promedio") == 0
                                                        select prom.Promedio).First();

                                        var porcentajeProm = (double)(((20 - promedio) * 100) / 20);

                                        var materia = repositorioMateria.GetById(miMateria);

                                        var uc = materia.Creditos;

                                        var porcentajeUC = (uc * 100) / mayorCredito;

                                        alumnoMateria.Prioridad = (porcentajeProm + porcentajeUC) / 2;
                                    }

                                    //Se toma en cuenta las notas obtenidas en las evaluaciones
                                    foreach (var miEvaluacion in misEvaluaciones)
                                    {
                                        var miNota = (from cE in listCronograma
                                                      where cE.IdActividad == miEvaluacion.IdActividad
                                                      select cE.Nota).First();
                                        if (miNota != 0.0)
                                        {
                                            const int x1 = 10;
                                            const int y1 = 0;
                                            const int x2 = 20;
                                            var y2 = -alumnoMateria.Prioridad * (miEvaluacion.Ponderacion / 100.00);
                                            var pendiente1 = (y2 - y1) / (x2 - x1);
                                            var factorM = (miNota * pendiente1) - y2;
                                            alumnoMateria.Prioridad += factorM;
                                        }
                                    }

                                    repositorioAlumnoMat.Update(alumnoMateria);
                                }
                                ActividadesInteligentes(miAlumno.Cedula);
                            }
                            if (!String.IsNullOrEmpty(returnUrl))
                            {
                                return Redirect(returnUrl);
                            }
                            return RedirectToAction("Index", "Home");
                        }
                    }
                    else
                    {
                        var roleProfesor = Roles.GetUsersInRole("Profesor");
                        flag = false;
                        foreach (var rol in roleProfesor)
                        {
                            if (rol.CompareTo(model.UserName) == 0)
                            {
                                flag = true;
                            }
                        }
                        if (flag)
                        {
                            IRepositorio<Profesor> repoProfesor = new ProfesorRepositorio();
                            var miProfesor = repoProfesor.GetByUniqueAtribute(model.UserName);
                            if (miProfesor != null)
                            {
                                Session["cedula"] = miProfesor.Cedula;
                                repoProfesor.Update(miProfesor);
                                if (!String.IsNullOrEmpty(returnUrl))
                                {
                                    return Redirect(returnUrl);
                                }
                                return RedirectToAction("IndexProfesor", "Home");
                            }
                        }
                    }
                }
                ModelState.AddModelError("NCIncorrecto", "El nombre de usuario o la contraseña especificados son incorrectos.");
            }
            // Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
            return View(model);
        }
コード例 #5
0
        public ActionResult ConfigurationEstudiante()
        {
            IRepositorio<Alumno> repositorioAlumno = new AlumnoRepositorio();
            int cedula = (int)Session["cedula"];
            Alumno alumno = repositorioAlumno.GetById(cedula);
            IRepositorio<Materium> repositorioMaterium = new MateriumRepositorio();

            IRepositorio<ClaseEvaluacion> repositorioHorarioClase = new HorarioClaseRepositorio();
            var listCronograma = repositorioHorarioClase.GetAll().Where(a => a.Cedula == alumno.Cedula);

            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
            var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0);

            var misMaterias = (from d in listCronograma
                               from c in listActividades
                               where c.Tipo.CompareTo("Clase") == 0 &&
                                     d.IdActividad == c.IdActividad
                               select c.IdMateria).Distinct();

            alumno.Materiums = new List<Materium>();

            IRepositorio<HorarioPreferencia> repositorioHorarioPreferencia = new HorarioPreferenciaRepositorio();
            var listHorariosPreferencia = repositorioHorarioPreferencia.GetAll().Where(horario => horario.Cedula == alumno.Cedula).ToList();
            alumno.HorarioPreferencia = listHorariosPreferencia;

            IRepositorio<AlumnoMaterium> repositorioAlumnoMat = new AlumnoMateriumRepositorio();
            foreach (var materia in misMaterias)
            {
                var mat = repositorioMaterium.GetById(materia);
                mat.Preferencia = repositorioAlumnoMat.GetAll().Where(aM => aM.Cedula == cedula &&
                                                                            aM.IdMateria == mat.IdMateria).First().Preferencia;
                alumno.Materiums.Add(mat);
            }

            return View("Configuration", alumno);
        }
コード例 #6
0
        public ActionResult Configuration(Alumno alumno, FormCollection form)
        {
            int cont = 0;
            IRepositorio<AlumnoMaterium> repositorioAlumnoMateria = new AlumnoMateriumRepositorio();
            IList<AlumnoMaterium> listAlumnoMateria = repositorioAlumnoMateria.GetAll();

            IRepositorio<PromedioFactor> repositorioPromedioFactor = new PromedioFactorRepositorio();
            IList<PromedioFactor> listPromedioFactor = repositorioPromedioFactor.GetAll();

            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();

            IRepositorio<Materium> repositorioMaterium = new MateriumRepositorio();
            IList<Materium> listMaterium = repositorioMaterium.GetAll();

            IRepositorio<HorarioPreferencia> repositorioHorarioPreferencia = new HorarioPreferenciaRepositorio();

            IRepositorio<ClaseEvaluacion> repositorioHorarioClase = new HorarioClaseRepositorio();
            var listCronograma = repositorioHorarioClase.GetAll().Where(alum => alum.Cedula == alumno.Cedula);

            var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0);

            var misMaterias = (from d in listCronograma
                               from c in listActividades
                               where c.Tipo.CompareTo("Clase") == 0 &&
                                     d.IdActividad == c.IdActividad
                               select c.IdMateria).Distinct();

            var misEvaluaciones = (from d in listCronograma
                                   from c in listActividades
                                   where c.Tipo.CompareTo("Evaluacion") == 0 &&
                                         d.IdActividad == c.IdActividad
                                   select c).ToList();

            var mayorCredito = (from mat in listMaterium
                                select mat.Creditos).Max();

            alumno.Materiums = new List<Materium>();
            foreach (var materia in misMaterias)
            {
                Materium mat = repositorioMaterium.GetById(materia);
                alumno.Materiums.Add(mat);
            }
            var strings = form.GetValues("selrate");
            if (strings != null)
            {
                if ((alumno.Materiums.Count + 15) == strings.Count())
                {
                    int contador = 0;
                    int sum = 0;
                    foreach (var value in strings)
                    {
                        if (contador > 14)
                        {
                            var alumnoMateria = (from mat in listAlumnoMateria
                                                 where mat.IdMateria == alumno.Materiums.ElementAt(cont).IdMateria &&
                                                       mat.Cedula == alumno.Cedula
                                                 select mat).First();
                            alumnoMateria.Preferencia = Convert.ToInt32(value);
                            var porcentajePref = (alumnoMateria.Preferencia * 100) / 5.0;

                            var promedio = (from prom in listPromedioFactor
                                            where
                                                prom.IdMateria == alumno.Materiums.ElementAt(cont).IdMateria &&
                                                prom.Factor.CompareTo("Promedio") == 0
                                            select prom.Promedio).First();

                            var porcentajeProm = (double)(((20 - promedio) * 100) / 20);

                            var uc = alumno.Materiums.ElementAt(cont).Creditos;

                            var porcentajeUC = (uc * 100) / mayorCredito;

                            alumnoMateria.Prioridad = (porcentajePref + porcentajeProm + porcentajeUC) / 3;

                            //Se toma en cuenta las notas obtenidas en las evaluaciones
                            foreach (var miEvaluacion in misEvaluaciones)
                            {
                                var miNota = (from cE in listCronograma
                                              where cE.IdActividad == miEvaluacion.IdActividad
                                              select cE.Nota).First();
                                if (miNota != 0.0)
                                {
                                    const int x1 = 10;
                                    const int y1 = 0;
                                    const int x2 = 20;
                                    var y2 = -alumnoMateria.Prioridad * (miEvaluacion.Ponderacion / 100.00);
                                    var pendiente1 = (y2 - y1) / (x2 - x1);
                                    var factorM = (miNota * pendiente1) - y2;
                                    alumnoMateria.Prioridad += factorM;
                                }
                            }

                            repositorioAlumnoMateria.Update(alumnoMateria);

                            cont++;
                        }
                        else
                        {
                            int hora = contador + 7;
                            var horaIni = new DateTime(2012, 01, 01, hora, 0, 0);
                            var horaFin = new DateTime(2012, 01, 01, hora + 1, 0, 0);

                            var listHorarioPref = repositorioHorarioPreferencia.GetAll();
                            var horarioPreferencia = (from hp in listHorarioPref
                                                      where hp.Cedula == alumno.Cedula &
                                                            hp.HoraInicio.CompareTo(horaIni) == 0 &
                                                            hp.HoraFin.CompareTo(horaFin) == 0 &
                                                            hp.Tipo.CompareTo("Personal") == 0
                                                      select hp);

                            int valor = Convert.ToInt32(value);

                            if (horarioPreferencia.Count() != 0)
                            {
                                var horarioPref = horarioPreferencia.First();
                                var diferenciaPref = valor - horarioPref.Preferencia;
                                horarioPref.Preferencia = valor;
                                repositorioHorarioPreferencia.Update(horarioPref);
                                var horarioPreferenciaDef = (from hp in listHorarioPref
                                                             where hp.Cedula == alumno.Cedula &
                                                                   hp.HoraInicio.CompareTo(horaIni) == 0 &
                                                                   hp.HoraFin.CompareTo(horaFin) == 0 &
                                                                   hp.Tipo.CompareTo("Definitivo") == 0
                                                             select hp).First();
                                horarioPreferenciaDef.Preferencia += diferenciaPref;
                                repositorioHorarioPreferencia.Update(horarioPreferenciaDef);
                            }
                            else
                            {
                                var horarioPref = new HorarioPreferencia
                                                        {
                                                            Cedula = alumno.Cedula,
                                                            HoraFin = horaFin,
                                                            HoraInicio = horaIni,
                                                            Preferencia = valor,
                                                            Tipo = "Personal"
                                                        };
                                repositorioHorarioPreferencia.Save(horarioPref);

                                /*OJO: Definir los parametros que influyan en este valor*/
                                int valorDefinitivo = valor;

                                horarioPref.Tipo = "Definitivo";
                                horarioPref.Preferencia = valorDefinitivo;
                                repositorioHorarioPreferencia.Save(horarioPref);
                            }
                        }
                        contador++;
                    }
                    FormsService.SignIn(alumno.Username, false /* createPersistentCookie */);
                }
                else
                {
                    ModelState.AddModelError("preferencias", "Todos las preferencias son requeridas.");
                    return View(alumno);
                }

                //Elimino todas las actividades inteligentes luego de hoy y resto las horas acumuladas
                var misActividadesIEliminar = repositorioActividad.GetAll().Where(a => a.Cedula == alumno.Cedula &&
                                                                               a.Tipo.CompareTo("Inteligente") == 0 &&
                                                                               a.HoraInicio >= DateTime.Now).ToList();
                foreach (var materia in misMaterias)
                {
                    double cantHoras = 0;
                    foreach (var actividad in misActividadesIEliminar)
                    {
                        if (actividad.IdMateria == materia)
                        {
                            cantHoras += (actividad.HoraFin.Hour + actividad.HoraFin.Minute / 60.00 + actividad.HoraFin.Second / 3600.00) -
                                         (actividad.HoraInicio.Hour + actividad.HoraInicio.Minute / 60.00 + actividad.HoraFin.Second / 3600.00);
                            repositorioActividad.Delete(actividad);
                        }
                    }
                    var mat = repositorioAlumnoMateria.GetAll().Where(aM => aM.IdMateria == materia &&
                                                                            aM.Cedula == alumno.Cedula).First();
                    mat.HorasAcumuladas -= cantHoras;
                    repositorioAlumnoMateria.Update(mat);
                }

                ActividadesInteligentes(alumno.Cedula);
            }
            else
            {
                ModelState.AddModelError("preferencias", "Todos las preferencias son requeridas.");
                return View(alumno);
            }
            return RedirectToAction("Index", "Home");
        }
コード例 #7
0
        private void LeerCronogramas(Materium materia)
        {
            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
            var miCedula = (Int32)Session["cedula"];
            var wordApplication = new Microsoft.Office.Interop.Word.Application { Visible = false };
            var nameAndLocation = "~/UploadedFiles/" + Path.GetFileName(materia.File.FileName);
            materia.File.SaveAs(Server.MapPath(nameAndLocation));

            object filePath = Server.MapPath(nameAndLocation);

            object missing = Missing.Value;
            object readOnly = false;
            object isVisible = false;
            Document reportDoc = wordApplication.Documents.Open(
                ref filePath,
                ref missing,
                readOnly,
                ref missing,
                ref missing,
                ref missing,
                ref missing,
                ref missing,
                ref missing,
                ref missing,
                ref missing,
                ref isVisible);

            IRepositorio<ClaseEvaluacion> repositorioClaseEvaluacion = new HorarioClaseRepositorio();
            var listActividad = repositorioActividad.GetAll().Where(a => a.Tipo.CompareTo("Clase") == 0).ToList();
            var listActividades = (from a in listActividad
                                   where a.Periodo.CompareTo(_periodoActual) == 0 &&
                                         a.Seccion.CompareTo(materia.Seccion) == 0 &&
                                         a.Profesor == miCedula
                                   select a).ToList();

            reportDoc.Activate();
            for (int j = 1; j <= reportDoc.Tables.Count; j++)
            {
                Table tbl = reportDoc.Tables[j];
                if (tbl.Rows[1].Cells[1].Range.Text.Contains("Actividad Evaluativa") &&
                    tbl.Rows[1].Cells[2].Range.Text.Contains("Porcentaje") &&
                    tbl.Rows[1].Cells[3].Range.Text.Contains("Fecha"))
                {
                    for (int i = 2; i <= tbl.Rows.Count; i++)
                    {
                        var actividadEvaluativa = tbl.Rows[i].Cells[1].Range.Text;
                        var porcentaje = tbl.Rows[i].Cells[2].Range.Text;
                        var fecha = tbl.Rows[i].Cells[3].Range.Text;
                        var f = Convert.ToDateTime(fecha.Substring(0, fecha.Length - 2));
                        var actividad = new Actividad
                        {
                            Nombre = actividadEvaluativa.Substring(0, actividadEvaluativa.Length - 2),
                            IdMateria = materia.IdMateria,
                            Periodo = _periodoActual,
                            Ponderacion = Convert.ToInt32(porcentaje.Substring(0, porcentaje.Length - 2)),
                            Profesor = miCedula,
                            Seccion = materia.Seccion,
                            Tipo = "Evaluacion"
                        };
                        var act = (from a in listActividad
                                   where a.Periodo.CompareTo(_periodoActual) == 0 &
                                         a.HoraFin.Date.CompareTo(f.Date) == 0 &
                                         a.IdMateria == materia.IdMateria &&
                                         a.Profesor == miCedula
                                   select a).ToList();
                        if (act.Count() != 0)
                        {
                            var acti = act.First();
                            actividad.HoraInicio = acti.HoraInicio;
                            actividad.HoraFin = acti.HoraFin;
                        }
                        else
                        {
                            actividad.HoraInicio = new DateTime(f.Year, f.Month, f.Day, 7, 0, 0);
                            actividad.HoraFin = new DateTime(f.Year, f.Month, f.Day, 9, 0, 0);
                        }
                        repositorioActividad.Save(actividad);

                        if (listActividades.Count() > 0)
                        {
                            var alumnosInscritos =
                                repositorioClaseEvaluacion.GetAll().Where(
                                    cE => cE.IdActividad == listActividades.First().IdActividad).ToList();

                            foreach (var alumnosInscrito in alumnosInscritos)
                            {
                                var claseEvaluacion = new ClaseEvaluacion
                                                          {
                                                              Cedula = alumnosInscrito.Cedula,
                                                              IdActividad = actividad.IdActividad
                                                          };
                                repositorioClaseEvaluacion.Save(claseEvaluacion);
                            }
                        }
                    }
                }
            }
            reportDoc.Close();
            wordApplication.Quit();
        }
コード例 #8
0
        private void HorasPersonales(IEnumerable<int?> misMaterias, Alumno alumno)
        {
            var miEdad = (int)((_fechaActual - alumno.FechaNac).Days / 365.25);

            IRepositorio<DatosSociales> repositorioDatosSociales = new DatosSocialesRepositorio();
            var misDatosSociales =
                repositorioDatosSociales.GetByUniqueAtribute(alumno.Cedula.ToString());

            IRepositorio<PromedioFactor> repositorioPromedioFactor = new PromedioFactorRepositorio();
            var promedioFactor = repositorioPromedioFactor.GetAll();

            IRepositorio<Materium> repositorioMaterium = new MateriumRepositorio();
            // Se obtienen las horas base y se customiza segun los parametros del estudiante.
            foreach (int idMateria in misMaterias)
            {
                double horasBase = repositorioMaterium.GetById(idMateria).HorasBase;

                double promHistorico = 0;
                decimal nota = 0;
                int cantPersonalizacion = 0;

                // Personaliza segun la edad
                var fEdad = (from factor in promedioFactor
                             where factor.Factor.CompareTo("Edad") == 0 &&
                                   factor.Clasificacion.CompareTo(miEdad.ToString()) == 0 &&
                                   factor.IdMateria == idMateria
                             select factor);
                if (fEdad.Count() > 0)
                {
                    cantPersonalizacion++;
                    nota = fEdad.First().Promedio;
                    promHistorico = promHistorico + (double)nota;
                }

                //Personaliza segun Trabajo
                cantPersonalizacion++;
                if (misDatosSociales.Trabaja.CompareTo("Si") == 0)
                {
                    nota = (from factor in promedioFactor
                            where factor.Factor.CompareTo("Trabajo") == 0 &&
                                  factor.Clasificacion.CompareTo(misDatosSociales.RelacionTrabCarr) == 0 &&
                                  factor.IdMateria == idMateria
                            select factor.Promedio).First();
                }
                else
                {
                    nota = (from factor in promedioFactor
                            where factor.Factor.CompareTo("Trabajo") == 0 &&
                                  factor.Clasificacion.CompareTo("No Trabaja") == 0 &&
                                  factor.IdMateria == idMateria
                            select factor.Promedio).First();
                }
                promHistorico = promHistorico + Convert.ToDouble(nota);

                //Personaliza segun la materia
                cantPersonalizacion++;
                nota = (from factor in promedioFactor
                        where factor.Factor.CompareTo("Promedio") == 0 &&
                              factor.IdMateria == idMateria
                        select factor.Promedio).First();
                promHistorico = promHistorico + Convert.ToDouble(nota);

                //Personaliza segun el record de las materias que prelan esta materia
                IRepositorio<Requisito> repositorioRequisito = new RequisitoRepositorio();
                var misRequisitos = (from r in repositorioRequisito.GetAll()
                                     where r.IdMateriaHijo == idMateria
                                     select r.IdMateriaPadre).ToList();

                var prom = 0.0;
                if (misRequisitos.Count > 0)
                {
                    IRepositorio<SlRecordAcademico> repositorioSlRecord = new SlRecordAcademicoRepositorio();
                    IRepositorio<SlSeccion> repositorioSlSeccion = new SlSeccionRepositorio();
                    IRepositorio<SlMaterium> repositorioSlMateria = new SlMateriumRepositorio();
                    var anioPerdiodo = Convert.ToInt32(_periodoActual.Substring(0, 4));
                    var periodo = Convert.ToInt32(_periodoActual.Substring(4));
                    if (periodo > 21)
                    {
                        periodo--;
                    }
                    else
                    {
                        anioPerdiodo--;
                    }
                    var periodoAnterior = Convert.ToInt32(anioPerdiodo.ToString() + periodo.ToString());
                    var sum = 0;
                    foreach (var requisito in misRequisitos)
                    {
                        var materia = repositorioMaterium.GetById(requisito);
                        var slMateria = repositorioSlMateria.GetAll().Where(m => m.Nombre.CompareTo(materia.Nombre) == 0).First();
                        var slSeccion = repositorioSlSeccion.GetAll().Where(s => s.IdMateria == slMateria.IdMateria &&
                                                                                 s.Periodo.CompareTo(periodoAnterior) == 0).ToList();
                        var n = (from record in repositorioSlRecord.GetAll()
                                 from seccion in slSeccion
                                 where record.Cedula == alumno.Cedula &&
                                       record.IdSeccion == seccion.IdSeccion
                                 select record.Nota);
                        if (n.Count() > 0)
                        {
                            sum++;
                            prom += Convert.ToDouble(n.First());
                        }
                    }
                    if (prom > 0.0)
                    {
                        cantPersonalizacion++;
                        promHistorico += (prom / sum);
                    }
                }

                promHistorico = promHistorico / cantPersonalizacion;

                /*
                 * Segun el promedio obtenido segun las caracteristicas
                 * personales del alumno se le aumentan o disminuyen las
                 * horas de estudio segun una regla.
                 */
                const double pendiente = -0.075;
                var factorM = (promHistorico * pendiente) + 1.75;
                var horasPersonalizadas = horasBase * factorM;

                var misHorasPersonales = new AlumnoMaterium()
                {
                    IdMateria = idMateria,
                    Cedula = alumno.Cedula,
                    HorasPersonales = horasPersonalizadas
                };

                //Segun las notas obtenidas en las evaluaciones anteriores se afecta las horas personales
                IRepositorio<ClaseEvaluacion> repositorioHorarioClase = new HorarioClaseRepositorio();
                var listCronograma = repositorioHorarioClase.GetAll().Where(alum => alum.Cedula == alumno.Cedula).ToList();

                IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
                var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0).ToList();

                var misEvaluaciones = (from d in listCronograma
                                       from c in listActividades
                                       where c.Tipo.CompareTo("Evaluacion") == 0 &&
                                             d.IdActividad == c.IdActividad
                                       select c).ToList();

                foreach (var miEvaluacion in misEvaluaciones)
                {
                    var miNota = (from cE in listCronograma
                                  where cE.IdActividad == miEvaluacion.IdActividad
                                  select cE.Nota).First();
                    if (miNota != 0.0)
                    {
                        const int x1 = 10;
                        const int y1 = 0;
                        const int x2 = 20;
                        var y2 = (misHorasPersonales.HorasPersonales * (miEvaluacion.Ponderacion / 100.00)) * -1;
                        var pendiente1 = (y2 - y1) / (x2 - x1);
                        var factorMat = (miNota * pendiente1) - y2;
                        misHorasPersonales.HorasPersonales += factorMat;
                    }
                }

                if (prom > 0.00)
                {
                    if (prom < 4)
                    {
                        misHorasPersonales.Preferencia = 5;
                    }
                    else if (prom < 8)
                    {
                        misHorasPersonales.Preferencia = 4;
                    }
                    else if (prom < 12)
                    {
                        misHorasPersonales.Preferencia = 3;
                    }
                    else if (prom < 16)
                    {
                        misHorasPersonales.Preferencia = 2;
                    }
                    else if (prom <= 20)
                    {
                        misHorasPersonales.Preferencia = 1;
                    }
                }
                IRepositorio<AlumnoMaterium> repositorioAlumnoMateria = new AlumnoMateriumRepositorio();
                repositorioAlumnoMateria.Update(misHorasPersonales);
            }
        }
コード例 #9
0
        private void GuardarActMejorHorario(DateTime miFecha, AlumnoMaterium alumnoMaterium, int diasEstudio)
        {
            var periodoActual = Helper.CalcularPeriodoActual();
            IRepositorio<HorarioPreferencia> repositorioHorarioPreferencia = new HorarioPreferenciaRepositorio();
            IRepositorio<AlumnoMaterium> repositorioAlumnoMateria = new AlumnoMateriumRepositorio();

            IRepositorio<Materium> repositorioMaterium = new MateriumRepositorio();
            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();

            IRepositorio<ClaseEvaluacion> repositorioClaseEvaluacion = new HorarioClaseRepositorio();
            var listMisClasesEvaluacion = repositorioClaseEvaluacion.GetAll().Where(cE => cE.Cedula == alumnoMaterium.Cedula).ToList();

            var misActividades = (from a in repositorioActividad.GetAll()
                                  where a.Cedula == alumnoMaterium.Cedula
                                  select a).ToList();

            misActividades.AddRange(listMisClasesEvaluacion.Select(claseEvaluacion => repositorioActividad.GetById(claseEvaluacion.IdActividad)));

            var horarioDisponible = repositorioHorarioPreferencia.GetAll().
                        Where(hp => hp.Cedula == alumnoMaterium.Cedula &
                                    hp.Tipo.CompareTo("Definitivo") == 0).ToList();

            var miHorarioOcupado = (from a in misActividades
                                    where a.Cedula == alumnoMaterium.Cedula &
                                          a.HoraInicio.Date == miFecha.Date
                                    select a).ToList();

            foreach (var claseEvaluacion in listMisClasesEvaluacion)
            {
                var miActClase = repositorioActividad.GetById(claseEvaluacion.IdActividad);
                if (miActClase.HoraInicio.Date == miFecha.Date)
                {
                    miHorarioOcupado.Add(miActClase);
                }
            }

            //Elimino las horas ocupadas de HOY en el arreglo de disponibles
            foreach (var actividad in miHorarioOcupado)
            {
                DateTime horaFin = actividad.HoraFin.Minute > 0 ? actividad.HoraFin.AddHours(1) : actividad.HoraFin;
                for (int i = actividad.HoraInicio.Hour; i < horaFin.Hour; i++)
                {
                    var horaOcupada = (from hora in horarioDisponible
                                       where hora.HoraInicio.Hour == i
                                       select hora);
                    if (horaOcupada.Count() != 0)
                    {
                        horarioDisponible.Remove(horaOcupada.First());
                    }
                }
            }

            //Ordeno las horas disponibles segun su prioridad
            var miHorarioDisponible = (from horario in horarioDisponible
                                       orderby horario.Preferencia descending
                                       select horario).ToList();

            //Actualizo para c/hora disponible la fecha que voy a calendarizar
            foreach (var horarioPreferencia in miHorarioDisponible)
            {
                int horaIni = horarioPreferencia.HoraInicio.Hour;
                int horaFin = horarioPreferencia.HoraFin.Hour;
                horarioPreferencia.HoraInicio = new DateTime(miFecha.Year, miFecha.Month, miFecha.Day, horaIni, 0, 0);
                horarioPreferencia.HoraFin = new DateTime(miFecha.Year, miFecha.Month, miFecha.Day, horaFin, 0, 0);
            }

            //Calculo cuantas horas se calendarizaran
            var horaDiaria = Math.Ceiling(alumnoMaterium.HorasPersonales / diasEstudio);
            var horaDiariaReal = alumnoMaterium.HorasPersonales / diasEstudio;
            //Busco el mejor horario para calendarizar la actividad
            bool flag2;
            HorarioPreferencia preferenciaAux;
            double mayorPrioridad = 0;
            do
            {
                mayorPrioridad = miHorarioDisponible[0].Preferencia;
                var mayorPreferencia = new HorarioPreferencia();
                preferenciaAux = new HorarioPreferencia { MayorPreferencia = 0 };
                foreach (var horarioD in miHorarioDisponible)
                {
                    if (horarioD.Preferencia.CompareTo(mayorPrioridad) == 0)
                    {
                        mayorPreferencia.Cedula = horarioD.Cedula;
                        mayorPreferencia.HoraInicio = horarioD.HoraInicio;
                        mayorPreferencia.HoraFin = horarioD.HoraFin;
                        mayorPreferencia.Preferencia = horarioD.Preferencia;
                        mayorPreferencia.Tipo = horarioD.Tipo;
                        mayorPreferencia.IdPreferencia = horarioD.IdPreferencia;
                        mayorPreferencia.MayorPreferencia = horarioD.Preferencia;
                        for (int i = 1; i < horaDiaria; i++)
                        {
                            var horaBuscada = (from h in horarioDisponible
                                               where
                                                   h.HoraInicio.CompareTo(horarioD.HoraInicio.AddHours(i)) == 0
                                               select h);
                            if (horaBuscada.Count() != 0)
                            {
                                mayorPreferencia.MayorPreferencia += horaBuscada.First().Preferencia;
                            }
                            else
                            {
                                mayorPreferencia = new HorarioPreferencia();
                                break;
                            }
                        }
                        if (mayorPreferencia.Cedula != 0)
                        {
                            if (mayorPreferencia.MayorPreferencia > preferenciaAux.MayorPreferencia)
                            {
                                preferenciaAux.Cedula = mayorPreferencia.Cedula;
                                preferenciaAux.HoraInicio = mayorPreferencia.HoraInicio;
                                preferenciaAux.HoraFin = mayorPreferencia.HoraFin;
                                preferenciaAux.Preferencia = mayorPreferencia.Preferencia;
                                preferenciaAux.Tipo = mayorPreferencia.Tipo;
                                preferenciaAux.IdPreferencia = mayorPreferencia.IdPreferencia;
                                preferenciaAux.MayorPreferencia = mayorPreferencia.MayorPreferencia;
                            }
                        }
                    }
                }
                if (preferenciaAux.Cedula == 0)
                {
                    flag2 = true;
                    miHorarioDisponible.RemoveAt(0);
                }
                else
                {
                    flag2 = false;
                }
            } while (flag2 && miHorarioDisponible.Count != 0);

            //Si hay horario disponible se calendariza la actividad
            if (miHorarioDisponible.Count != 0)
            {
                var act = new Actividad
                {
                    HoraInicio = preferenciaAux.HoraInicio,
                    HoraFin = preferenciaAux.HoraInicio.AddHours(horaDiariaReal),
                    IdMateria = alumnoMaterium.IdMateria,
                    Nombre =
                        "Estudiar " +
                        repositorioMaterium.GetById(alumnoMaterium.IdMateria).Nombre,
                    Tipo = "Inteligente",
                    Periodo = periodoActual,
                    Cedula = alumnoMaterium.Cedula
                };
                repositorioActividad.Save(act);
                alumnoMaterium.HorasAcumuladas += horaDiariaReal;
                repositorioAlumnoMateria.Update(alumnoMaterium);
            }
        }
コード例 #10
0
        private void Calendarizar(AlumnoMaterium alumnoMaterium, int diasEstudio)
        {
            var periodoActual = Helper.CalcularPeriodoActual();
            var fechaActual = DateTime.Now;
            IRepositorio<Materium> repositorioMaterium = new MateriumRepositorio();
            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
            IList<Actividad> listActividades = repositorioActividad.GetAll();

            IRepositorio<ClaseEvaluacion> repositorioClaseEvaluacion = new HorarioClaseRepositorio();
            var listMisClasesEvaluacion = repositorioClaseEvaluacion.GetAll().Where(cE => cE.Cedula == alumnoMaterium.Cedula).ToList();

            IRepositorio<SlMaterium> repositorioSlMateria = new SlMateriumRepositorio();
            IRepositorio<SlSeccion> repositorioSlSeccion = new SlSeccionRepositorio();

            var fechaIniSemestre = (from seccion in repositorioSlSeccion.GetAll()
                                        .Where(
                                            sec =>
                                            sec.IdMateria ==
                                            repositorioSlMateria.GetAll().Where(
                                                mat =>
                                                mat.Nombre.CompareTo(
                                                    repositorioMaterium.GetById(alumnoMaterium.IdMateria).Nombre) == 0).First()
                                                .IdMateria)
                                    where seccion.Periodo.CompareTo(Convert.ToInt32(periodoActual)) == 0
                                    select seccion.InicioSem).First();

            bool flag = true;
            //if (_fechaActual < fechaIniSemestre.AddDays(5))
            //{

            //    var misActividadesFechaActual = new List<Actividad>();
            //    foreach (var claseEvaluacion in listMisClasesEvaluacion)
            //    {
            //        var miActClase = repositorioActividad.GetById(claseEvaluacion.IdActividad);
            //        if (miActClase.Tipo.CompareTo("Clase") == 0 &&
            //            miActClase.HoraInicio.Date < _fechaActual.Date &&
            //            miActClase.IdMateria == alumnoMaterium.IdMateria)
            //        {
            //            misActividadesFechaActual.Add(miActClase);
            //        }
            //    }

            //    if (misActividadesFechaActual.Count > 0)
            //    {
            //        flag = false;
            //    }
            //}
            if (flag)
            {
                //OJO: VACACIONES
                var semanasRestantes = (16 - Math.Round((double)((fechaActual - fechaIniSemestre).Days / 7.0)));
                double horasAjustadas = alumnoMaterium.HorasPersonales * semanasRestantes;

                var miFecha = fechaActual.AddDays(1);
                var horasTotales = alumnoMaterium.HorasAcumuladas + horasAjustadas;
                while (alumnoMaterium.HorasAcumuladas < horasTotales)
                {
                    if (diasEstudio < 7)
                    {
                        var misActividadesSemana = (from a in listActividades
                                                    where a.Cedula == alumnoMaterium.Cedula &&
                                                          a.HoraInicio.Date < miFecha.AddDays(7).Date &&
                                                          a.HoraInicio.Date >= miFecha.Date
                                                    select a).ToList();

                        foreach (var claseEvaluacion in listMisClasesEvaluacion)
                        {
                            var miActClase = repositorioActividad.GetById(claseEvaluacion.IdActividad);
                            if (miActClase.HoraInicio.Date < miFecha.AddDays(7).Date &&
                                miActClase.HoraInicio.Date >= miFecha.Date)
                            {
                                misActividadesSemana.Add(miActClase);
                            }
                        }

                        var horasOcupadas = new double[7];
                        for (int i = 0; i < 7; i++)
                        {
                            foreach (var actividad in misActividadesSemana)
                            {
                                if (actividad.HoraInicio.Date == miFecha.AddDays(i).Date)
                                {
                                    horasOcupadas[i] += (actividad.HoraFin - actividad.HoraInicio).Hours;
                                }
                            }
                        }

                        var mejoresDias = new List<DateTime>();
                        double aux = 9999;
                        int dia = 0;
                        for (int i = 0; i < diasEstudio; i++)
                        {
                            for (int j = 0; j < 7; j++)
                            {
                                if (horasOcupadas[j] < aux)
                                {
                                    aux = horasOcupadas[j];
                                    dia = j;
                                }
                            }
                            horasOcupadas[dia] = 9999;
                            mejoresDias.Add(miFecha.AddDays(dia));
                            aux = 9999;
                            dia = 0;
                        }

                        foreach (var mejorDia in mejoresDias)
                        {
                            GuardarActMejorHorario(mejorDia, alumnoMaterium, diasEstudio);
                        }

                        miFecha = miFecha.AddDays(7);
                    }
                    else
                    {
                        miFecha = miFecha.AddDays(1);
                        GuardarActMejorHorario(miFecha, alumnoMaterium, diasEstudio);
                    }
                }
            }
        }
コード例 #11
0
        protected void ActualizarAlumno(int miCedula)
        {
            var fechaActual = DateTime.Now;
            var semestre2 = new DateTime(fechaActual.Year, 03, 01);
            var verano1 = new DateTime(fechaActual.Year, 07, 01);
            var verano2 = new DateTime(fechaActual.Year, 10, 01);
            string periodoActual;
            if (fechaActual < semestre2)
            {
                periodoActual = (fechaActual.Year - 1) + "22";
            }
            else if (fechaActual > verano1 && fechaActual < verano2)
            {
                periodoActual = (fechaActual.Year - 1) + "23";
            }
            else
            {
                periodoActual = (fechaActual.Year - 1) + "21";
            }

            IRepositorio<Materium> repositorioMateria = new MateriumRepositorio();
            var listMaterias = repositorioMateria.GetAll();

            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
            var listActividades = new List<Actividad>();

            IRepositorio<ClaseEvaluacion> repositorioClaseE = new HorarioClaseRepositorio();
            var listClaseEvaluacion = repositorioClaseE.GetAll().Where(cE => cE.Cedula == miCedula).ToList();

            foreach (var claseEvaluacion in listClaseEvaluacion)
            {
                var actividad = repositorioActividad.GetById(claseEvaluacion.IdActividad);
                if (actividad.Tipo.CompareTo("Clase") == 0 &&
                    actividad.Periodo.CompareTo((periodoActual)) == 0 &&
                    actividad.HoraInicio >= fechaActual)
                {
                    listActividades.Add(actividad);
                }
            }

            foreach (var actividad in listActividades)
            {
                var materia = (from mat in listMaterias
                               where mat.IdMateria == actividad.IdMateria
                               select mat).First();
                actividad.Materia = materia;
            }

            IRepositorio<Profesor> repositorioProfesor = new ProfesorRepositorio();

            IRepositorio<SlMaterium> repositorioSlMateria = new SlMateriumRepositorio();
            var listSlMaterias = repositorioSlMateria.GetAll();

            IRepositorio<SlSeccion> repositorioSlSeccion = new SlSeccionRepositorio();
            var listSlSecciones = repositorioSlSeccion.GetAll();

            IRepositorio<SlClase> repositorioSlClase = new SlClaseRepositorio();
            var listSlClase = repositorioSlClase.GetAll();

            IRepositorio<SlProfesor> repositorioSlProfesor = new SlProfesorRepositorio();
            var listSlProfesor = repositorioSlProfesor.GetAll();
            foreach (var actividad in listActividades)
            {
                var flag = false;
                var slMateria = (from mat in listSlMaterias
                                 where mat.Nombre.CompareTo(actividad.Materia.Nombre) == 0
                                 select mat).First();
                if (slMateria.HorasLab != actividad.Materia.HorasLab)
                {
                    actividad.Materia.HorasLab = slMateria.HorasLab;
                    flag = true;
                    Trace.Write("Se encontro un cambio en las horas de laboratorio de la materia " +
                                actividad.Materia.Nombre);
                }
                if (slMateria.HorasPractica != actividad.Materia.HorasPractica)
                {
                    actividad.Materia.HorasPractica = slMateria.HorasPractica;
                    flag = true;
                    Trace.Write("Se encontro un cambio en las horas de practica de la materia " +
                                actividad.Materia.Nombre);
                }
                if (slMateria.HorasTeoria != actividad.Materia.HorasTeoria)
                {
                    actividad.Materia.HorasTeoria = slMateria.HorasTeoria;
                    flag = true;
                    Trace.Write("Se encontro un cambio en las horas de teoria de la materia " +
                                actividad.Materia.Nombre);
                }
                if (slMateria.Creditos != actividad.Materia.Creditos)
                {
                    actividad.Materia.Creditos = slMateria.Creditos;
                    flag = true;
                    Trace.Write("Se encontro un cambio en los creditos de la materia " + actividad.Materia.Nombre);
                }
                if (actividad.Materia.Descripcion != null)
                {
                    if (slMateria.Descripcion.CompareTo(actividad.Materia.Descripcion) != 0)
                    {
                        actividad.Materia.Descripcion = slMateria.Descripcion;
                        flag = true;
                        Trace.Write("Se encontro un cambio en la descripcion de la materia " +
                                    actividad.Materia.Nombre);
                    }
                }
                if (flag)
                {
                    Trace.WriteIf(repositorioMateria.Update(actividad.Materia).CompareTo("true") == 0,
                                  "Se actualizo la materia " + actividad.Materia.Nombre);
                }

                flag = false;
                var slSeccion = (from sec in listSlSecciones
                                 where sec.IdMateria == slMateria.IdMateria
                                 select sec).First();

                if (slSeccion.Seccion.CompareTo(actividad.Seccion) != 0)
                {
                    actividad.Seccion = slSeccion.Seccion;
                    flag = true;
                    Trace.Write("Se encontro un cambio de seccion en la materia " + actividad.Materia.Nombre);
                }
                if (flag)
                {
                    Trace.WriteIf(repositorioActividad.Update(actividad).CompareTo("true") == 0,
                                  "Se actualizo la actividad de la materia " + actividad.Materia.Nombre);
                }

                //var listMisSlClase = (from clase in listSlClase
                //               where clase.IdSeccion == slSeccion.IdSeccion
                //               select clase).ToList();
                //foreach (var slClase in listMisSlClase)
                //{
                //    var actividades = listActividades.Where(a => a.IdMateria == actividad.IdMateria &&
                //                                                 a.Seccion == slSeccion.Seccion).ToList();
                //    foreach (var act in actividades)
                //    {
                //        flag = false;
                //        if (slClase.HoraInicio.Hour.CompareTo(act.HoraInicio.Hour) != 0)
                //        {
                //            act.HoraInicio = new DateTime(act.HoraInicio.Year, act.HoraInicio.Month, act.HoraInicio.Day,
                //                                          slClase.HoraInicio.Hour, act.HoraInicio.Minute, 0);
                //            flag = true;
                //            Trace.Write("Se encontro un cambio en la hora inicio de la materia " +
                //                        actividad.Materia.Nombre);
                //        }
                //        if (slClase.HoraInicio.Minute.CompareTo(act.HoraInicio.Minute) != 0)
                //        {
                //            act.HoraInicio = new DateTime(act.HoraInicio.Year, act.HoraInicio.Month, act.HoraInicio.Day,
                //                                          act.HoraInicio.Minute, slClase.HoraInicio.Minute , 0);
                //            flag = true;
                //            Trace.Write("Se encontro un cambio en la hora inicio de la materia " +
                //                        actividad.Materia.Nombre);
                //        }
                //        if (slClase.HoraFin.Hour.CompareTo(act.HoraFin.Hour) != 0)
                //        {
                //            act.HoraFin = new DateTime(act.HoraFin.Year, act.HoraFin.Month, act.HoraFin.Day,
                //                                       slClase.HoraFin.Hour, act.HoraFin.Minute, 0);
                //            flag = true;
                //            Trace.Write("Se encontro un cambio en la hora inicio de la materia " +
                //                        actividad.Materia.Nombre);
                //        }
                //        if (slClase.HoraFin.Minute.CompareTo(act.HoraFin.Minute) != 0)
                //        {
                //            act.HoraFin = new DateTime(act.HoraFin.Year, act.HoraFin.Month, act.HoraFin.Day,
                //                                       act.HoraFin.Hour, slClase.HoraFin.Minute, 0);
                //            flag = true;
                //            Trace.Write("Se encontro un cambio en la hora inicio de la materia " +
                //                        actividad.Materia.Nombre);
                //        }
                //        if (flag)
                //        {
                //            Trace.WriteIf(repositorioActividad.Update(act).CompareTo("true") == 0,
                //                          "Se actualizo la actividad de la materia " + actividad.Materia.Nombre);
                //        }
                //    }
                //}

                flag = false;
                var slProfesor = (from p in listSlProfesor
                                  where p.Cedula == slSeccion.Profesor
                                  select p).First();
                var profesor = repositorioProfesor.GetAll().Where(p => p.Cedula == actividad.Profesor).First();
                if (slProfesor.Cedula.CompareTo(profesor.Cedula) != 0)
                {
                    profesor.Cedula = slProfesor.Cedula;
                    flag = true;
                    Trace.Write("Se encontro un cambio del profesor de la materia " + actividad.Materia.Nombre);
                }
                if (slProfesor.Nombre.CompareTo(profesor.Nombre) != 0)
                {
                    profesor.Nombre = slProfesor.Nombre;
                    flag = true;
                    Trace.Write("Se encontro un cambio en el nombre del profesor de la materia " +
                                actividad.Materia.Nombre);
                }
                if (slProfesor.Apellido.CompareTo(profesor.Apellido) != 0)
                {
                    profesor.Apellido = slProfesor.Apellido;
                    flag = true;
                    Trace.Write("Se encontro un cambio en el apellido del profesor de la materia " +
                                actividad.Materia.Nombre);
                }
                if (flag)
                {
                    Trace.WriteIf(repositorioProfesor.Update(profesor).CompareTo("true") == 0,
                                  "Se actualizo el profesor " + profesor.Nombre + " " + profesor.Apellido);
                }
            }
        }
コード例 #12
0
        public ActionResult Nota(ClaseEvaluacion miEvaluacion)
        {
            if (ModelState.IsValid)
            {
                var miCedula = (int)Session["cedula"];
                //Actualizo la evaluacion con la nota respectiva
                IRepositorio<ClaseEvaluacion> repositorioClaseEvaluacion = new HorarioClaseRepositorio();
                repositorioClaseEvaluacion.Update(miEvaluacion);

                IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
                var miActividad = repositorioActividad.GetById(miEvaluacion.IdActividad);

                IRepositorio<AlumnoMaterium> repositorioAlumnoMateria = new AlumnoMateriumRepositorio();

                //Elimino todas las actividades inteligentes luego de hoy y resto las horas acumuladas
                var misActividadesIEliminar = repositorioActividad.GetAll().Where(a => a.Cedula == miCedula &&
                                                                               a.Tipo.CompareTo("Inteligente") == 0 &&
                                                                               a.HoraInicio >= _fechaHoy).ToList();

                var listCronograma = repositorioClaseEvaluacion.GetAll().Where(alum => alum.Cedula == miCedula);

                var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0);

                var misMaterias = (from d in listCronograma
                                   from c in listActividades
                                   where c.Tipo.CompareTo("Clase") == 0 &&
                                         d.IdActividad == c.IdActividad
                                   select c.IdMateria).Distinct().ToList();
                foreach (var materia in misMaterias)
                {
                    double cantHoras = 0;
                    foreach (var actividad in misActividadesIEliminar.Where(a => a.IdMateria == materia).ToList())
                    {
                        cantHoras += (((actividad.HoraFin - actividad.HoraInicio).TotalSeconds) / 3600.00);
                        repositorioActividad.Delete(actividad);
                    }
                    var mat =
                        repositorioAlumnoMateria.GetAll().Where(aM => aM.IdMateria == materia && aM.Cedula == miCedula).
                            First();
                    mat.HorasAcumuladas -= cantHoras;
                    repositorioAlumnoMateria.Update(mat);
                }

                var miMateria = repositorioAlumnoMateria.GetAll().Where(aM => aM.Cedula == miCedula &&
                                                                              aM.IdMateria == miActividad.IdMateria).First();

                //HORAS DE ESTUDIO
                const int x1 = 10;
                const int y1 = 0;
                const int x2 = 20;
                var y2 = (miMateria.HorasPersonales * (miActividad.Ponderacion / 100.00)) * -1;
                var pendiente1 = (y2 - y1) / (x2 - x1);
                var factorM = (miEvaluacion.Nota * pendiente1) - y2;
                miMateria.HorasPersonales += factorM;

                //MATERIAS
                y2 = -miMateria.Prioridad * (miActividad.Ponderacion / 100.00);
                pendiente1 = (y2 - y1) / (x2 - x1);
                factorM = (miEvaluacion.Nota * pendiente1) - y2;
                miMateria.Prioridad = miMateria.Prioridad + factorM;

                repositorioAlumnoMateria.Update(miMateria);

                //BLOQUES DE ESTUDIO
                const double pendiente2 = 0.1;
                var factor = (pendiente2 * miEvaluacion.Nota - 1) * (miEvaluacion.Rating / 100.00);
                IRepositorio<HorarioPreferencia> repositorioHorarioPref = new HorarioPreferenciaRepositorio();

                var misPreferencias = repositorioHorarioPref.GetAll().Where(p => p.Cedula == miCedula &&
                                                                                 p.Tipo.CompareTo("Definitivo") == 0).ToList();

                var actividadesIAnteriores = repositorioActividad.GetAll().Where(a => a.Cedula == miCedula &&
                                                                               a.Tipo.CompareTo("Inteligente") == 0 &&
                                                                               a.IdMateria == miMateria.IdMateria &&
                                                                               a.HoraInicio < _fechaHoy).ToList();
                var misActividadesIAnteriores = new List<Actividad>();
                foreach (var actividadIAnterior in actividadesIAnteriores)
                {
                    var hI = new DateTime(2012, 01, 01, actividadIAnterior.HoraInicio.Hour, 0, 0);
                    var hF = new DateTime(2012, 01, 01, actividadIAnterior.HoraFin.Hour, 0, 0);
                    var actividad = new Actividad()
                                        {
                                            Cedula = actividadIAnterior.Cedula,
                                            FechaFinRepeticion = actividadIAnterior.FechaFinRepeticion,
                                            HoraFin = hF,
                                            HoraInicio = hI,
                                            IdActividad = actividadIAnterior.IdMateria,
                                            IdMateria = actividadIAnterior.IdMateria,
                                            IsMyComboDisabled = actividadIAnterior.IsMyComboDisabled,
                                            IsRepetible = actividadIAnterior.IsRepetible,
                                            Materia = actividadIAnterior.Materia,
                                            Nombre = actividadIAnterior.Nombre
                                        };
                    if (!misActividadesIAnteriores.Contains(actividad))
                    {
                        misActividadesIAnteriores.Add(actividad);
                    }
                }

                foreach (var actividadesIAnteriore in misActividadesIAnteriores)
                {
                    foreach (var horarioPreferencia in misPreferencias)
                    {
                        if (horarioPreferencia.HoraInicio.Hour == actividadesIAnteriore.HoraInicio.Hour)
                        {
                            var hora = horarioPreferencia.HoraInicio;
                            while (hora.Hour <= actividadesIAnteriore.HoraFin.Hour)
                            {
                                horarioPreferencia.Preferencia = horarioPreferencia.Preferencia + factor;
                                repositorioHorarioPref.Update(horarioPreferencia);
                                hora = hora.AddHours(1);
                            }
                        }
                    }
                }

                if (misActividadesIEliminar.Count > 0)
                {
                    //Calculo nuevamente las actividades inteligentes
                    var accountController = new AccountController();
                    accountController.ActividadesInteligentes(miCedula);
                }
                return RedirectToAction("Index");
            }
            return View(miEvaluacion);
        }
コード例 #13
0
        public ActionResult Nota(int id)
        {
            var miCedula = (int)Session["cedula"];
            IRepositorio<ClaseEvaluacion> repositorioClaseEvaluacion = new HorarioClaseRepositorio();
            var miEvaluacion = repositorioClaseEvaluacion.GetAll().Where(cE => cE.IdActividad == id &&
                                                                               cE.Cedula == miCedula).First();

            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
            var miActividad = repositorioActividad.GetById(miEvaluacion.IdActividad);

            var listCronograma = repositorioClaseEvaluacion.GetAll().Where(alum => alum.Cedula == miCedula);

            var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0);

            var misActividadesEvaluacion = (from d in listCronograma
                                    from c in listActividades
                                    where c.Tipo.CompareTo("Evaluacion") == 0 &&
                                          d.IdActividad == c.IdActividad
                                    select c).ToList();
            var fechaMin = DateTime.Now;
            int? idActividad = 0;
            //Busco una actividad evaluativa de la misma materia anterior a esta
            foreach (var actividad in misActividadesEvaluacion)
            {
                if (actividad.HoraFin < fechaMin &&
                    actividad.HoraFin < miActividad.HoraInicio &&
                    actividad.IdActividad != miActividad.IdActividad &&
                    actividad.IdMateria == miActividad.IdMateria)
                {
                    fechaMin = actividad.HoraFin;
                    idActividad = actividad.IdActividad;
                }
            }
            List<Actividad> actividadesIAnteriores;
            if (idActividad != 0)
            {
                var actividadAnterior = repositorioActividad.GetById(idActividad);
                actividadesIAnteriores = repositorioActividad.GetAll().Where(a => a.Cedula == miCedula &&
                                                                                  a.Tipo.CompareTo("Inteligente") == 0 &&
                                                                                  a.IdMateria == miActividad.IdMateria &&
                                                                                  a.HoraInicio < miActividad.HoraInicio &&
                                                                                  a.HoraInicio > actividadAnterior.HoraInicio).ToList();
            }
            else
            {
                actividadesIAnteriores = repositorioActividad.GetAll().Where(a => a.Cedula == miCedula &&
                                                                                  a.Tipo.CompareTo("Inteligente") == 0 &&
                                                                                  a.IdMateria == miActividad.IdMateria &&
                                                                                  a.HoraInicio < miActividad.HoraInicio).ToList();
            }
            double numHoras = 0;
            foreach (var actividad in actividadesIAnteriores)
            {
                numHoras += (((actividad.HoraFin - actividad.HoraInicio).TotalSeconds)/3600.00);
            }
            miEvaluacion.CantidadHoras = numHoras;
            miEvaluacion.Actividad = miActividad;
            IRepositorio<Materium> repositorioMateria = new MateriumRepositorio();
            miEvaluacion.Materium = repositorioMateria.GetById(miActividad.IdMateria);
            miEvaluacion.Rating = 50;
            return View(miEvaluacion);
        }
コード例 #14
0
        public ActionResult Edit(Actividad Actividad)
        {
            if (ModelState.IsValid)
            {
                IRepositorio<Actividad> myRepoActividad = new ActividadRepositorio();
                String resultado = myRepoActividad.Update(Actividad);

                if (resultado.Equals("true"))
                    return RedirectToAction("Index");

            }

            var miCedula = (Int32)Session["cedula"];

            IRepositorio<ClaseEvaluacion> repositorioClaseEvaluacion = new HorarioClaseRepositorio();

            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();

            var listCronograma = repositorioClaseEvaluacion.GetAll().Where(alum => alum.Cedula == miCedula);

            var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0);

            var misMaterias = (from d in listCronograma
                               from c in listActividades
                               where c.Tipo.CompareTo("Clase") == 0 &&
                                     d.IdActividad == c.IdActividad
                               select c.IdMateria).Distinct().ToList();

            IRepositorio<Materium> repositorioMateria = new MateriumRepositorio();
            IList<String> nombresMaterias =
                misMaterias.Select(mat => repositorioMateria.GetById(mat).Nombre).ToList();

            ViewData["Materia.Nombre"] = new SelectList(nombresMaterias);

            return View(Actividad);
        }
コード例 #15
0
        //
        // GET: /Actividad/Edit/5
        public ActionResult Edit(int id)
        {
            IRepositorio<Actividad> repoActividad = new ActividadRepositorio();
            Actividad actividad = repoActividad.GetById(id);

            IRepositorio<Materium> repositorioMateria = new MateriumRepositorio();

            if (actividad.Tipo.CompareTo("Extracurricular") != 0)
            {
                actividad.Materia = repositorioMateria.GetById(actividad.IdMateria);
            }

            var miCedula = (Int32)Session["cedula"];
            IRepositorio<ClaseEvaluacion> repositorioClaseEvaluacion = new HorarioClaseRepositorio();

            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();

            var listCronograma = repositorioClaseEvaluacion.GetAll().Where(alum => alum.Cedula == miCedula);

            var listActividades = repositorioActividad.GetAll().Where(a => a.Periodo.CompareTo(_periodoActual) == 0);

            var misMaterias = (from d in listCronograma
                               from c in listActividades
                               where c.Tipo.CompareTo("Clase") == 0 &&
                                     d.IdActividad == c.IdActividad
                               select c.IdMateria).Distinct().ToList();

            IList<String> nombresMaterias =
                misMaterias.Select(mat => repositorioMateria.GetById(mat).Nombre).ToList();

            ViewData["Materia.Nombre"] = new SelectList(nombresMaterias);

            return View(actividad);
        }
コード例 #16
0
 public ActionResult Data()
 {
     if (Session["cedula"] != null)
     {
         var miCedula = (Int32)Session["cedula"];
         IRepositorio<ClaseEvaluacion> repositorioClaseEvaluacion = new HorarioClaseRepositorio();
         var listClaseEvaluacion = repositorioClaseEvaluacion.GetAll().Where(cE => cE.Cedula == miCedula).ToList();
         IRepositorio<Actividad> repoActividad = new ActividadRepositorio();
         var listActividades = repoActividad.GetAll();
         var misActividades = new List<Actividad>();
         foreach (var actividad in listActividades)
         {
             if (actividad.Cedula == miCedula)
             {
                 misActividades.Add(actividad);
             }
             else
             {
                 if (actividad.Cedula == null)
                 {
                     foreach (var claseEvaluacion in listClaseEvaluacion)
                     {
                         if (claseEvaluacion.IdActividad == actividad.IdActividad)
                         {
                             misActividades.Add(actividad);
                         }
                     }
                 }
             }
         }
         return View(misActividades);
     }
     else
     {
         var account = new AccountController();
         account.LogOff();
     }
     return View();
 }