public ActionResult ConsultarMaterias()
{
try
{
List <MateriaConsultaViewModel> lista = new List <MateriaConsultaViewModel>();
MateriaRepository materiaRep = new MateriaRepository();
foreach (Materia materia in materiaRep.FindAll())
{
lista.Add(new MateriaConsultaViewModel()
{
IdMateria = materia.IdMateria,
Nome = materia.Nome,
PesoProva1 = materia.PesoProva1,
PesoProva2 = materia.PesoProva2,
PesoProva3 = materia.PesoProva3
});
}
return(Json(lista, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(e.Message, JsonRequestBehavior.AllowGet));
}
}
public List <SelectListItem> ObtenerMateriasSelect(string id)
{
var result = MateriaRepository.getMateriaSelect2(HttpContext.Session["institucion"].ToString(), id);
return(result);
}
public UnitOfWork(AppDbContext appDbContext)
{
_appDbContext = appDbContext;
Materias = new MateriaRepository(_appDbContext);
Estudiantes = new EstudianteRepository(_appDbContext);
Matriculas = new MatriculaRepository(_appDbContext);
Asistencias = new AsistenciaRepository(_appDbContext);
}
public ActionResult Index()
{
List <Materia> materias = MateriaRepository.getMaterias(HttpContext.Session["institucion"].ToString());
Session["materias"] = materias;
ViewBag.Materias = materias;
return(View());
}
public string ObterSituacaoPeriodoAcademicoAluno(int idAluno)
{
MateriaRepository materiaRep = new MateriaRepository();
MateriaAlunoRepository materiaAlunoRep = new MateriaAlunoRepository();
string situacao = string.Empty;
int quantMateriasAprovadas = 0;
int quantMateriasReprovadas = 0;
int quantMaterias = 0;
foreach (MateriaAluno materiaAluno in materiaAlunoRep.FindAllByIdAluno(idAluno))
{
quantMaterias++;
Materia materia = materiaRep.FindById(materiaAluno.IdMateria);
decimal mediaPonderada = CalcularMediaPonderada(materiaAluno.NotaProva1,
materiaAluno.NotaProva2, materiaAluno.NotaProva3, materia.PesoProva1,
materia.PesoProva2, materia.PesoProva3);
if (mediaPonderada >= 6.0M)
{
quantMateriasAprovadas++;
}
else if (mediaPonderada <= 4.0M)
{
quantMateriasReprovadas++;
}
else
{
//calcula a média aritmética entre a média ponderada e a prova final
decimal mediaAritmetica = CalcularMediaAritmetica(mediaPonderada, materiaAluno.NotaProvaFinal);
if (mediaAritmetica >= 5.0M)
{
quantMateriasAprovadas++;
}
else
{
quantMateriasReprovadas++;
}
}
}
if (quantMateriasAprovadas >= quantMaterias * 0.6)
{
situacao = "APROVADO";
}
else
{
situacao = "REPROVADO";
}
return(situacao);
}
public UnitOfWork(ConsultaUTNContext context)
{
_context = context;
Materias = new MateriaRepository(_context);
Departamentos = new DepartamentoRepository(_context);
Usuarios = new UsuarioRepository(_context);
HorariosConsulta = new HorarioConsultaRepository(_context);
HorariosConsultaFechados = new HorarioConsultaFechadoRepository(_context);
Inscripciones = new InscripcionRepository(_context);
}
public CAEFController(IFIADRepository repositorioFIAD,
UsuarioServices repositorioUsuario, RolServices servicioRol,
SolicitudAdministrativaServices servicioSolicitud, CarreraRepository repositorioCarrera,
MateriaRepository repositorioMateria)
{
_repositorioFIAD = repositorioFIAD;
_servicioUsuario = repositorioUsuario;
_serviocioRol = servicioRol;
_servicioSolicitud = servicioSolicitud;
_repositorioCarrera = repositorioCarrera;
_repositorioMateria = repositorioMateria;
}
public void TestDeleteMateriaERROR()
{
var materiaRepository = new MateriaRepository();
var materiaModel = new MateriaModel()
{
MateriaDesc = "Matemática",
MateriaDataCad = DateTime.Parse("10/10/2000"),
materiaSitacao = "A"
};
Assert.AreEqual(materiaRepository.DeleteMateria(materiaModel), false);
}
public ActionResult Crear(Materia materia)
{
materia.InstitucionID = Convert.ToInt64(HttpContext.Session["institucion"].ToString());
var mensaje = MateriaRepository.createMateria(materia);
if (mensaje == "OK")
{
ViewBag.mensaje = "La carga se realizó exitosamente.";
}
else
{
ViewBag.error = mensaje;
}
return(View());
}
public ActionResult Eliminar(Materia materia)
{
var mensaje = MateriaRepository.deleteMateria(materia.ID);
if (mensaje == "OK")
{
ViewBag.mensaje = "La materia se eliminó exitosamente.";
}
else
{
ViewBag.error = mensaje;
}
return(RedirectToAction("Index"));
}
public ActionResult Editar(Materia materia)
{
materia.InstitucionID = Convert.ToInt64(HttpContext.Session["institucion"].ToString());
var mensaje = MateriaRepository.updateMateria(materia);
if (mensaje == "OK")
{
ViewBag.mensaje = "La carga se editó exitosamente.";
}
else
{
ViewBag.error = mensaje;
}
return(RedirectToAction("Index"));
}
public JsonResult ConsultarDetalhesProvasAluno(int id)
{
try
{
List <DetalheProvasAlunoViewModel> detalhes = new List <DetalheProvasAlunoViewModel>();
MateriaAlunoRepository materiaAlunoRep = new MateriaAlunoRepository();
MateriaRepository materiaRep = new MateriaRepository();
ISimulacaoPeriodoAcademico simulador = new SimulacaoPeriodoAcademico();
foreach (MateriaAluno ma in materiaAlunoRep.FindAllByIdAluno(id))
{
DetalheProvasAlunoViewModel d = new DetalheProvasAlunoViewModel();
Materia materia = materiaRep.FindById(ma.IdMateria);
if (materia != null)
{
d.NomeMateria = materia.Nome;
d.Prova1 = Math.Round(ma.NotaProva1, 1);
d.Prova2 = Math.Round(ma.NotaProva2, 1);
d.Prova3 = Math.Round(ma.NotaProva3, 1);
d.ProvaFinal = Math.Round(ma.NotaProvaFinal, 1);
d.MediaPonderada = simulador.CalcularMediaPonderada(
d.Prova1, d.Prova2, d.Prova3, materia.PesoProva1,
materia.PesoProva2, materia.PesoProva3);
if (simulador.VerificaSeFazProvaFinal(d.MediaPonderada))
{
d.MediaAritmetica = simulador.CalcularMediaAritmetica(
d.MediaPonderada, d.ProvaFinal);
}
d.Situacao = simulador.ObterSituacaoMateria(d.MediaPonderada, d.MediaAritmetica);
}
detalhes.Add(d);
}
return(Json(detalhes, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(e.Message, JsonRequestBehavior.AllowGet));
}
}
public void Simular()
{
MateriaRepository materiaRep = new MateriaRepository();
AlunoRepository alunoRep = new AlunoRepository();
MateriaAlunoRepository materiaAlunoRep = new MateriaAlunoRepository();
Random random = new Random();
//Exclui a simulação existente para incluir a nova(1(uma) sumulação por vez)
foreach (MateriaAluno ma in materiaAlunoRep.FindAll())
{
materiaAlunoRep.Delete(ma);
}
//Faz a nova simulação
foreach (Materia materia in materiaRep.FindAll())
{
foreach (Aluno aluno in alunoRep.FindAll())
{
MateriaAluno ma = new MateriaAluno();
ma.IdMateria = materia.IdMateria;
ma.IdAluno = aluno.IdAluno;
ma.NotaProva1 = Math.Round(Convert.ToDecimal(random.NextDouble() * 10), 1);
ma.NotaProva2 = Math.Round(Convert.ToDecimal(random.NextDouble() * 10), 1);
ma.NotaProva3 = Math.Round(Convert.ToDecimal(random.NextDouble() * 10), 1);
//calcula a média ponderada das notas para saber se precisa
//simular a prova final
decimal mediaPonderada = CalcularMediaPonderada(
ma.NotaProva1, ma.NotaProva2, ma.NotaProva3,
materia.PesoProva1, materia.PesoProva2, materia.PesoProva3);
if (mediaPonderada > 4.0M && mediaPonderada < 6.0M)
{
//simula a prova final
ma.NotaProvaFinal = Math.Round(Convert.ToDecimal(random.NextDouble() * 10), 1);
}
materiaAlunoRep.Insert(ma);
}
}
}
public void TestDeleteNotaOK()
{
var notaRepository = new NotaRepository();
var alunoRepository = new AlunoRepository();
var materiaRepository = new MateriaRepository();
var alunoModel = new AlunoModel()
{
AlunoCPF = 99689899082,
AlunoNome = "Logan",
AlunoSobrenome = "Da Silva",
AlunoCurso = "Geografia",
AlunoNascimento = Convert.ToDateTime("10/02/1998"),
};
alunoRepository.CreateAluno(alunoModel);
alunoRepository.VerificaCPFAluno(alunoModel.AlunoCPF.ToString(), out int?idAluno);
var materiaModel = new MateriaModel()
{
MateriaDesc = "Matemática",
MateriaDataCad = DateTime.Parse("10/10/2000"),
materiaSitacao = "A"
};
materiaRepository.CreateMateria(materiaModel);
materiaRepository.VerificaMateriaCadastrada(materiaModel.MateriaDesc, out int?idMateria);
var notaModel = new NotasAlunoModel()
{
AlunoID = Convert.ToInt32(idAluno),
MateriaID = Convert.ToInt32(idMateria),
notaMateria = 100
};
notaRepository.SalvaNotaMateriaAluno(notaModel);
Assert.AreEqual(notaRepository.DeletaNotaMateriaAluno(notaModel), true);
notaRepository.DeletaNotaMateriaAluno(notaModel);
alunoRepository.DeleteAluno(alunoModel);
materiaRepository.DeleteMateria(materiaModel);
}
public JsonResult InserirMateria(MateriaInclusaoViewModel model)
{
try
{
Materia materia = new Materia();
materia.Nome = model.Nome;
materia.PesoProva1 = model.PesoProva1;
materia.PesoProva2 = model.PesoProva2;
materia.PesoProva3 = model.PesoProva3;
MateriaRepository materiaRep = new MateriaRepository();
materiaRep.Insert(materia);
return(Json("Matéria inserida com sucesso!"));
}
catch (Exception e)
{
return(Json(e.Message));
}
}
public void CreateMateria()
{
var menu = new MenuService();
var optionMenu = new OptionMenuService();
var materia = new MateriaModel();
var materiaRepository = new MateriaRepository();
string descMateria;
string dataCadastro;
string situacaoMateria;
bool valid = false;
Console.Clear();
Console.WriteLine("------------------------------------------");
Console.WriteLine(" Universidade Ecológica do Sítio do Caqui ");
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Cadastrar Matéria |");
Console.WriteLine("------------------------------------------");
Console.Write("Descrição: ");
while (!valid)
{
descMateria = Console.ReadLine();
var nomeMateria = descMateria.Split(' ');
if (string.IsNullOrEmpty(descMateria))
{
valid = false;
}
for (var i = 0; i < nomeMateria.Length; i++)
{
bool verifica = nomeMateria[i].All(char.IsLetter);
if (verifica)
{
valid = true;
continue;
}
else
{
valid = false;
}
}
if (!valid)
{
optionMenu.OperationError();
Console.Write("Descrição: ");
}
else
{
materia.MateriaDesc = descMateria;
continue;
}
}
valid = false;
Console.Write("Data cadastro (dd/mm/aaaa): ");
while (!valid)
{
dataCadastro = Console.ReadLine();
try
{
string data = dataCadastro;
int maiorAnoPermitido = DateTime.Now.Year;
int menorAnoPermitido = 1800;
string[] val = data.Split('/');
int dia, mes, ano;
if (int.TryParse(val[0], out dia) && int.TryParse(val[1], out mes) && int.TryParse(val[2], out ano))
{
if (ano >= menorAnoPermitido && ano <= maiorAnoPermitido)
{
if (mes >= 1 && mes <= 12)
{
int maxDia = (mes == 2 ? (ano % 4 == 0 ? 29 : 28) : mes <= 7 ? (mes % 2 == 0 ? 30 : 31) : (mes % 2 == 0 ? 31 : 30));
if (dia >= 1 && dia <= maxDia)
{
valid = true;
}
else
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Dia inválido! |");
Console.WriteLine("------------------------------------------");
valid = false;
}
}
else
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Mês inválido! |");
Console.WriteLine("------------------------------------------");
valid = false;
}
}
else
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Ano inválido! |");
Console.WriteLine("------------------------------------------");
valid = false;
}
}
else
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Data inválida! |");
Console.WriteLine("------------------------------------------");
valid = false;
}
}
catch
{
valid = false;
}
if (!valid)
{
optionMenu.OperationError();
Console.Write("Data nascimento (dd/mm/aaaa): ");
}
else
{
materia.MateriaDataCad = Convert.ToDateTime(dataCadastro);
continue;
}
}
valid = false;
Console.Write("Situação (A - Ativo | I - Inativo): ");
while (!valid)
{
situacaoMateria = Console.ReadLine();
valid = !string.IsNullOrWhiteSpace(situacaoMateria) &&
situacaoMateria.All(char.IsLetter);
if (situacaoMateria.ToUpper().Equals("A") ||
situacaoMateria.ToUpper().Equals("I"))
{
valid = true;
}
else
{
valid = false;
}
if (!valid)
{
optionMenu.OperationError();
Console.Write("Situação (A - Ativo | I - Inativo): ");
}
else
{
materia.materiaSitacao = situacaoMateria.ToUpper();
continue;
}
}
optionMenu.SalvaExcluiSair();
Console.Write("-> ");
var opcao = Console.ReadLine();
try
{
switch (opcao)
{
case "1":
menu.Menu();
break;
case "2":
var cadastado = materiaRepository.CreateMateria(materia);
if (!cadastado)
{
Console.Clear();
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Já existe essa matéria cadastrada |");
}
else
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Matéria cadastrada! |");
}
optionMenu.MenuEscolha();
break;
case "3":
var deletado = materiaRepository.CreateMateria(materia);
if (!deletado)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Não existe essa matéria cadastrada! |");
}
else
{
Console.Clear();
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Matéria deletada! |");
}
optionMenu.MenuEscolha();
break;
default:
break;
}
}
catch (Exception)
{
throw;
}
}
public void CreateAlunoNota()
{
var menu = new MenuService();
var optionMenu = new OptionMenuService();
string cpfAluno;
string descMateria;
string notaAluno;
bool valid = false;
var notasAluno = new NotasAlunoModel();
var alunoRepository = new AlunoRepository();
var notaRepository = new NotaRepository();
var materiaRepository = new MateriaRepository();
Console.Clear();
Console.WriteLine("------------------------------------------");
Console.WriteLine(" Universidade Ecológica do Sítio do Caqui ");
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Cadastrar Nota |");
Console.WriteLine("------------------------------------------");
Console.Write("Aluno CPF: ");
while (!valid)
{
cpfAluno = Console.ReadLine();
if (ValidaCPF.IsCpf(cpfAluno))
{
valid = true;
}
else
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("| CPF inválido! |");
Console.WriteLine("------------------------------------------");
valid = false;
}
if (!valid)
{
optionMenu.OperationError();
Console.Write("Aluno CPF: ");
}
else
{
if (alunoRepository.VerificaCPFAluno(cpfAluno, out int?idAluno))
{
notasAluno.AlunoID = Convert.ToInt32(idAluno);
valid = true;
}
else
{
valid = false;
}
}
}
valid = false;
Console.Write("Matéria: ");
while (!valid)
{
descMateria = Console.ReadLine();
if (string.IsNullOrEmpty(descMateria))
{
valid = false;
}
else
{
valid = true;
}
if (!valid)
{
optionMenu.OperationError();
Console.Write("Matéria: ");
}
else
{
if (materiaRepository.VerificaMateriaCadastrada(descMateria, out int?idMateria))
{
notasAluno.MateriaID = Convert.ToInt32(idMateria);
valid = true;
}
else
{
valid = false;
}
}
}
valid = false;
Console.Write("Nota (0 a 100): ");
while (!valid)
{
notaAluno = Console.ReadLine();
int notaint = 0;
valid = !string.IsNullOrWhiteSpace(notaAluno);
if (notaAluno.All(char.IsNumber))
{
try
{
notaint = Convert.ToInt32(notaAluno);
if (notaint >= 0 && notaint <= 100)
{
Console.WriteLine(notaint);
notasAluno.notaMateria = notaint;
valid = true;
continue;
}
else
{
valid = false;
}
}
catch
{
valid = false;
}
}
else
{
valid = false;
}
if (!valid)
{
optionMenu.OperationError();
Console.Write("Nota (0 a 100): ");
}
else
{
Console.WriteLine(notaint);
notasAluno.notaMateria = notaint;
continue;
}
}
optionMenu.SalvaExcluiSair();
Console.Write("-> ");
var opcao = Console.ReadLine();
try
{
switch (opcao)
{
case "1":
menu.Menu();
break;
case "2":
var cadastrado = notaRepository.SalvaNotaMateriaAluno(notasAluno);
if (!cadastrado)
{
Console.Clear();
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Já possui nota cadastrada nessa matéria|");
}
else
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Nota cadastrada! |");
}
optionMenu.MenuEscolha();
break;
case "3":
var deletado = notaRepository.DeletaNotaMateriaAluno(notasAluno);
if (!deletado)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Essa nota não está cadastrada! |");
}
else
{
Console.Clear();
Console.WriteLine("------------------------------------------");
Console.WriteLine("| Nota deletada! |");
}
optionMenu.MenuEscolha();
break;
default:
break;
}
}
catch (Exception)
{
throw;
}
}
