public static async Task SetPrivilegedAccess(string login, IEnumerable <PrivilegedAccess> lista)
{
using (SMEManagementContextData db = new SMEManagementContextData())
{
var listaBanco = db.PrivilegedAccess.Where(x => x.Login.Equals(login));
var listaDeletar = listaBanco.Where(x => !lista.Any(y => y.OccupationPlaceCode == x.OccupationPlaceCode));
var listaAdicionar = lista.Where(x => !listaBanco.Any(y => y.OccupationPlaceCode == x.OccupationPlaceCode));
if (!listaDeletar.Any() && !listaAdicionar.Any())
{
return;
}
if (listaDeletar.Any())
{
foreach (var deletar in listaDeletar)
{
db.PrivilegedAccess.Remove(deletar);
}
}
if (listaAdicionar.Any())
{
foreach (var adicionar in listaAdicionar)
{
db.PrivilegedAccess.Add(adicionar);
}
}
await db.SaveChangesAsync();
}
}
private static void AdicionaOUAlteraAlunosERespostas(SMEManagementContextData contexto, Sondagem sondagem, AlunoSondagemMatematicaDto aluno)
{
var alunoSondagem = sondagem.AlunosSondagem.Where(a => a.CodigoAluno == aluno.CodigoAluno).FirstOrDefault();
if (alunoSondagem != null)
{
if (aluno.Respostas == null || aluno.Respostas.Count == 0)
{
contexto.SondagemAluno.Remove(alunoSondagem);
}
else
{
AtualizaNovasRespostas(aluno, alunoSondagem, sondagem.PeriodoId);
RemoveRespostasSemValor(contexto, aluno, alunoSondagem);
}
}
else
{
if (aluno.Respostas != null)
{
if (aluno.Respostas.Any(r => r.PeriodoId == sondagem.PeriodoId))
{
var alunoNovoSondagem = CriaNovoAlunoSondagem(sondagem, aluno);
sondagem.AlunosSondagem.Add(alunoNovoSondagem);
}
}
}
}
public async Task <IEnumerable <AlunosNaTurmaDTO> > ObterAlunosEOL(string schoolYear, string codigoTurmaEol, string term)
{
filtrosRelatorioDTO filtro = new filtrosRelatorioDTO()
{
AnoLetivo = int.Parse(schoolYear),
PeriodoId = ""
};
using (var contexto = new SMEManagementContextData())
{
var periodo = contexto.Periodo.Where(x => x.Descricao == term).FirstOrDefault();
filtro.PeriodoId = periodo.Id;
}
var periodos = await ConsultaTotalDeAlunos.BuscaDatasPeriodoFixoAnual(filtro);
if (periodos.Count() == 0)
{
throw new Exception("Período fixo anual não encontrado");
}
var endpoits = new EndpointsAPI();
var alunoApi = new AlunosAPI(endpoits);
return((await alunoApi.ObterAlunosAtivosPorTurmaEPeriodo(codigoTurmaEol, periodos.First().DataFim)).OrderBy(a => a.NomeAluno));
}
public static async Task DeleteRole(UserRole role)
{
using (SMEManagementContextData db = new SMEManagementContextData())
{
db.UserRoles.Remove(role);
await db.SaveChangesAsync();
}
}
private async Task SalvarAlunoComResposta(SMEManagementContextData contexto, AlunoSondagemMatematicaDto aluno, SondagemAutoral alunoAutoral)
{
foreach (var resposta in aluno.Respostas)
{
var alunoSalvar = await CriarObtejetoSalvar(contexto, resposta, alunoAutoral, aluno);
await AdicicionarOuAlterar(contexto, alunoSalvar);
}
}
public async Task <IEnumerable <PeriodoDto> > ObterPeriodoMatematica()
{
using (var contexto = new SMEManagementContextData())
{
var periodos = await contexto.Periodo.Where(x => x.TipoPeriodo == Models.Enums.TipoPeriodoEnum.Semestre).ToListAsync();
return(periodos.Select(x => (PeriodoDto)x));
}
}
public static async Task <LoggedUser> GetLoggedUser(string username, string session, string refreshToken)
{
using (SMEManagementContextData db = new SMEManagementContextData())
return(await
(from current in db.LoggedUsers.Include(".User")
where current.User.Name == username &&
current.Session == session &&
current.RefreshToken == refreshToken
select current).FirstOrDefaultAsync());
}
private async Task AdicicionarOuAlterar(SMEManagementContextData context, SondagemAutoral sondagemAutoral)
{
if (string.IsNullOrWhiteSpace(sondagemAutoral.Id))
{
await context.SondagemAutoral.AddAsync(sondagemAutoral);
}
else
{
context.SondagemAutoral.Update(sondagemAutoral);
}
}
private static void IncluiIdDoComponenteCurricularEhDoPeriodoNoFiltro(filtrosRelatorioDTO filtro)
{
using (var contexto = new SMEManagementContextData())
{
var componenteCurricular = contexto.ComponenteCurricular.Where(x => x.Descricao == filtro.DescricaoDisciplina).FirstOrDefault();
filtro.ComponenteCurricularId = componenteCurricular.Id;
var periodo = contexto.Periodo.Where(x => x.Descricao == filtro.DescricaoPeriodo).FirstOrDefault();
filtro.PeriodoId = periodo.Id;
}
}
public static bool ValidateUser(string username)
{
try
{
using (SMEManagementContextData db = new SMEManagementContextData())
return(db.Users.Any(x => x.Name == username));
}
catch (Exception ex)
{
throw ex;
}
}
private static async Task <List <Sondagem> > ObterSondagemAutoralMatematica(FiltrarListagemMatematicaDTO filtrarListagemDto)
{
using (var contexto = new SMEManagementContextData())
{
return(await contexto.Sondagem.Where(s => s.AnoLetivo == filtrarListagemDto.AnoLetivo &&
s.AnoTurma == filtrarListagemDto.AnoEscolar &&
s.CodigoDre == filtrarListagemDto.CodigoDre &&
s.CodigoUe == filtrarListagemDto.CodigoUe &&
s.ComponenteCurricularId.Equals(filtrarListagemDto.ComponenteCurricular.ToString()) &&
s.CodigoTurma == filtrarListagemDto.CodigoTurma).
Include(x => x.AlunosSondagem).ThenInclude(x => x.ListaRespostas).ToListAsync());
}
}
private async Task RetornaPerguntasDoRelatorio(filtrosRelatorioDTO filtro, RelatorioMatematicaPorTurmaDTO relatorio)
{
relatorio.Perguntas = new List <PerguntasRelatorioDTO>();
using (var contexto = new SMEManagementContextData())
{
var perguntasBanco = await contexto.PerguntaAnoEscolar.Include(x => x.Pergunta).Where(perguntaAnoEscolar => perguntaAnoEscolar.AnoEscolar == filtro.AnoEscolar).OrderBy(x => x.Ordenacao).Select(x => MapearPergunta(x)).ToListAsync();
relatorio.Perguntas = perguntasBanco.Select(x => new PerguntasRelatorioDTO
{
Id = x.Id,
Nome = x.Descricao
}).ToList();
}
}
public async Task SalvarSondagemMatematica(IEnumerable <AlunoSondagemMatematicaDto> alunoSondagemMatematicaDto)
{
if (alunoSondagemMatematicaDto == null || !alunoSondagemMatematicaDto.Any())
{
throw new Exception("É necessário realizar a sondagem de pelo menos 1 aluno");
}
try
{
var periodosRespostas = new List <string>();
var perguntaId = await ObterPeriodosDasRespostasEhPerguntaDaSondagem(alunoSondagemMatematicaDto, periodosRespostas);
var listaIdPeriodos = periodosRespostas.Distinct();
var filtroSondagem = CriaFiltroListagemMatematica(alunoSondagemMatematicaDto, perguntaId);
foreach (var periodoId in listaIdPeriodos)
{
using (var contexto = new SMEManagementContextData())
{
var sondagem = await ObterSondagemAutoralMatematicaPorPeriodo(filtroSondagem, periodoId, contexto);
if (sondagem != null)
{
foreach (var aluno in alunoSondagemMatematicaDto)
{
AdicionaOUAlteraAlunosERespostas(contexto, sondagem, aluno);
}
contexto.Sondagem.Update(sondagem);
await contexto.SaveChangesAsync();
}
else
{
var novaSondagem = CriaNovaSondagem(alunoSondagemMatematicaDto, periodoId, filtroSondagem);
contexto.Sondagem.Add(novaSondagem);
await contexto.SaveChangesAsync();
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public static async Task <LoggedUser> GetLoggedUser(string userName)
{
using (SMEManagementContextData db = new SMEManagementContextData())
{
var currentUser = await(from current in db.LoggedUsers.Include(".User")
where current.User.Name.Equals(userName.Trim())
select current).LastOrDefaultAsync();
if (DateTime.Now > currentUser.ExpiresAt || DateTime.Now.Day > currentUser.ExpiresAt.Day)
{
var retornoRevalidacao = await new NovoSGPAPI().RevalidarAutenticacao(currentUser.RefreshToken);
await LoginUser(userName, currentUser.Session, retornoRevalidacao.Token, retornoRevalidacao.DataHoraExpiracao);
return(await GetLoggedUser(userName));
}
return(currentUser);
}
}
private async Task <SondagemAutoral> CriarObtejetoSalvar(SMEManagementContextData contexto, AlunoRespostaDto resposta, SondagemAutoral alunoAutoral, AlunoSondagemMatematicaDto aluno)
{
var alunoBanco = await contexto.SondagemAutoral
.FirstOrDefaultAsync(sondagem => sondagem.PerguntaId == resposta.Pergunta &&
sondagem.PeriodoId == resposta.PeriodoId &&
sondagem.CodigoAluno == alunoAutoral.CodigoAluno &&
sondagem.CodigoTurma == alunoAutoral.CodigoTurma);
if (alunoBanco == null)
{
alunoBanco = new SondagemAutoral(alunoAutoral);
}
alunoBanco.PerguntaId = resposta.Pergunta;
alunoBanco.RespostaId = resposta.Resposta;
alunoBanco.PeriodoId = resposta.PeriodoId;
return(alunoBanco);
}
public async Task SalvarSondagem(IEnumerable <AlunoSondagemMatematicaDto> alunoSondagemMatematicaDto)
{
if (alunoSondagemMatematicaDto == null || !alunoSondagemMatematicaDto.Any())
{
throw new Exception("É necessário realizar a sondagem de pelo menos 1 aluno");
}
try
{
using (var contexto = new SMEManagementContextData())
{
await SalvarAluno(alunoSondagemMatematicaDto, contexto);
await contexto.SaveChangesAsync();
}
}
catch (Exception ex)
{
throw ex;
}
}
private async Task IncluiOrdensEPerguntasNoRelatorio(filtrosRelatorioDTO filtro, RelatorioCapacidadeLeituraPorTurma relatorio)
{
using (var contexto = new SMEManagementContextData())
{
var listaOrdemPergunta = await contexto.OrdemPergunta.Include(x => x.Pergunta).Where(y => y.GrupoId == filtro.GrupoId).OrderBy(x => x.OrdenacaoNaTela).ToListAsync();
relatorio.Perguntas = listaOrdemPergunta.Select(x => new PerguntasRelatorioDTO
{
Id = x.PerguntaId,
Nome = x.Pergunta.Descricao
}).ToList();
var grupos = await contexto.Grupo.Include(x => x.Ordem).Where(x => x.Id == filtro.GrupoId).FirstOrDefaultAsync();
relatorio.Ordens = grupos.Ordem.OrderBy(x => x.Ordenacao).Select(x => new OrdemRelatorioPorTurmaDTO
{
Id = x.Id,
Nome = x.Descricao
}).ToList();
}
}
public async Task <IEnumerable <PerguntaDto> > ObterPerguntas(int anoEscolar)
{
List <PerguntaDto> perguntas = default;
List <PerguntaResposta> perguntasResposta = default;
using (var contexto = new SMEManagementContextData())
{
perguntas = await ObterPerguntas(anoEscolar, perguntas, contexto);
perguntasResposta = await ObterPerguntasRespostas(perguntas, perguntasResposta, contexto);
}
perguntas.ForEach(pergunta =>
{
IEnumerable <PerguntaResposta> respostasDaPergunta = ObterRespostaDaPergunta(pergunta, perguntasResposta);
MapearRespostas(pergunta, respostasDaPergunta);
});
return(perguntas.OrderBy(x => x.Ordenacao));
}
public static async Task <bool> LogoutUser(string username, string session)
{
using (SMEManagementContextData db = new SMEManagementContextData())
{
LoggedUser loggedUser = await
(from current in db.LoggedUsers.Include(".User")
where current.User.Name == username &&
current.Session == session
select current).FirstOrDefaultAsync();
if (loggedUser != null)
{
db.LoggedUsers.Remove(loggedUser);
await db.SaveChangesAsync();
return(true);
}
return(false);
}
}
public static async Task <bool> LoginUser(string username, string session, string refreshToken, DateTime expiresAt)
{
using (SMEManagementContextData db = new SMEManagementContextData())
{
LoggedUser loggedUser = await
(from current in db.LoggedUsers.Include(".User")
where current.User.Name == username
select current).FirstOrDefaultAsync();
if (loggedUser == null)
{
User user = await
(from current in db.Users
where current.Name == username
select current).FirstOrDefaultAsync();
loggedUser = new LoggedUser()
{
User = user,
RefreshToken = refreshToken,
Session = session,
LastAccess = DateTime.Now,
ExpiresAt = expiresAt
};
await db.LoggedUsers.AddAsync(loggedUser);
}
else
{
loggedUser.RefreshToken = refreshToken;
loggedUser.Session = session;
loggedUser.LastAccess = DateTime.Now;
loggedUser.ExpiresAt = expiresAt;
}
await db.SaveChangesAsync();
return(true);
}
}
private static void RemoveRespostasSemValor(SMEManagementContextData contexto, AlunoSondagemMatematicaDto aluno, SondagemAluno alunoSondagem)
{
var ListaRespostasRemovidas = new List <SondagemAlunoRespostas>();
if (alunoSondagem.ListaRespostas.Any(x => x.RespostaId != ""))
{
foreach (var alunoResposta in alunoSondagem.ListaRespostas)
{
var respostaSondagem = aluno.Respostas.Where(x => x.Pergunta == alunoResposta.PerguntaId && x.Resposta != "").FirstOrDefault();
if (respostaSondagem == null)
{
ListaRespostasRemovidas.Add(alunoResposta);
}
}
if (ListaRespostasRemovidas.Count > 0)
{
contexto.SondagemAlunoRespostas.RemoveRange(ListaRespostasRemovidas);
}
}
else
{
contexto.SondagemAluno.Remove(alunoSondagem);
}
}
public async Task <RelatorioCapacidadeLeituraPorTurma> ObterRelatorioCapacidadeLeituraPorTurma(RelatorioPortuguesFiltroDto filtro)
{
var filtrosRelatorio = CriaMapFiltroRelatorio(filtro);
var periodos = await ConsultaTotalDeAlunos.BuscaDatasPeriodoFixoAnual(filtrosRelatorio);
if (periodos.Count() == 0)
{
throw new Exception("Periodo fixo anual nao encontrado");
}
var alunosEol = await alunoAPI.ObterAlunosAtivosPorTurmaEPeriodo(filtro.CodigoTurma, periodos.First().DataFim);
var queryPorTurma = ConsultasRelatorios.QueryRelatorioPorTurmaPortuguesCapacidadeDeLeitura();
var listaAlunoRespostas = await RetornaListaRespostasAlunoPorTurma(filtrosRelatorio, queryPorTurma);
var relatorio = await CriaRelatorioAlunos(filtrosRelatorio, alunosEol, listaAlunoRespostas);
using (var contexto = new SMEManagementContextData())
{
await CriaGraficosRelatorio(relatorio, contexto);
}
relatorio.Alunos = relatorio.Alunos.OrderBy(x => x.NomeAluno).ToList();
return(relatorio);
}
public async Task <RelatorioPortuguesTurmaDto> ObterRelatorioPorTurmasPortugues(RelatorioPortuguesFiltroDto relatorioPortuguesFiltroDto)
{
IEnumerable <SondagemAluno> dados = null;
PeriodoFixoAnual periodo = null;
IEnumerable <Pergunta> perguntas = null;
Grupo grupo = null;
var relatorio = new RelatorioPortuguesTurmaDto();
using (var contexto = new SMEManagementContextData())
{
grupo = await ObterGrupo(relatorioPortuguesFiltroDto, grupo, contexto);
periodo = await ObterPeriodo(relatorioPortuguesFiltroDto, contexto);
perguntas = await ObterPerguntas(relatorioPortuguesFiltroDto, perguntas, contexto);
dados = await ObterDadosRelatorioPorTurma(relatorioPortuguesFiltroDto, dados, contexto);
}
var alunos = await ObterAlunosTurma(relatorioPortuguesFiltroDto, periodo);
if (dados == null)
{
PreencherAlunosSemRespostas(relatorio, alunos);
PreencherGraficoSemRespostas(perguntas, grupo, relatorio, alunos);
}
else
{
MapearRelatorioPorTurma(dados, perguntas, relatorio, alunos);
MapearGraficoPorTurma(dados, perguntas, grupo, alunos, relatorio);
}
relatorio.Alunos = relatorio.Alunos.OrderBy(x => x.NomeAluno).ToList();
return(relatorio);
}
private static async Task CriaGraficosRelatorio(RelatorioCapacidadeLeituraPorTurma relatorio, SMEManagementContextData contexto)
{
var perguntasBanco = await contexto.PerguntaResposta.Include(x => x.Pergunta).Include(y => y.Resposta).Where(pr => relatorio.Perguntas.Any(p => p.Id == pr.Pergunta.Id)).ToListAsync();
relatorio.Graficos = new List <GraficoOrdem>();
relatorio.Ordens.ForEach(o =>
{
var graficoOrdem = new GraficoOrdem();
graficoOrdem.Ordem = o.Nome;
graficoOrdem.perguntasGrafico = new List <Grafico>();
relatorio.Perguntas.ForEach(p =>
{
var grafico = new Grafico();
grafico.NomeGrafico = p.Nome;
var listaRespostas = perguntasBanco.Where(x => x.Pergunta.Id == p.Id);
listaRespostas.ForEach(r =>
{
var barra = new GraficoBarra();
barra.Label = r.Resposta.Descricao;
barra.Value = relatorio.Alunos.Count(x => x.Ordens.Any(ordem => ordem.Id == o.Id && ordem.Perguntas.Any(pr => pr.Id == p.Id && pr.Valor == r.Resposta.Descricao)));
grafico.Barras.Add(barra);
});
var barraAlunosSemPreenchimento = new GraficoBarra();
barraAlunosSemPreenchimento.Label = "Sem Preenchimento";
barraAlunosSemPreenchimento.Value = relatorio.Alunos.Count() - grafico.Barras.Sum(x => x.Value);
grafico.Barras.Add(barraAlunosSemPreenchimento);
graficoOrdem.perguntasGrafico.Add(grafico);
});
relatorio.Graficos.Add(graficoOrdem);
});
}
public async Task <RelatorioAutoralLeituraProducaoDto> ObterRelatorioConsolidadoPortugues(RelatorioPortuguesFiltroDto filtroRelatorioSondagem)
{
var dados = new List <SondagemAlunoRespostas>();
PeriodoFixoAnual periodo = null;
Grupo grupo = null;
IEnumerable <Pergunta> perguntas = null;
var relatorio = new RelatorioAutoralLeituraProducaoDto();
using (var contexto = new SMEManagementContextData())
{
dados = await contexto.SondagemAlunoRespostas.Include(x => x.SondagemAluno).Include(x => x.Pergunta).Include(x => x.Resposta)
.FromSql(ObterConsultaCompleta(filtroRelatorioSondagem),
ObterParametros(filtroRelatorioSondagem)).ToListAsync();
periodo = await contexto.PeriodoFixoAnual.FirstOrDefaultAsync(x => x.PeriodoId == filtroRelatorioSondagem.PeriodoId && x.Ano == filtroRelatorioSondagem.AnoLetivo);
grupo = await contexto.Grupo.FirstOrDefaultAsync(x => x.Id == filtroRelatorioSondagem.GrupoId);
perguntas = await contexto.OrdemPergunta.Include(x => x.Pergunta).Where(x => x.GrupoId.Equals(filtroRelatorioSondagem.GrupoId)).OrderBy(p => p.OrdenacaoNaTela).Select(x => x.Pergunta).ToListAsync();
}
if (grupo == null)
{
throw new Exception($"Não encontrado grupo com o id '{filtroRelatorioSondagem.GrupoId}'");
}
relatorio.GrupoDescricao = grupo.Descricao;
int quantidade = await ObterQuantidadeAlunosAtivos(filtroRelatorioSondagem, periodo);
if (quantidade == 0)
{
throw new Exception("Não foi possivel obter os alunos ativos para o filtro especificado");
}
relatorio.Totais = new RelatorioPortuguesTotalizadores {
Quantidade = quantidade
};
if (filtroRelatorioSondagem.GrupoId != GrupoEnum.ProducaoTexto.Name())
{
relatorio.Totais.Porcentagem = 100;
}
var listaRetorno = new List <RelatorioPortuguesPerguntasDto>();
if (dados == null || !dados.Any())
{
PreencherPerguntasForaLista(listaRetorno, perguntas);
ObterSemPreenchimento(dados, quantidade, listaRetorno);
relatorio.Perguntas = listaRetorno;
MapearGrafico(grupo, relatorio);
return(relatorio);
}
PopularListaRetorno(dados, quantidade, perguntas, listaRetorno);
relatorio.Perguntas = listaRetorno;
MapearGrafico(grupo, relatorio);
return(relatorio);
}
private async Task <List <PerguntaDto> > ObterPerguntas(int anoEscolar, List <PerguntaDto> perguntas, SMEManagementContextData contexto)
{
perguntas = await contexto.PerguntaAnoEscolar.Include(x => x.Pergunta).Where(perguntaAnoEscolar => perguntaAnoEscolar.AnoEscolar == anoEscolar).Select(x => MapearPergunta(x)).ToListAsync();
if (perguntas == null || !perguntas.Any())
{
throw new Exception("Não foi possivel obter as perguntas da sondagem");
}
return(perguntas);
}
private static async Task <List <PerguntaResposta> > ObterPerguntasRespostas(List <PerguntaDto> perguntas, List <PerguntaResposta> perguntasResposta, SMEManagementContextData contexto)
{
perguntasResposta = await contexto.PerguntaResposta.Include(x => x.Pergunta).Include(x => x.Resposta).Where(resposta => perguntas.Any(z => z.Id.Equals(resposta.Pergunta.Id))).ToListAsync();
if (perguntasResposta == null || !perguntasResposta.Any())
{
throw new Exception("Não foi possivel obter as respostas da sondagem");
}
return(perguntasResposta);
}
public async Task <RelatorioMatematicaPorTurmaDTO> ObterRelatorioPorTurma(filtrosRelatorioDTO filtro)
{
IncluiIdDoComponenteCurricularEhDoPeriodoNoFiltro(filtro);
var periodos = await ConsultaTotalDeAlunos.BuscaDatasPeriodoFixoAnual(filtro);
if (periodos.Count() == 0)
{
throw new Exception("Periodo fixo anual nao encontrado");
}
var endpoits = new EndpointsAPI();
var alunoApi = new AlunosAPI(endpoits);
var alunosEol = await alunoApi.ObterAlunosAtivosPorTurmaEPeriodo(filtro.CodigoTurmaEol, periodos.First().DataFim);
var QueryAlunosRespostas = ConsultasRelatorios.QueryRelatorioPorTurmaMatematica();
var listaAlunoRespostas = await RetornaListaRespostasAlunoPorTurma(filtro, QueryAlunosRespostas);
var AlunosAgrupados = listaAlunoRespostas.GroupBy(x => x.CodigoAluno);
var relatorio = new RelatorioMatematicaPorTurmaDTO();
await RetornaPerguntasDoRelatorio(filtro, relatorio);
var ListaAlunos = new List <AlunoPorTurmaRelatorioDTO>();
alunosEol.ForEach(alunoRetorno =>
{
var aluno = new AlunoPorTurmaRelatorioDTO();
aluno.CodigoAluno = alunoRetorno.CodigoAluno;
aluno.NomeAluno = alunoRetorno.NomeAlunoRelatorio;
aluno.Perguntas = new List <PerguntaRespostaPorAluno>();
var alunoRespostas = AlunosAgrupados.Where(x => x.Key == aluno.CodigoAluno.ToString()).ToList();
foreach (var perguntaBanco in relatorio.Perguntas)
{
var pergunta = new PerguntaRespostaPorAluno()
{
Id = perguntaBanco.Id,
Valor = string.Empty
};
var respostaAluno = listaAlunoRespostas.Where(x => x.PerguntaId == perguntaBanco.Id && x.CodigoAluno == aluno.CodigoAluno.ToString()).FirstOrDefault();
if (respostaAluno != null)
{
pergunta.Valor = respostaAluno.RespostaDescricao;
}
aluno.Perguntas.Add(pergunta);
}
ListaAlunos.Add(aluno);
});
relatorio.Alunos = ListaAlunos.OrderBy(aluno => aluno.NomeAluno);
relatorio.Graficos = new List <GraficosRelatorioDTO>();
using (var contexto = new SMEManagementContextData())
{
var perguntasBanco = await contexto.PerguntaResposta.Include(x => x.Pergunta).Include(y => y.Resposta).Where(pr => relatorio.Perguntas.Any(p => p.Id == pr.Pergunta.Id)).ToListAsync();
foreach (var pergunta in relatorio.Perguntas)
{
var grafico = new GraficosRelatorioDTO();
grafico.nomeGrafico = pergunta.Nome;
grafico.Barras = new List <BarrasGraficoDTO>();
var listaRespostas = perguntasBanco.Where(x => x.Pergunta.Id == pergunta.Id).ToList();
listaRespostas.ForEach(resposta =>
{
var barra = new BarrasGraficoDTO();
barra.label = resposta.Resposta.Descricao;
barra.value = relatorio.Alunos.Count(x => x.Perguntas.Any(r => r.Id == pergunta.Id && r.Valor == resposta.Resposta.Descricao));
grafico.Barras.Add(barra);
});
var barraAlunosSemPreenchimento = new BarrasGraficoDTO();
barraAlunosSemPreenchimento.label = "Sem Preenchimento";
barraAlunosSemPreenchimento.value = relatorio.Alunos.Count() - grafico.Barras.Sum(x => x.value);
grafico.Barras.Add(barraAlunosSemPreenchimento);
relatorio.Graficos.Add(grafico);
}
}
return(relatorio);
}
private static async Task <Sondagem> ObterSondagemAutoralMatematicaPorPeriodo(FiltrarListagemMatematicaDTO filtrarListagemDto, string periodoId, SMEManagementContextData contexto)
{
return(await contexto.Sondagem.Where(s => s.PeriodoId == periodoId &&
s.AnoLetivo == filtrarListagemDto.AnoLetivo &&
s.AnoTurma == filtrarListagemDto.AnoEscolar &&
s.CodigoDre == filtrarListagemDto.CodigoDre &&
s.CodigoUe == filtrarListagemDto.CodigoUe &&
s.ComponenteCurricularId.Equals(filtrarListagemDto.ComponenteCurricular.ToString()) &&
s.CodigoTurma == filtrarListagemDto.CodigoTurma).
Include(x => x.AlunosSondagem).ThenInclude(x => x.ListaRespostas).FirstOrDefaultAsync());
}
private async Task SalvarAluno(IEnumerable <AlunoSondagemMatematicaDto> alunoSondagemMatematicaDto, SMEManagementContextData contexto)
{
foreach (var aluno in alunoSondagemMatematicaDto)
{
var alunoAutoral = (SondagemAutoral)aluno;
if (aluno.Respostas != null && aluno.Respostas.Any())
{
await SalvarAlunoComResposta(contexto, aluno, alunoAutoral);
}
}
}
