private void EnviaNotificacaoParaDre(long dreId, IEnumerable <PeriodoFechamentoBimestre> fechamentosBimestre)
{
var dre = repositorioDre.ObterPorId(dreId);
if (dre != null)
{
try
{
Notificacao notificacao = MontaNotificacao(dre.Nome, "SME", fechamentosBimestre, null, dre.CodigoDre);
var adminsSgpDre = servicoEol.ObterAdministradoresSGPParaNotificar(dre.CodigoDre).Result;
if (adminsSgpDre != null && adminsSgpDre.Any())
{
foreach (var adminSgpUe in adminsSgpDre)
{
var usuario = servicoUsuario.ObterUsuarioPorCodigoRfLoginOuAdiciona(adminSgpUe);
notificacao.UsuarioId = usuario.Id;
servicoNotificacao.Salvar(notificacao);
}
}
}
catch (Exception)
{
throw;
}
}
}
private async Task <bool> UeEmFechamento(Turma turma, TipoCalendario tipoCalendario, string ueCodigo, string dreCodigo, int bimestre, DateTime dataReferencia)
{
if (turma.Ue == null)
{
turma.AdicionarUe(repositorioUe.ObterPorId(turma.UeId));
}
if (turma.Ue.Dre == null)
{
turma.Ue.AdicionarDre(repositorioDre.ObterPorId(turma.Ue.DreId));
}
return(await repositorioEventoFechamento.UeEmFechamento(dataReferencia, turma.Ue.Dre.CodigoDre, turma.Ue.CodigoUe, tipoCalendario.Id, bimestre));
}
public async Task <bool> TurmaEmPeriodoDeFechamento(string turmaCodigo, DateTime dataReferencia, int bimestre)
{
var turma = repositorioTurma.ObterPorId(turmaCodigo);
var ue = repositorioUe.ObterPorId(turma.UeId);
var dre = repositorioDre.ObterPorId(ue.DreId);
var tipoCalendario = repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo
, turma.ModalidadeCodigo == Modalidade.EJA ? ModalidadeTipoCalendario.EJA : ModalidadeTipoCalendario.FundamentalMedio
, dataReferencia.Month <= 6 ? 1 : 2);
var ueEmFechamento = await repositorioEventoFechamento.UeEmFechamento(dataReferencia, dre.CodigoDre, ue.CodigoUe, bimestre, tipoCalendario.Id);
return(ueEmFechamento || await UeEmReaberturaDeFechamento(tipoCalendario.Id, ue.CodigoUe, dre.CodigoDre, bimestre, dataReferencia));
}
public void NotificarCompensacaoAusencia(long compensacaoId)
{
// Verifica se compensação possui alunos vinculados
var alunos = repositorioCompensacaoAusenciaAluno.ObterPorCompensacao(compensacaoId).Result;
if (alunos == null || !alunos.Any())
{
return;
}
// Verifica se possui aluno não notificado na compensação
alunos = alunos.Where(a => !a.Notificado);
if (!alunos.Any())
{
return;
}
// Carrega dados da compensacao a notificar
var compensacao = repositorioCompensacaoAusencia.ObterPorId(compensacaoId);
var turma = repositorioTurma.ObterPorId(compensacao.TurmaId);
var ue = repositorioUe.ObterUEPorTurma(turma.CodigoTurma);
var dre = repositorioDre.ObterPorId(ue.DreId);
var disciplinaEOL = ObterNomeDisciplina(compensacao.DisciplinaId);
MeusDadosDto professor = servicoEOL.ObterMeusDados(compensacao.CriadoRF).Result;
// Carrega dados dos alunos não notificados
var alunosTurma = servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma).Result;
var alunosDto = new List <CompensacaoAusenciaAlunoQtdDto>();
foreach (var aluno in alunos)
{
var alunoEol = alunosTurma.FirstOrDefault(a => a.CodigoAluno == aluno.CodigoAluno);
alunosDto.Add(new CompensacaoAusenciaAlunoQtdDto()
{
NumeroAluno = alunoEol.NumeroAlunoChamada,
CodigoAluno = aluno.CodigoAluno,
NomeAluno = alunoEol.NomeAluno,
QuantidadeCompensacoes = aluno.QuantidadeFaltasCompensadas
});
}
var gestores = BuscaGestoresUe(ue.CodigoUe);
if (gestores != null && gestores.Any())
{
foreach (var gestor in gestores)
{
var notificacaoId = NotificarCompensacaoAusencia(compensacaoId
, gestor.Usuario
, professor.Nome
, professor.CodigoRf
, disciplinaEOL
, turma.CodigoTurma
, turma.Nome
, turma.ModalidadeCodigo.GetAttribute <DisplayAttribute>().ShortName
, ue.CodigoUe
, ue.Nome
, ue.TipoEscola.GetAttribute <DisplayAttribute>().ShortName
, dre.CodigoDre
, dre.Nome
, compensacao.Bimestre
, compensacao.Nome
, alunosDto);
// Grava vinculo de notificação x compensação
repositorioNotificacaoCompensacaoAusencia.Inserir(notificacaoId, compensacaoId);
}
// Marca aluno como notificado
alunosDto.ForEach(alunoDto =>
{
var aluno = alunos.FirstOrDefault(a => a.CodigoAluno == alunoDto.CodigoAluno);
aluno.Notificado = true;
repositorioCompensacaoAusenciaAluno.Salvar(aluno);
});
}
}
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);
}
