public async Task <bool> AtividadeAvaliativaDentroPeriodo(string turmaId, DateTime dataAula)
{
var turma = await consultasTurma.ObterComUeDrePorCodigo(turmaId);
if (turma == null)
{
throw new NegocioException($"Não foi possivel obter a turma da aula");
}
var bimestreAtual = await consultasPeriodoEscolar.ObterBimestre(DateTime.Now, turma.ModalidadeCodigo, turma.Semestre);
var bimestreAvaliacao = await consultasPeriodoEscolar.ObterBimestre(dataAula, turma.ModalidadeCodigo, turma.Semestre);
if (bimestreAtual == 0 || bimestreAvaliacao == 0)
{
return(false);
}
if (bimestreAvaliacao >= bimestreAtual)
{
return(true);
}
return(await consultasPeriodoFechamento.TurmaEmPeriodoDeFechamento(turma, DateTime.Now, bimestreAtual));
}
public async Task <IActionResult> PeriodoTurmaAberto(string turmaCodigo, int bimestre, [FromQuery] DateTime dataReferencia, [FromServices] IConsultasPeriodoFechamento consultasFechamento)
{
if (dataReferencia == DateTime.MinValue)
{
dataReferencia = DateTime.Now;
}
return(Ok(await consultasFechamento.TurmaEmPeriodoDeFechamento(turmaCodigo, dataReferencia, bimestre)));
}
public async Task <bool> TurmaEmPeriodoAberto(Turma turma, DateTime dataReferencia, int bimestre = 0, bool ehAnoLetivo = false, TipoCalendario tipoCalendario = null)
{
if (tipoCalendario == null)
{
tipoCalendario = await consultasTipoCalendario.ObterPorTurma(turma);
if (tipoCalendario == null)
{
throw new NegocioException($"Tipo de calendário para turma {turma.CodigoTurma} não localizado!");
}
}
var periodoEmAberto = await consultasTipoCalendario.PeriodoEmAberto(tipoCalendario, dataReferencia, bimestre, ehAnoLetivo);
return(periodoEmAberto || await consultasPeriodoFechamento.TurmaEmPeriodoDeFechamento(turma, tipoCalendario, dataReferencia, bimestre));
}
private async Task <bool> VerificaPeriodoFechamentoEmAberto(string turmaCodigo, int bimestre) => await consultasFechamento.TurmaEmPeriodoDeFechamento(turmaCodigo, DateTime.Today, bimestre);
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 <ConselhoClasseNotaRetornoDto> SalvarConselhoClasseAlunoNotaAsync(ConselhoClasseNotaDto conselhoClasseNotaDto, string alunoCodigo, long conselhoClasseId, long fechamentoTurmaId, string codigoTurma, int bimestre)
{
var conselhoClasseNota = new ConselhoClasseNota();
var fechamentoTurma = await repositorioFechamentoTurma.ObterCompletoPorIdAsync(fechamentoTurmaId);
var fechamentoTurmaDisciplina = new FechamentoTurmaDisciplina();
if (fechamentoTurma == null)
{
var turma = await consultasTurma.ObterPorCodigo(codigoTurma);
if (turma == null)
{
throw new NegocioException("Turma não encontrada");
}
var ue = repositorioUe.ObterPorId(turma.UeId);
ue.AdicionarDre(repositorioDre.ObterPorId(ue.DreId));
turma.AdicionarUe(ue);
if (turma.AnoLetivo == DateTime.Today.Year)
{
throw new NegocioException("Não existe fechamento de turma para o conselho de classe");
}
var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, turma.ModalidadeTipoCalendario, turma.Semestre);
if (tipoCalendario == null)
{
throw new NegocioException("Tipo calendário não encontrado");
}
var periodoEscolar = await consultasPeriodoEscolar.ObterPeriodoEscolarPorTipoCalendarioBimestre(tipoCalendario.Id, bimestre);
fechamentoTurma = new FechamentoTurma()
{
TurmaId = turma.Id,
Migrado = false,
PeriodoEscolarId = periodoEscolar?.Id,
Turma = turma,
PeriodoEscolar = periodoEscolar
};
fechamentoTurmaDisciplina = new FechamentoTurmaDisciplina()
{
DisciplinaId = conselhoClasseNotaDto.CodigoComponenteCurricular
};
}
try
{
unitOfWork.IniciarTransacao();
if (fechamentoTurmaDisciplina.DisciplinaId > 0)
{
await repositorioFechamentoTurma.SalvarAsync(fechamentoTurma);
fechamentoTurmaDisciplina.FechamentoTurmaId = fechamentoTurma.Id;
await repositorioFechamentoTurmaDisciplina.SalvarAsync(fechamentoTurmaDisciplina);
}
if (fechamentoTurma.PeriodoEscolarId.HasValue)
{
// Fechamento Bimestral
if (!await consultasPeriodoFechamento.TurmaEmPeriodoDeFechamento(fechamentoTurma.Turma, DateTime.Today, fechamentoTurma.PeriodoEscolar.Bimestre))
{
throw new NegocioException($"Turma {fechamentoTurma.Turma.Nome} não esta em período de fechamento para o {fechamentoTurma.PeriodoEscolar.Bimestre}º Bimestre!");
}
}
else
{
// Fechamento Final
if (fechamentoTurma.Turma.AnoLetivo != 2020)
{
var validacaoConselhoFinal = await consultasConselhoClasse.ValidaConselhoClasseUltimoBimestre(fechamentoTurma.Turma);
if (!validacaoConselhoFinal.Item2 && fechamentoTurma.Turma.AnoLetivo == DateTime.Today.Year)
{
throw new NegocioException($"Para acessar este aba você precisa registrar o conselho de classe do {validacaoConselhoFinal.Item1}º bimestre");
}
}
}
unitOfWork.PersistirTransacao();
}
catch (Exception e)
{
unitOfWork.Rollback();
throw e;
}
long conselhoClasseAlunoId = 0;
try
{
if (conselhoClasseId == 0)
{
var conselhoClasse = new ConselhoClasse();
conselhoClasse.FechamentoTurmaId = fechamentoTurma.Id;
unitOfWork.IniciarTransacao();
await repositorioConselhoClasse.SalvarAsync(conselhoClasse);
conselhoClasseId = conselhoClasse.Id;
conselhoClasseAlunoId = await SalvarConselhoClasseAlunoResumido(conselhoClasse.Id, alunoCodigo);
conselhoClasseNota = ObterConselhoClasseNota(conselhoClasseNotaDto, conselhoClasseAlunoId);
if (fechamentoTurma.Turma.AnoLetivo == 2020)
{
ValidarNotasFechamentoConselhoClasse2020(conselhoClasseNota);
}
await repositorioConselhoClasseNota.SalvarAsync(conselhoClasseNota);
unitOfWork.PersistirTransacao();
}
else
{
var conselhoClasseAluno = await repositorioConselhoClasseAluno.ObterPorConselhoClasseAlunoCodigoAsync(conselhoClasseId, alunoCodigo);
unitOfWork.IniciarTransacao();
conselhoClasseAlunoId = conselhoClasseAluno != null ? conselhoClasseAluno.Id : await SalvarConselhoClasseAlunoResumido(conselhoClasseId, alunoCodigo);
conselhoClasseNota = await repositorioConselhoClasseNota.ObterPorConselhoClasseAlunoComponenteCurricularAsync(conselhoClasseAlunoId, conselhoClasseNotaDto.CodigoComponenteCurricular);
if (conselhoClasseNota == null)
{
conselhoClasseNota = ObterConselhoClasseNota(conselhoClasseNotaDto, conselhoClasseAlunoId);
}
else
{
conselhoClasseNota.Justificativa = conselhoClasseNotaDto.Justificativa;
if (conselhoClasseNotaDto.Nota.HasValue)
{
// Gera histórico de alteração
if (conselhoClasseNota.Nota != conselhoClasseNotaDto.Nota.Value)
{
await mediator.Send(new SalvarHistoricoNotaConselhoClasseCommand(conselhoClasseNota.Id, conselhoClasseNota.Nota.Value, conselhoClasseNotaDto.Nota.Value));
}
conselhoClasseNota.Nota = conselhoClasseNotaDto.Nota.Value;
}
else
{
conselhoClasseNota.Nota = null;
}
if (conselhoClasseNotaDto.Conceito.HasValue)
{
// Gera histórico de alteração
if (conselhoClasseNota.ConceitoId != conselhoClasseNotaDto.Conceito.Value)
{
await mediator.Send(new SalvarHistoricoConceitoConselhoClasseCommand(conselhoClasseNota.Id, conselhoClasseNota.ConceitoId.Value, conselhoClasseNotaDto.Conceito.Value));
}
conselhoClasseNota.ConceitoId = conselhoClasseNotaDto.Conceito.Value;
}
}
if (fechamentoTurma.Turma.AnoLetivo == 2020)
{
ValidarNotasFechamentoConselhoClasse2020(conselhoClasseNota);
}
await repositorioConselhoClasseNota.SalvarAsync(conselhoClasseNota);
unitOfWork.PersistirTransacao();
}
}
catch (Exception e)
{
unitOfWork.Rollback();
throw e;
}
// TODO Verificar se o fechamentoTurma.Turma carregou UE
if (await VerificaNotasTodosComponentesCurriculares(alunoCodigo, fechamentoTurma.Turma, fechamentoTurma.PeriodoEscolarId))
{
await VerificaRecomendacoesAluno(conselhoClasseAlunoId);
}
var usuarioLogado = await mediator.Send(new ObterUsuarioLogadoQuery());
await mediator.Send(new PublicaFilaAtualizacaoSituacaoConselhoClasseCommand(conselhoClasseId, usuarioLogado));
var auditoria = (AuditoriaDto)conselhoClasseNota;
var conselhoClasseNotaRetorno = new ConselhoClasseNotaRetornoDto()
{
ConselhoClasseId = conselhoClasseId,
FechamentoTurmaId = fechamentoTurma.Id,
Auditoria = auditoria
};
return(conselhoClasseNotaRetorno);
}
public async Task <ConsultasConselhoClasseRecomendacaoConsultaDto> ObterRecomendacoesAlunoFamilia(long conselhoClasseId, long fechamentoTurmaId, string alunoCodigo, string codigoTurma, int?bimestre)
{
var fechamentoTurma = await consultasFechamentoTurma.ObterCompletoPorIdAsync(fechamentoTurmaId);
var turma = fechamentoTurma?.Turma;
var periodoEscolar = fechamentoTurma?.PeriodoEscolar;
var emFechamento = true;
if (fechamentoTurma == null)
{
turma = await consultasTurma.ObterPorCodigo(codigoTurma);
if (turma == null)
{
throw new NegocioException("Turma não encontrada");
}
var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, turma.ModalidadeTipoCalendario, turma.Semestre);
if (tipoCalendario == null)
{
throw new NegocioException("Tipo calendário não encontrado");
}
periodoEscolar = await consultasPeriodoEscolar.ObterPeriodoEscolarPorTipoCalendarioBimestre(tipoCalendario.Id, bimestre.Value);
}
if (!bimestre.HasValue)
{
if (fechamentoTurma.Turma.AnoLetivo != 2020)
{
var validacaoConselhoFinal = await consultasConselhoClasse.ValidaConselhoClasseUltimoBimestre(turma);
if (!validacaoConselhoFinal.Item2)
{
throw new NegocioException($"Para acessar este aba você precisa registrar o conselho de classe do {validacaoConselhoFinal.Item1}º bimestre");
}
}
emFechamento = await consultasPeriodoFechamento.TurmaEmPeriodoDeFechamento(turma.CodigoTurma, DateTime.Today);
}
else
{
emFechamento = await consultasPeriodoFechamento.TurmaEmPeriodoDeFechamento(turma.CodigoTurma, DateTime.Today, bimestre.Value);
}
var anotacoesDoAluno = await consultasFechamentoAluno.ObterAnotacaoAlunoParaConselhoAsync(alunoCodigo, fechamentoTurmaId);
if (anotacoesDoAluno == null)
{
anotacoesDoAluno = new List <FechamentoAlunoAnotacaoConselhoDto>();
}
var conselhoClasseAluno = fechamentoTurma != null ? await repositorioConselhoClasseAluno.ObterPorFechamentoAsync(fechamentoTurma.Id, alunoCodigo): null;
if (conselhoClasseAluno == null || string.IsNullOrEmpty(conselhoClasseAluno.RecomendacoesAluno) || string.IsNullOrEmpty(conselhoClasseAluno.RecomendacoesFamilia))
{
return(await ObterRecomendacoesIniciais(conselhoClasseAluno, anotacoesDoAluno, emFechamento));
}
return(TransformaEntidadeEmConsultaDto(conselhoClasseAluno, anotacoesDoAluno, emFechamento));
}
