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 <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 void Sair()
{
var login = servicoUsuario.ObterLoginAtual();
var chaveRedis = $"perfis-usuario-{login}";
repositorioCache.SalvarAsync(chaveRedis, string.Empty);
}
public async Task <IActionResult> InserirDados()
{
await RemoverChaves();
var i = 1111111;
while (i != 4444444)
{
string randomValoresRandomicos = ObterValor();
var chave = $"teste-redis-{i}";
await repositorioCache.SalvarAsync(chave, randomValoresRandomicos);
i++;
}
return(Ok());
}
public async Task <string> Handle(ObterUltimaVersaoQuery request, CancellationToken cancellationToken)
{
var versao = await repositorioCache.ObterAsync("versao", false);
if (string.IsNullOrWhiteSpace(versao))
{
string numeroVersao = await servicoGithub.RecuperarUltimaVersao();
await repositorioCache.SalvarAsync("versao", numeroVersao, 1080, false);
return(numeroVersao);
}
return(versao);
}
public async Task <IEnumerable <PrioridadePerfil> > ObterPerfisUsuario(string login)
{
var chaveRedis = $"perfis-usuario-{login}";
var perfisPorLogin = await servicoEOL.ObterPerfisPorLogin(login);
if (perfisPorLogin == null)
{
throw new NegocioException($"Não foi possível obter os perfis do usuário {login}");
}
var perfisDoUsuario = repositorioPrioridadePerfil.ObterPerfisPorIds(perfisPorLogin.Perfis);
await repositorioCache.SalvarAsync(chaveRedis, JsonConvert.SerializeObject(perfisDoUsuario));
return(perfisDoUsuario);
}
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 = await repositorioCache.ObterAsync("ObjetivosAprendizagem", true);
if (!string.IsNullOrWhiteSpace(objetivosCacheString))
{
return(JsonConvert.DeserializeObject <List <ObjetivoAprendizagemDto> >(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, true);
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);
}