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);
}
public async Task <IActionResult> ObterDisciplinas(string codigoTurma, [FromQuery] bool turmaPrograma, [FromServices] IConsultasDisciplina consultasDisciplina)
{
var retorno = await consultasDisciplina.ObterDisciplinasPorProfessorETurma(codigoTurma, turmaPrograma);
return(Ok(retorno));
}
public async Task <IActionResult> Get(long codigoTurma, string codigoRF, [FromServices] IConsultasDisciplina consultasDisciplina)
{
return(Ok(await consultasDisciplina.ObterDisciplinasPorProfessorETurma(codigoTurma)));
}