public async Task <PeriodoEscolarListaDto> ObterPorTipoCalendario(long tipoCalendarioId)
{
var lista = await repositorio.ObterPorTipoCalendario(tipoCalendarioId);
if (lista == null || !lista.Any())
{
return(null);
}
return(EntidadeParaDto(lista));
}
private async Task <PeriodoEscolar> ObterPeriodoEscolarFechamentoReabertura(long tipoCalendarioId, Ue ue, int bimestre)
{
var periodoFechamento = await servicoPeriodoFechamento.ObterPorTipoCalendarioDreEUe(tipoCalendarioId, ue.Dre, ue);
var periodoFechamentoBimestre = periodoFechamento?.FechamentosBimestres.FirstOrDefault(x => x.Bimestre == bimestre);
if (periodoFechamento == null || periodoFechamentoBimestre == null)
{
var hoje = DateTime.Today;
var tipodeEventoReabertura = ObterTipoEventoFechamentoBimestre();
if (await repositorioEvento.TemEventoNosDiasETipo(hoje, hoje, (TipoEvento)tipodeEventoReabertura.Codigo, tipoCalendarioId, ue.CodigoUe, ue.Dre.CodigoDre))
{
var fechamentoReabertura = await repositorioFechamentoReabertura.ObterReaberturaFechamentoBimestrePorDataReferencia(bimestre, hoje, tipoCalendarioId, ue.Dre.CodigoDre, ue.CodigoUe);
if (fechamentoReabertura == null)
{
throw new NegocioException($"Não localizado período de fechamento em aberto para turma informada no {bimestre}º Bimestre");
}
return((await repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendarioId)).FirstOrDefault(a => a.Bimestre == bimestre));
}
}
return(periodoFechamentoBimestre?.PeriodoEscolar);
}
public List <DateTime> BuscarDiasLetivos(long tipoCalendarioId)
{
List <DateTime> dias = new List <DateTime>();
var periodoEscolar = repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendarioId);
periodoEscolar
.ToList()
.ForEach(x => dias
.AddRange(
Enumerable
.Range(0, 1 + (x.PeriodoFim - x.PeriodoInicio).Days)
.Select(y => x.PeriodoInicio.AddDays(y))
.Where(w => EhDiaUtil(w))
.ToList())
);
return(dias);
}
public async Task Salvar(Evento evento, bool dataConfirmada = false)
{
var tipoEvento = repositorioEventoTipo.ObterPorId(evento.TipoEventoId);
if (tipoEvento == null)
{
throw new NegocioException("O tipo do evento deve ser informado.");
}
var tipoCalendario = repositorioTipoCalendario.ObterPorId(evento.TipoCalendarioId);
if (tipoCalendario == null)
{
throw new NegocioException("Calendário não encontrado.");
}
evento.AdicionarTipoEvento(tipoEvento);
evento.ValidaPeriodoEvento();
var usuario = await servicoUsuario.ObterUsuarioLogado();
usuario.PodeCriarEvento(evento);
if (!evento.PermiteConcomitancia())
{
var existeOutroEventoNaMesmaData = repositorioEvento.ExisteEventoNaMesmaDataECalendario(evento.DataInicio, evento.TipoCalendarioId);
if (existeOutroEventoNaMesmaData)
{
throw new NegocioException("Não é permitido cadastrar um evento nesta data pois esse tipo de evento não permite concomitância.");
}
}
var periodos = repositorioPeriodoEscolar.ObterPorTipoCalendario(evento.TipoCalendarioId);
if (evento.DeveSerEmDiaLetivo())
{
evento.EstaNoPeriodoLetivo(periodos);
}
await VerificaParticularidadesSME(evento, usuario, periodos, dataConfirmada);
repositorioEvento.Salvar(evento);
}
private void ValidarSeTipoCalendarioPossuiPeriodoCadastrado(IEnumerable <PeriodoEscolar> periodos, TipoCalendario tipo)
{
if (periodos.Any(x => x.Id == 0))
{
var periodoEscolar = repositorioPeriodoEscolar.ObterPorTipoCalendario(tipo.Id).ToList();
if (periodoEscolar != null && periodoEscolar.Any())
{
throw new NegocioException("Não é possível inserir mais de um período escolar para o tipo de calendário informado");
}
}
}
private async Task <IEnumerable <PeriodoEscolar> > BuscarPeriodosEscolaresDaAtividade(AtividadeAvaliativa atividadeAvaliativa)
{
var dataFinal = atividadeAvaliativa.DataAvaliacao.Date.AddHours(23).AddMinutes(59).AddSeconds(59);
var aula = await repositorioAula.ObterAulaIntervaloTurmaDisciplina(atividadeAvaliativa.DataAvaliacao, dataFinal, atividadeAvaliativa.TurmaId, atividadeAvaliativa.Id);
if (aula == null)
{
throw new NegocioException($"Não encontrada aula para a atividade avaliativa '{atividadeAvaliativa.NomeAvaliacao}' no dia {atividadeAvaliativa.DataAvaliacao.Date.ToString("dd/MM/yyyy")}");
}
IEnumerable <PeriodoEscolar> periodosEscolares = await repositorioPeriodoEscolar.ObterPorTipoCalendario(aula.TipoCalendarioId);
return(periodosEscolares);
}
private IEnumerable <PeriodoEscolar> ObterPeriodoEscolar(int anoLetivo, Modalidade modalidade)
{
var modalidadeTipoCalendario = ModalidadeParaModalidadeTipoCalendario(modalidade);
var tipoCalendario = repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(anoLetivo, modalidadeTipoCalendario);
if (tipoCalendario == null)
{
return(null);
}
var periodoEscolar = repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id);
return(periodoEscolar);
}
private IEnumerable <PeriodoEscolar> ObterPeriodoEscolar(string turmaId, int anoLetivo)
{
var turma = repositorioTurma.ObterPorId(turmaId);
if (turma == null)
{
throw new NegocioException("Turma não encontrada.");
}
var modalidade = turma.ModalidadeCodigo == Modalidade.EJA ? ModalidadeTipoCalendario.EJA : ModalidadeTipoCalendario.FundamentalMedio;
var tipoCalendario = repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(anoLetivo, modalidade);
if (tipoCalendario == null)
{
throw new NegocioException("Tipo de calendário não encontrado.");
}
var periodos = repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id);
if (periodos == null)
{
throw new NegocioException("Período escolar não encontrado.");
}
return(periodos);
}
public async Task Salvar(AtribuicaoEsporadica atribuicaoEsporadica, int anoLetivo, bool ehInfantil)
{
var atribuicoesConflitantes = repositorioAtribuicaoEsporadica.ObterAtribuicoesDatasConflitantes(atribuicaoEsporadica.DataInicio, atribuicaoEsporadica.DataFim, atribuicaoEsporadica.ProfessorRf, atribuicaoEsporadica.Id);
if (atribuicoesConflitantes != null && atribuicoesConflitantes.Any())
{
throw new NegocioException("Já existem outras atribuições, para este professor, no periodo especificado");
}
var modalidade = ehInfantil ? ModalidadeTipoCalendario.Infantil : ModalidadeTipoCalendario.FundamentalMedio;
var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(anoLetivo, modalidade);
if (tipoCalendario == null)
{
throw new NegocioException("Nenhum tipo de calendario para o ano letivo vigente encontrado");
}
var periodosEscolares = await repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id);
if (periodosEscolares == null || !periodosEscolares.Any())
{
throw new NegocioException("Nenhum periodo escolar encontrado para o ano letivo vigente");
}
bool ehPerfilSelecionadoSME = servicoUsuario.UsuarioLogadoPossuiPerfilSme();
atribuicaoEsporadica.Validar(ehPerfilSelecionadoSME, anoLetivo, periodosEscolares);
using (var transacao = unitOfWork.IniciarTransacao())
{
repositorioAtribuicaoEsporadica.Salvar(atribuicaoEsporadica);
Guid perfilAtribuicao = ehInfantil ? Perfis.PERFIL_CJ_INFANTIL : Perfis.PERFIL_CJ;
await AdicionarAtribuicaoEOL(atribuicaoEsporadica.ProfessorRf, perfilAtribuicao);
unitOfWork.PersistirTransacao();
}
}
public async Task <IEnumerable <EventosAulasTipoCalendarioDto> > ObterTipoEventosAulas(FiltroEventosAulasCalendarioMesDto filtro)
{
if (!filtro.TodasTurmas && string.IsNullOrWhiteSpace(filtro.TurmaId))
{
throw new NegocioException("É necessario informar uma turma para pesquisa");
}
var usuario = await servicoUsuario.ObterUsuarioLogado();
string rf = usuario.TemPerfilGestaoUes() ? string.Empty : usuario.CodigoRf;
var eventosAulas = new List <EventosAulasTipoCalendarioDto>();
var periodoEscolar = repositorioPeriodoEscolar.ObterPorTipoCalendario(filtro.TipoCalendarioId);
if (periodoEscolar is null || !periodoEscolar.Any())
{
throw new NegocioException($"Não existe periodo escolar cadastrado para o tipo de calendario de id {filtro.TipoCalendarioId}");
}
var ano = periodoEscolar.FirstOrDefault().PeriodoInicio.Year;
var aulas = await repositorioAula.ObterAulas(filtro.TipoCalendarioId, filtro.TurmaId, filtro.UeId, rf, filtro.Mes);
var eventos = await repositorioEvento.ObterEventosPorTipoDeCalendarioDreUeMes(filtro.TipoCalendarioId, filtro.DreId, filtro.UeId, filtro.Mes, filtro.EhEventoSme);
var atividadesAvaliativas = await repositorioAtividadeAvaliativa.ObterAtividadesPorMes(filtro.DreId, filtro.UeId, filtro.Mes, ano, rf, filtro.TurmaId);
var diasAulas = ObterDiasAulas(aulas);
var diasEventos = ObterDiasEventos(eventos, filtro.Mes);
var diasAtividade = ObterDiasAtividades(atividadesAvaliativas);
diasAulas.AddRange(diasEventos);
diasAulas.AddRange(diasAtividade);
return(MapearParaDtoTipo(eventosAulas, diasAulas));
}
private IEnumerable <PeriodoEscolar> ObterPeriodosEscolares(long tipoCalendarioId)
{
return(repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendarioId));
}
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);
}
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 <FechamentoDto> ObterPorTipoCalendarioDreEUe(long tipoCalendarioId, Dre dre, Ue ue)
{
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
var dreIdFiltro = !(dre == null) || usuarioLogado.EhPerfilUE() ? dre?.Id : null;
var fechamentoSME = repositorioPeriodoFechamento.ObterPorFiltros(tipoCalendarioId, null, null, null);
var fechamentoSMEDre = repositorioPeriodoFechamento.ObterPorFiltros(tipoCalendarioId, dreIdFiltro, null, null);
if (fechamentoSMEDre == null)
{
LimparCamposNaoUtilizadosRegistroPai(fechamentoSME);
fechamentoSMEDre = fechamentoSME;
if (fechamentoSMEDre == null)
{
fechamentoSMEDre = new PeriodoFechamento(null, null);
var tipoCalendario = await repositorioTipoCalendario.ObterPorIdAsync(tipoCalendarioId);
if (tipoCalendario == null)
{
throw new NegocioException("Tipo de calendário não encontrado.");
}
var periodoEscolar = await repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendarioId);
if (periodoEscolar == null || !periodoEscolar.Any())
{
throw new NegocioException("Período escolar não encontrado.");
}
foreach (var periodo in periodoEscolar)
{
periodo.AdicionarTipoCalendario(tipoCalendario);
fechamentoSMEDre.AdicionarFechamentoBimestre(new PeriodoFechamentoBimestre(fechamentoSMEDre.Id, periodo, periodo.PeriodoInicio, periodo.PeriodoFim));
}
}
}
var fechamentoDreUe = repositorioPeriodoFechamento.ObterPorFiltros(tipoCalendarioId, dre?.Id, ue?.Id, null);
if (fechamentoDreUe == null)
{
LimparCamposNaoUtilizadosRegistroPai(fechamentoSMEDre);
fechamentoDreUe = fechamentoSMEDre;
fechamentoDreUe.Dre = dre;
fechamentoDreUe.Ue = ue;
}
var fechamentoDto = MapearParaDto(fechamentoDreUe);
var fechamentoSMEDto = MapearParaDto(fechamentoSME);
foreach (var bimestreSME in fechamentoSMEDre.FechamentosBimestre)
{
FechamentoBimestreDto bimestreFechamentoSME = null;
if (fechamentoSMEDto != null)
{
bimestreFechamentoSME = fechamentoSMEDto.FechamentosBimestres.FirstOrDefault(c => c.Bimestre == bimestreSME.PeriodoEscolar.Bimestre);
}
var bimestreDreUe = fechamentoDto.FechamentosBimestres.FirstOrDefault(c => c.Bimestre == bimestreSME.PeriodoEscolar.Bimestre);
if (bimestreDreUe != null)
{
bimestreDreUe.PeriodoEscolar = bimestreSME.PeriodoEscolar;
if (fechamentoSMEDre.Id > 0 && !(dre == null) || !(ue == null))
{
if (bimestreFechamentoSME != null)
{
bimestreDreUe.InicioMinimo =
bimestreFechamentoSME.InicioDoFechamento < bimestreSME.InicioDoFechamento ?
bimestreFechamentoSME.InicioDoFechamento.Value : bimestreSME.InicioDoFechamento;
bimestreDreUe.FinalMaximo =
bimestreFechamentoSME.FinalDoFechamento > bimestreSME.FinalDoFechamento ?
bimestreFechamentoSME.FinalDoFechamento.Value : bimestreSME.FinalDoFechamento;
}
else
{
bimestreDreUe.InicioMinimo = bimestreSME.InicioDoFechamento;
bimestreDreUe.FinalMaximo = bimestreSME.FinalDoFechamento;
}
}
else
{
bimestreDreUe.InicioMinimo = new DateTime(bimestreSME.InicioDoFechamento.Year, 01, 01);
bimestreDreUe.FinalMaximo = new DateTime(bimestreSME.InicioDoFechamento.Year, 12, 31);
}
}
}
return(fechamentoDto);
}
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);
}
private async Task <IEnumerable <PeriodoEscolar> > ObterPeriodosEscolares(long tipoCalendarioId)
{
return(await repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendarioId));
}
public async Task <FechamentoFinalConsultaRetornoDto> ObterFechamentos(FechamentoFinalConsultaFiltroDto filtros)
{
var retorno = new FechamentoFinalConsultaRetornoDto();
var turma = await repositorioTurma.ObterTurmaComUeEDrePorCodigo(filtros.TurmaCodigo);
if (turma == null)
{
throw new NegocioException("Não foi possível localizar a turma.");
}
var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, turma.ObterModalidadeTipoCalendario());
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.");
}
if (turma.AnoLetivo != 2020)
{
await VerificaSePodeFazerFechamentoFinal(periodosEscolares, turma);
}
var ultimoPeriodoEscolar = periodosEscolares.OrderByDescending(a => a.Bimestre).FirstOrDefault();
retorno.EventoData = ultimoPeriodoEscolar.PeriodoFim;
var alunosDaTurma = await servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma);
if (alunosDaTurma == null || !alunosDaTurma.Any())
{
throw new NegocioException("Não foram encontrandos alunos para a turma informada.");
}
var tipoNota = repositorioNotaTipoValor.ObterPorTurmaId(turma.Id);
if (tipoNota == null)
{
throw new NegocioException("Não foi possível localizar o tipo de nota para esta turma.");
}
retorno.EhNota = tipoNota.EhNota();
//Codigo aluno / NotaConceito / Código Disciplina / bimestre
var listaAlunosNotas = new List <(string, string, long, int)>();
var disciplinas = new List <DisciplinaResposta>();
var disciplinaEOL = await consultasDisciplina.ObterDisciplina(filtros.DisciplinaCodigo);
var usuarioAtual = await servicoUsuario.ObterUsuarioLogado();
if (filtros.EhRegencia)
{
var disciplinasRegencia = await consultasDisciplina.ObterComponentesRegencia(turma, filtros.DisciplinaCodigo);
if (disciplinasRegencia == null || !disciplinasRegencia.Any())
{
throw new NegocioException("Não foram encontrados componentes curriculares para a regência informada.");
}
disciplinas.AddRange(disciplinasRegencia);
}
else
{
disciplinas.Add(new DisciplinaResposta()
{
Nome = disciplinaEOL.Nome, CodigoComponenteCurricular = disciplinaEOL.CodigoComponenteCurricular
});
}
retorno.EhSintese = !disciplinaEOL.LancaNota;
var fechamentosTurmaDisciplina = await repositorioFechamentoTurmaDisciplina.ObterFechamentosTurmaDisciplinas(turma.CodigoTurma, new long[] { filtros.DisciplinaCodigo });
var notasFechamentosFinais = Enumerable.Empty <FechamentoNota>();
if (fechamentosTurmaDisciplina != null && fechamentosTurmaDisciplina.Any())
{
notasFechamentosFinais = await repositorioFechamentoNota.ObterPorFechamentosTurma(fechamentosTurmaDisciplina.Select(ftd => ftd.Id).ToArray());
}
var notasFechamentosBimestres = Enumerable.Empty <FechamentoNotaAlunoDto>();
if (!retorno.EhSintese)
{
notasFechamentosBimestres = await ObterNotasFechamentosBimestres(filtros.DisciplinaCodigo, turma, periodosEscolares, retorno.EhNota);
}
var usuarioEPeriodoPodeEditar = await PodeEditarNotaOuConceitoPeriodoUsuario(usuarioAtual, ultimoPeriodoEscolar, turma, filtros.DisciplinaCodigo.ToString(), retorno.EventoData);
foreach (var aluno in alunosDaTurma.Where(a => a.NumeroAlunoChamada > 0 || a.CodigoSituacaoMatricula.Equals(SituacaoMatriculaAluno.Ativo)).OrderBy(a => a.NumeroAlunoChamada).ThenBy(a => a.NomeValido()))
{
FechamentoFinalConsultaRetornoAlunoDto fechamentoFinalAluno = await TrataFrequenciaAluno(filtros, periodosEscolares, aluno, turma);
var marcador = servicoAluno.ObterMarcadorAluno(aluno, new PeriodoEscolar()
{
PeriodoFim = retorno.EventoData
});
if (marcador != null)
{
fechamentoFinalAluno.Informacao = marcador.Descricao;
}
if (retorno.EhSintese)
{
var sinteseDto = await consultasFrequencia.ObterSinteseAluno(fechamentoFinalAluno.Frequencia, disciplinaEOL);
fechamentoFinalAluno.Sintese = sinteseDto.Valor;
}
else
{
foreach (var periodo in periodosEscolares.OrderBy(a => a.Bimestre))
{
foreach (var disciplinaParaAdicionar in disciplinas)
{
//BIMESTRE / NOTA / DISCIPLINA ID / ALUNO CODIGO
var nota = notasFechamentosBimestres.FirstOrDefault(a => a.Bimestre == periodo.Bimestre && a.DisciplinaId == disciplinaParaAdicionar.CodigoComponenteCurricular && a.AlunoCodigo == aluno.CodigoAluno);
var notaParaAdicionar = (nota == null ? null : nota.NotaConceito);
fechamentoFinalAluno.NotasConceitoBimestre.Add(new FechamentoFinalConsultaRetornoAlunoNotaConceitoDto()
{
Bimestre = periodo.Bimestre,
Disciplina = disciplinaParaAdicionar.Nome,
DisciplinaCodigo = disciplinaParaAdicionar.CodigoComponenteCurricular,
NotaConceito = notaParaAdicionar
});
}
}
foreach (var disciplinaParaAdicionar in disciplinas)
{
var nota = notasFechamentosFinais.FirstOrDefault(a => a.DisciplinaId == disciplinaParaAdicionar.CodigoComponenteCurricular && a.FechamentoAluno.AlunoCodigo == aluno.CodigoAluno);
string notaParaAdicionar = string.Empty;
if (nota != null)
{
notaParaAdicionar = (tipoNota.EhNota() ? nota.Nota.ToString() : nota.ConceitoId.ToString());
}
fechamentoFinalAluno.NotasConceitoFinal.Add(new FechamentoFinalConsultaRetornoAlunoNotaConceitoDto()
{
Disciplina = disciplinaParaAdicionar.Nome,
DisciplinaCodigo = disciplinaParaAdicionar.CodigoComponenteCurricular,
NotaConceito = notaParaAdicionar == string.Empty ? null : notaParaAdicionar,
});
}
}
fechamentoFinalAluno.PodeEditar = usuarioEPeriodoPodeEditar ? aluno.PodeEditarNotaConceito() : false;
fechamentoFinalAluno.Codigo = aluno.CodigoAluno;
retorno.Alunos.Add(fechamentoFinalAluno);
}
retorno.AuditoriaAlteracao = MontaTextoAuditoriaAlteracao(fechamentosTurmaDisciplina.Any() ? fechamentosTurmaDisciplina.FirstOrDefault() : null, retorno.EhNota);
retorno.AuditoriaInclusao = MontaTextoAuditoriaInclusao(fechamentosTurmaDisciplina.Any() ? fechamentosTurmaDisciplina.FirstOrDefault() : null, retorno.EhNota);
retorno.NotaMedia = double.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(TipoParametroSistema.MediaBimestre, DateTime.Today.Year)));
retorno.FrequenciaMedia = await consultasFrequencia.ObterFrequenciaMedia(disciplinaEOL);
return(retorno);
}
public async Task <string> Salvar(Evento evento, bool alterarRecorrenciaCompleta = false, bool dataConfirmada = false, bool unitOfWorkJaEmUso = false)
{
ObterTipoEvento(evento);
TipoCalendario tipoCalendario = ObterTipoCalendario(evento);
evento.ValidaPeriodoEvento();
var usuario = await servicoUsuario.ObterUsuarioLogado();
bool ehAlteracao = true;
if (evento.Id == 0)
{
ehAlteracao = false;
evento.TipoPerfilCadastro = usuario.ObterTipoPerfilAtual();
}
else
{
var entidadeNaoModificada = repositorioEvento.ObterPorId(evento.Id);
ObterTipoEvento(entidadeNaoModificada);
usuario.PodeAlterarEvento(entidadeNaoModificada);
}
usuario.PodeCriarEvento(evento);
var periodos = repositorioPeriodoEscolar.ObterPorTipoCalendario(evento.TipoCalendarioId);
if (evento.DeveSerEmDiaLetivo())
{
evento.EstaNoPeriodoLetivo(periodos);
}
bool devePassarPorWorkflowLiberacaoExcepcional = await ValidaDatasETiposDeEventos(evento, dataConfirmada, usuario, periodos);
AtribuirNullSeVazio(evento);
if (!unitOfWorkJaEmUso)
{
unitOfWork.IniciarTransacao();
}
repositorioEvento.Salvar(evento);
// Envia para workflow apenas na Inclusão ou alteração apos aprovado
var enviarParaWorkflow = !string.IsNullOrWhiteSpace(evento.UeId) && devePassarPorWorkflowLiberacaoExcepcional;
if (!ehAlteracao || (evento.Status == EntidadeStatus.Aprovado))
{
if (enviarParaWorkflow)
{
await PersistirWorkflowEvento(evento, devePassarPorWorkflowLiberacaoExcepcional);
}
}
if (!unitOfWorkJaEmUso)
{
unitOfWork.PersistirTransacao();
}
if (evento.EventoPaiId.HasValue && evento.EventoPaiId > 0 && alterarRecorrenciaCompleta)
{
SME.Background.Core.Cliente.Executar(() => AlterarRecorrenciaEventos(evento, alterarRecorrenciaCompleta));
}
if (ehAlteracao)
{
if (enviarParaWorkflow)
{
return("Evento alterado e será válido após aprovação.");
}
else
{
return("Evento alterado com sucesso.");
}
}
else
{
if (enviarParaWorkflow)
{
return("Evento cadastrado e será válido após aprovação.");
}
else
{
return("Evento cadastrado com sucesso.");
}
}
}
public async Task <IEnumerable <PeriodoEscolar> > Handle(ObterPeriodosEscolaresPorTipoCalendarioQuery request, CancellationToken cancellationToken) => await repositorioPeriodoEscolar.ObterPorTipoCalendario(request.TipoCalendarioId);
public async Task <FechamentoDto> ObterPorTipoCalendarioDreEUe(long tipoCalendarioId, string dreId, string ueId)
{
var tipoCalendario = repositorioTipoCalendario.ObterPorId(tipoCalendarioId);
if (tipoCalendario == null)
{
throw new NegocioException("Tipo de calendário não encontrado.");
}
var periodoEscolar = repositorioPeriodoEscolar.ObterPorTipoCalendario(tipoCalendarioId);
if (periodoEscolar == null || !periodoEscolar.Any())
{
throw new NegocioException("Período escolar não encontrado para o tipo de calendário informado.");
}
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
var(dre, ue) = ObterDreEUe(dreId, ueId);
var dreIdFiltro = !string.IsNullOrWhiteSpace(ueId) || usuarioLogado.EhPerfilUE() ? dre?.Id : null;
var fechamentoSMEDre = repositorioFechamento.ObterPorTipoCalendarioDreEUE(tipoCalendarioId, dreIdFiltro, null);
var ehRegistroExistente = (dreId == null && fechamentoSMEDre != null);
if (fechamentoSMEDre == null)
{
fechamentoSMEDre = repositorioFechamento.ObterPorTipoCalendarioDreEUE(tipoCalendarioId, null, null);
ehRegistroExistente = fechamentoSMEDre != null;
if (fechamentoSMEDre == null)
{
if (!usuarioLogado.EhPerfilSME())
{
throw new NegocioException("Fechamento da SME/Dre não encontrado para este tipo de calendário.");
}
else
{
fechamentoSMEDre = new PeriodoFechamento(null, null);
foreach (var periodo in periodoEscolar)
{
periodo.AdicionarTipoCalendario(tipoCalendario);
fechamentoSMEDre.AdicionarFechamentoBimestre(new PeriodoFechamentoBimestre(fechamentoSMEDre.Id, periodo, null, null));
}
}
}
}
var fechamentoDreUe = repositorioFechamento.ObterPorTipoCalendarioDreEUE(tipoCalendarioId, dre?.Id, ue?.Id);
if (fechamentoDreUe == null)
{
ehRegistroExistente = false;
fechamentoDreUe = fechamentoSMEDre;
fechamentoDreUe.Dre = dre;
fechamentoDreUe.Ue = ue;
}
else
{
ehRegistroExistente = true;
}
var fechamentoDto = MapearParaDto(fechamentoDreUe);
fechamentoDto.EhRegistroExistente = ehRegistroExistente;
foreach (var bimestreSME in fechamentoSMEDre.FechamentosBimestre)
{
var bimestreDreUe = fechamentoDto.FechamentosBimestres.FirstOrDefault(c => c.Bimestre == bimestreSME.PeriodoEscolar.Bimestre);
if (bimestreDreUe != null)
{
if (fechamentoSMEDre.Id > 0 && (!string.IsNullOrWhiteSpace(dreId) || !string.IsNullOrWhiteSpace(ueId)))
{
bimestreDreUe.InicioMinimo = bimestreSME.InicioDoFechamento;
bimestreDreUe.FinalMaximo = bimestreSME.FinalDoFechamento;
}
else
{
bimestreDreUe.InicioMinimo = new DateTime(DateTime.Now.Year, 01, 01);
bimestreDreUe.FinalMaximo = new DateTime(DateTime.Now.Year, 12, 31);
}
}
}
return(fechamentoDto);
}