public async Task GerarPendenciasFechamento(long disciplinaId, Turma turma, PeriodoEscolar periodoEscolar, FechamentoTurmaDisciplina fechamento, Usuario usuarioLogado, bool componenteSemNota = false, bool registraFrequencia = true)
{
var situacaoFechamento = SituacaoFechamento.ProcessadoComSucesso;
if (!componenteSemNota)
{
await servicoPendenciaFechamento.ValidarAvaliacoesSemNotasParaNenhumAluno(fechamento.Id, turma.CodigoTurma, disciplinaId, periodoEscolar.PeriodoInicio, periodoEscolar.PeriodoFim);
await servicoPendenciaFechamento.ValidarPercentualAlunosAbaixoDaMedia(fechamento);
await servicoPendenciaFechamento.ValidarAlteracaoExtemporanea(fechamento.Id, turma.CodigoTurma, fechamento.CriadoRF);
}
await servicoPendenciaFechamento.ValidarAulasReposicaoPendente(fechamento.Id, turma, disciplinaId, periodoEscolar.PeriodoInicio, periodoEscolar.PeriodoFim);
await servicoPendenciaFechamento.ValidarAulasSemPlanoAulaNaDataDoFechamento(fechamento.Id, turma, disciplinaId, periodoEscolar.PeriodoInicio, periodoEscolar.PeriodoFim);
if (registraFrequencia)
{
await servicoPendenciaFechamento.ValidarAulasSemFrequenciaRegistrada(fechamento.Id, turma, disciplinaId, periodoEscolar.PeriodoInicio, periodoEscolar.PeriodoFim);
}
var quantidadePendencias = servicoPendenciaFechamento.ObterQuantidadePendenciasGeradas();
if (quantidadePendencias > 0)
{
situacaoFechamento = SituacaoFechamento.ProcessadoComPendencias;
await GerarNotificacaoFechamento(fechamento, turma, quantidadePendencias, usuarioLogado, periodoEscolar);
}
fechamento.AtualizarSituacao(situacaoFechamento);
await repositorioFechamentoTurmaDisciplina.SalvarAsync(fechamento);
}
private static void NovoPerioEscolar(PeriodoEscolar periodoEscolar, int bimestre, DateTime inicio, DateTime fim)
{
periodoEscolar.Bimestre = bimestre;
periodoEscolar.PeriodoInicio = inicio;
periodoEscolar.PeriodoFim = fim;
periodoEscolar.TipoCalendarioId = 1;
}
private async Task <string> ObterTipoNota(PeriodoEscolar periodoEscolar, Turma turma)
{
return(await mediator.Send(new ObterTipoNotaQuery()
{
PeriodoEscolar = periodoEscolar,
Turma = turma
}));
}
public bool PodeEditarNotaConceitoNoPeriodo(PeriodoEscolar periodoEscolar)
{
if (!PodeEditarNotaConceito())
{
return(DataSituacao >= periodoEscolar?.PeriodoFim);
}
return(true);
}
public async Task Deve_Buscar_Evento_E_Aulas_Do_Ano_Todo_Por_Tipo_Calendario_Dre_Ue()
{
List <DateTime> diasLetivos = new List <DateTime>();
List <DateTime> diasNaoLetivos = new List <DateTime>();
FiltroEventosAulasCalendarioDto filtro = new FiltroEventosAulasCalendarioDto
{
DreId = "1",
UeId = "2",
TurmaId = "1",
TipoCalendarioId = 1
};
PeriodoEscolar periodoEscolar = new PeriodoEscolar();
PeriodoEscolar periodoEscolar2 = new PeriodoEscolar();
PeriodoEscolar periodoEscolar3 = new PeriodoEscolar();
PeriodoEscolar periodoEscolar4 = new PeriodoEscolar();
AulaDto aula = new AulaDto();
AulaDto aula2 = new AulaDto();
Evento evento = new Evento();
Evento evento2 = new Evento();
NovoPerioEscolar(periodoEscolar, 1, new DateTime(2019, 02, 01), new DateTime(2019, 03, 30));
NovoPerioEscolar(periodoEscolar2, 2, new DateTime(2019, 04, 01), new DateTime(2019, 06, 30));
NovoPerioEscolar(periodoEscolar3, 3, new DateTime(2019, 07, 01), new DateTime(2019, 09, 30));
NovoPerioEscolar(periodoEscolar4, 4, new DateTime(2019, 10, 01), new DateTime(2019, 11, 30));
NovaAula(aula, new DateTime(2019, 11, 1));
NovaAula(aula2, new DateTime(2019, 12, 1));
NovoEvento(evento, "Teste 1", new DateTime(2019, 11, 21), new DateTime(2019, 12, 1));
NovoEvento(evento2, "Teste 2", new DateTime(2019, 12, 1), new DateTime(2019, 12, 1));
IEnumerable <PeriodoEscolar> periodos = new List <PeriodoEscolar> {
periodoEscolar, periodoEscolar2, periodoEscolar3, periodoEscolar4
};
IEnumerable <AulaDto> aulas = new List <AulaDto> {
aula, aula2
};
IEnumerable <Evento> eventos = new List <Evento> {
evento, evento2
};
repositorioPeriodoEscolar.Setup(r => r.ObterPorTipoCalendario(It.IsAny <long>())).Returns(periodos);
repositorioAula.Setup(r => r.ObterAulas(It.IsAny <long>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(aulas));
repositorioEvento.Setup(r => r.ObterEventosPorTipoDeCalendarioDreUe(It.IsAny <long>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>())).Returns(eventos);
var dias = comandosDiasLetivos.BuscarDiasLetivos(1);
var diasEventosNaoLetivos = comandosDiasLetivos.ObterDias(eventos, diasNaoLetivos, Dominio.EventoLetivo.Nao);
var diasEventosLetivos = comandosDiasLetivos.ObterDias(eventos, diasLetivos, Dominio.EventoLetivo.Sim);
comandosDiasLetivosMock.Setup(r => r.BuscarDiasLetivos(It.IsAny <long>())).Returns(dias);
comandosDiasLetivosMock.Setup(r => r.ObterDias(It.IsAny <IEnumerable <Evento> >(), It.IsAny <List <DateTime> >(), EventoLetivo.Nao)).Returns(diasEventosNaoLetivos);
comandosDiasLetivosMock.Setup(r => r.ObterDias(It.IsAny <IEnumerable <Evento> >(), It.IsAny <List <DateTime> >(), EventoLetivo.Sim)).Returns(diasEventosLetivos);
var eventosAulas = await consultasEventosAulasCalendario.ObterEventosAulasMensais(filtro);
Assert.True(eventosAulas.ToList().Where(x => x.Mes == 11).Select(s => s.EventosAulas).FirstOrDefault() == 8);
}
private PeriodoEscolarDto MapearParaDto(PeriodoEscolar periodo)
=> periodo == null ? null : new PeriodoEscolarDto()
{
Id = periodo.Id,
Bimestre = periodo.Bimestre,
Migrado = periodo.Migrado,
PeriodoInicio = periodo.PeriodoInicio,
PeriodoFim = periodo.PeriodoFim
};
public async Task Deve_Buscar_Tipos_De_Evento_E_Aulas_Do_Mes_Por_Tipo_Calendario_Dre_Ue()
{
FiltroEventosAulasCalendarioMesDto filtro = new FiltroEventosAulasCalendarioMesDto
{
DreId = "1",
UeId = "2",
TurmaId = "1",
TipoCalendarioId = 1,
Mes = 11
};
PeriodoEscolar periodoEscolar = new PeriodoEscolar();
PeriodoEscolar periodoEscolar2 = new PeriodoEscolar();
PeriodoEscolar periodoEscolar3 = new PeriodoEscolar();
PeriodoEscolar periodoEscolar4 = new PeriodoEscolar();
AulaDto aula = new AulaDto();
AulaDto aula2 = new AulaDto();
Evento evento = new Evento();
Evento evento2 = new Evento();
NovaAula(aula, new DateTime(2019, 11, 1));
NovaAula(aula2, new DateTime(2019, 11, 2));
NovoEvento(evento, "Teste 1", new DateTime(2019, 11, 21), new DateTime(2019, 12, 1));
NovoEvento(evento2, "Teste 2", new DateTime(2019, 11, 1), new DateTime(2019, 11, 1));
NovoPerioEscolar(periodoEscolar, 1, new DateTime(2019, 02, 01), new DateTime(2019, 03, 30));
NovoPerioEscolar(periodoEscolar2, 2, new DateTime(2019, 04, 01), new DateTime(2019, 06, 30));
NovoPerioEscolar(periodoEscolar3, 3, new DateTime(2019, 07, 01), new DateTime(2019, 09, 30));
NovoPerioEscolar(periodoEscolar4, 4, new DateTime(2019, 10, 01), new DateTime(2019, 11, 30));
IEnumerable <PeriodoEscolar> periodos = new List <PeriodoEscolar> {
periodoEscolar, periodoEscolar2, periodoEscolar3, periodoEscolar4
};
IEnumerable <AulaDto> aulas = new List <AulaDto> {
aula, aula2
};
IEnumerable <Evento> eventos = new List <Evento> {
evento, evento2
};
repositorioAula.Setup(r => r.ObterAulas(It.IsAny <long>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), null, null, null)).Returns(Task.FromResult(aulas));
repositorioEvento.Setup(r => r.ObterEventosPorTipoDeCalendarioDreUeMes(It.IsAny <long>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <bool>())).Returns(Task.FromResult(eventos));
repositorioPeriodoEscolar.Setup(r => r.ObterPorTipoCalendario(It.IsAny <long>())).Returns(periodos);
var dias = comandosDiasLetivos.BuscarDiasLetivos(1);
comandosDiasLetivosMock.Setup(r => r.BuscarDiasLetivos(It.IsAny <long>())).Returns(dias);
var eventosAulas = await consultasEventosAulasCalendario.ObterTipoEventosAulas(filtro);
Assert.True(eventosAulas.Count() == 11);
}
private async Task EnviarRelatorio(Guid codigoRelatorio, Ue ue, PeriodoEscolar periodoEscolarEncerrado)
{
var componentesUe = await VerificaComponentesUe(ue);
var siglasComponentesUe = ObterSiglasComponentes(componentesUe);
var nomesComponentesUe = OterNomesComponentes(componentesUe);
var descricaoUe = $"{ue.TipoEscola.ShortName()} {ue.Nome} ({ue.Dre.Abreviacao})";
var titulo = $"Validação bimestral de frequência {siglasComponentesUe} - {periodoEscolarEncerrado.Bimestre}º Bimestre - {descricaoUe}";
var mensagem = $"Segue o relatório de frequência dos componentes de {nomesComponentesUe} do <b>{periodoEscolarEncerrado.Bimestre}º Bimestre</b> da <b>{descricaoUe}</b> para sua validação.<br/><br/>Clique no botão abaixo para fazer o download do arquivo.<br/><br/>";
mensagem += await MontarBotaoDownload(codigoRelatorio);
await mediator.Send(new EnviarNotificacaoCommand(titulo, mensagem, NotificacaoCategoria.Workflow_Aprovacao, NotificacaoTipo.Frequencia, ObterCargos(), ue.Dre.CodigoDre, ue.CodigoUe));
}
public async Task <IEnumerable <PeriodoEscolar> > ObterPeriodosEmAberto(long ueId, Modalidade modalidadeCodigo, int anoLetivo)
{
List <PeriodoEscolar> periodos = new List <PeriodoEscolar>();
PeriodoEscolar periodoAtual = await ObterPeriodoEscolarEmAberto(modalidadeCodigo, anoLetivo);
if (periodoAtual != null)
{
periodos.Add(periodoAtual);
}
periodos.AddRange(await consultasPeriodoFechamento.ObterPeriodosComFechamentoEmAberto(ueId));
return(periodos);
}
private async Task NotificarUe(Ue ue, PeriodoEscolar periodoEscolar, PeriodoFechamentoBimestre periodoFechamentoBimestre)
{
var descricaoUe = $"{ue.TipoEscola.ShortName()} {ue.Nome} ({ue.Dre.Abreviacao})";
var titulo = $"Início do período de fechamento do {periodoEscolar.Bimestre}º bimestre - {descricaoUe}";
var mensagem = $@"O fechamento do <b>{periodoEscolar.Bimestre}º bimestre</b> na <b>{descricaoUe}</b> irá iniciar no dia <b>{periodoFechamentoBimestre.InicioDoFechamento.Date.ToString("dd/MM/yyyy")}</b>.";
var usuarios = await ObterUsuarios(ue);
if (usuarios != null && usuarios.Any())
{
await mediator.Send(new EnviarNotificacaoUsuariosCommand(titulo, mensagem, NotificacaoCategoria.Aviso, NotificacaoTipo.Calendario, usuarios, ue.Dre.CodigoDre, ue.CodigoUe));
}
await mediator.Send(new EnviarNotificacaoCommand(titulo, mensagem.ToString(), NotificacaoCategoria.Aviso, NotificacaoTipo.Calendario, ObterCargosGestaoEscola(),
periodoFechamentoBimestre.PeriodoFechamento.Ue.Dre.CodigoDre,
periodoFechamentoBimestre.PeriodoFechamento.Ue.CodigoUe));
}
private async Task EnviarNotificacaoProfessores(IEnumerable <Turma> turmas, PeriodoEscolar periodoEscolar, PeriodoFechamentoBimestre periodoFechamentoBimestre, Ue ue)
{
var descricaoUe = $"{ue.TipoEscola.ShortName()} {ue.Nome} ({ue.Dre.Abreviacao})";
var titulo = $"Término do período de fechamento do {periodoEscolar.Bimestre}º bimestre - {descricaoUe}";
var mensagem = $@"O fechamento do <b>{periodoEscolar.Bimestre}º bimestre</b> na <b>{descricaoUe}</b> irá encerrar no dia <b>{periodoFechamentoBimestre.FinalDoFechamento.Date:dd/MM/yyyy}</b>.
<br/><br/>Após esta data o sistema será bloqueado para edições neste bimestre.";
var professores = await ObterProfessores(turmas);
if (professores != null && professores.Any())
{
await mediator.Send(new EnviarNotificacaoUsuariosCommand(titulo, mensagem, NotificacaoCategoria.Aviso, NotificacaoTipo.Calendario, professores, ue.Dre.CodigoDre, ue.CodigoUe));
}
await mediator.Send(new EnviarNotificacaoCommand(titulo, mensagem.ToString(), NotificacaoCategoria.Aviso, NotificacaoTipo.Calendario, ObterCargosGestaoEscola(),
periodoFechamentoBimestre.PeriodoFechamento.Ue.Dre.CodigoDre,
periodoFechamentoBimestre.PeriodoFechamento.Ue.CodigoUe));
}
private async Task EnviarNotasWfAprovacao(long fechamentoTurmaDisciplinaId, PeriodoEscolar periodoEscolar, Usuario usuarioLogado)
{
if (notasEnvioWfAprovacao.Any())
{
var lancaNota = !notasEnvioWfAprovacao.First().ConceitoId.HasValue;
var notaConceitoMensagem = lancaNota ? "nota" : "conceito";
var mensagem = await MontaMensagemWfAprovacao(notaConceitoMensagem, periodoEscolar, usuarioLogado);
var wfAprovacaoNota = new WorkflowAprovacaoDto()
{
Ano = DateTime.Today.Year,
NotificacaoCategoria = NotificacaoCategoria.Workflow_Aprovacao,
EntidadeParaAprovarId = fechamentoTurmaDisciplinaId,
Tipo = WorkflowAprovacaoTipo.AlteracaoNotaFechamento,
TurmaId = turmaFechamento.CodigoTurma,
UeId = turmaFechamento.Ue.CodigoUe,
DreId = turmaFechamento.Ue.Dre.CodigoDre,
NotificacaoTitulo = $"Alteração em {notaConceitoMensagem} final - Turma {turmaFechamento.Nome} ({turmaFechamento.AnoLetivo})",
NotificacaoTipo = NotificacaoTipo.Notas,
NotificacaoMensagem = mensagem
};
wfAprovacaoNota.AdicionarNivel(Cargo.CP);
wfAprovacaoNota.AdicionarNivel(Cargo.Diretor);
wfAprovacaoNota.AdicionarNivel(Cargo.Supervisor);
var idWorkflow = await comandosWorkflowAprovacao.Salvar(wfAprovacaoNota);
foreach (var notaFechamento in notasEnvioWfAprovacao)
{
await repositorioWfAprovacaoNotaFechamento.SalvarAsync(new WfAprovacaoNotaFechamento()
{
WfAprovacaoId = idWorkflow,
FechamentoNotaId = notaFechamento.Id,
Nota = notaFechamento.Nota,
ConceitoId = notaFechamento.ConceitoId
});
}
}
}
public NotificaFrequenciaPeriodoUeCommand(PeriodoEscolar periodoEscolarEncerrado)
{
PeriodoEscolarEncerrado = periodoEscolarEncerrado;
}
public MarcadorFrequenciaDto ObterMarcadorAluno(AlunoPorTurmaResposta aluno, PeriodoEscolar bimestre, bool ehInfantil = false)
{
MarcadorFrequenciaDto marcador = null;
string dataSituacao = $"{aluno.DataSituacao.Day}/{aluno.DataSituacao.Month}/{aluno.DataSituacao.Year}";
switch (aluno.CodigoSituacaoMatricula)
{
case SituacaoMatriculaAluno.Ativo:
// Macador "Novo" durante 15 dias se iniciou depois do inicio do bimestre
if ((aluno.DataSituacao > bimestre.PeriodoInicio) && (aluno.DataSituacao.AddDays(15) >= DateTime.Now.Date))
{
marcador = new MarcadorFrequenciaDto()
{
Tipo = TipoMarcadorFrequencia.Novo,
Descricao = $"{(ehInfantil ? "Criança Nova" : "Estudante Novo")}: Data da matrícula {dataSituacao}"
}
}
;
break;
case SituacaoMatriculaAluno.Transferido:
var detalheEscola = aluno.Transferencia_Interna ?
$"para escola {aluno.EscolaTransferencia} e turma {aluno.TurmaTransferencia}" :
"para outras redes";
marcador = new MarcadorFrequenciaDto()
{
Tipo = TipoMarcadorFrequencia.Transferido,
Descricao = $"{(ehInfantil ? "Criança Transferida" : "Estudante Transferido")}: {detalheEscola} em {dataSituacao}"
};
break;
case SituacaoMatriculaAluno.RemanejadoSaida:
marcador = new MarcadorFrequenciaDto()
{
Tipo = TipoMarcadorFrequencia.Remanejado,
Descricao = $"{(ehInfantil ? "Criança Remanejada" : "Estudante Remanejado")}: turma {aluno.TurmaRemanejamento} em {dataSituacao}"
};
break;
case SituacaoMatriculaAluno.Desistente:
case SituacaoMatriculaAluno.VinculoIndevido:
case SituacaoMatriculaAluno.Falecido:
case SituacaoMatriculaAluno.NaoCompareceu:
case SituacaoMatriculaAluno.Deslocamento:
case SituacaoMatriculaAluno.Cessado:
case SituacaoMatriculaAluno.ReclassificadoSaida:
marcador = new MarcadorFrequenciaDto()
{
Tipo = TipoMarcadorFrequencia.Inativo,
Descricao = $"{(ehInfantil ? "Criança Inativa" : "Estudante Inativo")} em {dataSituacao}"
};
break;
default:
break;
}
return(marcador);
}
private async Task <bool> UsuarioTemAtribuicao(Usuario usuario, string turmaCodigo, long componenteCurricularId, PeriodoEscolar periodoEscolar)
{
var validacao = await mediator.Send(new ObterUsuarioPossuiPermissaoNaTurmaEDisciplinaNoPeriodoQuery(componenteCurricularId, turmaCodigo, usuario.CodigoRf, periodoEscolar.PeriodoInicio, periodoEscolar.PeriodoFim));
return(validacao);
}
private IndicativoFrequenciaDto ObterIndicativoFrequencia(AlunoPorTurmaResposta aluno, string disciplinaId, PeriodoEscolar bimestre, int percentualAlerta, int percentualCritico)
{
var frequenciaAluno = repositorioFrequenciaAlunoDisciplinaPeriodo.Obter(aluno.CodigoAluno, disciplinaId, bimestre.Id, TipoFrequenciaAluno.PorDisciplina, aluno.CodigoTurma.ToString());
// Frequencia não calculada
if (frequenciaAluno == null)
{
if (aluno.PodeEditarNotaConceito())
{
return new IndicativoFrequenciaDto()
{
Tipo = TipoIndicativoFrequencia.Info, Percentual = 100
}
}
;
return(null);
}
int percentualFrequencia = (int)Math.Round(frequenciaAluno.PercentualFrequencia, 0);
// Critico
if (percentualFrequencia <= percentualCritico)
{
return new IndicativoFrequenciaDto()
{
Tipo = TipoIndicativoFrequencia.Critico, Percentual = percentualFrequencia
}
}
;
// Alerta
if (percentualFrequencia <= percentualAlerta)
{
return new IndicativoFrequenciaDto()
{
Tipo = TipoIndicativoFrequencia.Alerta, Percentual = percentualFrequencia
}
}
;
return(new IndicativoFrequenciaDto()
{
Tipo = TipoIndicativoFrequencia.Info, Percentual = percentualFrequencia
});
}
private ComponenteRegenciaComNotaFinal ObterNotasRegencia(ComponenteCurricularPorTurma componenteCurricular, PeriodoEscolar periodoEscolar, IEnumerable <NotaConceitoBimestreComponente> notasConselhoClasse, IEnumerable <NotaConceitoBimestreComponente> notasFechamento, Turma turma)
{
var notasComponente = ObterNotasComponente(componenteCurricular, periodoEscolar, notasFechamento);
return(new ComponenteRegenciaComNotaFinal()
{
Componente = componenteCurricular.Disciplina,
EhEja = turma.EhEja,
NotaConceitoBimestre1 = notasComponente.FirstOrDefault(n => n.Bimestre == 1)?.NotaConceito,
NotaConceitoBimestre2 = notasComponente.FirstOrDefault(n => n.Bimestre == 2)?.NotaConceito,
NotaConceitoBimestre3 = notasComponente.FirstOrDefault(n => n.Bimestre == 3)?.NotaConceito,
NotaConceitoBimestre4 = notasComponente.FirstOrDefault(n => n.Bimestre == 4)?.NotaConceito,
NotaFinal = ObterNotaPosConselho(componenteCurricular, periodoEscolar?.Bimestre, notasConselhoClasse, notasFechamento)
});
}
private async Task <string> MontarLinhaDaTurma(Turma turma, IEnumerable <ComponenteCurricularDto> componentes, Ue ue, PeriodoEscolar periodoEscolar)
{
var mensagem = new StringBuilder();
var componentesDaTurma = await ObterComponentesDaTurma(turma, ue);
var componentesCurriculares = componentes.Where(c => componentesDaTurma.Any(t => t.Codigo == c.Codigo));
foreach (var componenteCurricular in componentesCurriculares)
{
mensagem.Append("<tr>");
if (componenteCurricular.Codigo == componentesCurriculares.First().Codigo)
{
mensagem.Append($"<td style='padding:2px' rowspan='{componentesCurriculares.Count()}'>{turma.Nome}</td>");
}
mensagem.Append($"<td style='padding:2px'>{componenteCurricular.Descricao}</td>");
mensagem.Append($"<td style='padding:2px'>{await ObterSituacaoFechamento(turma, componenteCurricular, periodoEscolar)}</td>");
if (componenteCurricular.Codigo == componentesCurriculares.First().Codigo)
{
mensagem.Append($"<td style='padding:2px' rowspan='{componentesCurriculares.Count()}'>{await ObterSituacaoConselhoClasse(turma, periodoEscolar)}</td>");
}
mensagem.Append("</tr>");
}
return(mensagem.ToString());
}
public async Task <IEnumerable <AlunoDadosBasicosDto> > ObterDadosAlunos(string turmaCodigo, int anoLetivo, PeriodoEscolar periodoEscolar = null)
{
var dadosAlunos = await servicoEOL.ObterAlunosPorTurma(turmaCodigo);
if (dadosAlunos == null || !dadosAlunos.Any())
{
throw new NegocioException($"Não foram localizados dados dos alunos para turma {turmaCodigo} no EOL para o ano letivo {anoLetivo}");
}
var dadosAlunosDto = new List <AlunoDadosBasicosDto>();
foreach (var dadoAluno in dadosAlunos)
{
var dadosBasicos = (AlunoDadosBasicosDto)dadoAluno;
dadosBasicos.TipoResponsavel = ObterTipoResponsavel(dadoAluno.TipoResponsavel);
// se informado periodo escolar carrega marcadores no periodo
if (periodoEscolar != null)
{
dadosBasicos.Marcador = servicoAluno.ObterMarcadorAluno(dadoAluno, periodoEscolar);
}
dadosAlunosDto.Add(dadosBasicos);
}
return(dadosAlunosDto);
}
public ObterDadosAlunosQuery(string turmaCodigo, int anoLetivo, PeriodoEscolar periodoEscolar = null)
{
TurmaCodigo = turmaCodigo;
AnoLetivo = anoLetivo;
PeriodoEscolar = periodoEscolar;
}
private async Task <bool> VerificaSePodeEditarNota(string alunoCodigo, Turma turma, PeriodoEscolar periodoEscolar)
{
var turmaFechamento = await servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma, turma.AnoLetivo);
if (turmaFechamento == null || !turmaFechamento.Any())
{
throw new NegocioException($"Não foi possível obter os dados da turma {turma.CodigoTurma}");
}
var aluno = turmaFechamento.FirstOrDefault(a => a.CodigoAluno == alunoCodigo);
if (aluno == null)
{
throw new NegocioException($"Não foi possível obter os dados do aluno {alunoCodigo}");
}
return(aluno.PodeEditarNotaConceitoNoPeriodo(periodoEscolar));
}
private async Task <bool> PodeEditarNotaOuConceitoPeriodoUsuario(Usuario usuarioLogado, PeriodoEscolar periodoEscolar, Turma turma, string codigoComponenteCurricular, DateTime data)
{
var usuarioPodeEditar = await servicoEOL.PodePersistirTurmaDisciplina(usuarioLogado.CodigoRf, turma.CodigoTurma, codigoComponenteCurricular, data);
if (!usuarioPodeEditar)
{
return(false);
}
var periodoFechamento = await consultasPeriodoFechamento.ObterPeriodoFechamentoTurmaAsync(turma, periodoEscolar.Bimestre, periodoEscolar.Id);
var reabertura = await repositorioFechamentoReabertura.ObterReaberturaFechamentoBimestrePorDataReferencia(periodoEscolar.Bimestre, DateTime.Today, periodoEscolar.TipoCalendarioId, turma.Ue.Dre.CodigoDre, turma.Ue.CodigoUe);
var dentroPeriodo = (periodoFechamento != null && periodoFechamento.DataDentroPeriodo(DateTime.Today)) ||
(reabertura != null && reabertura.DataDentroPeriodo(DateTime.Now));
return(dentroPeriodo);
}
private async Task <ComponenteFrequenciaRegenciaFinal> ObterNotasFrequenciaRegencia(ComponenteCurricularPorTurma disciplina, FrequenciaAluno frequenciaAluno, PeriodoEscolar periodoEscolar, Turma turma, IEnumerable <NotaConceitoBimestreComponente> notasConselhoClasse, IEnumerable <NotaConceitoBimestreComponente> notasFechamento, Usuario usuario)
{
var percentualFrequencia = frequenciaAluno != null && frequenciaAluno.Id > 0 && frequenciaAluno.TotalAulas > 0 ? frequenciaAluno?.PercentualFrequencia ?? 100 : 100;
//Frequência especifica para 2020.
if (frequenciaAluno != null && turma.AnoLetivo.Equals(2020))
{
percentualFrequencia = frequenciaAluno.PercentualFrequenciaFinal;
}
var conselhoClasseComponente = new ComponenteFrequenciaRegenciaFinal()
{
Aulas = frequenciaAluno?.TotalAulas ?? 0,
Faltas = frequenciaAluno?.TotalAusencias ?? 0,
AusenciasCompensadas = frequenciaAluno?.TotalCompensacoes ?? 0,
Frequencia = percentualFrequencia
};
var componentesRegencia = await mediator.Send(new ObterComponentesCurricularesRegenciaQuery()
{
Turma = turma,
CdComponenteCurricular = disciplina.CodDisciplina,
Usuario = usuario
});
foreach (var componenteRegencia in componentesRegencia)
{
conselhoClasseComponente.ComponentesCurriculares.Add(ObterNotasRegencia(componenteRegencia, periodoEscolar, notasConselhoClasse, notasFechamento, turma));
}
return(conselhoClasseComponente);
}
private List <NotaBimestre> ObterNotasComponente(ComponenteCurricularPorTurma componenteCurricular, PeriodoEscolar periodoEscolar, IEnumerable <NotaConceitoBimestreComponente> notasFechamentoAluno)
{
var notasFinais = new List <NotaBimestre>();
if (periodoEscolar != null)
{
notasFinais.Add(ObterNotaFinalComponentePeriodo(componenteCurricular.CodDisciplina, periodoEscolar.Bimestre, notasFechamentoAluno));
}
else
{
notasFinais.AddRange(ObterNotasFinaisComponentePeriodos(componenteCurricular.CodDisciplina, notasFechamentoAluno));
}
return(notasFinais);
}
private async Task <ComponenteComNotaFinal> ObterNotasFrequenciaComponenteComNotaFinal(ComponenteCurricularPorTurma disciplina, FrequenciaAluno frequenciaAluno, PeriodoEscolar periodoEscolar, Turma turma, IEnumerable <NotaConceitoBimestreComponente> notasConselhoClasseAluno, IEnumerable <NotaConceitoBimestreComponente> notasFechamentoAluno)
{
var percentualFrequencia = frequenciaAluno != null && frequenciaAluno.Id > 0 && frequenciaAluno.TotalAulas > 0 ? frequenciaAluno?.PercentualFrequencia ?? 100 : 100;
if (frequenciaAluno != null && turma.AnoLetivo.Equals(2020))
{
percentualFrequencia = frequenciaAluno.PercentualFrequenciaFinal;
}
var notasComponente = ObterNotasComponente(disciplina, periodoEscolar, notasFechamentoAluno);
var conselhoClasseComponente = new ComponenteComNotaFinal()
{
EhEja = turma.EhEja,
Componente = disciplina.Disciplina,
Faltas = frequenciaAluno?.TotalAusencias ?? 0,
AusenciasCompensadas = frequenciaAluno?.TotalCompensacoes ?? 0,
Frequencia = percentualFrequencia,
NotaConceitoBimestre1 = notasComponente.FirstOrDefault(n => n.Bimestre == 1)?.NotaConceito,
NotaConceitoBimestre2 = notasComponente.FirstOrDefault(n => n.Bimestre == 2)?.NotaConceito,
NotaConceitoBimestre3 = notasComponente.FirstOrDefault(n => n.Bimestre == 3)?.NotaConceito,
NotaConceitoBimestre4 = notasComponente.FirstOrDefault(n => n.Bimestre == 4)?.NotaConceito,
NotaFinal = ObterNotaPosConselho(disciplina, periodoEscolar?.Bimestre, notasConselhoClasseAluno, notasFechamentoAluno)
};
return(conselhoClasseComponente);
}
private async Task <string> ObterSituacaoConselhoClasse(Turma turma, PeriodoEscolar periodoEscolar)
{
var situacao = await mediator.Send(new ObterSituacaoConselhoClasseQuery(turma.Id, periodoEscolar.Id));
return(situacao.Name());
}
private async Task EnviarNotificacaoTurmas(IEnumerable <Turma> turmas, IEnumerable <ComponenteCurricularDto> componentes, PeriodoEscolar periodoEscolar, Ue ue)
{
var titulo = $"Situação do processo de fechamento ({periodoEscolar.Bimestre}º Bimestre)";
var mensagem = new StringBuilder($"Segue abaixo o situação do processo de fechamento do <b>{periodoEscolar.Bimestre}° bimestre da {ue.TipoEscola.ShortName()} {ue.Nome} ({ue.Dre.Abreviacao}):</b>");
mensagem.Append("<table style='margin-left: auto; margin-right: auto; margin-top: 10px' border='2' cellpadding='5'>");
foreach (var turmasPorModalidade in turmas.GroupBy(c => c.ModalidadeCodigo))
{
mensagem.Append(ObterHeaderModalidade(turmasPorModalidade.Key.Name()));
foreach (var turma in turmasPorModalidade)
{
mensagem.Append(await MontarLinhaDaTurma(turma, componentes, ue, periodoEscolar));
}
}
mensagem.Append("</table>");
await EnviarNotificacao(titulo, mensagem.ToString(), ue.Dre.CodigoDre, ue.CodigoUe);
}
private async Task <RecuperacaoParalelaListagemDto> MapearParaDtoAsync(IEnumerable <AlunoPorTurmaResposta> alunosEol, IEnumerable <RetornoRecuperacaoParalela> alunosRecuperacaoParalela, long turmaId, long periodoId, RecuperacaoParalelaOrdenacao?ordenacao, PeriodoEscolar periodoEscolarAtual)
{
//alunos eol que não estão ainda na tabela de recuperação paralela
var alunos = alunosEol.Where(w => !alunosRecuperacaoParalela.Select(s => s.AlunoId).Contains(Convert.ToInt32(w.CodigoAluno))).ToList();
var respostas = await repositorioResposta.Listar(periodoId);
var objetivos = await repositorioObjetivo.Listar(periodoId);
var eixos = await repositorioEixo.Listar(periodoId);
var alunosRecParalela = alunosRecuperacaoParalela.ToList();
//adicionar na lista de recuperação paralela com o id zerado, com isso saberá que será um novo registro
alunos.ForEach(x => alunosRecParalela.Add(new RetornoRecuperacaoParalela {
AlunoId = Convert.ToInt64(x.CodigoAluno)
}));
var retorno = alunosRecParalela.Select(s => new { s.AlunoId, s.Id }).Distinct();
var alunoCriado = alunosRecParalela.OrderByDescending(o => o.CriadoEm).FirstOrDefault();
var alunoAlterado = alunosRecParalela.OrderByDescending(o => o.AlteradoEm).FirstOrDefault();
var bimestreEdicao = alunosRecParalela.FirstOrDefault().BimestreEdicao;
var recuperacaoParalelaPeriodo = repositorioRecuperacaoParalelaPeriodo.ObterPorId(periodoId);
if (bimestreEdicao == 0)
{
bimestreEdicao = recuperacaoParalelaPeriodo?.BimestreEdicao ?? 0;
}
var somenteLeitura = bimestreEdicao != 0 && (periodoEscolarAtual == null || bimestreEdicao != periodoEscolarAtual.Bimestre);
var recuperacaoRetorno = new RecuperacaoParalelaListagemDto
{
Ordenacao = ordenacao,
Eixos = eixos,
Objetivos = objetivos,
Respostas = respostas,
SomenteLeitura = somenteLeitura,
Periodo = new RecuperacaoParalelaPeriodoListagemDto
{
Id = periodoId,
CriadoPor = alunoCriado.CriadoPor,
CriadoEm = alunoCriado.CriadoEm == DateTime.MinValue ? null : alunoCriado.CriadoEm,
CriadoRF = alunoCriado.CriadoRF,
AlteradoPor = alunoAlterado.AlteradoPor,
AlteradoEm = alunoAlterado.AlteradoEm == DateTime.MinValue ? null : alunoAlterado.AlteradoEm,
AlteradoRF = alunoAlterado.AlteradoRF,
Alunos = retorno.Select(a =>
{
var aluno = alunosEol.FirstOrDefault(w => Convert.ToInt32(w.CodigoAluno) == a.AlunoId);
return(new RecuperacaoParalelaAlunoListagemDto
{
Id = a.Id,
Concluido = servicoRecuperacaoParalela.ObterStatusRecuperacaoParalela(
alunosRecuperacaoParalela.Count(x => objetivos.Any(z => z.Id == x.ObjetivoId) && x.Id == a.Id),
objetivos.Count()),
ParecerConclusivo = aluno.ParecerConclusivo,
Nome = aluno.NomeAluno,
NumeroChamada = aluno.NumeroAlunoChamada,
CodAluno = a.AlunoId,
Turma = aluno.TurmaEscola,
TurmaId = aluno.CodigoTurma,
TurmaRecuperacaoParalelaId = turmaId,
Respostas = alunosRecuperacaoParalela
.Where(w => w.Id == a.Id && objetivos.Any(x => x.Id == w.ObjetivoId))
.Select(s => new ObjetivoRespostaDto
{
ObjetivoId = s.ObjetivoId,
RespostaId = s.RespostaId
}).ToList()
});
}).ToList()
}
};
if (recuperacaoParalelaPeriodo.Id == 1)
{
//parecer conclusivo
recuperacaoRetorno.Periodo.Alunos
.Where(w => w.Id == 0 && w.ParecerConclusivo.HasValue && char.GetNumericValue(w.ParecerConclusivo.Value) <= 3)
.ToList()
.ForEach(x => x.Respostas.Add(
new ObjetivoRespostaDto
{
ObjetivoId = 3,
RespostaId = servicoRecuperacaoParalela.ValidarParecerConclusivo(x.ParecerConclusivo.Value)
}));
}
if (periodoId != (int)PeriodoRecuperacaoParalela.Encaminhamento && alunos.Any())
{
//pegar as frequencias de acordo com os critérios
var frequencias = await servicoRecuperacaoParalela.ObterFrequencias(alunosEol.Select(w => w.CodigoAluno).ToArray(), string.Empty, alunos.First().Ano, (PeriodoRecuperacaoParalela)periodoId);
recuperacaoRetorno.Periodo.Alunos.ForEach(aluno =>
{
var frequencia = frequencias.FirstOrDefault(x => Convert.ToInt32(x.Key) == aluno.CodAluno);
aluno.Respostas.Add(new ObjetivoRespostaDto
{
ObjetivoId = 4,
RespostaId = frequencia.Value
});
});
//frequencias
foreach (var frequencia in frequencias)
{
if (recuperacaoRetorno.Periodo.Alunos.Any(w => w.CodAluno == Convert.ToInt32(frequencia.Key)))
{
recuperacaoRetorno.Periodo.Alunos
.FirstOrDefault(w => w.CodAluno == Convert.ToInt32(frequencia.Key))
.Respostas
.Add(new ObjetivoRespostaDto
{
ObjetivoId = 4,
RespostaId = frequencia.Value
});
}
}
}
else
{
//setar não como default para não os que ainda não foram salvos
foreach (var item in recuperacaoRetorno.Periodo.Alunos.Where(w => w.Id == 0))
{
item.Respostas.Add(new ObjetivoRespostaDto {
ObjetivoId = 1, RespostaId = 2
});
item.Respostas.Add(new ObjetivoRespostaDto {
ObjetivoId = 2, RespostaId = 2
});
}
;
}
switch (ordenacao)
{
case RecuperacaoParalelaOrdenacao.AlfabeticoDecrescente:
recuperacaoRetorno.Periodo.Alunos = recuperacaoRetorno.Periodo.Alunos.OrderByDescending(w => w.Nome).ToList();
break;
case RecuperacaoParalelaOrdenacao.NumericoCrescente:
recuperacaoRetorno.Periodo.Alunos = recuperacaoRetorno.Periodo.Alunos.OrderBy(w => w.NumeroChamada).ToList();
break;
case RecuperacaoParalelaOrdenacao.NumericoDecrescente:
recuperacaoRetorno.Periodo.Alunos = recuperacaoRetorno.Periodo.Alunos.OrderByDescending(w => w.NumeroChamada).ToList();
break;
default:
recuperacaoRetorno.Periodo.Alunos = recuperacaoRetorno.Periodo.Alunos.OrderBy(w => w.Nome).ToList();
break;
}
return(recuperacaoRetorno);
}
private async Task <string> ObterSituacaoFechamento(Turma turma, ComponenteCurricularDto componenteCurricular, PeriodoEscolar periodoEscolar)
{
var situacao = await mediator.Send(new ObterSituacaoFechamentoTurmaComponenteQuery(turma.Id, long.Parse(componenteCurricular.Codigo), periodoEscolar.Id));
return(situacao.Name());
}
private void TrataPeriodosEscolaresParaAluno(FechamentoFinalConsultaFiltroDto filtros, AlunoPorTurmaResposta aluno, ref int totalAusencias, ref int totalAusenciasCompensadas, ref int totalDeAulas, PeriodoEscolar periodo)
{
var frequenciaAluno = repositorioFrequenciaAlunoDisciplinaPeriodo.ObterPorAlunoData(aluno.CodigoAluno, periodo.PeriodoFim, TipoFrequenciaAluno.PorDisciplina, filtros.DisciplinaCodigo.ToString());
if (frequenciaAluno != null)
{
totalAusencias += frequenciaAluno.TotalAusencias;
totalAusenciasCompensadas += frequenciaAluno.TotalCompensacoes;
totalDeAulas += frequenciaAluno.TotalAulas;
}
}
