public async Task <int> ValidarAulasReposicaoPendente(long fechamentoId, Turma turma, long disciplinaId, DateTime inicioPeriodo, DateTime fimPeriodo)
{
var aulasPendentes = repositorioAula.ObterAulasReposicaoPendentes(turma.CodigoTurma, disciplinaId.ToString(), inicioPeriodo, fimPeriodo);
if (aulasPendentes != null && aulasPendentes.Any())
{
var componenteCurricular = (await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { disciplinaId })).ToList()?.FirstOrDefault();
if (componenteCurricular == null)
{
throw new NegocioException("Componente curricular não encontrado.");
}
var mensagem = new StringBuilder($"A aulas de reposição de {componenteCurricular.Nome} da turma {turma.Nome} a seguir estão pendentes de aprovação:<br>");
foreach (var aula in aulasPendentes.OrderBy(a => a.DataAula))
{
var professor = servicoUsuario.ObterUsuarioPorCodigoRfLoginOuAdiciona(aula.ProfessorRf);
if (professor == null)
{
throw new NegocioException($"Professor com RF {aula.ProfessorRf} não encontrado.");
}
mensagem.AppendLine($"Professor { aula.ProfessorRf} - { professor.Nome}, dia {aula.DataAula.ToString("dd/MM/yyyy")}.<br>");
}
var professorRf = aulasPendentes.First().ProfessorRf;
await GerarPendencia(fechamentoId, TipoPendencia.AulasReposicaoPendenteAprovacao, mensagem.ToString(), professorRf);
}
else
{
repositorioPendencia.AtualizarPendencias(fechamentoId, SituacaoPendencia.Resolvida, TipoPendencia.AulasReposicaoPendenteAprovacao);
}
aulasReposicaoPendentes = aulasPendentes.Count();
return(aulasReposicaoPendentes);
}
public async Task <IEnumerable <DisciplinaResposta> > ObterComponentesCJ(Modalidade?modalidade, string codigoTurma, string ueId, long codigoDisciplina, string rf, bool ignorarDeParaRegencia = false)
{
IEnumerable <DisciplinaResposta> componentes = null;
var atribuicoes = await repositorioAtribuicaoCJ.ObterPorFiltros(modalidade,
codigoTurma,
ueId,
codigoDisciplina,
rf,
string.Empty,
true);
if (atribuicoes == null || !atribuicoes.Any())
{
return(null);
}
var disciplinasEol = await repositorioComponenteCurricular.ObterDisciplinasPorIds(atribuicoes.Select(a => a.DisciplinaId).Distinct().ToArray());
var componenteRegencia = disciplinasEol?.FirstOrDefault(c => c.Regencia);
if (componenteRegencia == null || ignorarDeParaRegencia)
{
return(TransformarListaDisciplinaEolParaRetornoDto(disciplinasEol));
}
var componentesRegencia = await repositorioComponenteCurricular.ObterDisciplinasPorIds(IDS_COMPONENTES_REGENCIA);
if (componentesRegencia != null)
{
return(TransformarListaDisciplinaEolParaRetornoDto(componentesRegencia));
}
return(componentes);
}
public async Task <IEnumerable <AlunoAusenteDto> > ObterListaAlunosComAusencia(string turmaId, string disciplinaId, int bimestre)
{
var alunosAusentesDto = new List <AlunoAusenteDto>();
// Busca dados da turma
var turma = await BuscaTurma(turmaId);
// Busca periodo
var periodo = await BuscaPeriodo(turma, bimestre);
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 = await repositorioComponenteCurricular.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(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(TipoParametroSistema.QuantidadeMaximaCompensacaoAusencia, DateTime.Today.Year)));
var percentualFrequenciaAlerta = int.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(disciplinasEOL.First().Regencia ? TipoParametroSistema.CompensacaoAusenciaPercentualRegenciaClasse : TipoParametroSistema.CompensacaoAusenciaPercentualFund2, DateTime.Today.Year)));
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 async Task <DisciplinaDto> ObterDisciplina(long idDisciplina)
{
long[] disciplinaId = { idDisciplina };
var disciplina = await repositorioComponenteCurricular.ObterDisciplinasPorIds(disciplinaId);
if (!disciplina.Any())
{
throw new NegocioException("Disciplina não encontrada no EOL.");
}
return(disciplina.FirstOrDefault());
}
public async Task <IEnumerable <DisciplinaDto> > Handle(ObterComponentesCurricularesPorIdsQuery request, CancellationToken cancellationToken)
{
if (request.PossuiTerritorio.HasValue && request.PossuiTerritorio.Value)
{
return(await servicoEol.ObterDisciplinasPorIdsAgrupadas(request.Ids));
}
else
{
return(await repositorioComponenteCurricular.ObterDisciplinasPorIds(request.Ids));
}
}
public async Task <PaginacaoResultadoDto <PendenciaFechamentoResumoDto> > Listar(FiltroPendenciasFechamentosDto filtro)
{
var retornoConsultaPaginada = await repositorioPendenciaFechamento.ListarPaginada(Paginacao, filtro.TurmaCodigo, filtro.Bimestre, filtro.ComponenteCurricularId);
if (retornoConsultaPaginada.Items != null && retornoConsultaPaginada.Items.Any())
{
// Atualiza nome da situacao
retornoConsultaPaginada.Items.ToList()
.ForEach(i => i.SituacaoNome = Enum.GetName(typeof(SituacaoPendencia), i.Situacao));
// Carrega nomes das disciplinas para o DTO de retorno
var disciplinasEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(retornoConsultaPaginada.Items.Select(a => a.DisciplinaId).Distinct().ToArray());
foreach (var disciplinaEOL in disciplinasEOL)
{
retornoConsultaPaginada.Items.Where(c => c.DisciplinaId == disciplinaEOL.CodigoComponenteCurricular).ToList()
.ForEach(d => d.ComponenteCurricular = disciplinaEOL.Nome);
}
}
return(retornoConsultaPaginada);
}
public async Task Reprocessar(long fechamentoTurmaDisciplinaId)
{
var fechamentoTurmaDisciplina = repositorioFechamentoTurmaDisciplina.ObterPorId(fechamentoTurmaDisciplinaId);
if (fechamentoTurmaDisciplina == null)
{
throw new NegocioException("Fechamento ainda não realizado para essa turma.");
}
var turma = await repositorioTurma.ObterTurmaComUeEDrePorId(fechamentoTurmaDisciplina.FechamentoTurma.TurmaId);
if (turma == null)
{
throw new NegocioException("Turma não encontrada.");
}
var disciplinaEOL = (await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { fechamentoTurmaDisciplina.DisciplinaId })).ToList().FirstOrDefault();
if (disciplinaEOL == null)
{
throw new NegocioException("Componente Curricular não localizado.");
}
var periodoEscolar = repositorioPeriodoEscolar.ObterPorId(fechamentoTurmaDisciplina.FechamentoTurma.PeriodoEscolarId.Value);
if (periodoEscolar == null)
{
throw new NegocioException("Período escolar não encontrado.");
}
fechamentoTurmaDisciplina.AdicionarPeriodoEscolar(periodoEscolar);
fechamentoTurmaDisciplina.AtualizarSituacao(SituacaoFechamento.EmProcessamento);
repositorioFechamentoTurmaDisciplina.Salvar(fechamentoTurmaDisciplina);
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
Cliente.Executar <IServicoFechamentoTurmaDisciplina>(c => c.GerarPendenciasFechamento(fechamentoTurmaDisciplina.DisciplinaId, turma, periodoEscolar, fechamentoTurmaDisciplina, usuarioLogado, !disciplinaEOL.LancaNota, disciplinaEOL.RegistraFrequencia));
}
public async Task <IEnumerable <ComponenteCurricularEol> > Handle(ObterComponentesCJQuery request, CancellationToken cancellationToken)
{
var atribuicoes = await repositorioAtribuicaoCJ.ObterPorFiltros(request.Modalidade,
request.TurmaCodigo,
request.UeCodigo,
request.ComponenteCurricular,
request.ProfessorRf,
string.Empty,
true);
if (atribuicoes == null || !atribuicoes.Any())
{
return(null);
}
var disciplinasEol = await repositorioComponenteCurricular.ObterDisciplinasPorIds(atribuicoes.Select(a => a.DisciplinaId).Distinct().ToArray());
IEnumerable <ComponenteCurricularEol> componentes = null;
var componenteRegencia = disciplinasEol?.FirstOrDefault(c => c.Regencia);
if (request.ListarComponentesPlanejamento && componenteRegencia != null)
{
var componentesRegencia = await repositorioComponenteCurricular.ObterDisciplinasPorIds(IDS_COMPONENTES_REGENCIA);
if (componentesRegencia != null)
{
componentes = TransformarListaDisciplinaEolParaRetornoDto(componentesRegencia);
}
}
else
{
componentes = TransformarListaDisciplinaEolParaRetornoDto(disciplinasEol);
}
return(componentes);
}
private async Task ValidaComponentesCurricularesQueNaoPodemSerSubstituidos(AtribuicaoCJ atribuicaoCJ)
{
if (componentesQueNaoPodemSerSubstituidos.Any(a => a == atribuicaoCJ.DisciplinaId))
{
var nomeComponenteCurricular = await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { atribuicaoCJ.DisciplinaId });
if (nomeComponenteCurricular != null && nomeComponenteCurricular.Any())
{
throw new NegocioException($"O componente curricular {nomeComponenteCurricular.FirstOrDefault().Nome} não pode ser substituido.");
}
else
{
throw new NegocioException($"Não foi possível localizar o nome do componente curricular de identificador {atribuicaoCJ.DisciplinaId} no EOL.");
}
}
}
private async Task ConsisteDisciplina(long disciplinaId, IEnumerable <string> disciplinasRegenciaIds, bool registroMigrado)
{
var disciplinasEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { disciplinaId });
if (!disciplinasEOL.Any())
{
throw new NegocioException("Disciplina não encontrada no EOL.");
}
var disciplina = disciplinasEOL.FirstOrDefault();
if (!registroMigrado && disciplina.Regencia && ((disciplinasRegenciaIds == null) || !disciplinasRegenciaIds.Any()))
{
throw new NegocioException("Regência de classe deve informar a(s) disciplina(s) relacionadas a esta atividade.");
}
}
private async Task <IEnumerable <AtribuicaoCJListaRetornoDto> > TransformaEntidadesEmDtosListaRetorno(IEnumerable <AtribuicaoCJ> listaDto)
{
var idsDisciplinas = listaDto
.Select(a => a.DisciplinaId)
.Distinct <long>()
.ToArray();
var disciplinasEol = await repositorioComponenteCurricular.ObterDisciplinasPorIds(idsDisciplinas);
if (!disciplinasEol.Any())
{
throw new NegocioException("Não foi possível obter as descrições das disciplinas no Eol.");
}
var professoresDisciplinas = listaDto
.GroupBy(a => new { a.ProfessorRf, a.Modalidade, a.TurmaId, a.UeId }).ToList();
var listRetorno = new List <AtribuicaoCJListaRetornoDto>();
professoresDisciplinas.ForEach(a =>
{
var disciplinasIds = a.Select(b => b.DisciplinaId);
var disciplinasDescricoes = disciplinasEol
.Where(c => disciplinasIds.Contains(c.CodigoComponenteCurricular))
.ToList();
var professorDisciplina = a.FirstOrDefault();
var atribuicaoDto = new AtribuicaoCJListaRetornoDto()
{
Modalidade = a.Key.Modalidade.GetAttribute <DisplayAttribute>().Name,
ModalidadeId = (int)a.Key.Modalidade,
Turma = professorDisciplina.Turma.Nome,
TurmaId = professorDisciplina.TurmaId,
Disciplinas = disciplinasDescricoes.Select(d => d.Nome).ToArray()
};
listRetorno.Add(atribuicaoDto);
});
return(listRetorno);
}
public async Task <CompensacaoAusenciaCompletoDto> ObterPorId(long id)
{
var compensacao = repositorioCompensacaoAusencia.ObterPorId(id);
if (compensacao == null)
{
throw new NegocioException("Compensação de ausencia não localizada.");
}
var compensacaoDto = MapearParaDtoCompleto(compensacao);
compensacao.Alunos = await consultasCompensacaoAusenciaAluno.ObterPorCompensacao(compensacao.Id);
// Busca os nomes de alunos do EOL por turma
var turma = await repositorioTurma.ObterPorId(compensacao.TurmaId);
compensacaoDto.TurmaId = turma.CodigoTurma;
var alunos = await servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma);
if (alunos == null)
{
throw new NegocioException("Alunos não localizados para a turma.");
}
var disciplinasEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { long.Parse(compensacao.DisciplinaId) });
if (disciplinasEOL == null || !disciplinasEOL.Any())
{
throw new NegocioException("Disciplina informada na compensação não localizada no EOL.");
}
var quantidadeMaximaCompensacoes = int.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(TipoParametroSistema.QuantidadeMaximaCompensacaoAusencia, DateTime.Today.Year)));
var percentualFrequenciaAlerta = int.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(disciplinasEOL.First().Regencia ? TipoParametroSistema.CompensacaoAusenciaPercentualRegenciaClasse : TipoParametroSistema.CompensacaoAusenciaPercentualFund2, DateTime.Today.Year)));
foreach (var aluno in compensacao.Alunos)
{
// Adiciona nome do aluno no Dto de retorno
var alunoEol = alunos.FirstOrDefault(a => a.CodigoAluno == aluno.CodigoAluno);
if (alunoEol != null)
{
var alunoDto = MapearParaDtoAlunos(aluno);
alunoDto.Nome = alunoEol.NomeAluno;
var frequenciaAluno = consultasFrequencia.ObterPorAlunoDisciplinaData(aluno.CodigoAluno, compensacao.DisciplinaId, DateTime.Now);
if (frequenciaAluno != null)
{
alunoDto.QuantidadeFaltasTotais = int.Parse((frequenciaAluno.NumeroFaltasNaoCompensadas + alunoDto.QuantidadeFaltasCompensadas).ToString());
alunoDto.PercentualFrequencia = frequenciaAluno.PercentualFrequencia;
alunoDto.MaximoCompensacoesPermitidas = quantidadeMaximaCompensacoes > alunoDto.QuantidadeFaltasTotais ? alunoDto.QuantidadeFaltasTotais : quantidadeMaximaCompensacoes;
alunoDto.Alerta = frequenciaAluno.PercentualFrequencia <= percentualFrequenciaAlerta;
}
else
{
alunoDto.PercentualFrequencia = 100;
}
compensacaoDto.Alunos.Add(alunoDto);
}
}
if (disciplinasEOL.First().Regencia)
{
var disciplinasRegencia = await consultasCompensacaoAusenciaDisciplinaRegencia.ObterPorCompensacao(compensacao.Id);
var disciplinasIds = disciplinasRegencia.Select(x => long.Parse(x.DisciplinaId));
if (!disciplinasIds.Any())
{
return(compensacaoDto);
}
disciplinasEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(disciplinasIds.ToArray());
foreach (var disciplinaEOL in disciplinasEOL)
{
compensacaoDto.DisciplinasRegencia.Add(new DisciplinaNomeDto()
{
Codigo = disciplinaEOL.CodigoComponenteCurricular.ToString(),
Nome = disciplinaEOL.Nome
});
}
}
return(compensacaoDto);
}
public async Task <DiaEventoAula> ObterEventoAulasDia(FiltroEventosAulasCalendarioDiaDto filtro)
{
List <EventosAulasTipoDiaDto> eventosAulas = new List <EventosAulasTipoDiaDto>();
if (!filtro.TodasTurmas && string.IsNullOrWhiteSpace(filtro.TurmaId))
{
throw new NegocioException("É necessario informar uma turma para pesquisa");
}
var temTurmaInformada = !string.IsNullOrEmpty(filtro.TurmaId);
var data = filtro.Data.Date;
var perfil = servicoUsuario.ObterPerfilAtual();
var usuario = await servicoUsuario.ObterUsuarioLogado();
string rf = usuario.TemPerfilGestaoUes() ? string.Empty : usuario.CodigoRf;
var disciplinasUsuario = usuario.EhProfessorCj() ?
await consultasDisciplina.ObterDisciplinasPerfilCJ(filtro.TurmaId, usuario.CodigoRf) :
await servicoEOL.ObterDisciplinasPorCodigoTurmaLoginEPerfil(filtro.TurmaId, usuario.CodigoRf, usuario.PerfilAtual);
var eventos = await repositorioEvento.ObterEventosPorTipoDeCalendarioDreUeDia(filtro.TipoCalendarioId, filtro.DreId, filtro.UeId, data, filtro.EhEventoSme, usuario.PodeVisualizarEventosLibExcepRepoRecessoGestoresUeDreSme());
var aulas = await ObterAulasDia(filtro, data, perfil, rf, disciplinasUsuario);
var atividades = await repositorioAtividadeAvaliativa.ObterAtividadesPorDia(filtro.DreId, filtro.UeId, data, rf, filtro.TurmaId);
ObterEventosParaEventosAulasDia(eventosAulas, eventos);
var turmasAulas = aulas.GroupBy(x => x.TurmaId).Select(x => x.Key);
var turmasAbrangencia = await ObterTurmasAbrangencia(turmasAulas, filtro.TurmaHistorico);
var idsDisciplinasAulas = aulas.Select(a => long.Parse(a.DisciplinaId)).Distinct().ToList();
var idsDisciplinasCompartilhadas = aulas.Where(a => !String.IsNullOrEmpty(a.DisciplinaCompartilhadaId) && !a.DisciplinaCompartilhadaId.Equals("null"))
.Select(a => long.Parse(a.DisciplinaCompartilhadaId)).Distinct();
if (idsDisciplinasCompartilhadas != null && idsDisciplinasCompartilhadas.Any())
{
idsDisciplinasAulas.AddRange(idsDisciplinasCompartilhadas);
}
IEnumerable <DisciplinaDto> disciplinasEol = new List <DisciplinaDto>();
if (idsDisciplinasAulas != null && idsDisciplinasAulas.Any())
{
disciplinasEol = await repositorioComponenteCurricular.ObterDisciplinasPorIds(idsDisciplinasAulas.ToArray());
}
aulas
.ToList()
.ForEach(x =>
{
bool podeCriarAtividade = true;
var listaAtividades = atividades.Where(w => w.DataAvaliacao.Date == x.DataAula.Date && w.TurmaId == x.TurmaId &&
PossuiDisciplinas(w.Id, x.DisciplinaId)).ToList();
var disciplina = disciplinasEol?.FirstOrDefault(d => d.CodigoComponenteCurricular.ToString().Equals(x.DisciplinaId));
var disciplinaCompartilhada = disciplinasEol?.FirstOrDefault(d => d.CodigoComponenteCurricular.ToString().Equals(x.DisciplinaCompartilhadaId));
if (atividades != null && disciplina != null)
{
foreach (var item in listaAtividades)
{
if (disciplina.Regencia)
{
var disciplinasRegenciasComAtividades = repositorioAtividadeAvaliativaRegencia.Listar(item.Id).Result;
disciplinasRegenciasComAtividades.ToList().ForEach(async r => r.DisciplinaContidaRegenciaNome = (await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { Convert.ToInt64(r.DisciplinaContidaRegenciaId) })).ToList().FirstOrDefault().Nome);
item.AtividadeAvaliativaRegencia = new List <AtividadeAvaliativaRegencia>();
item.AtividadeAvaliativaRegencia.AddRange(disciplinasRegenciasComAtividades);
podeCriarAtividade = true;
}
else
{
podeCriarAtividade = false;
}
}
}
var turma = turmasAbrangencia.FirstOrDefault(t => t.CodigoTurma.Equals(x.TurmaId));
eventosAulas.Add(new EventosAulasTipoDiaDto
{
Id = x.Id,
TipoEvento = x.AulaCJ ? "CJ" : "Aula",
DadosAula = new DadosAulaDto
{
DisciplinaId = disciplina?.CodigoComponenteCurricular ?? null,
Disciplina = $"{(disciplina?.Nome ?? "Disciplina não encontrada")} {(x.TipoAula == TipoAula.Reposicao ? "(Reposição)" : "")} {(x.Status == EntidadeStatus.AguardandoAprovacao ? "- Aguardando aprovação" : "")}",
DisciplinaCompartilhadaId = disciplinaCompartilhada?.CodigoComponenteCurricular ?? null,
DisciplinaCompartilhada = $"{(disciplinaCompartilhada?.Nome ?? "Disciplina não encontrada")} ",
EhRegencia = disciplina.Regencia,
EhCompartilhada = disciplina.Compartilhada,
PermiteRegistroFrequencia = disciplina.RegistraFrequencia && !x.SomenteConsulta,
PodeCadastrarAvaliacao = podeCriarAtividade,
Horario = x.DataAula.ToString("hh:mm tt", CultureInfo.InvariantCulture),
Modalidade = turma?.Modalidade.GetAttribute <DisplayAttribute>().Name ?? "Modalidade",
Tipo = turma?.TipoEscola.GetAttribute <DisplayAttribute>().ShortName ?? "Escola",
Turma = x.TurmaNome,
DentroPeriodo = x.DentroPeriodo,
UnidadeEscolar = x.UeNome,
Atividade = listaAtividades
}
});
});
var dentroDoPeriodo = await consultasAula.AulaDentroPeriodo(filtro.TurmaId, filtro.Data) || await PodeCriarAulaNoPeriodo(filtro.Data, filtro.TipoCalendarioId, filtro.UeId, filtro.DreId);
return(new DiaEventoAula
{
EventosAulas = eventosAulas,
Letivo = comandosDiasLetivos.VerificarSeDataLetiva(eventos, data),
DentroPeriodo = dentroDoPeriodo
});
}
public async Task <NotasConceitosRetornoDto> ListarNotasConceitos(ListaNotasConceitosConsultaDto filtro)
{
var modalidadeTipoCalendario = ObterModalidadeCalendario(filtro.Modalidade);
var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(filtro.AnoLetivo, modalidadeTipoCalendario, filtro.Semestre);
if (tipoCalendario == null)
{
throw new NegocioException("Não foi encontrado tipo de calendário escolar, para a modalidade informada.");
}
var periodosEscolares = await 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.ObterComponentesCurricularesPorProfessorETurma(filtro.TurmaCodigo, true);
var disciplinasFilha = disciplinasProfessor.Where(d => d.CdComponenteCurricularPai == long.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 tipoAvaliacaoBimestral = await repositorioTipoAvaliacao.ObterTipoAvaliacaoBimestral();
retorno.BimestreAtual = bimestre.Value;
retorno.MediaAprovacaoBimestre = double.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(TipoParametroSistema.MediaBimestre, DateTime.Today.Year)));
retorno.MinimoAvaliacoesBimestrais = tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre;
retorno.PercentualAlunosInsuficientes = double.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(TipoParametroSistema.PercentualAlunosInsuficientes, DateTime.Today.Year)));
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 = await repositorioComponenteCurricular.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 fechamentosTurma = await consultasFechamentoTurmaDisciplina.ObterFechamentosTurmaDisciplina(filtro.TurmaCodigo, filtro.DisciplinaCodigo, valorBimestreAtual);
var alunosForeach = from a in alunos
where (a.EstaAtivo(periodoAtual.PeriodoFim)) ||
(a.EstaInativo(periodoAtual.PeriodoFim) && a.DataSituacao.Date >= periodoAtual.PeriodoInicio.Date)
orderby a.NomeValido(), a.NumeroAlunoChamada
select a;
foreach (var aluno in alunosForeach)
{
var notaConceitoAluno = new NotasConceitosAlunoRetornoDto()
{
Id = aluno.CodigoAluno,
Nome = aluno.NomeValido(),
NumeroChamada = aluno.NumeroAlunoChamada
};
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 && (!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);
var notaAvaliacao = new NotasConceitosNotaAvaliacaoRetornoDto()
{
AtividadeAvaliativaId = atividadeAvaliativa.Id,
NotaConceito = notaParaVisualizar,
Ausente = ausente,
PodeEditar = aluno.EstaAtivo(atividadeAvaliativa.DataAvaliacao) ||
(aluno.EstaInativo(atividadeAvaliativa.DataAvaliacao) && atividadeAvaliativa.DataAvaliacao.Date <= aluno.DataSituacao.Date)
};
notasAvaliacoes.Add(notaAvaliacao);
}
notaConceitoAluno.PodeEditar = notasAvaliacoes.Any(na => na.PodeEditar);
notaConceitoAluno.Marcador = servicoAluno.ObterMarcadorAluno(aluno, new PeriodoEscolar()
{
Bimestre = valorBimestreAtual,
PeriodoInicio = periodoAtual.PeriodoInicio,
PeriodoFim = periodoAtual.PeriodoFim
});
notaConceitoAluno.NotasAvaliacoes = notasAvaliacoes;
var fechamentoTurma = (from ft in fechamentosTurma
from fa in ft.FechamentoAlunos
where fa.AlunoCodigo.Equals(aluno.CodigoAluno)
select ft).FirstOrDefault();
// Carrega Notas do Bimestre
if (fechamentoTurma != null)
{
bimestreParaAdicionar.FechamentoTurmaId = fechamentoTurma.Id;
bimestreParaAdicionar.Situacao = fechamentoTurma.Situacao;
retorno.AuditoriaBimestreInserido = $"Nota final do bimestre inserida por {fechamentoTurma.CriadoPor}({fechamentoTurma.CriadoRF}) em {fechamentoTurma.CriadoEm.ToString("dd/MM/yyyy")}, às {fechamentoTurma.CriadoEm.ToString("HH:mm")}.";
if (fechamentoTurma.AlteradoEm.HasValue)
{
retorno.AuditoriaBimestreAlterado = $"Nota final do bimestre alterada por {fechamentoTurma.AlteradoPor}({fechamentoTurma.CriadoRF}) em {fechamentoTurma.AlteradoEm.Value.ToString("dd/MM/yyyy")}, às {fechamentoTurma.AlteradoEm.Value.ToString("HH:mm")}.";
}
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 FechamentoNotaRetornoDto()
{
DisciplinaId = disciplinaRegencia.CodigoComponenteCurricular,
Disciplina = disciplinaRegencia.Nome,
};
var notaRegencia = notasConceitoBimestre?.FirstOrDefault(c => c.DisciplinaId == disciplinaRegencia.CodigoComponenteCurricular);
if (notaRegencia != null)
{
nota.NotaConceito = (notaRegencia.ConceitoId.HasValue ? notaRegencia.ConceitoId.Value : notaRegencia.Nota);
nota.EhConceito = notaRegencia.ConceitoId.HasValue;
}
notaConceitoAluno.NotasBimestre.Add(nota);
}
}
else
{
foreach (var notaConceitoBimestre in notasConceitoBimestre)
{
notaConceitoAluno.NotasBimestre.Add(new FechamentoNotaRetornoDto()
{
DisciplinaId = notaConceitoBimestre.DisciplinaId,
Disciplina = disciplinaEOL.Nome,
NotaConceito = notaConceitoBimestre.ConceitoId.HasValue ?
notaConceitoBimestre.ConceitoId.Value :
notaConceitoBimestre.Nota,
EhConceito = notaConceitoBimestre.ConceitoId.HasValue
});
}
}
}
else
if (disciplinaEOL.Regencia)
{
// Regencia carrega disciplinas mesmo sem nota de fechamento
foreach (var disciplinaRegencia in disciplinasRegencia)
{
notaConceitoAluno.NotasBimestre.Add(new FechamentoNotaRetornoDto()
{
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 = await repositorioComponenteCurricular.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);
}