public async Task <string> AlterarAsync(FechamentoReabertura fechamentoReabertura, DateTime dataInicialAnterior, DateTime dataFimAnterior, bool confirmacacaoAlteracaoHierarquica)
{
var fechamentoReaberturas = await repositorioFechamentoReabertura.Listar(fechamentoReabertura.TipoCalendarioId, null, null, null);
var fechamentoReaberturasParaVerificar = fechamentoReaberturas.Where(a => a.Id != fechamentoReabertura.Id);
var fechamentoReaberturasParaAtualizar = fechamentoReaberturasParaVerificar.Where(a => fechamentoReabertura.Inicio > a.Inicio || a.Fim > fechamentoReabertura.Fim);
var usuarioAtual = await servicoUsuario.ObterUsuarioLogado();
fechamentoReabertura.PodeSalvar(fechamentoReaberturasParaVerificar, usuarioAtual);
fechamentoReabertura.VerificaStatus();
unitOfWork.IniciarTransacao();
var fechamentoReaberturaId = await repositorioFechamentoReabertura.SalvarAsync(fechamentoReabertura);
var mensagemRetorno = "Reabertura de Fechamento alterado com sucesso.";
if (fechamentoReabertura.Status == EntidadeStatus.AguardandoAprovacao)
{
fechamentoReabertura.WorkflowAprovacaoId = PersistirWorkflowFechamentoReabertura(fechamentoReabertura);
await repositorioFechamentoReabertura.SalvarAsync(fechamentoReabertura);
mensagemRetorno = "Reabertura de Fechamento alterado e será válido após aprovação.";
}
await VerificaEAtualizaFechamentosReaberturasParaAlterar(fechamentoReabertura, fechamentoReaberturasParaAtualizar, confirmacacaoAlteracaoHierarquica);
unitOfWork.PersistirTransacao();
return(mensagemRetorno);
}
public async Task <string> Alterar(long id, ComunicadoInserirDto comunicadoDto)
{
Comunicado comunicado = BuscarComunicado(id);
ComunicadoInserirAeDto comunicadoServico = new ComunicadoInserirAeDto();
var usuarioLogado = (await servicoUsuario.ObterUsuarioLogado())
?? throw new NegocioException("Usuário logado não encontrado");
await ValidarAbrangenciaUsuario(comunicadoDto, usuarioLogado);
MapearAlteracao(comunicadoDto, comunicado);
try
{
unitOfWork.IniciarTransacao();
await repositorio.SalvarAsync(comunicado);
MapearParaEntidadeServico(comunicadoServico, comunicado);
await servicoAcompanhamentoEscolar.AlterarComunicado(comunicadoServico, id);
unitOfWork.PersistirTransacao();
}
catch
{
unitOfWork.Rollback();
throw;
}
return("Comunicado alterado com sucesso");
}
public async Task Registrar(long aulaId, IEnumerable <RegistroAusenciaAluno> registroAusenciaAlunos)
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
var aula = ObterAula(aulaId);
var turma = await ObterTurma(aula.TurmaId);
if (!aula.PermiteRegistroFrequencia(turma))
{
throw new NegocioException("Não é permitido registro de frequência para este componente curricular.");
}
ValidaSeUsuarioPodeCriarAula(aula, usuario);
await ValidaProfessorPodePersistirTurmaDisciplina(aula.TurmaId, usuario.CodigoRf, aula.DisciplinaId, aula.DataAula, usuario);
var alunos = await ObterAlunos(aula);
var registroFrequencia = repositorioFrequencia.ObterRegistroFrequenciaPorAulaId(aulaId);
var alteracaoRegistro = registroFrequencia != null;
unitOfWork.IniciarTransacao();
registroFrequencia = RegistraFrequenciaTurma(aula, registroFrequencia);
RegistraAusenciaAlunos(registroAusenciaAlunos, alunos, registroFrequencia, aula.Quantidade, aula.DataAula);
unitOfWork.PersistirTransacao();
// Quando for alteração de registro de frequencia chama o servico para verificar se atingiu o limite de dias para alteração e notificar
if (alteracaoRegistro)
{
Background.Core.Cliente.Executar <IServicoNotificacaoFrequencia>(e => e.VerificaRegraAlteracaoFrequencia(registroFrequencia.Id, registroFrequencia.CriadoEm, DateTime.Now, usuario.Id));
}
}
public async Task ExcluirPlanoDaAula(long aulaId)
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
var aula = repositorioAula.ObterPorId(aulaId);
await VerificaSeProfessorPodePersistirTurmaDisciplina(usuario.CodigoRf, aula.TurmaId, aula.DisciplinaId, aula.DataAula, usuario);
await repositorio.ExcluirPlanoDaAula(aulaId);
}
public async Task <string> Alterar(AulaDto dto, long id)
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
var aulaOrigem = repositorioAula.ObterPorId(id);
var aulaOrigemQuantidade = aulaOrigem.Quantidade;
var aula = MapearDtoParaEntidade(dto, usuario.CodigoRf, usuario.EhProfessorCj(), aulaOrigem);
return(await servicoAula.Salvar(aula, usuario, dto.RecorrenciaAula, aulaOrigemQuantidade));
}
public async Task Salvar(long id, CompensacaoAusenciaDto compensacaoDto)
{
// Busca dados da turma
var turma = BuscaTurma(compensacaoDto.TurmaId);
// Consiste periodo
var periodo = BuscaPeriodo(turma.AnoLetivo, turma.ModalidadeCodigo, compensacaoDto.Bimestre, turma.Semestre);
var usuario = await servicoUsuario.ObterUsuarioLogado();
ValidaProfessorPodePersistirTurma(compensacaoDto.TurmaId, usuario.CodigoRf, periodo.PeriodoFim);
// Valida mesma compensação no ano
var compensacaoExistente = await repositorioCompensacaoAusencia.ObterPorAnoTurmaENome(turma.AnoLetivo, turma.Id, compensacaoDto.Atividade, id);
if (compensacaoExistente != null)
{
throw new NegocioException($"Já existe essa compensação cadastrada para turma no ano letivo.");
}
// Carrega dasdos da disciplina no EOL
ConsisteDisciplina(long.Parse(compensacaoDto.DisciplinaId), compensacaoDto.DisciplinasRegenciaIds);
// Persiste os dados
var compensacao = MapearEntidade(id, compensacaoDto);
compensacao.TurmaId = turma.Id;
compensacao.AnoLetivo = turma.AnoLetivo;
List <string> codigosAlunosCompensacao = new List <string>();
unitOfWork.IniciarTransacao();
try
{
await repositorioCompensacaoAusencia.SalvarAsync(compensacao);
await GravarDisciplinasRegencia(id > 0, compensacao.Id, compensacaoDto.DisciplinasRegenciaIds);
codigosAlunosCompensacao = await GravarCompensacaoAlunos(id > 0, compensacao.Id, compensacaoDto.TurmaId, compensacaoDto.DisciplinaId, compensacaoDto.Alunos, periodo);
unitOfWork.PersistirTransacao();
}
catch (Exception)
{
unitOfWork.Rollback();
throw;
}
if (codigosAlunosCompensacao.Any())
{
Cliente.Executar <IServicoCalculoFrequencia>(c => c.CalcularFrequenciaPorTurma(codigosAlunosCompensacao, periodo.PeriodoFim, compensacaoDto.TurmaId, compensacaoDto.DisciplinaId));
}
Cliente.Executar <IServicoNotificacaoFrequencia>(c => c.NotificarCompensacaoAusencia(compensacao.Id));
}
public async Task <AulaConsultaDto> BuscarPorId(long id)
{
var aula = repositorio.ObterPorId(id);
if (aula == null)
{
throw new NegocioException($"Aula de id {id} não encontrada");
}
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
string disciplinaId = await ObterDisciplinaIdAulaEOL(usuarioLogado, aula, usuarioLogado.EhProfessorCj());
return(MapearParaDto(aula, disciplinaId));
}
public async Task <IEnumerable <PlanoAnualCompletoDto> > Salvar(PlanoAnualDto planoAnualDto)
{
var usuarioAtual = servicoUsuario.ObterUsuarioLogado().Result;
if (string.IsNullOrWhiteSpace(usuarioAtual.CodigoRf))
{
throw new NegocioException("Não foi possível obter o RF do usuário.");
}
unitOfWork.IniciarTransacao();
foreach (var bimestrePlanoAnual in planoAnualDto.Bimestres)
{
PlanoAnual planoAnual = await ObterPlanoAnualSimplificado(planoAnualDto, bimestrePlanoAnual.Bimestre.Value);
if (planoAnual != null)
{
if (!usuarioAtual.EhProfessorCj() && !await servicoUsuario.PodePersistirTurmaDisciplina(usuarioAtual.CodigoRf, planoAnualDto.TurmaId.ToString(), planoAnualDto.ComponenteCurricularEolId.ToString(), DateTime.Now))
{
throw new NegocioException("Você não pode fazer alterações ou inclusões nesta turma, disciplina e data.");
}
}
planoAnual = MapearParaDominio(planoAnualDto, planoAnual, bimestrePlanoAnual.Bimestre.Value, bimestrePlanoAnual.Descricao);
Salvar(planoAnualDto, planoAnual, bimestrePlanoAnual);
}
unitOfWork.PersistirTransacao();
var resposta = await consultasPlanoAnual.ObterPorUETurmaAnoEComponenteCurricular(planoAnualDto.EscolaId, planoAnualDto.TurmaId.ToString(), planoAnualDto.AnoLetivo.Value, planoAnualDto.ComponenteCurricularEolId);
return(resposta);
}
private async Task <bool> VerificarPlanoAnualExistente(long aulaId)
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
var aula = repositorioAula.ObterPorId(aulaId);
if (aula == null)
{
throw new NegocioException("Aula não encontrada");
}
var periodoEscolar = consultasPeriodoEscolar.ObterPeriodoEscolarPorData(aula.TipoCalendarioId, aula.DataAula);
if (periodoEscolar == null)
{
throw new NegocioException("Período escolar não encontrado");
}
var planoAnualId = await consultasPlanoAnual.ObterIdPlanoAnualPorAnoEscolaBimestreETurma(
aula.DataAula.Year, aula.UeId, long.Parse(aula.TurmaId), periodoEscolar.Bimestre, long.Parse(aula.DisciplinaId));
if (planoAnualId <= 0 && !usuario.EhProfessorCj())
{
return(false);
}
return(true);
}
public async Task <IEnumerable <EntidadeBase> > Salvar(PlanoAnualTerritorioSaberDto planoAnualTerritorioSaberDto)
{
Validar(planoAnualTerritorioSaberDto);
var listaAuditoria = new List <EntidadeBase>();
unitOfWork.IniciarTransacao();
var usuarioAtual = servicoUsuario.ObterUsuarioLogado().Result;
if (string.IsNullOrWhiteSpace(usuarioAtual.CodigoRf))
{
throw new NegocioException("Não foi possível obter o RF do usuário.");
}
foreach (var bimestrePlanoAnual in planoAnualTerritorioSaberDto.Bimestres)
{
PlanoAnualTerritorioSaber planoAnualTerritorioSaber = await ObterPlanoAnualTerritorioSaberSimplificado(planoAnualTerritorioSaberDto, bimestrePlanoAnual.Bimestre.Value);
if (planoAnualTerritorioSaber != null)
{
if (usuarioAtual.PerfilAtual == Perfis.PERFIL_PROFESSOR && !servicoUsuario.PodePersistirTurmaDisciplina(usuarioAtual.CodigoRf, planoAnualTerritorioSaberDto.TurmaId.ToString(), planoAnualTerritorioSaberDto.TerritorioExperienciaId.ToString(), DateTime.Now).Result)
{
throw new NegocioException("Você não pode fazer alterações ou inclusões nesta turma, disciplina e data.");
}
}
planoAnualTerritorioSaber = MapearParaDominio(planoAnualTerritorioSaberDto, planoAnualTerritorioSaber, bimestrePlanoAnual.Bimestre.Value, bimestrePlanoAnual.Desenvolvimento, bimestrePlanoAnual.Reflexao);
repositorioPlanoAnualTerritorioSaber.Salvar(planoAnualTerritorioSaber);
listaAuditoria.Add(planoAnualTerritorioSaber);
}
unitOfWork.PersistirTransacao();
return(listaAuditoria);
}
public async Task <PaginacaoResultadoDto <EventoTipoDto> > Listar(FiltroEventoTipoDto Filtro)
{
var retornoQueryPaginada = await repositorioEventoTipo.ListarTipos(Filtro.LocalOcorrencia, Filtro.Letivo, Filtro.Descricao, Paginacao);
var retornoConsultaPaginada = new PaginacaoResultadoDto <EventoTipoDto>
{
TotalPaginas = retornoQueryPaginada.TotalPaginas,
TotalRegistros = retornoQueryPaginada.TotalRegistros
};
bool nenhumItemEncontrado = retornoQueryPaginada.Items == null ||
!retornoQueryPaginada.Items.Any() ||
retornoQueryPaginada.Items.ElementAt(0).Id == 0;
if (!nenhumItemEncontrado && Filtro.EhCadastro)
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
if (usuario.EhPerfilUE())
{
retornoQueryPaginada.Items = retornoQueryPaginada.Items
.Where(r => r.Id != (long)TipoEvento.LiberacaoExcepcional &&
r.Id != (long)TipoEvento.ReposicaoNoRecesso);
}
}
retornoConsultaPaginada.Items = nenhumItemEncontrado
? null
: retornoQueryPaginada.Items.Select(x => EntidadeParaDto(x)).ToList();
return(retornoConsultaPaginada);
}
public async Task <IEnumerable <DatasAulasDto> > Executar(ConsultaDatasAulasDto param)
{
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
var professorRF = usuarioLogado.EhProfessor() && !usuarioLogado.EhProfessorInfantil() ? usuarioLogado.CodigoRf : string.Empty;
return(await mediator.Send(new ObterDatasAulasPorProfessorEComponenteQuery(professorRF, param.TurmaCodigo, param.ComponenteCurricularCodigo, usuarioLogado.EhProfessorCj(), usuarioLogado.EhProfessor() || usuarioLogado.EhProfessorCj())));
}
public async Task <IEnumerable <TurmaRetornoDto> > ObterTurmasCopia(string turmaId, string disciplinaId)
{
var retorno = new List <TurmaRetornoDto>();
var turma = await repositorioTurma.ObterPorCodigo(turmaId.ToString());
var usuario = await servicoUsuario.ObterUsuarioLogado();
var turmasAtribuidasAoProfessor = consultasProfessor.Listar(usuario.CodigoRf);
var lstTurmasCJ = await repositorioAtribuicaoCJ.ObterPorFiltros(turma.ModalidadeCodigo, null, null,
Convert.ToInt64(disciplinaId), usuario.CodigoRf, null, true);
var turmasTitular = turmasAtribuidasAoProfessor.Where(t => t.AnoLetivo == turma.AnoLetivo &&
t.Ano == turma.Ano &&
t.Modalidade == turma.ModalidadeCodigo.ToString() &&
t.CodTurma.ToString() != turma.CodigoTurma);
if (turmasTitular != null && turmasTitular.Any())
{
retorno.AddRange(turmasTitular
.Select(x => new TurmaRetornoDto()
{
Codigo = x.CodTurma.ToString(), Nome = x.NomeTurma
})
.ToList());
}
var turmasCJ = lstTurmasCJ.Where(t => t.Turma.AnoLetivo == turma.AnoLetivo &&
t.Turma.Ano == turma.Ano &&
t.Turma.ModalidadeCodigo == turma.ModalidadeCodigo &&
t.TurmaId != turma.CodigoTurma);
if (turmasCJ != null && turmasCJ.Any())
{
retorno.AddRange(turmasCJ
.Select(x => new TurmaRetornoDto()
{
Codigo = x.TurmaId, Nome = x.Turma.Nome
})
.ToList());
}
return(retorno);
}
private async Task VerificaSeProfessorPodePersistirTurma(string codigoRf, string turmaId, DateTime data)
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
if (!usuario.EhProfessorCj() && !await servicoUsuario.PodePersistirTurma(codigoRf, turmaId, data))
{
throw new NegocioException("Você não pode fazer alterações ou inclusões nesta turma e data.");
}
}
private async Task VerificaPendenciaDiasLetivosInsuficientes(Evento evento)
{
if (evento.EhEventoLetivo())
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
await mediator.Send(new IncluirFilaExcluirPendenciasDiasLetivosInsuficientesCommand(evento.TipoCalendarioId, evento.DreId, evento.UeId, usuario));
}
}
public async Task Salvar(IEnumerable <NotaConceito> notasConceitos, string professorRf, string turmaId, string disciplinaId)
{
turma = await repositorioTurma.ObterTurmaComUeEDrePorCodigo(turmaId);
if (turma == null)
{
throw new NegocioException($"Turma com código [{turmaId}] não localizada");
}
var idsAtividadesAvaliativas = notasConceitos.Select(x => x.AtividadeAvaliativaID);
var atividadesAvaliativas = repositorioAtividadeAvaliativa.ListarPorIds(idsAtividadesAvaliativas);
var alunos = await servicoEOL.ObterAlunosPorTurma(turmaId);
if (alunos == null || !alunos.Any())
{
throw new NegocioException("Não foi encontrado nenhum aluno para a turma informada");
}
ValidarAvaliacoes(idsAtividadesAvaliativas, atividadesAvaliativas, professorRf);
var entidadesSalvar = new List <NotaConceito>();
var notasPorAvaliacoes = notasConceitos.GroupBy(x => x.AtividadeAvaliativaID);
var usuario = await servicoUsuario.ObterUsuarioLogado();
await VerificaSeProfessorPodePersistirTurmaDisciplina(professorRf, turmaId, disciplinaId, DateTime.Today, usuario);
foreach (var notasPorAvaliacao in notasPorAvaliacoes)
{
var avaliacao = atividadesAvaliativas.FirstOrDefault(x => x.Id == notasPorAvaliacao.Key);
entidadesSalvar.AddRange(await ValidarEObter(notasPorAvaliacao.ToList(), avaliacao, alunos, professorRf, disciplinaId, usuario, turma));
}
SalvarNoBanco(entidadesSalvar);
var alunosId = alunos.Select(a => a.CodigoAluno).ToList();
await validarMediaAlunos(idsAtividadesAvaliativas, alunosId, usuario, disciplinaId);
}
public async Task <PaginacaoResultadoDto <EventoCompletoDto> > Listar(FiltroEventosDto filtroEventosDto)
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
return(MapearParaDtoComPaginacao(await repositorioEvento
.Listar(filtroEventosDto.TipoCalendarioId,
filtroEventosDto.TipoEventoId,
filtroEventosDto.NomeEvento,
filtroEventosDto.DataInicio,
filtroEventosDto.DataFim,
Paginacao,
filtroEventosDto.DreId,
filtroEventosDto.UeId,
filtroEventosDto.EhTodasDres,
filtroEventosDto.EhTodasUes,
usuario,
usuario.PerfilAtual,
usuario.TemPerfilSupervisorOuDiretor(),
usuario.PodeVisualizarEventosOcorrenciaDre(),
usuario.PodeVisualizarEventosLibExcepRepoRecessoGestoresUeDreSme(),
filtroEventosDto.ConsideraHistorico)));
}
public async Task <IEnumerable <RecuperacaoParalelaPeriodoPAPDto> > BuscarListaPeriodos(string turmaId)
{
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
var turmaPossuiComponente = await servicoEOL.TurmaPossuiComponenteCurricularPAP(turmaId, usuarioLogado.Login, usuarioLogado.PerfilAtual);
if (!turmaPossuiComponente)
{
return(null);
}
return(repositorioRecuperacaoParalelaPeriodo.Listar().Select(x => (RecuperacaoParalelaPeriodoPAPDto)x));
}
public async Task <IEnumerable <TurmaParaCopiaPlanoAnualDto> > ObterTurmasParaCopia(int turmaId, long componenteCurricular)
{
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
var turmasEOL = await servicoEOL.ObterTurmasParaCopiaPlanoAnual(usuarioLogado.CodigoRf, componenteCurricular, turmaId);
if (turmasEOL != null && turmasEOL.Any())
{
var idsTurmas = turmasEOL.Select(c => c.TurmaId.ToString());
turmasEOL = repositorioPlanoAnual.ValidaSeTurmasPossuemPlanoAnual(idsTurmas.ToArray());
}
return(turmasEOL);
}
public async Task <AulaConsultaDto> BuscarPorId(long id)
{
var aula = repositorio.ObterPorId(id);
if (aula == null || aula.Excluido)
{
throw new NegocioException($"Aula de id {id} não encontrada");
}
if (aula.AulaPaiId.HasValue)
{
aula.AulaPai = await repositorio.ObterCompletoPorIdAsync(aula.AulaPaiId.Value);
}
var aberto = await AulaDentroPeriodo(aula);
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
string disciplinaId = await ObterDisciplinaIdAulaEOL(usuarioLogado, aula, usuarioLogado.EhProfessorCj());
return(MapearParaDto(aula, disciplinaId, aberto));
}
public async Task Reprocessar(long fechamentoTurmaDisciplinaId)
{
var fechamentoTurmaDisciplina = repositorioFechamentoTurmaDisciplina.ObterPorId(fechamentoTurmaDisciplinaId);
if (fechamentoTurmaDisciplina == null)
{
throw new NegocioException("Fechamento ainda não realizado para essa turma.");
}
var turma = await repositorioTurma.ObterTurmaComUeEDrePorId(fechamentoTurmaDisciplina.FechamentoTurma.TurmaId);
if (turma == null)
{
throw new NegocioException("Turma não encontrada.");
}
var disciplinaEOL = (await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { fechamentoTurmaDisciplina.DisciplinaId })).ToList().FirstOrDefault();
if (disciplinaEOL == null)
{
throw new NegocioException("Componente Curricular não localizado.");
}
var periodoEscolar = repositorioPeriodoEscolar.ObterPorId(fechamentoTurmaDisciplina.FechamentoTurma.PeriodoEscolarId.Value);
if (periodoEscolar == null)
{
throw new NegocioException("Período escolar não encontrado.");
}
fechamentoTurmaDisciplina.AdicionarPeriodoEscolar(periodoEscolar);
fechamentoTurmaDisciplina.AtualizarSituacao(SituacaoFechamento.EmProcessamento);
repositorioFechamentoTurmaDisciplina.Salvar(fechamentoTurmaDisciplina);
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
Cliente.Executar <IServicoFechamentoTurmaDisciplina>(c => c.GerarPendenciasFechamento(fechamentoTurmaDisciplina.DisciplinaId, turma, periodoEscolar, fechamentoTurmaDisciplina, usuarioLogado, !disciplinaEOL.LancaNota, disciplinaEOL.RegistraFrequencia));
}
private async Task ValidaSePerfilPodeIncluir()
{
var usuarioAtual = await servicoUsuario.ObterUsuarioLogado();
if (usuarioAtual == null)
{
throw new NegocioException("Não foi possível obter o usuário logado.");
}
if (usuarioAtual.PerfilAtual == Perfis.PERFIL_CP || usuarioAtual.PerfilAtual == Perfis.PERFIL_DIRETOR)
{
throw new NegocioException("Este perfil não pode fazer substituição.");
}
}
public async Task <GradeComponenteTurmaAulasDto> ObterGradeAulasTurmaProfessor(string turmaCodigo, long disciplina, int semana, DateTime dataAula, string codigoRf = null, bool ehRegencia = false)
{
var ue = repositorioUe.ObterUEPorTurma(turmaCodigo);
if (ue == null)
{
throw new NegocioException("Ue não localizada.");
}
var turma = repositorioTurma.ObterPorId(turmaCodigo);
if (turma == null)
{
throw new NegocioException("Turma não localizada.");
}
// Busca grade a partir dos dados da abrangencia da turma
var grade = await ObterGradeTurma(ue.TipoEscola, turma.ModalidadeCodigo, turma.QuantidadeDuracaoAula);
if (grade == null)
{
return(null);
}
// verifica se é regencia de classe
var horasGrade = await TratarHorasGrade(disciplina, turma, grade, ehRegencia);
if (horasGrade == 0)
{
return(null);
}
if (string.IsNullOrEmpty(codigoRf))
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
codigoRf = usuario.CodigoRf;
}
var horascadastradas = await ObtenhaHorasCadastradas(disciplina, semana, dataAula, codigoRf, turma, ehRegencia);
return(new GradeComponenteTurmaAulasDto
{
QuantidadeAulasGrade = horasGrade,
QuantidadeAulasRestante = horasGrade - horascadastradas
});
}
public async Task <IEnumerable <ObjetivoAprendizagemDto> > ObterObjetivosPlanoDisciplina(int ano, int bimestre, long turmaId, long componenteCurricularId, long disciplinaId, bool regencia = false)
{
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
var filtrarSomenteRegencia = regencia && !usuarioLogado.EhProfessorCj();
var objetivosPlano = repositorioObjetivosPlano.ObterObjetivosPlanoDisciplina(ano,
bimestre,
turmaId,
componenteCurricularId,
disciplinaId,
filtrarSomenteRegencia);
var objetivosJurema = await Listar();
// filtra objetivos do jurema com os objetivos cadastrados no plano anual nesse bimestre
return(objetivosJurema.
Where(c => objetivosPlano.Any(o => o.ObjetivoAprendizagemJuremaId == c.Id)));
}
private void ValidacaoPermissaoEdicaoExclusaoPorPerfilUsuarioTipoEevento(Evento evento)
{
var usuario = servicoUsuario.ObterUsuarioLogado().Result;
if (evento.EhEventoSME() && !usuario.EhPerfilSME())
{
throw new NegocioException(evento.Nome);
}
if (evento.EhEventoDRE() && ((!usuario.EhPerfilDRE() && !usuario.EhPerfilSME()) || !servicoAbrangencia.DreEstaNaAbrangencia(usuario.Login, usuario.PerfilAtual, evento.DreId)))
{
throw new NegocioException(evento.Nome);
}
if (evento.EhEventoUE() && ((!usuario.EhPerfilUE() && !usuario.EhPerfilDRE() && !usuario.EhPerfilSME()) || !servicoAbrangencia.UeEstaNaAbrangecia(usuario.Login, usuario.PerfilAtual, evento.DreId, evento.UeId)))
{
throw new NegocioException(evento.Nome);
}
}
public async Task <TrocaPerfilDto> ModificarPerfil(Guid perfil)
{
string loginAtual = servicoUsuario.ObterLoginAtual();
string codigoRfAtual = servicoUsuario.ObterRf();
string nomeLoginAtual = servicoUsuario.ObterNomeLoginAtual();
await servicoUsuario.PodeModificarPerfil(perfil, loginAtual);
var permissionamentos = await servicoEOL.ObterPermissoesPorPerfil(perfil);
if (permissionamentos == null || !permissionamentos.Any())
{
throw new NegocioException($"Não foi possível obter os permissionamentos do perfil selecionado");
}
else
{
var listaPermissoes = permissionamentos
.Distinct()
.Select(a => (Permissao)a)
.ToList();
await servicoAbrangencia.Salvar(loginAtual, perfil, false);
var usuario = await servicoUsuario.ObterUsuarioLogado();
usuario.DefinirPerfilAtual(perfil);
//await servicoTokenJwt.RevogarToken(loginAtual);
var tokenStr = servicoTokenJwt.GerarToken(loginAtual, nomeLoginAtual, codigoRfAtual, perfil, listaPermissoes);
return(new TrocaPerfilDto
{
Token = tokenStr,
DataHoraExpiracao = servicoTokenJwt.ObterDataHoraExpiracao(),
EhProfessor = usuario.EhProfessor(),
EhProfessorCj = usuario.EhProfessorCj(),
EhProfessorPoa = usuario.EhProfessorPoa(),
EhProfessorInfantil = usuario.EhProfessorInfantil(),
EhProfessorCjInfantil = usuario.EhProfessorCjInfantil(),
EhPerfilProfessor = usuario.EhPerfilProfessor()
});
}
}
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 async Task ValidarInsercao(SolicitarInclusaoComunicadoEscolaAquiCommand comunicado)
{
var usuarioLogado = await _servicoUsuario.ObterUsuarioLogado();
await ValidarAbrangenciaUsuario(comunicado, usuarioLogado);
if (comunicado.CodigoDre == TODAS && !comunicado.CodigoUe.Equals(TODAS))
{
throw new NegocioException("Não é possivel especificar uma escola quando o comunicado é para todas as DREs");
}
if (comunicado.CodigoUe == TODAS && comunicado.Turmas.Any())
{
throw new NegocioException("Não é possivel especificar uma turma quando o comunicado é para todas as UEs");
}
if ((comunicado.Turmas == null || !comunicado.Turmas.Any()) && (comunicado.AlunosEspecificados || (comunicado.Alunos?.Any() ?? false)))
{
throw new NegocioException("Não é possivel especificar alunos quando o comunicado é para todas as Turmas");
}
}
public async Task <IEnumerable <DisciplinaDto> > ObterDisciplinasParaPlanejamento(FiltroDisciplinaPlanejamentoDto filtroDisciplinaPlanejamentoDto)
{
IEnumerable <DisciplinaDto> disciplinasDto = null;
var usuario = await servicoUsuario.ObterUsuarioLogado();
var chaveCache = $"Disciplinas-planejamento-{filtroDisciplinaPlanejamentoDto.CodigoTurma}-{usuario.Login}-{filtroDisciplinaPlanejamentoDto.CodigoDisciplina}";
var disciplinasCacheString = await repositorioCache.ObterAsync(chaveCache);
if (!string.IsNullOrWhiteSpace(disciplinasCacheString))
{
return(TratarRetornoDisciplinasPlanejamento(JsonConvert.DeserializeObject <IEnumerable <DisciplinaDto> >(disciplinasCacheString), filtroDisciplinaPlanejamentoDto));
}
IEnumerable <DisciplinaResposta> disciplinas;
if (usuario.EhProfessorCj())
{
disciplinas = await ObterComponentesCJ(null, filtroDisciplinaPlanejamentoDto.CodigoTurma.ToString(),
string.Empty,
filtroDisciplinaPlanejamentoDto.CodigoDisciplina,
usuario.Login);
}
else
{
disciplinas = await servicoEOL.ObterDisciplinasParaPlanejamento(filtroDisciplinaPlanejamentoDto.CodigoTurma, usuario.Login, servicoUsuario.ObterPerfilAtual());
}
if (disciplinas == null || !disciplinas.Any())
{
return(disciplinasDto);
}
disciplinasDto = await MapearParaDto(disciplinas, filtroDisciplinaPlanejamentoDto.TurmaPrograma);
await repositorioCache.SalvarAsync(chaveCache, JsonConvert.SerializeObject(disciplinasDto));
return(TratarRetornoDisciplinasPlanejamento(disciplinasDto, filtroDisciplinaPlanejamentoDto));
}
public async Task <GradeComponenteTurmaAulasDto> Handle(ObterGradeAulasPorTurmaEProfessorQuery request, CancellationToken cancellationToken)
{
var semana = UtilData.ObterSemanaDoAno(request.DataAula);
var turma = await repositorioTurma.ObterTurmaComUeEDrePorCodigo(request.TurmaCodigo);
if (turma == null)
{
throw new NegocioException("Turma não localizada.");
}
// verifica se é regencia de classe
var horasGrade = await TratarHorasGrade(request.ComponenteCurricular, turma, request.EhRegencia);
if (horasGrade == 0)
{
return(null);
}
if (string.IsNullOrEmpty(request.CodigoRf))
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
request.CodigoRf = usuario.CodigoRf;
}
var horascadastradas = await ObtenhaHorasCadastradas(request.ComponenteCurricular, semana, request.DataAula, request.CodigoRf, turma, request.EhRegencia);
var aulasRestantes = horasGrade - horascadastradas;
return(new GradeComponenteTurmaAulasDto
{
QuantidadeAulasGrade = horasGrade,
QuantidadeAulasRestante = aulasRestantes,
PodeEditar = aulasRestantes > 1 && !(request.EhRegencia && turma.EhEJA())
});
}
