public async Task <IEnumerable <AbrangenciaDreRetorno> > ObterDres()
{
var loginAtual = servicoUsuario.ObterLoginAtual();
var perfilAtual = servicoUsuario.ObterPerfilAtual();
if (perfilAtual == Perfis.PERFIL_CJ)
{
var codigosDres = new List <string>();
ObterAtribuicoesCjDre(loginAtual, codigosDres);
ObterAtribuicoesEsporadicasDre(loginAtual, codigosDres);
await ObterAtribuicoesEolDre(loginAtual, codigosDres);
var dres = repositorioDre.ListarPorCodigos(codigosDres.Distinct().ToArray());
if (dres != null && dres.Any())
{
return(TransformarDresEmDresDto(dres));
}
else
{
return(null);
}
}
else
{
return(await consultasAbrangencia.ObterDres(null, 0));
}
}
public async Task <IEnumerable <AbrangenciaFiltroRetorno> > ObterAbrangenciaPorfiltro(string texto, bool consideraHistorico)
{
var login = servicoUsuario.ObterLoginAtual();
var perfil = servicoUsuario.ObterPerfilAtual();
return(await repositorioAbrangencia.ObterAbrangenciaPorFiltro(texto, login, perfil, consideraHistorico));
}
public async Task <IEnumerable <DisciplinaDto> > ObterDisciplinasParaPlanejamento(FiltroDisciplinaPlanejamentoDto filtroDisciplinaPlanejamentoDto)
{
IEnumerable <DisciplinaDto> disciplinasDto = null;
var login = servicoUsuario.ObterLoginAtual();
var chaveCache = $"Disciplinas-planejamento-{filtroDisciplinaPlanejamentoDto.CodigoTurma}-{login}";
var disciplinasCacheString = repositorioCache.Obter(chaveCache);
if (!string.IsNullOrWhiteSpace(disciplinasCacheString))
{
return(TratarRetornoDisciplinasPlanejamento(JsonConvert.DeserializeObject <IEnumerable <DisciplinaDto> >(disciplinasCacheString), filtroDisciplinaPlanejamentoDto));
}
var disciplinas = await servicoEOL.ObterDisciplinasParaPlanejamento(filtroDisciplinaPlanejamentoDto.CodigoTurma, login, servicoUsuario.ObterPerfilAtual());
if (disciplinas == null || !disciplinas.Any())
{
return(disciplinasDto);
}
disciplinasDto = await MapearParaDto(disciplinas);
await repositorioCache.SalvarAsync(chaveCache, JsonConvert.SerializeObject(disciplinasDto));
return(TratarRetornoDisciplinasPlanejamento(disciplinasDto, filtroDisciplinaPlanejamentoDto));
}
public async Task <IEnumerable <UnidadeEscolarDto> > ObterEscolasPorDre(string dreId)
{
var login = servicoUsuario.ObterLoginAtual();
var perfil = servicoUsuario.ObterPerfilAtual();
var escolasPorDre = await repositorioAbrangencia.ObterUes(dreId, login, perfil);
var lista = from a in escolasPorDre
select new UnidadeEscolarDto()
{
Codigo = a.Codigo,
Nome = a.Nome
};
return(lista);
}
public async Task <IEnumerable <CalendarioTipoEventoPorDiaDto> > ObterQuantidadeDeEventosPorDia(CalendarioEventosFiltroDto calendarioEventosMesesFiltro, int mes)
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
var perfilAtual = servicoUsuario.ObterPerfilAtual();
var listaQuery = await repositorioEvento.ObterQuantidadeDeEventosPorDia(calendarioEventosMesesFiltro, mes, usuario, perfilAtual, usuario.TemPerfilSupervisorOuDiretor(),
usuario.PodeVisualizarEventosOcorrenciaDre(),
usuario.PodeVisualizarEventosLibExcepRepoRecessoGestoresUeDreSme());
List <CalendarioTipoEventoPorDiaDto> listaRetorno = new List <CalendarioTipoEventoPorDiaDto>();
if (listaQuery.Any())
{
var listaDiasEventos = listaQuery.GroupBy(a => a.Dia).ToList();
listaDiasEventos.ForEach(a =>
{
var tipoEventos = a.GroupBy(b => b.TipoEvento).Select(b => b.Key).ToList();
listaRetorno.Add(new CalendarioTipoEventoPorDiaDto()
{
Dia = a.Key,
TiposEvento = tipoEventos.ToArray(),
});
});
}
return(listaRetorno);
}
public async Task <IEnumerable <DashBoard> > Handle(ObterDashBoardPorPerfilQuery request, CancellationToken cancellationToken)
{
var perfilAtual = servicoUsuario.ObterPerfilAtual();
var roles = servicoUsuario.ObterPermissoes();
var listaDashBoard = new List <DashBoard>();
if (perfil_1.Contains(perfilAtual))
{
listaDashBoard.Add(CarregaDashBoard(Permissao.CI_C, roles));
listaDashBoard.Add(CarregaDashBoard(Permissao.DDB_C, roles));
listaDashBoard.Add(CarregaDashBoard(Permissao.PDA_C, roles, descricao: "Frequência"));
}
else if (perfil_2.Contains(perfilAtual))
{
listaDashBoard.Add(CarregaDashBoard(Permissao.CP_C, roles));
listaDashBoard.Add(CarregaDashBoard(Permissao.PA_C, roles));
listaDashBoard.Add(CarregaDashBoard(Permissao.PDA_C, roles));
}
else
{
listaDashBoard.Add(CarregaDashBoard(Permissao.PA_C, roles));
listaDashBoard.Add(CarregaDashBoard(Permissao.C_C, roles, false));
listaDashBoard.Add(CarregaDashBoard(Permissao.E_C, roles, false));
}
return(listaDashBoard);
}
public async Task <IEnumerable <TipoCalendarioDto> > ListarPorAnoLetivo(int anoLetivo)
{
var login = servicoUsuario.ObterLoginAtual();
var perfil = servicoUsuario.ObterPerfilAtual();
var modalidadesUsuario = await repositorioAbrangencia.ObterModalidades(login, perfil, anoLetivo, false);
var modalidadesTipoCalendario = MapearModalidadesUsuario(modalidadesUsuario.Select(s => (Modalidade)s));
var retorno = await repositorio.ListarPorAnoLetivoEModalidades(anoLetivo, modalidadesTipoCalendario.Select(a => (int)a).ToArray());
return(from t in retorno
select EntidadeParaDto(t));
}
public async Task <IEnumerable <SupervisorEscolasDto> > ObterPorDre(string dreId)
{
var login = servicoUsuario.ObterLoginAtual();
var perfil = servicoUsuario.ObterPerfilAtual();
var escolasPorDre = await repositorioAbrangencia.ObterUes(dreId, login, perfil);
var supervisoresEscolasDres = repositorioSupervisorEscolaDre.ObtemPorDreESupervisor(dreId, string.Empty);
var listaRetorno = new List <SupervisorEscolasDto>();
TratarRegistrosComSupervisores(escolasPorDre, supervisoresEscolasDres, listaRetorno);
TrataEscolasSemSupervisores(escolasPorDre, listaRetorno);
return(listaRetorno);
}
public async Task <IEnumerable <OpcaoDropdownDto> > Handle(ObterFiltroRelatoriosModalidadesPorUeQuery request, CancellationToken cancellationToken)
{
if (request.CodigoUe == "-99")
{
return(EnumExtensao.ListarDto <Modalidade>().Select(c => new OpcaoDropdownDto(c.Id.ToString(), c.Descricao)));
}
var login = servicoUsuario.ObterLoginAtual();
var perfil = servicoUsuario.ObterPerfilAtual();
var listaAbrangencia = await repositorioAbrangencia.ObterModalidades(login, perfil, request.AnoLetivo, request.ConsideraHistorico);
var modalidades = await repositorioAbrangencia.ObterModalidadesPorUe(request.CodigoUe);
return(modalidades?.Where(m => listaAbrangencia.Contains((int)m))?.Select(c => new OpcaoDropdownDto(((int)c).ToString(), c.Name())));
}
public async Task <RecuperacaoParalelaListagemDto> Salvar(RecuperacaoParalelaDto recuperacaoParalelaDto)
{
var list = new List <RecuperacaoParalelaListagemDto>();
//var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
var usuarioLogin = servicoUsuario.ObterLoginAtual();
var usuarioPerfil = servicoUsuario.ObterPerfilAtual();
var turmaRecuperacaoParalelaId = recuperacaoParalelaDto.Periodo.Alunos.FirstOrDefault().TurmaRecuperacaoParalelaId;
var turmaRecuperacaoParalela = await mediator.Send(new ObterTurmaSimplesPorIdQuery(turmaRecuperacaoParalelaId));
//var turmaCodigo = recuperacaoParalelaDto.Periodo.Alunos.FirstOrDefault().TurmaRecuperacaoParalelaId;
var turmaPap = await servicoEOL.TurmaPossuiComponenteCurricularPAP(turmaRecuperacaoParalela.Codigo, usuarioLogin, usuarioPerfil);
if (!turmaPap)
{
throw new NegocioException("Somente é possivel realizar acompanhamento para turmas PAP");
}
var turmasCodigo = recuperacaoParalelaDto.Periodo.Alunos.Select(a => a.TurmaId.ToString()).Distinct().ToArray();
var turmas = await mediator.Send(new ObterTurmasPorCodigosQuery(turmasCodigo));
unitOfWork.IniciarTransacao();
foreach (var item in recuperacaoParalelaDto.Periodo.Alunos)
{
var turmaDoItem = turmas.FirstOrDefault(a => a.CodigoTurma == item.TurmaId.ToString());
var recuperacaoParalela = MapearEntidade(recuperacaoParalelaDto, item, turmaDoItem.Id, turmaRecuperacaoParalela.Id, turmaDoItem.AnoLetivo);
await repositorioRecuperacaoParalela.SalvarAsync(recuperacaoParalela);
await repositorioRecuperacaoParalelaPeriodoObjetivoResposta.Excluir(item.Id, recuperacaoParalelaDto.Periodo.Id);
await SalvarRespostasAluno(recuperacaoParalelaDto, item, recuperacaoParalela);
}
unitOfWork.PersistirTransacao();
return(await consultaRecuperacaoParalela.Listar(new Infra.FiltroRecuperacaoParalelaDto
{
Ordenacao = recuperacaoParalelaDto.Ordenacao,
PeriodoId = recuperacaoParalelaDto.Periodo.Id,
TurmaId = turmaRecuperacaoParalelaId,
TurmaCodigo = long.Parse(turmaRecuperacaoParalela.Codigo)
}));
}
private async Task PersistirWorkflowEvento(Evento evento, bool workflowDeLiberacaoExcepcional)
{
var loginAtual = servicoUsuario.ObterLoginAtual();
var perfilAtual = servicoUsuario.ObterPerfilAtual();
var escola = await repositorioAbrangencia.ObterUe(evento.UeId, loginAtual, perfilAtual);
if (escola == null)
{
throw new NegocioException($"Não foi possível localizar a escola da criação do evento.");
}
var linkParaEvento = $"{configuration["UrlFrontEnd"]}calendario-escolar/eventos/editar/{evento.Id}/";
long idWorkflow = 0;
if (workflowDeLiberacaoExcepcional)
{
idWorkflow = CriarWorkflowParaEventoExcepcionais(evento, escola, linkParaEvento);
}
evento.EnviarParaWorkflowDeAprovacao(idWorkflow);
repositorioEvento.Salvar(evento);
}
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 <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);
}
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 <FechamentoTurmaDisciplinaBimestreDto> ObterNotasFechamentoTurmaDisciplina(string turmaId, long disciplinaId, int?bimestre, int semestre)
{
var turma = await repositorioTurma.ObterPorCodigo(turmaId);
var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, ModalidadeParaModalidadeTipoCalendario(turma.ModalidadeCodigo), 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 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,
Periodo = tipoCalendario.Periodo,
TotalAulasDadas = 0, // Carregar
TotalAulasPrevistas = 0, // Carregar
Alunos = new List <NotaConceitoAlunoBimestreDto>()
};
var disciplinaEOL = await consultasDisciplina.ObterDisciplina(disciplinaId);
IEnumerable <DisciplinaResposta> disciplinasRegencia = null;
if (disciplinaEOL.Regencia)
{
disciplinasRegencia = await servicoEOL.ObterDisciplinasParaPlanejamento(long.Parse(turmaId), servicoUsuario.ObterLoginAtual(), servicoUsuario.ObterPerfilAtual());
}
fechamentoBimestre.EhSintese = !disciplinaEOL.LancaNota;
// Carrega fechamento da Turma x Disciplina x Bimestre
var fechamentosTurma = await ObterFechamentosTurmaDisciplina(turmaId, disciplinaId.ToString(), bimestreAtual.Value);
if ((fechamentosTurma != null && fechamentosTurma.Any()) || fechamentoBimestre.EhSintese)
{
if (fechamentosTurma != null && fechamentosTurma.Any())
{
fechamentoBimestre.Situacao = fechamentosTurma.First().Situacao;
fechamentoBimestre.SituacaoNome = fechamentosTurma.First().Situacao.Name();
fechamentoBimestre.FechamentoId = fechamentosTurma.First().Id;
fechamentoBimestre.DataFechamento = fechamentosTurma.First().AlteradoEm.HasValue ? fechamentosTurma.First().AlteradoEm.Value : fechamentosTurma.First().CriadoEm;
}
fechamentoBimestre.Alunos = new List <NotaConceitoAlunoBimestreDto>();
var bimestreDoPeriodo = await consultasPeriodoEscolar.ObterPeriodoEscolarPorData(tipoCalendario.Id, periodoAtual.PeriodoFim);
foreach (var aluno in alunos.Where(a => a.NumeroAlunoChamada > 0 || a.CodigoSituacaoMatricula.Equals(SituacaoMatriculaAluno.Ativo)).OrderBy(a => a.NumeroAlunoChamada).ThenBy(a => a.NomeValido()))
{
var fechamentoTurma = (from ft in fechamentosTurma
from fa in ft.FechamentoAlunos
where fa.AlunoCodigo.Equals(aluno.CodigoAluno)
select ft).FirstOrDefault();
var alunoDto = new NotaConceitoAlunoBimestreDto();
alunoDto.CodigoAluno = aluno.CodigoAluno;
alunoDto.NumeroChamada = aluno.NumeroAlunoChamada;
alunoDto.Nome = aluno.NomeAluno;
alunoDto.Ativo = aluno.CodigoSituacaoMatricula.Equals(SituacaoMatriculaAluno.Ativo);
var anotacaoAluno = await consultasFehcamentoAluno.ObterAnotacaoPorAlunoEFechamento(fechamentoTurma?.Id ?? 0, aluno.CodigoAluno);
alunoDto.TemAnotacao = anotacaoAluno != null && anotacaoAluno.Anotacao != null &&
!string.IsNullOrEmpty(anotacaoAluno.Anotacao.Trim());
var marcador = servicoAluno.ObterMarcadorAluno(aluno, bimestreDoPeriodo);
if (marcador != null)
{
alunoDto.Informacao = marcador.Descricao;
}
var frequenciaAluno = consultasFrequencia.ObterPorAlunoDisciplinaData(aluno.CodigoAluno, disciplinaId.ToString(), periodoAtual.PeriodoFim);
if (frequenciaAluno != null)
{
alunoDto.QuantidadeFaltas = frequenciaAluno.TotalAusencias;
alunoDto.QuantidadeCompensacoes = frequenciaAluno.TotalCompensacoes;
alunoDto.PercentualFrequencia = frequenciaAluno.PercentualFrequencia;
}
else
{
// Quando não tem registro de frequencia assume 100%
alunoDto.QuantidadeFaltas = 0;
alunoDto.QuantidadeCompensacoes = 0;
alunoDto.PercentualFrequencia = 100;
}
// Carrega Frequencia do aluno
if (aluno.CodigoAluno != null)
{
if (fechamentoBimestre.EhSintese && fechamentoTurma == null)
{
var sinteseDto = await consultasFrequencia.ObterSinteseAluno(alunoDto.PercentualFrequencia, disciplinaEOL);
alunoDto.SinteseId = sinteseDto.Id;
alunoDto.Sintese = sinteseDto.Valor;
}
else
{
// Carrega notas do bimestre
var notasConceitoBimestre = await ObterNotasBimestre(aluno.CodigoAluno, fechamentoTurma != null?fechamentoTurma.Id : 0);
if (notasConceitoBimestre.Any())
{
alunoDto.Notas = new List <FechamentoNotaRetornoDto>();
}
if (fechamentoBimestre.EhSintese)
{
var notaConceitoBimestre = notasConceitoBimestre.FirstOrDefault();
if (notaConceitoBimestre != null && notaConceitoBimestre.SinteseId.HasValue)
{
alunoDto.SinteseId = (SinteseEnum)notaConceitoBimestre.SinteseId.Value;
alunoDto.Sintese = ObterSintese(notaConceitoBimestre.SinteseId.Value);
}
}
else
{
foreach (var notaConceitoBimestre in notasConceitoBimestre)
{
string nomeDisciplina;
if (disciplinaEOL.Regencia)
{
nomeDisciplina = disciplinasRegencia.FirstOrDefault(a => a.CodigoComponenteCurricular == notaConceitoBimestre.DisciplinaId)?.Nome;
}
else
{
nomeDisciplina = disciplinaEOL.Nome;
}
((List <FechamentoNotaRetornoDto>)alunoDto.Notas).Add(new FechamentoNotaRetornoDto()
{
DisciplinaId = notaConceitoBimestre.DisciplinaId,
Disciplina = nomeDisciplina,
NotaConceito = notaConceitoBimestre.ConceitoId.HasValue ? ObterConceito(notaConceitoBimestre.ConceitoId.Value) : notaConceitoBimestre.Nota,
EhConceito = notaConceitoBimestre.ConceitoId.HasValue,
ConceitoDescricao = notaConceitoBimestre.ConceitoId.HasValue ? ObterConceitoDescricao(notaConceitoBimestre.ConceitoId.Value) : string.Empty
});
}
}
}
fechamentoBimestre.Alunos.Add(alunoDto);
}
}
}
var aulaPrevisa = await consultasAulaPrevista.ObterAulaPrevistaDada(turma.ModalidadeCodigo, turma.CodigoTurma, disciplinaId.ToString(), semestre);
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;
fechamentoBimestre.PodeProcessarReprocessar = await consultasFechamento.TurmaEmPeriodoDeFechamento(turma.CodigoTurma, DateTime.Today, bimestreAtual.Value);
return(fechamentoBimestre);
}
