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; } }