//
        // GET: /Actividad/Delete/5
        public ActionResult Delete(int id)
        {
            if(ModelState.IsValid)
            {
                IRepositorio<Actividad> myRepoActividad = new ActividadRepositorio();
                String resultado = myRepoActividad.Delete(myRepoActividad.GetById(id));

                if (resultado.Equals("true"))
                    return RedirectToAction("Index"); return RedirectToAction("Index");
            }
             return RedirectToAction("Index");
        }
 public ActionResult ConfigurationProfesor(Profesor profesor)
 {
     foreach (var materium in profesor.Materiums)
     {
         if (materium.File != null)
         {
             var httpPostedFileBase = materium.File;
             {
                 string extension = Path.GetExtension(httpPostedFileBase.FileName);
                 if (extension != null && !extension.Contains(".doc"))
                 {
                     ModelState.AddModelError("archivos", "Solo se admiten archivos de Microsoft Word.");
                 }
                 else
                 {
                     IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
                     var listActividades = repositorioActividad.GetAll().Where(act => act.Seccion == materium.Seccion &&
                                                                                      act.IdMateria == materium.IdMateria &&
                                                                                      act.Periodo.CompareTo(_periodoActual) == 0 &&
                                                                                      act.Tipo.CompareTo("Evaluacion") == 0 &&
                                                                                      act.Cedula == profesor.Cedula).ToList();
                     foreach (var actividad in listActividades)
                     {
                         repositorioActividad.Delete(actividad);
                     }
                     LeerCronogramas(materium);
                     return RedirectToAction("IndexProfesor", "Home");
                 }
             }
         }
     }
     return View();
 }
        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");
        }
        public ActionResult Save(Evento changedEvent, FormCollection actionValues)
        {
            String actionType = actionValues["!nativeeditor_status"];
            Int64 sourceId = Int64.Parse(actionValues["id"]);
            Int64 targetId = sourceId;

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

            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
            try
            {
                switch (actionType)
                {
                    case "inserted":
                        {
                            var actividad = new Actividad
                            {
                                Nombre = changedEvent.text,
                                HoraInicio = changedEvent.start_date,
                                HoraFin = changedEvent.end_date,
                                Cedula = miCedula,
                                Tipo = changedEvent.tipo,
                                Periodo = Helper.CalcularPeriodoActual()
                            };
                            repositorioActividad.Save(actividad);
                        }
                        break;
                    case "deleted":
                        {
                            int id = changedEvent.id;
                            var actividad = repositorioActividad.GetById(id);
                            if (actividad != null)
                            {
                                repositorioActividad.Delete(actividad);
                            }
                        }
                        break;
                    default: // "updated"
                        {
                            int id = changedEvent.id;
                            var actividad = repositorioActividad.GetById(id);
                            if (actividad != null)
                            {
                                actividad.HoraInicio = changedEvent.start_date;
                                actividad.HoraFin = changedEvent.end_date;
                                actividad.Nombre = changedEvent.text;
                                repositorioActividad.Update(actividad);
                            }
                        }
                        break;
                }
            }
            catch
            {
                actionType = "error";
            }

            return View(new ActividadActionResponseModel(actionType, sourceId, targetId));
        }
        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);
        }
        //
        // GET: /Actividad/Delete/5
        public ActionResult Delete(int id)
        {
            if (ModelState.IsValid)
            {
                IRepositorio<Actividad> myRepoActividad = new ActividadRepositorio();
                var actividad = myRepoActividad.GetById(id);
                String resultado = myRepoActividad.Delete(actividad);

                if (resultado.Equals("true"))
                {
                    if (actividad.Tipo.CompareTo("Inteligente") == 0)
                    {
                        var miCedula = (int)Session["cedula"];
                        IRepositorio<AlumnoMaterium> repositorioAlumnoMateria = new AlumnoMateriumRepositorio();
                        var alumnoMateria =
                            repositorioAlumnoMateria.GetAll().Where(
                                am => am.Cedula == miCedula && am.IdMateria == actividad.IdMateria).First();
                        alumnoMateria.HorasAcumuladas -= ((actividad.HoraFin - actividad.HoraInicio).Minutes / 60.00);
                        repositorioAlumnoMateria.Update(alumnoMateria);
                    }
                    return RedirectToAction("Index");
                }
            }
            return RedirectToAction("Index");
        }