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 DisciplinaDto ObterDisciplina(long idDisciplina)
{
long[] disciplinaId = { idDisciplina };
var disciplina = servicoEOL.ObterDisciplinasPorIds(disciplinaId);
if (!disciplina.Any())
{
throw new NegocioException("Disciplina não encontrada no EOL.");
}
return(disciplina.FirstOrDefault());
}
private void ValidaComponentesCurricularesQueNaoPodemSerSubstituidos(AtribuicaoCJ atribuicaoCJ)
{
if (componentesQueNaoPodemSerSubstituidos.Any(a => a == atribuicaoCJ.DisciplinaId))
{
var nomeComponenteCurricular = servicoEOL.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 void ConsisteDisciplina(long disciplinaId, IEnumerable <string> disciplinasRegenciaIds)
{
var disciplinasEOL = servicoEOL.ObterDisciplinasPorIds(new long[] { disciplinaId });
if (!disciplinasEOL.Any())
{
throw new NegocioException("Disciplina não encontrada no EOL.");
}
var disciplina = disciplinasEOL.FirstOrDefault();
if (disciplina.Regencia && ((disciplinasRegenciaIds == null) || !disciplinasRegenciaIds.Any()))
{
throw new NegocioException("Regência de classe deve informar a(s) disciplina(s) relacionadas a esta atividade.");
}
}
private IEnumerable <AtribuicaoCJListaRetornoDto> TransformaEntidadesEmDtosListaRetorno(IEnumerable <AtribuicaoCJ> listaDto)
{
var idsDisciplinas = listaDto
.Select(a => a.DisciplinaId)
.Distinct <long>()
.ToArray();
var disciplinasEol = servicoEOL.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);
}
private async Task <string> ValidaMinimoAvaliacoesBimestre(long tipoCalendarioId, string turmaId, long disciplinaId, int bimestre)
{
var validacoes = new StringBuilder();
var tipoAvaliacaoBimestral = await repositorioTipoAvaliacao.ObterTipoAvaliacaoBimestral();
var disciplinasEOL = servicoEOL.ObterDisciplinasPorIds(new long[] { disciplinaId });
if (disciplinasEOL.First().Regencia)
{
// Disciplinas Regencia de Classe
disciplinasEOL = await consultasDisciplina.ObterDisciplinasParaPlanejamento(new FiltroDisciplinaPlanejamentoDto()
{
CodigoTurma = long.Parse(turmaId),
CodigoDisciplina = disciplinaId,
Regencia = true
});
foreach (var disciplina in disciplinasEOL)
{
var avaliacoes = await repositorioAtividadeAvaliativaRegencia.ObterAvaliacoesBimestrais(tipoCalendarioId, turmaId, disciplina.CodigoComponenteCurricular.ToString(), bimestre);
if ((avaliacoes == null) || (avaliacoes.Count() < tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre))
{
validacoes.AppendLine($"A disciplina [{disciplina.Nome}] não tem o número mínimo de avaliações bimestrais: Necessário {tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre}");
}
}
}
else
{
var disciplinaEOL = disciplinasEOL.First();
var avaliacoes = await repositorioAtividadeAvaliativaDisciplina.ObterAvaliacoesBimestrais(tipoCalendarioId, turmaId, disciplinaEOL.CodigoComponenteCurricular.ToString(), bimestre);
if ((avaliacoes == null) || (avaliacoes.Count() < tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre))
{
validacoes.AppendLine($"A disciplina [{disciplinaEOL.Nome}] não tem o número mínimo de avaliações bimestrais: Necessário {tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre}");
}
}
return(validacoes.ToString());
}
public async Task <List <DisciplinaDto> > ObterDisciplinasAgrupadasPorProfessorETurma(string codigoTurma, bool turmaPrograma)
{
var disciplinasDto = new List <DisciplinaDto>();
var login = servicoUsuario.ObterLoginAtual();
var perfilAtual = servicoUsuario.ObterPerfilAtual();
var chaveCache = $"Disciplinas-Agrupadas-{codigoTurma}-{login}--{perfilAtual}";
var disciplinasCacheString = repositorioCache.Obter(chaveCache);
if (!string.IsNullOrWhiteSpace(disciplinasCacheString))
{
disciplinasDto = JsonConvert.DeserializeObject <List <DisciplinaDto> >(disciplinasCacheString);
}
else
{
if (perfilAtual == Perfis.PERFIL_CJ)
{
// Carrega Disciplinas da Atribuição do CJ
var atribuicoes = await repositorioAtribuicaoCJ.ObterPorFiltros(null, codigoTurma, string.Empty, 0, login, string.Empty, true);
if (atribuicoes != null && atribuicoes.Any())
{
var disciplinasEol = servicoEOL.ObterDisciplinasPorIds(atribuicoes.Select(a => a.DisciplinaId).Distinct().ToArray());
foreach (var disciplinaEOL in disciplinasEol)
{
if (disciplinaEOL.CdComponenteCurricularPai > 0)
{
// TODO Consulta por disciplina pai não esta funcionando no EOL. Refatorar na proxima sprint
disciplinaEOL.CdComponenteCurricularPai = 11211124;
disciplinaEOL.Nome = "REG CLASSE INTEGRAL";
//var consultaDisciplinaPai = servicoEOL.ObterDisciplinasPorIds(new long[] { disciplinaEOL.CodigoComponenteCurricularId });
//if (consultaDisciplinaPai == null)
// throw new NegocioException($"Disciplina Pai de codigo [{disciplinaEOL.CodigoComponenteCurricularId}] não localizada no EOL.");
//disciplinasDto.Add(consultaDisciplinaPai.First());
}
else
{
disciplinasDto.Add(disciplinaEOL);
}
}
}
}
else
{
// Carrega disciplinas do professor
IEnumerable <DisciplinaResposta> disciplinas = await servicoEOL.ObterDisciplinasPorCodigoTurmaLoginEPerfil(codigoTurma, login, perfilAtual);
foreach (var disciplina in disciplinas)
{
if (disciplina.CodigoComponenteCurricularPai.HasValue)
{
// TODO Consulta por disciplina pai não esta funcionando no EOL. Refatorar na proxima sprint
disciplina.CodigoComponenteCurricular = 11211124;
disciplina.Nome = "REG CLASSE INTEGRAL";
//var consultaDisciplinaPai = servicoEOL.ObterDisciplinasPorIds(new long[] { disciplina.CodigoComponenteCurricularPai.Value });
//if (consultaDisciplinaPai == null)
// throw new NegocioException($"Disciplina Pai de codigo [{disciplina.CodigoComponenteCurricularPai}] não localizada no EOL.");
//disciplinasDto.Add(consultaDisciplinaPai.First());
}
disciplinasDto.Add(await MapearParaDto(disciplina, true));
}
}
if (disciplinasDto.Any())
{
await repositorioCache.SalvarAsync(chaveCache, JsonConvert.SerializeObject(disciplinasDto));
}
}
return(disciplinasDto);
}
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);
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 = servicoEOL.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(r => r.DisciplinaContidaRegenciaNome = servicoEOL.ObterDisciplinasPorIds(new long[] { Convert.ToInt64(r.DisciplinaContidaRegenciaId) }).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,
UnidadeEscolar = x.UeNome,
Atividade = listaAtividades
}
});
});
return(new DiaEventoAula
{
EventosAulas = eventosAulas,
Letivo = comandosDiasLetivos.VerificarSeDataLetiva(eventos, data)
});
}
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 = 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 = servicoEOL.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(repositorioParametrosSistema.ObterValorPorTipoEAno(TipoParametroSistema.QuantidadeMaximaCompensacaoAusencia));
var percentualFrequenciaAlerta = int.Parse(repositorioParametrosSistema.ObterValorPorTipoEAno(disciplinasEOL.First().Regencia ? TipoParametroSistema.CompensacaoAusenciaPercentualRegenciaClasse : TipoParametroSistema.CompensacaoAusenciaPercentualFund2));
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));
disciplinasEOL = servicoEOL.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 <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);
}