public async Task <IActionResult> DeleteConfirmed(AlunoTurma alunoTurma)
{
_context.AlunoTurmas.Remove(alunoTurma);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index), new { turmaId = alunoTurma.TurmaId }));
}
public ICommandResult Handler(CadastrarAlunoTurmaCommand command)
{
command.Validar();
if (command.Invalid)
{
return(new GenericCommandResult(false, "Dados Inválidos!", command.Notifications));
}
var aluno = _repositorioAluno.BuscarPorId(command.IdAluno);
if (aluno == null)
{
return(new GenericCommandResult(false, "Aluno não encontrado", null));
}
var turma = _repositorioTurma.BuscarTurmaPorId(command.IdTurma);
if (turma == null)
{
return(new GenericCommandResult(false, "Turma não encontrada", null));
}
var alunoTurma = new AlunoTurma(command.IdAluno, command.IdTurma, command.AnotacaoProfessor);
if (alunoTurma.Valid)
{
_repositorio.AdicionarAlunoATurma(alunoTurma);
}
return(new GenericCommandResult(true, "Aluno inserido na turma com sucesso", alunoTurma));
}
public async Task <Ranking> DiminuirNotaRankingAluno(ObjetivoAluno _aluno, AlunoTurma _alunoTurma)
{
try
{
//Buscando os dados do Usuario de acordo com o IdUsuairo inserindo no objeto alunoTurma
Usuario usuario = _repositoryUsuario.BuscarUsuarioPorId((int)_alunoTurma.IdUsuario);
//Procurando o ranking do aluno para poder alterar sua nota
Ranking _rankingProcurado = BuscarRankingDoAluno(usuario.Nome);
//Verificando a nota do objetivo excluido e abatendo seu valor da nota total do aluno
_rankingProcurado.NotaTotal -= _aluno.Nota;
//Buscando os dados do Objetivo concluido para verficarmos se o mesmo é um objetivo oculto
Objetivo _objetivo = _repositoryObjetivo.BuscarObjetivoPorId((int)_aluno.IdObjetivo);
//Caso seja um objetivo oculto, subtrairemos a quantidade de objetivos oculto concluidos do aluno
if (_objetivo.IdCategoria == 3)
{
_rankingProcurado.ObjetivosOculto -= 1;
}
//Salvando os dados corrigidos
_contexto.Entry(_rankingProcurado).State = EntityState.Modified;
await _contexto.SaveChangesAsync();
return(_rankingProcurado);
}
catch (Exception _e)
{
throw new Exception(_e.Message);
}
}
public async Task <IActionResult> Edit(int?id, [Bind("AlunoId,TurmaId")] AlunoTurma alunoTurma)
{
if (id != alunoTurma.AlunoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(alunoTurma);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AlunoTurmaExists(alunoTurma.AlunoId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AlunoId"] = new SelectList(_context.Alunos, "Id", "Nome", alunoTurma.AlunoId);
ViewData["TurmaId"] = new SelectList(_context.Turmas, "Id", "Idioma", alunoTurma.TurmaId);
return(View(alunoTurma));
}
public ActionResult <AlunoTurma> MatricularAluno(long id, [FromBody] long idAluno)
{
var turma = _context.Turmas.FirstOrDefault(f => f.Id == id);
if (turma.Vagas < 1)
{
throw new ApplicationException("Turma sem vagas!");
}
var turmasAluno = _context.AlunosTurmas.Where(w => w.IdAluno == idAluno && w.IdTurma == id);
if (turmasAluno.Any())
{
throw new ApplicationException("Aluno já matriculado na turma!");
}
turma.Vagas--;
var matricula = new AlunoTurma()
{
IdAluno = idAluno,
IdTurma = id
};
_context.AlunosTurmas.Add(matricula);
_context.SaveChanges();
return(matricula);
}
public async Task <IActionResult> PutAlunoTurma(Guid id, AlunoTurma alunoTurma)
{
if (id != alunoTurma.IdAlunoTurma)
{
return(BadRequest());
}
_context.Entry(alunoTurma).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AlunoTurmaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async void DeveCalcularMediaCorretamente()
{
// Arrange
float?[] notas = new float?[4] {
7.9F, 7.4F, 4.4F, 7.2F
};
float mediaEsperada = 7.5F;
var alunoTurma = new AlunoTurma()
{
Id = "1", AlunoId = "1", TurmaId = "1", Notas = notas
};
var alunoTurmaRepositoryMock = new Mock <Repository <AlunoTurma> >();
alunoTurmaRepositoryMock.Setup(r => r.GetItemAsync(It.IsAny <string>()))
.Returns(Task.FromResult(alunoTurma));
var alunosTurmaService = new AlunoTurmaServiceImp(alunoTurmaRepositoryMock.Object);
float media = await alunosTurmaService.GetAlunoTurmaMedia(alunoTurma.TurmaId, alunoTurma.AlunoId);
Assert.Equal(mediaEsperada, media);
}
public async Task <ActionResult <AlunoTurma> > PostAlunoTurma(AlunoTurma alunoTurma)
{
_context.AlunoTurma.Add(alunoTurma);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAlunoTurma", new { id = alunoTurma.IdAlunoTurma }, alunoTurma));
}
public IActionResult PostAlunoTurma([FromForm] AlunoTurma alunoTurma)
{
_alunoRepository.Adicionar(alunoTurma);
return(CreatedAtAction("GetAlunoTurma", new { id = alunoTurma.IdAlunoTurma }, alunoTurma));
}
public async Task <ObjetivoAluno> AlterarObjetivosDoAluno(ObjetivoAluno _objetivoAluno)
{
try
{
//Verificando o objetivoAluno previamente cadastrados para verificar as alterações
ObjetivoAluno _objetivo = BuscarObjetivoDoAlunoPorId(_objetivoAluno.Id);
//Buscando o objeto alunoTurma de acordo com o IdAlunoTurma do objetivoAluno cadastrado
AlunoTurma _alunoTurma = _alunoTurmaRepository.BuscarAlunoTurmaPorId((int)_objetivoAluno.IdAlunoTurma);
//Passando ambos os objetos para o nosso ranking, para reavaliarmos a nota do aluno
await _rankingRepository.AlterarNotaRankingAluno(_objetivoAluno, _objetivo, _alunoTurma);
_objetivo.IdAlunoTurma = _objetivoAluno.IdAlunoTurma;
_objetivo.IdObjetivo = _objetivoAluno.IdObjetivo;
_objetivo.Nota = _objetivoAluno.Nota;
_contexto.Entry(_objetivo).State = EntityState.Modified;
await _contexto.SaveChangesAsync();
return(_objetivo);
}
catch (Exception _e)
{
throw new Exception(_e.Message);
}
}
/// <summary>
/// Fazer uma alteração no cadastro do aluno
/// </summary>
/// <param name="alunoturma">Aluno alterado</param>
public void Editar(AlunoTurma alunoturma)
{
try
{
//Busca o Id do aluno
AlunoTurma alunoTurma1 = BuscarPorId(alunoturma.Id);
//Verificar se o aluno existe (ou não)
if (alunoTurma1 == null)
{
throw new Exception("Aluno não encontrado");
}
//Dados do aluno que podem ser alterados
alunoTurma1.Matricula = alunoturma.Matricula;
alunoTurma1.Turma = alunoturma.Turma;
alunoTurma1.Usuario = alunoturma.Usuario;
//Alterar
_ctx.AlunoTurma.Update(alunoTurma1);
//Salvar
_ctx.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public Ranking AdicionarAlunoAoRanking(AlunoTurma _aluno)
{
try
{
Ranking _ranking = new Ranking();
//Pegando os dados de alunoTurma e aprovetando o IdUsuario para buscar as informações do
//próprio usuário;
Usuario _alunoCadastrado = _repositoryUsuario.BuscarUsuarioPorId((int)_aluno.IdUsuario);
//Atribuindo o nome de usuário e sua turma ao seu ranking
_ranking.NomeAluno = _alunoCadastrado.Nome;
_ranking.IdTurma = _aluno.IdTurma;
//Adicionando ranking ao banco de dados
_contexto.Ranking.Add(_ranking);
_contexto.SaveChanges();
return(_ranking);
}catch (Exception _e)
{
throw new Exception(_e.Message);
}
}
public void Editar(AlunoTurma alunoturma)
{
try
{
AlunoTurma alunoTurmaTemp = BuscarPorId(alunoturma.IdAlunoTurma);
if (alunoTurmaTemp == null)
{
throw new Exception("Aluno não foi encontrado");
}
//Caso exista, fará a alteração
alunoTurmaTemp.Matricula = alunoturma.Matricula;
alunoTurmaTemp.IdUsuario = alunoturma.IdUsuario;
alunoTurmaTemp.IdTurma = alunoturma.IdTurma;
_ctx.AlunoTurma.Update(alunoTurmaTemp);
_ctx.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// Adiciona um tipo alunoTurma
/// </summary>
/// <param name="alunoTurma">alunoTurma para ser adicionado</param>
public void Adicionar(AlunoTurma alunoTurma)
{
using (EduxContext _ctx = new EduxContext())
{
_ctx.AlunoTurma.Add(alunoTurma);
_ctx.SaveChanges();
}
}
public bool DeleteFromTurma(Guid idAluno, Guid idTurma)
{
var entity = new AlunoTurma(idAluno, idTurma);
entity.Delete();
_repositoryAlunoTurma.DeleteAlunoTurma(entity);
return(true);
}
public static AlunoTurma ToDomainModel(AlunoTurmaVieModel model)
{
var alunoturma = new AlunoTurma(
Guid.NewGuid(),
model.AlunoId,
model.TurmaId);
return(alunoturma);
}
public async Task <IActionResult> EntrarTurma(int id, [Bind("Id,ChaveAcesso")] Turma chave)
{
var turma = await _context.Turmas.Include("Alunos.Aluno").SingleOrDefaultAsync(m => m.Id == id);
var user = _userManager.GetUserAsync(User);
Aluno aluno = (Aluno)await user;
var alunoturma = _context.AlunoTurmas.Where(x => x.AlunoId == aluno.Id && x.TurmaId == turma.Id && x.Ativo == true).SingleOrDefault();
//var senha = chave.ChaveAcesso.Equals(null) ? "" : chave.ChaveAcesso;
// if (!turma.IAluno.Contains(aluno))
if (alunoturma == null)
{
if (chave.ChaveAcesso == null)
{
AlunoTurma at = new AlunoTurma
{
AlunoId = aluno.Id,
TurmaId = turma.Id,
Ativo = true,
DataIngressao = DateTime.Now
};
_context.AlunoTurmas.Update(at);
}
else
{
if (chave.ChaveAcesso.Equals(turma.ChaveAcesso))
{
AlunoTurma at = new AlunoTurma
{
AlunoId = aluno.Id,
TurmaId = turma.Id,
Ativo = true,
DataIngressao = DateTime.Now
};
_context.AlunoTurmas.Update(at);
}
else
{
return(NotFound());
}
}
await _context.SaveChangesAsync();
LogUsuariosController log = new LogUsuariosController(_context);
await log.SetLog($"{aluno.FullName} entrou na turma {turma.Nome}", aluno.Id);
TempData["alert"] = $"Você entrou na turma";
}
else
{
TempData["alert"] = $"Você ja está na turma";
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction(nameof(Index)));
}
public AddAlunoResponse Add(AddAlunoRequest aluno)
{
var entity = new Aluno(aluno.Nome, aluno.Matricula);
entity = _repository.Create(entity);
var alunoTurma = new AlunoTurma(entity.IdAluno, aluno.IdTurma);
_repositoryAlunoTurma.AddAluno(alunoTurma);
return((AddAlunoResponse)entity);
}
public async Task <AlunoTurma> AdicionarTurma(AlunoTurma turma)
{
var ok = await this._alunoTurmaRepository.Add(turma);
if (ok)
{
return(turma);
}
return(null);
}
/*
* public List<AlunoTurma> BuscarPorNome(string nome)
* {
* throw new NotImplementedException();
* }*/
public void Editar(AlunoTurma alunoTurma)
{
AlunoTurma alunoTurma1 = BuscarPorId(alunoTurma.Id);
if (alunoTurma.Id == null)
{
_ctx.AlunosTurmas.Update(alunoTurma1);
}
_ctx.SaveChanges();
}
public AlunoTurma BuscarPorId(Guid id)
{
AlunoTurma alunoTurma = _ctx.AlunosTurmas.Find(id);
if (alunoTurma == null)
{
throw new Exception("Aluno não localizado");
}
return(alunoTurma);
}
public IActionResult Put(Guid id, AlunoTurma alunoturma)
{
try {
_alunoturmaRepository.Editar(alunoturma);
return(Ok(alunoturma));
}
catch (Exception ex) {
return(BadRequest(ex.Message));
}
}
public IActionResult Post([FromForm] AlunoTurma alunoturma)
{
try {
_alunoturmaRepository.Adicionar(alunoturma);
return(Ok(alunoturma));
}
catch (Exception ex) {
return(BadRequest(ex.Message));
}
}
public void Excluir(Guid id)
{
AlunoTurma alunoTurma = BuscarPorId(id);
if (alunoTurma == null)
{
throw new Exception("Aluno não localizado");
}
_ctx.AlunosTurmas.Remove(alunoTurma);
_ctx.SaveChanges();
}
public AlunoTurma AdicionarAlunoTurma(AlunoTurma alunoturma)
{
alunoturma.ValidationResult = new AlunoTurmaProntoParaCadastroValidations(_alunoturmarepository).Validate(alunoturma);
if (!alunoturma.ValidationResult.IsValid)
{
return(alunoturma);
}
alunoturma.ValidationResult.Message = "Aluno cadastrado com sucesso :)";
return(_alunoturmarepository.AdicionarAlunoTurma(alunoturma));
}
public void Adicionar(AlunoTurma alunoturma)
{
try {
_context.AlunoTurma.Add(alunoturma);
_context.SaveChanges();
}
catch (Exception ex) {
throw new Exception(ex.Message);
}
}
public IActionResult Post([FromBody] AlunoTurma alunoTurma)
{
try
{
_repo.Adicionar(alunoTurma);
return(Ok(alunoTurma));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void Remover(Guid id)
{
try {
AlunoTurma alunoturmaTemp = BuscarPorId(id);
_context.AlunoTurma.Remove(alunoturmaTemp);
_context.SaveChanges();
}
catch (Exception ex) {
throw new Exception(ex.Message);
}
}
public AlunoTurma BuscarPorId(Guid id)
{
try
{
AlunoTurma alunoTurma = _ctx.AlunoTurma.Find(id);
return(alunoTurma);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> Create([Bind("AlunoId,TurmaId")] AlunoTurma alunoTurma)
{
if (ModelState.IsValid)
{
_context.Add(alunoTurma);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["AlunoId"] = new SelectList(_context.Alunos, "Id", "Nome", alunoTurma.AlunoId);
ViewData["TurmaId"] = new SelectList(_context.Turmas, "Id", "Idioma", alunoTurma.TurmaId);
return(View(alunoTurma));
}
