public async Task <IEnumerable <DisciplinaDto> > ObterDisciplinasParaPlanejamento(FiltroDisciplinaPlanejamentoDto filtroDisciplinaPlanejamentoDto)
{
IEnumerable <DisciplinaDto> disciplinasDto = null;
var login = servicoUsuario.ObterLoginAtual();
var chaveCache = $"Disciplinas-planejamento-{filtroDisciplinaPlanejamentoDto.CodigoTurma}-{login}";
var disciplinasCacheString = repositorioCache.Obter(chaveCache);
if (!string.IsNullOrWhiteSpace(disciplinasCacheString))
{
return(TratarRetornoDisciplinasPlanejamento(JsonConvert.DeserializeObject <IEnumerable <DisciplinaDto> >(disciplinasCacheString), filtroDisciplinaPlanejamentoDto));
}
var disciplinas = await servicoEOL.ObterDisciplinasParaPlanejamento(filtroDisciplinaPlanejamentoDto.CodigoTurma, login, servicoUsuario.ObterPerfilAtual());
if (disciplinas == null || !disciplinas.Any())
{
return(disciplinasDto);
}
disciplinasDto = await MapearParaDto(disciplinas);
await repositorioCache.SalvarAsync(chaveCache, JsonConvert.SerializeObject(disciplinasDto));
return(TratarRetornoDisciplinasPlanejamento(disciplinasDto, filtroDisciplinaPlanejamentoDto));
}
public async Task RevogarToken(string login)
{
var chaveLogin = ObterChaveLogin(login);
var token = cache.Obter(chaveLogin);
if (!string.IsNullOrWhiteSpace(token))
{
await cache.RemoverAsync(chaveLogin);
}
}
public async Task <Usuario> Handle(ObterUsuarioLogadoQuery request, CancellationToken cancellationToken)
{
var login = ObterLoginAtual();
if (string.IsNullOrWhiteSpace(login))
{
throw new NegocioException("Usuário não encontrado.");
}
var usuario = repositorioUsuario.ObterPorCodigoRfLogin(string.Empty, login);
if (usuario == null)
{
throw new NegocioException("Usuário não encontrado.");
}
var chaveRedis = $"perfis-usuario-{login}";
var perfisUsuarioString = repositorioCache.Obter(chaveRedis);
IEnumerable <PrioridadePerfil> perfisDoUsuario = null;
perfisDoUsuario = string.IsNullOrWhiteSpace(perfisUsuarioString)
? await ObterPerfisUsuario(login)
: JsonConvert.DeserializeObject <IEnumerable <PrioridadePerfil> >(perfisUsuarioString);
usuario.DefinirPerfis(perfisDoUsuario);
usuario.DefinirPerfilAtual(ObterPerfilAtual());
return(usuario);
}
public async Task <IEnumerable <AlunoPorTurmaResposta> > ObterAlunosPorTurma(string turmaId)
{
var alunos = new List <AlunoPorTurmaResposta>();
var chaveCache = ObterChaveCacheAlunosTurma(turmaId);
var cacheAlunos = cache.Obter(chaveCache);
if (cacheAlunos != null)
{
alunos = JsonConvert.DeserializeObject <List <AlunoPorTurmaResposta> >(cacheAlunos);
}
else
{
var resposta = await httpClient.GetAsync($"turmas/{turmaId}");
if (resposta.IsSuccessStatusCode)
{
var json = await resposta.Content.ReadAsStringAsync();
alunos = JsonConvert.DeserializeObject <List <AlunoPorTurmaResposta> >(json);
// Salva em cache por 5 min
await cache.SalvarAsync(chaveCache, json, 5);
}
}
return(alunos);
}
public async Task <Usuario> ObterUsuarioLogado()
{
var login = ObterLoginAtual();
var usuario = repositorioUsuario.ObterPorCodigoRfLogin(string.Empty, login);
if (usuario == null)
{
throw new NegocioException("Usuário não encontrado.");
}
var chaveRedis = $"perfis-usuario-{login}";
var perfisUsuarioString = repositorioCache.Obter(chaveRedis);
IEnumerable <PrioridadePerfil> perfisDoUsuario = null;
if (string.IsNullOrWhiteSpace(perfisUsuarioString))
{
var perfisPorLogin = await servicoEOL.ObterPerfisPorLogin(login);
if (perfisPorLogin == null)
{
throw new NegocioException($"Não foi possível obter os perfis do usuário {login}");
}
perfisDoUsuario = repositorioPrioridadePerfil.ObterPerfisPorIds(perfisPorLogin.Perfis);
_ = repositorioCache.SalvarAsync(chaveRedis, JsonConvert.SerializeObject(perfisDoUsuario));
}
else
{
perfisDoUsuario = JsonConvert.DeserializeObject <IEnumerable <PrioridadePerfil> >(perfisUsuarioString);
}
usuario.DefinirPerfis(perfisDoUsuario);
return(usuario);
}
public async Task <IEnumerable <AlunoPorTurmaResposta> > Handle(ObterAlunosPorTurmaQuery request, CancellationToken cancellationToken)
{
var alunos = new List <AlunoPorTurmaResposta>();
var chaveCache = $"alunos-turma:{request.TurmaCodigo}";
var cacheAlunos = repositorioCache.Obter(chaveCache);
if (cacheAlunos != null)
{
alunos = JsonConvert.DeserializeObject <List <AlunoPorTurmaResposta> >(cacheAlunos);
}
else
{
var httpClient = httpClientFactory.CreateClient("servicoEOL");
var resposta = await httpClient.GetAsync($"turmas/{request.TurmaCodigo}");
if (resposta.IsSuccessStatusCode)
{
var json = await resposta.Content.ReadAsStringAsync();
alunos = JsonConvert.DeserializeObject <List <AlunoPorTurmaResposta> >(json);
// Salva em cache por 5 min
await repositorioCache.SalvarAsync(chaveCache, json, 5);
}
}
return(alunos);
}
public async Task <UsuarioAutenticacaoRetornoDto> Autenticar(string login, string senha)
{
login = login.Trim().ToLower();
var retornoAutenticacaoEol = await servicoAutenticacao.AutenticarNoEol(login, senha);
if (!retornoAutenticacaoEol.Item1.Autenticado)
{
return(retornoAutenticacaoEol.Item1);
}
if (!retornoAutenticacaoEol.Item4 && retornoAutenticacaoEol.Item5)
{
retornoAutenticacaoEol.Item3 = ValidarPerfilCJ(retornoAutenticacaoEol.Item2, retornoAutenticacaoEol.Item1.UsuarioId, retornoAutenticacaoEol.Item3, login).Result;
}
var dadosUsuario = await servicoEOL.ObterMeusDados(login);
var usuario = servicoUsuario.ObterUsuarioPorCodigoRfLoginOuAdiciona(retornoAutenticacaoEol.Item2, login, dadosUsuario.Nome, dadosUsuario.Email, true);
retornoAutenticacaoEol.Item1.PerfisUsuario = await servicoPerfil.DefinirPerfilPrioritario(retornoAutenticacaoEol.Item3, usuario);
var perfilSelecionado = retornoAutenticacaoEol.Item1.PerfisUsuario.PerfilSelecionado;
var permissionamentos = await repositorioCache.Obter($"Permissionamento-{perfilSelecionado.ToString()}", () => servicoEOL.ObterPermissoesPorPerfil(perfilSelecionado), 720);
if (permissionamentos == null || !permissionamentos.Any())
{
retornoAutenticacaoEol.Item1.Autenticado = false;
return(retornoAutenticacaoEol.Item1);
}
var listaPermissoes = permissionamentos
.Distinct()
.Select(a => (Permissao)a)
.ToList();
// Revoga token atual para geração de um novo
//await servicoTokenJwt.RevogarToken(login);
// Gera novo token e guarda em cache
retornoAutenticacaoEol.Item1.Token =
servicoTokenJwt.GerarToken(login, dadosUsuario.Nome, usuario.CodigoRf, retornoAutenticacaoEol.Item1.PerfisUsuario.PerfilSelecionado, listaPermissoes);
retornoAutenticacaoEol.Item1.DataHoraExpiracao = servicoTokenJwt.ObterDataHoraExpiracao();
//var fromDate = servicoTokenJwt.ObterDataHoraCriacao();
usuario.AtualizaUltimoLogin();
repositorioUsuario.Salvar(usuario);
await servicoAbrangencia.Salvar(login, perfilSelecionado, true);
return(retornoAutenticacaoEol.Item1);
}
public async Task <Usuario> ObterUsuarioLogado()
{
var login = ObterLoginAtual();
var usuario = repositorioUsuario.ObterPorCodigoRfLogin(string.Empty, login);
if (usuario == null)
{
throw new NegocioException("Usuário não encontrado.");
}
var perfisDoUsuario = await repositorioCache.Obter($"perfis-usuario-{login}", async() => await ObterPerfisUsuario(login));
usuario.DefinirPerfis(perfisDoUsuario);
usuario.DefinirPerfilAtual(ObterPerfilAtual());
return(usuario);
}
public async Task <IEnumerable <TurmaDto> > ObterTurmasAtribuidasAoProfessorPorEscolaEAnoLetivo(string rfProfessor, string codigoEscola, int anoLetivo)
{
IEnumerable <TurmaDto> turmasDto = null;
var chaveCache = $"Turmas-Professor-{rfProfessor}-ano-{anoLetivo}-escolal-{codigoEscola}";
var disciplinasCacheString = repositorioCache.Obter(chaveCache);
if (!string.IsNullOrWhiteSpace(disciplinasCacheString))
{
turmasDto = JsonConvert.DeserializeObject <IEnumerable <TurmaDto> >(disciplinasCacheString);
}
else
{
turmasDto = await servicoEOL.ObterTurmasAtribuidasAoProfessorPorEscolaEAnoLetivo(rfProfessor, codigoEscola, anoLetivo);
if (turmasDto != null && turmasDto.Any())
{
await repositorioCache.SalvarAsync(chaveCache, JsonConvert.SerializeObject(turmasDto));
}
}
return(turmasDto);
}
public async Task <IEnumerable <ObjetivoAprendizagemDto> > Listar()
{
List <ObjetivoAprendizagemDto> objetivos;
var objetivosCacheString = repositorioCache.Obter("ObjetivosAprendizagem");
if (string.IsNullOrEmpty(objetivosCacheString))
{
var objetivosJuremaDto = await servicoJurema.ObterListaObjetivosAprendizagem();
objetivos = MapearParaDto(objetivosJuremaDto).ToList();
var tempoExpiracao = int.Parse(configuration.GetSection("ExpiracaoCache").GetSection("ObjetivosAprendizagem").Value);
await repositorioCache.SalvarAsync("ObjetivosAprendizagem", JsonConvert.SerializeObject(objetivos), tempoExpiracao);
}
else
{
objetivos = JsonConvert.DeserializeObject <List <ObjetivoAprendizagemDto> >(objetivosCacheString);
}
return(objetivos);
}
public async Task <List <DisciplinaDto> > ObterDisciplinasAgrupadasPorProfessorETurma(string codigoTurma, bool turmaPrograma)
{
var disciplinasDto = new List <DisciplinaDto>();
var login = servicoUsuario.ObterLoginAtual();
var perfilAtual = servicoUsuario.ObterPerfilAtual();
var chaveCache = $"Disciplinas-Agrupadas-{codigoTurma}-{login}--{perfilAtual}";
var disciplinasCacheString = repositorioCache.Obter(chaveCache);
if (!string.IsNullOrWhiteSpace(disciplinasCacheString))
{
disciplinasDto = JsonConvert.DeserializeObject <List <DisciplinaDto> >(disciplinasCacheString);
}
else
{
if (perfilAtual == Perfis.PERFIL_CJ)
{
// Carrega Disciplinas da Atribuição do CJ
var atribuicoes = await repositorioAtribuicaoCJ.ObterPorFiltros(null, codigoTurma, string.Empty, 0, login, string.Empty, true);
if (atribuicoes != null && atribuicoes.Any())
{
var disciplinasEol = servicoEOL.ObterDisciplinasPorIds(atribuicoes.Select(a => a.DisciplinaId).Distinct().ToArray());
foreach (var disciplinaEOL in disciplinasEol)
{
if (disciplinaEOL.CdComponenteCurricularPai > 0)
{
// TODO Consulta por disciplina pai não esta funcionando no EOL. Refatorar na proxima sprint
disciplinaEOL.CdComponenteCurricularPai = 11211124;
disciplinaEOL.Nome = "REG CLASSE INTEGRAL";
//var consultaDisciplinaPai = servicoEOL.ObterDisciplinasPorIds(new long[] { disciplinaEOL.CodigoComponenteCurricularId });
//if (consultaDisciplinaPai == null)
// throw new NegocioException($"Disciplina Pai de codigo [{disciplinaEOL.CodigoComponenteCurricularId}] não localizada no EOL.");
//disciplinasDto.Add(consultaDisciplinaPai.First());
}
else
{
disciplinasDto.Add(disciplinaEOL);
}
}
}
}
else
{
// Carrega disciplinas do professor
IEnumerable <DisciplinaResposta> disciplinas = await servicoEOL.ObterDisciplinasPorCodigoTurmaLoginEPerfil(codigoTurma, login, perfilAtual);
foreach (var disciplina in disciplinas)
{
if (disciplina.CodigoComponenteCurricularPai.HasValue)
{
// TODO Consulta por disciplina pai não esta funcionando no EOL. Refatorar na proxima sprint
disciplina.CodigoComponenteCurricular = 11211124;
disciplina.Nome = "REG CLASSE INTEGRAL";
//var consultaDisciplinaPai = servicoEOL.ObterDisciplinasPorIds(new long[] { disciplina.CodigoComponenteCurricularPai.Value });
//if (consultaDisciplinaPai == null)
// throw new NegocioException($"Disciplina Pai de codigo [{disciplina.CodigoComponenteCurricularPai}] não localizada no EOL.");
//disciplinasDto.Add(consultaDisciplinaPai.First());
}
disciplinasDto.Add(await MapearParaDto(disciplina, true));
}
}
if (disciplinasDto.Any())
{
await repositorioCache.SalvarAsync(chaveCache, JsonConvert.SerializeObject(disciplinasDto));
}
}
return(disciplinasDto);
}
public async Task <List <DisciplinaDto> > ObterComponentesCurricularesPorProfessorETurma(string codigoTurma, bool turmaPrograma)
{
List <DisciplinaDto> disciplinasDto;
var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();
var chaveCache = $"Disciplinas-{codigoTurma}-{usuarioLogado.PerfilAtual}";
var dataInicioNovoSGP = await mediator.Send(new ObterParametroSistemaPorTipoQuery(TipoParametroSistema.DataInicioSGP));
if (!usuarioLogado.EhProfessor())
{
var disciplinasCacheString = await repositorioCache.ObterAsync(chaveCache);
if (!string.IsNullOrWhiteSpace(disciplinasCacheString))
{
return(JsonConvert.DeserializeObject <List <DisciplinaDto> >(disciplinasCacheString));
}
}
var turma = await repositorioTurma.ObterPorCodigo(codigoTurma);
if (turma == null)
{
throw new NegocioException("Não foi possível encontrar a turma");
}
if (usuarioLogado.EhProfessorCj())
{
var disciplinas = await ObterDisciplinasPerfilCJ(codigoTurma, usuarioLogado.Login);
disciplinasDto = MapearParaDto(disciplinas, turmaPrograma, turma.EnsinoEspecial)?.OrderBy(c => c.Nome)?.ToList();
}
else
{
var componentesCurriculares = await servicoEOL.ObterComponentesCurricularesPorCodigoTurmaLoginEPerfil(codigoTurma, usuarioLogado.Login, usuarioLogado.PerfilAtual);
disciplinasDto = (await repositorioComponenteCurricular.ObterDisciplinasPorIds(
componentesCurriculares?
.Select(a => a.TerritorioSaber ? (a.CodigoComponenteTerritorioSaber == 0 ? a.Codigo : a.CodigoComponenteTerritorioSaber) : a.Codigo).ToArray()))?.OrderBy(c => c.Nome)?.ToList();
var componentesCurricularesJurema = await repositorioCache.Obter("ComponentesJurema", () => Task.FromResult(repositorioComponenteCurricularJurema.Listar()));
if (componentesCurricularesJurema == null)
{
throw new NegocioException("Não foi possível recuperar a lista de componentes curriculares.");
}
disciplinasDto.ForEach(d =>
{
var componenteEOL = componentesCurriculares.FirstOrDefault(a => (a.TerritorioSaber && a.CodigoComponenteTerritorioSaber > 0) ? a.CodigoComponenteTerritorioSaber == d.CodigoComponenteCurricular : a.Codigo == d.CodigoComponenteCurricular);
d.PossuiObjetivos = turma.AnoLetivo < Convert.ToInt32(dataInicioNovoSGP) ? false : componenteEOL.PossuiObjetivosDeAprendizagem(componentesCurricularesJurema, turmaPrograma, turma.ModalidadeCodigo, turma.Ano);
d.CodigoComponenteCurricular = componenteEOL.Codigo;
d.Regencia = componenteEOL.Regencia;
if (d.TerritorioSaber)
{
d.Nome = componenteEOL.Descricao;
}
d.ObjetivosAprendizagemOpcionais = componenteEOL.PossuiObjetivosDeAprendizagemOpcionais(componentesCurricularesJurema, turma.EnsinoEspecial);
});
if (!usuarioLogado.EhProfessor())
{
await repositorioCache.SalvarAsync(chaveCache, JsonConvert.SerializeObject(disciplinasDto));
}
}
return(disciplinasDto);
}