public async Task <PaginacaoResultadoDto <CompensacaoAusenciaListagemDto> > ListarPaginado(string turmaId, string disciplinaId, int bimestre, string nomeAtividade, string nomeAluno)
{
var listaCompensacoesDto = new List <CompensacaoAusenciaListagemDto>();
var listaCompensacoes = await repositorioCompensacaoAusencia.Listar(Paginacao, turmaId, disciplinaId, bimestre, nomeAtividade);
// Busca os nomes de alunos do EOL por turma
var alunos = await servicoEOL.ObterAlunosPorTurma(turmaId);
foreach (var compensacaoAusencia in listaCompensacoes.Items)
{
var compensacaoDto = MapearParaDto(compensacaoAusencia);
compensacaoAusencia.Alunos = await consultasCompensacaoAusenciaAluno.ObterPorCompensacao(compensacaoAusencia.Id);
if (compensacaoAusencia.Alunos.Any())
{
foreach (var aluno in compensacaoAusencia.Alunos)
{
// Adiciona nome do aluno no Dto de retorno
var alunoEol = alunos.FirstOrDefault(a => a.CodigoAluno == aluno.CodigoAluno);
if (alunoEol != null)
{
compensacaoDto.Alunos.Add(alunoEol.NomeAluno);
}
}
}
listaCompensacoesDto.Add(compensacaoDto);
}
;
if (!string.IsNullOrEmpty(nomeAluno))
{
listaCompensacoesDto = listaCompensacoesDto.Where(c => c.Alunos.Exists(a => a.ToLower().Contains(nomeAluno.ToLower()))).ToList();
}
// Mostrar apenas 3 alunos
foreach (var compensacaoDto in listaCompensacoesDto.Where(c => c.Alunos.Count > 3))
{
var qtd = compensacaoDto.Alunos.Count();
compensacaoDto.Alunos = compensacaoDto.Alunos.GetRange(0, 3);
compensacaoDto.Alunos.Add($"mais {qtd - 3} alunos");
}
var resultado = new PaginacaoResultadoDto <CompensacaoAusenciaListagemDto>();
resultado.TotalPaginas = listaCompensacoes.TotalPaginas;
resultado.TotalRegistros = listaCompensacoes.TotalRegistros;
resultado.Items = listaCompensacoesDto;
return(resultado);
}
public async Task <IEnumerable <AlunoAusenteDto> > ObterListaAlunosComAusencia(string turmaId, string disciplinaId, int bimestre)
{
var alunosAusentesDto = new List <AlunoAusenteDto>();
// Busca dados da turma
var turma = BuscaTurma(turmaId);
// Busca periodo
var periodo = BuscaPeriodo(turma.AnoLetivo, turma.ModalidadeCodigo, bimestre, turma.Semestre);
var alunosEOL = await servicoEOL.ObterAlunosPorTurma(turmaId);
if (alunosEOL == null || !alunosEOL.Any())
{
throw new NegocioException("Não foram localizados alunos para a turma selecionada.");
}
var disciplinasEOL = servicoEOL.ObterDisciplinasPorIds(new long[] { long.Parse(disciplinaId) });
if (disciplinasEOL == null || !disciplinasEOL.Any())
{
throw new NegocioException("Disciplina informada não localizada no EOL.");
}
var quantidadeMaximaCompensacoes = int.Parse(repositorioParametrosSistema.ObterValorPorTipoEAno(TipoParametroSistema.QuantidadeMaximaCompensacaoAusencia));
var percentualFrequenciaAlerta = int.Parse(repositorioParametrosSistema.ObterValorPorTipoEAno(disciplinasEOL.First().Regencia ? TipoParametroSistema.CompensacaoAusenciaPercentualRegenciaClasse : TipoParametroSistema.CompensacaoAusenciaPercentualFund2));
foreach (var alunoEOL in alunosEOL)
{
var frequenciaAluno = repositorioFrequenciaAlunoDisciplinaPeriodo.ObterPorAlunoDisciplinaData(alunoEOL.CodigoAluno, disciplinaId, periodo.PeriodoFim);
if (frequenciaAluno == null || frequenciaAluno.NumeroFaltasNaoCompensadas == 0)
{
continue;
}
var faltasNaoCompensadas = int.Parse(frequenciaAluno.NumeroFaltasNaoCompensadas.ToString());
alunosAusentesDto.Add(new AlunoAusenteDto()
{
Id = alunoEOL.CodigoAluno,
Nome = alunoEOL.NomeAluno,
QuantidadeFaltasTotais = faltasNaoCompensadas,
MaximoCompensacoesPermitidas = quantidadeMaximaCompensacoes > faltasNaoCompensadas ? faltasNaoCompensadas : quantidadeMaximaCompensacoes,
PercentualFrequencia = frequenciaAluno.PercentualFrequencia,
Alerta = frequenciaAluno.PercentualFrequencia <= percentualFrequenciaAlerta
});
}
return(alunosAusentesDto);
}
private void CargaAlunos(string codigoTurma)
{
var alunos = servicoEOL.ObterAlunosPorTurma(codigoTurma).Result;
if (alunos != null)
{
foreach (var aluno in alunos)
{
try
{
if (aluno.EstaInativo())
{
// Verifica Evento Matricula Gerado
if (!repositorioEventoMatricula.CheckarEventoExistente(aluno.CodigoSituacaoMatricula, aluno.DataSituacao, aluno.CodigoAluno))
{
// Inclui o Evento Matricula do aluno
IncluirEventoMatricula(aluno);
}
}
}
catch (Exception ex)
{
throw new Exception($"Aluno [{aluno.CodigoAluno}]: erro ao gerar evento matricula: {ex.Message}");
}
}
}
}
private async Task <IEnumerable <AlunoPorTurmaResposta> > ObterAlunos(Aula aula)
{
var alunos = await servicoEOL.ObterAlunosPorTurma(aula.TurmaId, aula.DataAula.Year);
if (alunos == null || !alunos.Any())
{
throw new NegocioException("Não foram encontrados alunos para a turma informada.");
}
return(alunos);
}
public async Task Salvar(IEnumerable <NotaConceito> notasConceitos, string professorRf, string turmaId, string disciplinaId)
{
turma = repositorioTurma.ObterTurmaComUeEDrePorId(turmaId);
if (turma == null)
{
throw new NegocioException($"Turma com código [{turmaId}] não localizada");
}
var idsAtividadesAvaliativas = notasConceitos.Select(x => x.AtividadeAvaliativaID);
var atividadesAvaliativas = repositorioAtividadeAvaliativa.ListarPorIds(idsAtividadesAvaliativas);
var alunos = await servicoEOL.ObterAlunosPorTurma(turmaId);
if (alunos == null || !alunos.Any())
{
throw new NegocioException("Não foi encontrado nenhum aluno para a turma informada");
}
ValidarAvaliacoes(idsAtividadesAvaliativas, atividadesAvaliativas, professorRf);
var entidadesSalvar = new List <NotaConceito>();
var notasPorAvaliacoes = notasConceitos.GroupBy(x => x.AtividadeAvaliativaID);
var usuario = await servicoUsuario.ObterUsuarioLogado();
await VerificaSeProfessorPodePersistirTurmaDisciplina(professorRf, turmaId, disciplinaId, DateTime.Today, usuario);
foreach (var notasPorAvaliacao in notasPorAvaliacoes)
{
var avaliacao = atividadesAvaliativas.FirstOrDefault(x => x.Id == notasPorAvaliacao.Key);
entidadesSalvar.AddRange(await ValidarEObter(notasPorAvaliacao.ToList(), avaliacao, alunos, professorRf, disciplinaId, usuario));
}
SalvarNoBanco(entidadesSalvar);
var alunosId = alunos.Select(a => a.CodigoAluno).ToList();
await validarMediaAlunos(idsAtividadesAvaliativas, alunosId, usuario, disciplinaId);
}
public void NotificarCompensacaoAusencia(long compensacaoId)
{
// Verifica se compensação possui alunos vinculados
var alunos = repositorioCompensacaoAusenciaAluno.ObterPorCompensacao(compensacaoId).Result;
if (alunos == null || !alunos.Any())
{
return;
}
// Verifica se possui aluno não notificado na compensação
alunos = alunos.Where(a => !a.Notificado);
if (!alunos.Any())
{
return;
}
// Carrega dados da compensacao a notificar
var compensacao = repositorioCompensacaoAusencia.ObterPorId(compensacaoId);
var turma = repositorioTurma.ObterPorId(compensacao.TurmaId);
var ue = repositorioUe.ObterUEPorTurma(turma.CodigoTurma);
var dre = repositorioDre.ObterPorId(ue.DreId);
var disciplinaEOL = ObterNomeDisciplina(compensacao.DisciplinaId);
MeusDadosDto professor = servicoEOL.ObterMeusDados(compensacao.CriadoRF).Result;
// Carrega dados dos alunos não notificados
var alunosTurma = servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma).Result;
var alunosDto = new List <CompensacaoAusenciaAlunoQtdDto>();
foreach (var aluno in alunos)
{
var alunoEol = alunosTurma.FirstOrDefault(a => a.CodigoAluno == aluno.CodigoAluno);
alunosDto.Add(new CompensacaoAusenciaAlunoQtdDto()
{
NumeroAluno = alunoEol.NumeroAlunoChamada,
CodigoAluno = aluno.CodigoAluno,
NomeAluno = alunoEol.NomeAluno,
QuantidadeCompensacoes = aluno.QuantidadeFaltasCompensadas
});
}
var gestores = BuscaGestoresUe(ue.CodigoUe);
if (gestores != null && gestores.Any())
{
foreach (var gestor in gestores)
{
var notificacaoId = NotificarCompensacaoAusencia(compensacaoId
, gestor.Usuario
, professor.Nome
, professor.CodigoRf
, disciplinaEOL
, turma.CodigoTurma
, turma.Nome
, turma.ModalidadeCodigo.GetAttribute <DisplayAttribute>().ShortName
, ue.CodigoUe
, ue.Nome
, ue.TipoEscola.GetAttribute <DisplayAttribute>().ShortName
, dre.CodigoDre
, dre.Nome
, compensacao.Bimestre
, compensacao.Nome
, alunosDto);
// Grava vinculo de notificação x compensação
repositorioNotificacaoCompensacaoAusencia.Inserir(notificacaoId, compensacaoId);
}
// Marca aluno como notificado
alunosDto.ForEach(alunoDto =>
{
var aluno = alunos.FirstOrDefault(a => a.CodigoAluno == alunoDto.CodigoAluno);
aluno.Notificado = true;
repositorioCompensacaoAusenciaAluno.Salvar(aluno);
});
}
}
public async Task <FechamentoTurmaDisciplinaBimestreDto> ObterNotasFechamentoTurmaDisciplina(string turmaId, long disciplinaId, int?bimestre)
{
var turma = repositorioTurma.ObterPorId(turmaId);
var tipoCalendario = repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, ModalidadeParaModalidadeTipoCalendario(turma.ModalidadeCodigo));
if (tipoCalendario == null)
{
throw new NegocioException("Não foi encontrado tipo de calendário escolar, para a modalidade informada.");
}
var periodosEscolares = repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id);
if (periodosEscolares == null || !periodosEscolares.Any())
{
throw new NegocioException("Não foi encontrado período Escolar para a modalidade informada.");
}
var bimestreAtual = bimestre;
if (!bimestreAtual.HasValue || bimestre == 0)
{
bimestreAtual = ObterBimestreAtual(periodosEscolares);
}
var periodoAtual = periodosEscolares.FirstOrDefault(x => x.Bimestre == bimestreAtual);
if (periodoAtual == null)
{
throw new NegocioException("Não foi encontrado período escolar para o bimestre solicitado.");
}
// Carrega alunos
var alunos = await servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma, turma.AnoLetivo);
if (alunos == null || !alunos.Any())
{
throw new NegocioException("Não foi encontrado alunos para a turma informada");
}
// DTO de retorno
var fechamentoBimestre = new FechamentoTurmaDisciplinaBimestreDto()
{
Bimestre = bimestreAtual.Value,
TotalAulasDadas = 0, // Carregar
TotalAulasPrevistas = 0, // Carregar
Alunos = new List <NotaConceitoAlunoBimestreDto>()
};
// Carrega fechamento da Turma x Disciplina x Bimestre
var fechamentoTurma = await ObterFechamentoTurmaDisciplina(turmaId, disciplinaId, bimestreAtual.Value);
if (fechamentoTurma != null)
{
var disciplinasId = new long[] { disciplinaId };
var disciplinaEOL = servicoEOL.ObterDisciplinasPorIds(disciplinasId).FirstOrDefault();
IEnumerable <DisciplinaResposta> disciplinasRegencia = null;
if (disciplinaEOL.Regencia)
{
disciplinasRegencia = await servicoEOL.ObterDisciplinasParaPlanejamento(long.Parse(turmaId), servicoUsuario.ObterLoginAtual(), servicoUsuario.ObterPerfilAtual());
}
fechamentoBimestre.Alunos = new List <NotaConceitoAlunoBimestreDto>();
var bimestreDoPeriodo = consultasPeriodoEscolar.ObterPeriodoEscolarPorData(tipoCalendario.Id, periodoAtual.PeriodoFim);
foreach (var aluno in alunos)
{
var alunoDto = new NotaConceitoAlunoBimestreDto();
alunoDto.NumeroChamada = aluno.NumeroAlunoChamada;
alunoDto.Nome = aluno.NomeAluno;
alunoDto.Ativo = aluno.CodigoSituacaoMatricula.Equals(SituacaoMatriculaAluno.Ativo);
var marcador = servicoAluno.ObterMarcadorAluno(aluno, bimestreDoPeriodo);
if (marcador != null)
{
alunoDto.Informacao = marcador.Descricao;
}
// Carrega Frequencia do aluno
if (aluno.CodigoAluno != null)
{
// Carrega notas do bimestre
var notasConceitoBimestre = await ObterNotasBimestre(aluno.CodigoAluno, fechamentoTurma.Id);
foreach (var notaConceitoBimestre in notasConceitoBimestre)
{
alunoDto.Notas = new List <NotaConceitoBimestreRetornoDto>();
((List <NotaConceitoBimestreRetornoDto>)alunoDto.Notas).Add(new NotaConceitoBimestreRetornoDto()
{
DisciplinaId = notaConceitoBimestre.DisciplinaId,
Disciplina = disciplinaEOL.Regencia ?
disciplinasRegencia.FirstOrDefault(a => a.CodigoComponenteCurricular == notaConceitoBimestre.DisciplinaId).Nome :
disciplinaEOL.Nome,
NotaConceito = notaConceitoBimestre.Nota > 0 ? notaConceitoBimestre.Nota.ToString() : ObterConceito(notaConceitoBimestre.ConceitoId)
});
}
var frequenciaAluno = repositorioFrequenciaAlunoDisciplinaPeriodo.ObterPorAlunoData(aluno.CodigoAluno, periodoAtual.PeriodoFim, TipoFrequenciaAluno.PorDisciplina, disciplinaId.ToString());
if (frequenciaAluno != null)
{
alunoDto.QuantidadeFaltas = frequenciaAluno.TotalAusencias;
alunoDto.QuantidadeCompensacoes = frequenciaAluno.TotalCompensacoes;
alunoDto.PercentualFrequencia = frequenciaAluno.PercentualFrequencia;
}
fechamentoBimestre.Alunos.Add(alunoDto);
}
}
}
var aulaPrevisa = await consultasAulaPrevista.ObterAulaPrevistaDada(turma.ModalidadeCodigo, turma.CodigoTurma, disciplinaId.ToString());
var aulaPrevistaBimestreAtual = new AulasPrevistasDadasDto();
if (aulaPrevisa != null)
{
aulaPrevistaBimestreAtual = aulaPrevisa.AulasPrevistasPorBimestre.FirstOrDefault(a => a.Bimestre == bimestreAtual);
}
fechamentoBimestre.Bimestre = bimestreAtual.Value;
fechamentoBimestre.TotalAulasDadas = aulaPrevistaBimestreAtual.Cumpridas;
fechamentoBimestre.TotalAulasPrevistas = aulaPrevistaBimestreAtual.Previstas.Quantidade;
return(fechamentoBimestre);
}
public async Task <NotasConceitosRetornoDto> ListarNotasConceitos(ListaNotasConceitosConsultaDto filtro)
{
var modalidadeTipoCalendario = ObterModalidadeCalendario(filtro.Modalidade);
var tipoCalendario = repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(filtro.AnoLetivo, modalidadeTipoCalendario);
if (tipoCalendario == null)
{
throw new NegocioException("Não foi encontrado tipo de calendário escolar, para a modalidade informada.");
}
var periodosEscolares = repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id);
if (periodosEscolares == null || !periodosEscolares.Any())
{
throw new NegocioException("Não foi encontrado período Escolar para a modalidade informada.");
}
var bimestre = filtro.Bimestre;
if (!bimestre.HasValue || bimestre == 0)
{
bimestre = ObterBimestreAtual(periodosEscolares);
}
var periodoAtual = periodosEscolares.FirstOrDefault(x => x.Bimestre == bimestre);
if (periodoAtual == null)
{
throw new NegocioException("Não foi encontrado período escolar para o bimestre solicitado.");
}
List <AtividadeAvaliativa> atividadesAvaliativaEBimestres = new List <AtividadeAvaliativa>();
// Carrega disciplinas filhas da disciplina passada como parametro
var disciplinasProfessor = await consultasDisciplina.ObterDisciplinasPorProfessorETurma(filtro.TurmaCodigo, true);
var disciplinasFilha = disciplinasProfessor.Where(d => d.CdComponenteCurricularPai == int.Parse(filtro.DisciplinaCodigo));
if (disciplinasFilha.Any())
{
foreach (var disciplinaFilha in disciplinasFilha)
{
atividadesAvaliativaEBimestres.AddRange(await consultasAtividadeAvaliativa.ObterAvaliacoesNoBimestre(filtro.TurmaCodigo, disciplinaFilha.CodigoComponenteCurricular.ToString(), periodoAtual.PeriodoInicio, periodoAtual.PeriodoFim));
}
}
else
{
// Disciplina não tem disciplinas filhas então carrega avaliações da propria
atividadesAvaliativaEBimestres.AddRange(await consultasAtividadeAvaliativa.ObterAvaliacoesNoBimestre(filtro.TurmaCodigo, filtro.DisciplinaCodigo, periodoAtual.PeriodoInicio, periodoAtual.PeriodoFim));
}
if (atividadesAvaliativaEBimestres is null || !atividadesAvaliativaEBimestres.Any())
{
return(ObterRetornoGenericoBimestreAtualVazio(periodosEscolares, bimestre.Value));
}
var alunos = await servicoEOL.ObterAlunosPorTurma(filtro.TurmaCodigo);
if (alunos == null || !alunos.Any())
{
throw new NegocioException("Não foi encontrado alunos para a turma informada");
}
var retorno = new NotasConceitosRetornoDto();
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
var tipoAvaliacaoBimestral = await repositorioTipoAvaliacao.ObterTipoAvaliacaoBimestral();
retorno.BimestreAtual = bimestre.Value;
retorno.MediaAprovacaoBimestre = double.Parse(repositorioParametrosSistema.ObterValorPorTipoEAno(TipoParametroSistema.MediaBimestre));
retorno.MinimoAvaliacoesBimestrais = tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre;
retorno.PercentualAlunosInsuficientes = double.Parse(repositorioParametrosSistema.ObterValorPorTipoEAno(TipoParametroSistema.PercentualAlunosInsuficientes));
DateTime?dataUltimaNotaConceitoInserida = null;
DateTime?dataUltimaNotaConceitoAlterada = null;
var usuarioRfUltimaNotaConceitoInserida = string.Empty;
var usuarioRfUltimaNotaConceitoAlterada = string.Empty;
var nomeAvaliacaoAuditoriaInclusao = string.Empty;
var nomeAvaliacaoAuditoriaAlteracao = string.Empty;
foreach (var periodoEscolar in periodosEscolares)
{
AtividadeAvaliativa atividadeAvaliativaParaObterTipoNota = null;
var valorBimestreAtual = periodoEscolar.Bimestre;
var bimestreParaAdicionar = new NotasConceitosBimestreRetornoDto()
{
Descricao = $"{valorBimestreAtual}º Bimestre",
Numero = valorBimestreAtual,
PeriodoInicio = periodoEscolar.PeriodoInicio,
PeriodoFim = periodoEscolar.PeriodoFim
};
if (valorBimestreAtual == periodoAtual.Bimestre)
{
var listaAlunosDoBimestre = new List <NotasConceitosAlunoRetornoDto>();
var atividadesAvaliativasdoBimestre = atividadesAvaliativaEBimestres.Where(a => a.DataAvaliacao.Date >= periodoAtual.PeriodoInicio.Date &&
periodoAtual.PeriodoFim.Date >= a.DataAvaliacao.Date)
.OrderBy(a => a.DataAvaliacao)
.ToList();
var alunosIds = alunos.Select(a => a.CodigoAluno).Distinct();
var notas = repositorioNotasConceitos.ObterNotasPorAlunosAtividadesAvaliativas(atividadesAvaliativasdoBimestre.Select(a => a.Id).Distinct(), alunosIds, filtro.DisciplinaCodigo);
var ausenciasAtividadesAvaliativas = await repositorioFrequencia.ObterAusencias(filtro.TurmaCodigo, filtro.DisciplinaCodigo, atividadesAvaliativasdoBimestre.Select(a => a.DataAvaliacao).Distinct().ToArray(), alunosIds.ToArray());
var consultaEOL = servicoEOL.ObterDisciplinasPorIds(new long[] { long.Parse(filtro.DisciplinaCodigo) });
if (consultaEOL == null || !consultaEOL.Any())
{
throw new NegocioException("Disciplina informada não encontrada no EOL");
}
var disciplinaEOL = consultaEOL.First();
IEnumerable <DisciplinaResposta> disciplinasRegencia = null;
if (disciplinaEOL.Regencia)
{
disciplinasRegencia = await servicoEOL.ObterDisciplinasParaPlanejamento(long.Parse(filtro.TurmaCodigo), servicoUsuario.ObterLoginAtual(), servicoUsuario.ObterPerfilAtual());
}
var professorRfTitularTurmaDisciplina = string.Empty;
professorRfTitularTurmaDisciplina = await ObterRfProfessorTitularDisciplina(filtro.TurmaCodigo, filtro.DisciplinaCodigo, atividadesAvaliativasdoBimestre);
var fechamentoTurma = await consultasFechamentoTurmaDisciplina.ObterFechamentoTurmaDisciplina(filtro.TurmaCodigo, long.Parse(filtro.DisciplinaCodigo), valorBimestreAtual);
foreach (var aluno in alunos.Where(a => a.NumeroAlunoChamada > 0 || a.CodigoSituacaoMatricula.Equals(SituacaoMatriculaAluno.Ativo)).OrderBy(a => a.NumeroAlunoChamada).ThenBy(a => a.NomeValido()))
{
var notaConceitoAluno = new NotasConceitosAlunoRetornoDto()
{
Id = aluno.CodigoAluno, Nome = aluno.NomeValido(), NumeroChamada = aluno.NumeroAlunoChamada, PodeEditar = true
};
var notasAvaliacoes = new List <NotasConceitosNotaAvaliacaoRetornoDto>();
foreach (var atividadeAvaliativa in atividadesAvaliativasdoBimestre)
{
var notaDoAluno = ObterNotaParaVisualizacao(notas, aluno, atividadeAvaliativa);
var notaParaVisualizar = string.Empty;
if (notaDoAluno != null)
{
notaParaVisualizar = notaDoAluno.ObterNota();
if (!dataUltimaNotaConceitoInserida.HasValue || notaDoAluno.CriadoEm > dataUltimaNotaConceitoInserida.Value)
{
usuarioRfUltimaNotaConceitoInserida = $"{notaDoAluno.CriadoPor}({notaDoAluno.CriadoRF})";
dataUltimaNotaConceitoInserida = notaDoAluno.CriadoEm;
nomeAvaliacaoAuditoriaInclusao = atividadeAvaliativa.NomeAvaliacao;
}
if (notaDoAluno.AlteradoEm.HasValue)
{
if (!dataUltimaNotaConceitoAlterada.HasValue || notaDoAluno.AlteradoEm.Value > dataUltimaNotaConceitoAlterada.Value)
{
usuarioRfUltimaNotaConceitoAlterada = $"{notaDoAluno.AlteradoPor}({notaDoAluno.AlteradoRF})";
dataUltimaNotaConceitoAlterada = notaDoAluno.AlteradoEm;
nomeAvaliacaoAuditoriaAlteracao = atividadeAvaliativa.NomeAvaliacao;
}
}
}
var ausente = ausenciasAtividadesAvaliativas.Any(a => a.AlunoCodigo == aluno.CodigoAluno && a.AulaData.Date == atividadeAvaliativa.DataAvaliacao.Date);
//bool podeEditar = PodeEditarNotaOuConceito(usuarioLogado, professorRfTitularTurmaDisciplina, atividadeAvaliativa, aluno);
var notaAvaliacao = new NotasConceitosNotaAvaliacaoRetornoDto()
{
AtividadeAvaliativaId = atividadeAvaliativa.Id, NotaConceito = notaParaVisualizar, Ausente = ausente, PodeEditar = true
};
notasAvaliacoes.Add(notaAvaliacao);
}
notaConceitoAluno.Marcador = servicoAluno.ObterMarcadorAluno(aluno, new PeriodoEscolarDto()
{
Bimestre = valorBimestreAtual,
PeriodoInicio = periodoAtual.PeriodoInicio,
PeriodoFim = periodoAtual.PeriodoFim
});
//notaConceitoAluno.PodeEditar = notaConceitoAluno.Marcador == null || notaConceitoAluno.Marcador.Tipo == TipoMarcadorFrequencia.Novo;
notaConceitoAluno.NotasAvaliacoes = notasAvaliacoes;
// Carrega Notas do Bimestre
if (fechamentoTurma != null)
{
bimestreParaAdicionar.FechamentoTurmaId = fechamentoTurma.Id;
retorno.AuditoriaBimestreInserido = $"Nota final do bimestre inserida por {fechamentoTurma.CriadoPor} em {fechamentoTurma.CriadoEm.ToString("dd/MM/yyyy")}, às {fechamentoTurma.CriadoEm.ToString("hh:mm:ss")}.";
if (fechamentoTurma.AlteradoEm.HasValue)
{
retorno.AuditoriaBimestreAlterado = $"Nota final do bimestre alterada por {fechamentoTurma.AlteradoPor} em {fechamentoTurma.AlteradoEm.Value.ToString("dd/MM/yyyy")}, às {fechamentoTurma.AlteradoEm.Value.ToString("hh:mm:ss")}.";
}
var notasConceitoBimestre = await consultasFechamentoTurmaDisciplina.ObterNotasBimestre(aluno.CodigoAluno, fechamentoTurma.Id);
if (disciplinaEOL.Regencia)
{
// Regencia carrega disciplinas mesmo sem nota de fechamento
foreach (var disciplinaRegencia in disciplinasRegencia)
{
var nota = new NotaConceitoBimestreRetornoDto()
{
DisciplinaId = disciplinaRegencia.CodigoComponenteCurricular,
Disciplina = disciplinaRegencia.Nome,
};
var notaRegencia = notasConceitoBimestre?.FirstOrDefault(c => c.DisciplinaId == disciplinaRegencia.CodigoComponenteCurricular);
if (notaRegencia != null)
{
nota.NotaConceito = (notaRegencia.Nota > 0 ? notaRegencia.Nota : notaRegencia.ConceitoId).ToString();
}
notaConceitoAluno.NotasBimestre.Add(nota);
}
}
else
{
foreach (var notaConceitoBimestre in notasConceitoBimestre)
{
notaConceitoAluno.NotasBimestre.Add(new NotaConceitoBimestreRetornoDto()
{
DisciplinaId = notaConceitoBimestre.DisciplinaId,
Disciplina = disciplinaEOL.Nome,
NotaConceito = notaConceitoBimestre.Nota > 0 ?
notaConceitoBimestre.Nota.ToString() :
notaConceitoBimestre.ConceitoId.ToString()
});
}
}
}
else
if (disciplinaEOL.Regencia)
{
// Regencia carrega disciplinas mesmo sem nota de fechamento
foreach (var disciplinaRegencia in disciplinasRegencia)
{
notaConceitoAluno.NotasBimestre.Add(new NotaConceitoBimestreRetornoDto()
{
DisciplinaId = disciplinaRegencia.CodigoComponenteCurricular,
Disciplina = disciplinaRegencia.Nome,
});
}
}
// Carrega Frequencia Aluno
var frequenciaAluno = repositorioFrequenciaAluno.ObterPorAlunoData(aluno.CodigoAluno, periodoAtual.PeriodoFim, TipoFrequenciaAluno.PorDisciplina, filtro.DisciplinaCodigo);
notaConceitoAluno.PercentualFrequencia = frequenciaAluno != null ?
(int)Math.Round(frequenciaAluno.PercentualFrequencia, 0) :
100;
listaAlunosDoBimestre.Add(notaConceitoAluno);
}
foreach (var avaliacao in atividadesAvaliativasdoBimestre)
{
var avaliacaoDoBimestre = new NotasConceitosAvaliacaoRetornoDto()
{
Id = avaliacao.Id,
Data = avaliacao.DataAvaliacao,
Descricao = avaliacao.DescricaoAvaliacao,
Nome = avaliacao.NomeAvaliacao
};
if (avaliacao.Categoria.Equals(CategoriaAtividadeAvaliativa.Interdisciplinar))
{
avaliacaoDoBimestre.EhInterdisciplinar = true;
var atividadeDisciplinas = await repositorioAtividadeAvaliativaDisciplina.ListarPorIdAtividade(avaliacao.Id);
var idsDisciplinas = atividadeDisciplinas.Select(a => long.Parse(a.DisciplinaId)).ToArray();
var disciplinas = servicoEOL.ObterDisciplinasPorIds(idsDisciplinas);
var nomesDisciplinas = disciplinas.Select(d => d.Nome).ToArray();
avaliacaoDoBimestre.Disciplinas = nomesDisciplinas;
}
bimestreParaAdicionar.Avaliacoes.Add(avaliacaoDoBimestre);
if (atividadeAvaliativaParaObterTipoNota == null)
{
atividadeAvaliativaParaObterTipoNota = avaliacao;
}
}
bimestreParaAdicionar.Alunos = listaAlunosDoBimestre;
bimestreParaAdicionar.QtdAvaliacoesBimestrais = atividadesAvaliativasdoBimestre.Where(x => x.TipoAvaliacaoId == tipoAvaliacaoBimestral.Id).Count();
bimestreParaAdicionar.PodeLancarNotaFinal = await VerificaPeriodoFechamentoEmAberto(filtro.TurmaCodigo, periodoAtual.Bimestre);
// Valida Avaliações Bimestrais
await ValidaMinimoAvaliacoesBimestrais(disciplinaEOL, disciplinasRegencia, tipoCalendario.Id, filtro.TurmaCodigo, valorBimestreAtual, tipoAvaliacaoBimestral, bimestreParaAdicionar);
if (atividadeAvaliativaParaObterTipoNota != null)
{
var notaTipo = await servicoDeNotasConceitos.TipoNotaPorAvaliacao(atividadeAvaliativaParaObterTipoNota, filtro.TurmaHistorico);
if (notaTipo == null)
{
throw new NegocioException("Não foi possível obter o tipo de nota desta avaliação.");
}
retorno.NotaTipo = notaTipo.TipoNota;
ObterValoresDeAuditoria(dataUltimaNotaConceitoInserida, dataUltimaNotaConceitoAlterada, usuarioRfUltimaNotaConceitoInserida, usuarioRfUltimaNotaConceitoAlterada, notaTipo.TipoNota, retorno, nomeAvaliacaoAuditoriaInclusao, nomeAvaliacaoAuditoriaAlteracao);
}
}
retorno.Bimestres.Add(bimestreParaAdicionar);
}
return(retorno);
}