public ActionResult Create(Actividad Actividad)
        {
            IRepositorio<Materium> repositorioMateria = new MateriumRepositorio();
            IList<Materium> listaMaterias = repositorioMateria.GetAll();

            foreach (var materia in listaMaterias)
                if (materia.Nombre == Actividad.Materia.Nombre)
                    Actividad.IdMateria = materia.IdMateria;

            if(ModelState.IsValid)
            {
                if (Actividad.HoraInicio > Actividad.HoraFin)
                {
                    ModelState.AddModelError("FechaInvalida",
                                             "La fecha/hora de inicio no puede ser mayor a la fecha/hora fin.");
                    return View(Actividad);
                }
                IRepositorio<Actividad> myRepoActividad = new ActividadRepositorio();
                String resultado = myRepoActividad.Save(Actividad);

                if(resultado.Equals("true"))
                    return RedirectToAction("Index");
            }
            return View(Actividad);
        }
        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();
        }
        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);
            }
        }
        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 CreateProfesor(Actividad actividad)
        {
            actividad.Tipo = "Evaluacion";

            if (actividad.HoraInicio > actividad.HoraFin)
            {
                ModelState.AddModelError("FechaInvalida",
                                            "La fecha/hora de inicio no puede ser mayor a la fecha/hora fin.");
                return View(actividad);
            }
            IRepositorio<Actividad> myRepoActividad = new ActividadRepositorio();
            String resultado = myRepoActividad.Save(actividad);

            var miCedula = (Int32)Session["cedula"];
            IRepositorio<Actividad> repositorioActividad = new ActividadRepositorio();
            IList<Actividad> listaActividad = repositorioActividad.GetAll();

            IRepositorio<Materium> repositorioMateria = new MateriumRepositorio();

            var misMaterias = (from alumnoMat in listaActividad
                               where alumnoMat.Profesor == miCedula
                               select alumnoMat.IdMateria).Distinct().ToList();

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

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

            return View(actividad);
        }
        public ActionResult Create(Actividad Actividad)
        {
            IRepositorio<Materium> repositorioMateria = new MateriumRepositorio();
            if (ModelState.IsValid)
            {
                IList<Materium> listaMaterias = repositorioMateria.GetAll();

                if (Actividad.IsRepetible)
                {
                    if (Actividad.FechaFinRepeticion == new DateTime(0001, 01, 01, 0, 0, 0))
                    {
                        ModelState.AddModelError("Repetible",
                                             "Debes indicar hasta cuando se debe repetir la actividad");
                        return View(Actividad);
                    }
                    if (Actividad.FechaFinRepeticion <= DateTime.Now)
                    {
                        ModelState.AddModelError("Repetible",
                                             "La fecha final de repeticion debe ser mayor al dia de hoy.");
                        return View(Actividad);
                    }
                    if (Actividad.Tipo.CompareTo("Clase") == 0 || Actividad.Tipo.CompareTo("Estudio") == 0)
                    {
                        ModelState.AddModelError("Repetible",
                                             "Las Evaluaciones ni las actividades de estudios se pueden repetir");
                        return View(Actividad);
                    }
                }

                if (Actividad.Tipo.CompareTo("Extracurricular") != 0)
                {
                    foreach (var materia in listaMaterias)
                        if (materia.Nombre == Actividad.Materia.Nombre)
                            Actividad.IdMateria = materia.IdMateria;
                }

                if (Actividad.HoraInicio > Actividad.HoraFin)
                {
                    ModelState.AddModelError("FechaInvalida",
                                             "La fecha/hora de inicio no puede ser mayor a la fecha/hora fin.");
                    return View(Actividad);
                }
                IRepositorio<Actividad> myRepoActividad = new ActividadRepositorio();
                String resultado = myRepoActividad.Save(Actividad);

                if (Actividad.IsRepetible)
                {
                    while (Actividad.HoraInicio < Actividad.FechaFinRepeticion)
                    {
                        Actividad.HoraInicio = Actividad.HoraInicio.AddDays(7);
                        Actividad.HoraFin = Actividad.HoraFin.AddDays(7);
                        myRepoActividad.Save(Actividad);
                    }
                }
            }
            else
            {
                Actividad.IsMyComboDisabled = Actividad.Tipo.CompareTo("Extracurricular") == 0;
            }

            var miCedula = (Int32)Session["cedula"];
            IRepositorio<AlumnoMaterium> repositorioAlumnoMateria = new AlumnoMateriumRepositorio();
            IList<AlumnoMaterium> listaAlumnoMaterium = repositorioAlumnoMateria.GetAll();
            var misMaterias = (from alumnoMat in listaAlumnoMaterium
                               where alumnoMat.Cedula == miCedula
                               select alumnoMat).ToList();

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

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

            return View(Actividad);
        }