public ActionResult Login(LoginViewModel model)
{
var ValidationLogic = new ValidationLogic(ModelState);
ValidationLogic.Valid(model.Usuario, "Usuario", ValidationOption.IsNotEmpty);
ValidationLogic.Valid(model.Contraseña, "Contraseña", ValidationOption.IsNotEmpty);
//TODO: Validar Credenciales;
// Si EsCoordinador esta activado, entonces no validar.
if (!ModelState.IsValid)
return View();
var PeriodoActual = SSIARepositoryFactory.GetPeriodosRepository().GetWhere(x => x.EsActual == true);
if (PeriodoActual.Count != 1)
{
PostMessage("No se puedo determinar el Período actual. No se puede continuar.", MessageType.Error);
return View();
}
var PeriodoActualId = PeriodoActual.First().PeriodoId;
Roles RolUsuario;
var AlumnoBE = SSIARepositoryFactory.GetAlumnosRepository().GetOne(model.Usuario);
var ProfesorBE = SSIARepositoryFactory.GetProfesoresRepository().GetOne(model.Usuario);
var CoordinadorBE = SSIARepositoryFactory.GetCoordinadoresRepository().GetOne(model.Usuario);
if (AlumnoBE != null)
RolUsuario = Roles.Estudiante;
else if (ProfesorBE != null)
RolUsuario = Roles.Profesor;
else if (CoordinadorBE != null)
RolUsuario = Roles.Coordinador;
else
{
PostMessage("No se puedo determinar el rol del usuario. No se puede continuar.", MessageType.Error);
return View();
}
var Periodos = new List<PeriodosBE>();
var Nombre = "";
String CoordinadorId = null;
switch (RolUsuario)
{
case Roles.Estudiante:
var PeriodosId = ePortafolioRepositoryFactory.GetTrabajosRepository().GetTrabajosEntregados(model.Usuario).Select(x => x.PeriodoId).Distinct();
Periodos = SSIARepositoryFactory.GetPeriodosRepository().GetWhere(x => PeriodosId.Contains(x.PeriodoId));
Periodos = Periodos.OrderByDescending(x => x.PeriodoId).ToList();
Nombre = AlumnoBE.Nombre;
break;
case Roles.Profesor:
Periodos = SSIARepositoryFactory.GetPeriodosRepository().PeriodosDictados(model.Usuario);
Nombre = ProfesorBE.Nombre;
break;
case Roles.Coordinador:
Periodos = new List<PeriodosBE>();
Nombre = CoordinadorBE.Nombre;
CoordinadorId = model.Usuario;
break;
}
Session.RemoveAll();
if (!Periodos.Any(x => x.PeriodoId == PeriodoActualId))
{
Periodos.Add(PeriodoActual.First());
Periodos = Periodos.OrderByDescending(x => x.PeriodoId).ToList();
}
Session.Set(GlobalKey.ActualPeriodoId, PeriodoActualId);
Session.Set(GlobalKey.PeriodosMatriculados, Periodos);
Session.Set(GlobalKey.Rol, RolUsuario);
Session.Set(GlobalKey.UsuarioId, model.Usuario);
Session.Set(GlobalKey.Nombre, Nombre);
Session.Set(GlobalKey.CoordinadorId, CoordinadorId);
switch (RolUsuario)
{
case Roles.Estudiante: return RedirectToAction("MostrarTrabajos", "Estudiante", new { PeriodoId = PeriodoActualId });
case Roles.Profesor: return RedirectToAction("MostrarTrabajos", "Profesor", new { PeriodoId = PeriodoActualId });
case Roles.Coordinador: return RedirectToAction("MostrarEvaluacionesOutcomes", "Coordinador", new { PeriodoId = PeriodoActualId });
}
PostMessage("Ha ocurrido un error.", MessageType.Error);
return View();
}
public ActionResult AgregarEvaluacionesOutcomes(AgregarEvaluacionesOutcomesViewModel model, FormCollection formCollection)
{
if (!PermitirAcceso())
return RedirigirFaltaAcceso();
var ValidationLogic = new ValidationLogic(ModelState);
var AlumnosValidos = new List<String>();
var AlumnosNuevos = new List<String>();
ValidationLogic.Valid(model.AlumnosId, "AlumnosId", ValidationOption.IsNotEmpty);
ValidationLogic.Valid(model.OutcomeId, "OutcomeId", ValidationOption.IsNotEmpty | ValidationOption.IsNotZero);
ValidationLogic.Valid(model.PeriodoId, "PeriodoId", ValidationOption.IsNotEmpty | ValidationOption.IsNotZero);
ValidationLogic.Valid(model.ProfesorId, "ProfesorId", ValidationOption.IsNotEmpty);
if (ModelState.IsValid)
{
var Outcome = SSIARepositoryFactory.GetOutcomesRepository().GetOne(model.OutcomeId);
var Profesor = SSIARepositoryFactory.GetProfesoresRepository().GetOne(model.ProfesorId);
var Periodo = SSIARepositoryFactory.GetPeriodosRepository().GetOne(model.PeriodoId);
if (Outcome == null)
ModelState.AddModelError("OutcomeId", "");
if (Profesor == null)
ModelState.AddModelError("ProfesorId", "");
if (Periodo == null)
ModelState.AddModelError("PeriodoId", "");
AlumnosNuevos = model.AlumnosId.Split(new char[] { ',', ';', ':', ' ' }, StringSplitOptions.RemoveEmptyEntries).Distinct().ToList();
AlumnosValidos = SSIARepositoryFactory.GetAlumnosRepository().GetWhere(x => AlumnosNuevos.Contains(x.AlumnoId)).Select(x => x.AlumnoId).ToList();
if (AlumnosValidos.Count != AlumnosNuevos.Count)
{
ModelState.AddModelError("AlumnosId", "");
PostMessage("Alguno de los alumnos ingresados no existe.", MessageType.Error);
}
}
if (!ModelState.IsValid)
{
if (AlumnosValidos.Count != AlumnosNuevos.Count)
PostMessage("Alguno de los alumnos ingresados no existe. Revisar los datos ingresados.", MessageType.Error);
else
PostMessage("Revisar los datos ingresados.", MessageType.Error);
return View(model);
}
try
{
using (TransactionScope scope = new TransactionScope())
{
var EvaluacionesOutcomeProfesor = new List<EvaluacionesOutcomeProfesorBE>();
foreach (var AlumnoNuevo in AlumnosValidos)
{
EvaluacionesOutcomeProfesor.Add(new EvaluacionesOutcomeProfesorBE()
{
AlumnoId = AlumnoNuevo,
ProfesorId = model.ProfesorId,
PeriodoId = model.PeriodoId,
OutcomeId = model.OutcomeId,
Nota = "NE",
EvaluacionId = null
});
}
ePortafolioRepositoryFactory.GetEvaluacionesOutcomeProfesorRepository().InsertOrUpdate(EvaluacionesOutcomeProfesor);
ePortafolioRepositoryFactory.SubmitChanges(true);
scope.Complete();
PostMessage("Los alumnos han sido asociados exitosamente.", MessageType.Success);
}
}
catch (Exception ex)
{
PostMessage("Ha ocurrido un error.", MessageType.Error);
return View(model);
}
return RedirectToAction("MostrarEvaluacionesOutcomes", new { ProfesorId = model.ProfesorId, PeriodoId = model.PeriodoId, OutcomeId = model.OutcomeId });
}
public ActionResult CrearGrupoIndependiente(FormCollection formCollection)
{
if (!PermitirAcceso())
return RedirigirFaltaAcceso();
var ValidationLogic = new ValidationLogic();
var NombreTrabajo = formCollection["NombreTrabajoIndependiente"];
var ActualAlumnoId = Session.Get(GlobalKey.UsuarioId).ToString();
var ActualPeriodoId = Session.Get(GlobalKey.ActualPeriodoId).ToString();
if (!ValidationLogic.Valid(NombreTrabajo, ValidationOption.IsNotEmpty))
{
PostMessage("El nombre del trabajo independiente es invalido. No se puede continuar.", MessageType.Error);
return RedirectToAction("MostrarTrabajosIndependientes");
}
try
{
using (TransactionScope scope = new TransactionScope())
{
var Trabajo = new TrabajosBE()
{
CursoId = 0,
EsGrupal = true,
FechaFin = null,
FechaInicio = null,
Iniciativa = "EST",
Instrucciones = "",
Nombre = NombreTrabajo,
PeriodoId = ActualPeriodoId,
};
ePortafolioRepositoryFactory.GetTrabajosRepository().InsertIdentity(Trabajo, true);
var Grupo = new GruposBE()
{
LiderId = ActualAlumnoId,
Nota = "NE",
SeccionId = "GEN",
TrabajoId = Trabajo.TrabajoId,
NombreTrabajo = NombreTrabajo,
EvaluacionId = null
};
ePortafolioRepositoryFactory.GetGruposRepository().InsertIdentity(Grupo, true);
var AlumnoGrupo = new AlumnosGrupoBE()
{
AlumnoId = ActualAlumnoId,
GrupoId = Grupo.GrupoId,
Nota = "NE",
EvaluacionId = null
};
ePortafolioRepositoryFactory.GetAlumnosGrupoRepository().Insert(AlumnoGrupo);
ePortafolioRepositoryFactory.SubmitChanges(true);
scope.Complete();
PostMessage("El trabajo se ha creado exitosamente.", MessageType.Success);
}
}
catch (Exception ex)
{
PostMessage("Ha ocurrido un error.", MessageType.Error);
}
return RedirectToAction("MostrarTrabajosIndependientes");
}
public ActionResult EditarTrabajo(int TrabajoId, FormCollection formCollection)
{
if (!PermitirAcceso())
return RedirigirFaltaAcceso();
var ActualProfesorId = Session.Get(GlobalKey.UsuarioId).ToString();
var ActualPeriodoId = Session.Get(GlobalKey.ActualPeriodoId).ToString();
var ValidationLogic = new ValidationLogic(ModelState);
var FechaInicio = formCollection["Trabajo.FechaInicio"].ToString();
var FechaFin = formCollection["Trabajo.FechaFin"].ToString();
var Nombre = formCollection["Trabajo.Nombre"].ToString();
ValidationLogic.Valid(FechaInicio, "Trabajo.FechaInicio", ValidationOption.IsEmpty, ValidationOption.IsDate);
ValidationLogic.Valid(FechaFin, "Trabajo.FechaFin", ValidationOption.IsEmpty, ValidationOption.IsDate);
ValidationLogic.Valid(Nombre, "Trabajo.Nombre", ValidationOption.IsNotEmpty);
if (!ModelState.IsValid)
{
var EditarTrabajoViewModel = new EditarTrabajoViewModel(TrabajoId, ActualProfesorId);
TryUpdateModel(EditarTrabajoViewModel);
return View(EditarTrabajoViewModel);
}
var Trabajo = ePortafolioRepositoryFactory.GetTrabajosRepository().GetOne(TrabajoId);
var CursosPeriodos = SSIARepositoryFactory.GetCursosPeriodosRepository().GetOne(Trabajo.CursoId, ActualPeriodoId);
if (CursosPeriodos.CoordinadorId != ActualProfesorId)
PostMessage("No tiene los permisos necesarios para editar el trabajo.", MessageType.Error);
else
{
Trabajo.FechaInicio = null;
Trabajo.FechaFin = null;
if (FechaInicio != String.Empty)
Trabajo.FechaInicio = Convert.ToDateTime(FechaInicio);
if (FechaFin != String.Empty)
Trabajo.FechaFin = Convert.ToDateTime(FechaFin);
if (Trabajo.FechaInicio != null && Trabajo.FechaFin != null && Trabajo.FechaInicio > Trabajo.FechaFin)
{
Trabajo.FechaInicio = Convert.ToDateTime(FechaFin);
Trabajo.FechaFin = Convert.ToDateTime(FechaInicio);
}
Trabajo.Nombre = Nombre;
Trabajo.EsGrupal = Convert.ToBoolean(formCollection["Trabajo.EsGrupal"]);
Trabajo.Instrucciones = formCollection["Trabajo.Instrucciones"].ToString();
try
{
using (TransactionScope scope = new TransactionScope())
{
ePortafolioRepositoryFactory.GetTrabajosRepository().Update(Trabajo);
ePortafolioRepositoryFactory.SubmitChanges(true);
scope.Complete();
PostMessage("El trabajo ha sido editado exitosamente.", MessageType.Success);
}
}
catch (Exception ex)
{
PostMessage("Ha ocurrido un error.", MessageType.Error);
}
}
return RedirectToAction("MostrarTrabajos", "Profesor", new { PeriodoId = Trabajo.PeriodoId });
}
