public void TestarGeracaoDePaginacao()
{
// Arrange
HtmlHelper helper = null;
Paginacao paginacao = new Paginacao
{
PaginaAtual = 2,
ItensPorPagina = 10,
ItensTotal = 28
};
Func<int, string> paginaUrl = i => "Pagina" + i;
// Act
MvcHtmlString result = helper.PageLinks(paginacao, paginaUrl);
// Assert
Assert.AreEqual
(
@"<a class=""btn btn-default"" href=""Pagina1"">1</a>"
+ @"<a class=""btn btn-default btn-primary selected"" href=""Pagina2"">2</a>"
+ @"<a class=""btn btn-default"" href=""Pagina3"">3</a>",
result.ToString()
);
}
public static MvcHtmlString PageLinks(this HtmlHelper html, Paginacao paginacao, Func<int, string> paginaUrl)
{
StringBuilder resultado = new StringBuilder();
for (int i = 1; i <= paginacao.TotalPagina; i++)
{
TagBuilder tag = new TagBuilder("a");
tag.MergeAttribute("href", paginaUrl(i));
tag.InnerHtml = i.ToString();
if (i == paginacao.PaginaAtual)
tag.AddCssClass("selected btn-primary");
tag.AddCssClass("btn btn-default");
resultado.Append(tag);
}
return MvcHtmlString.Create(resultado.ToString());
}
public void TestarSeApaginacaoEstaSendoGeradaCorretamente()
{
//arrange
HtmlHelper ohtml = null;
var paginacao = new Paginacao()
{
PaginaAtual = 2,
ItensPorPagina = 10,
ItensTotal = 28
};
Func<int,string> paginaUrl = i => "Pagina" + i;
var resultado = ohtml.PageLinks(paginacao, paginaUrl);
Assert.AreEqual(
@"<a class=""btn btn-default"" href=""Pagina1"">1</a>"
+ @"<a class=""btn btn-default btn-primary selected"" href=""Pagina2"">2</a>"
+ @"<a class=""btn btn-default"" href=""Pagina3"">3</a>", resultado.ToString()
);
}
public async Task <Retorno> DadosPaginado(int QtdPorPagina, int PagAtual, string TipoOrdenação, string Filtro = null, string ValueFiltro = null)
{
try
{
var lista = _ctx.Filme.Select(a => new FilmeDTO
{
Id = a.Id,
Nome = a.Nome,
}).ToList();
foreach (var item in lista)
{
item.Atores = _ctx.Ator
.Join(_ctx.FilmeXator, ator => ator.Id, fa => fa.IdAtor, (ator, fa) => new { ator, fa })
.Select(x => new AtorDTO
{
Id = x.ator.Id,
Nome = x.ator.Nome
}).ToList();
item.Diretores = _ctx.Diretor
.Join(_ctx.FilmeXdiretor, diretor => diretor.Id, fd => fd.Id, (diretor, fd) => new { diretor, fd })
.Select(x => new DiretorDTO
{
Id = x.diretor.Id,
Nome = x.diretor.Nome
}).ToList();
item.Generos = _ctx.Genero
.Join(_ctx.FilmeXgenero, genero => genero.Id, fg => fg.Id, (genero, fg) => new { genero, fg })
.Select(x => new GeneroDTO
{
Id = x.genero.Id,
Nome = x.genero.Nome
}).ToList();
var quantRegistros = _ctx.FilmeXnota.Where(b => b.IdFilme == item.Id).Count();
if (quantRegistros > 0)
{
item.MediaNota = (_ctx.FilmeXnota.Where(b => b.IdFilme == item.Id).Sum(a => a.Nota)) / quantRegistros;
}
}
var novaLista = new List <FilmeDTO>();
//filtro
if (Filtro != null && ValueFiltro != null)
{
Filtro = Filtro.Trim().ToUpper();
switch (Filtro)
{
case "DIRETOR":
foreach (var filme in lista)
{
foreach (var diretor in filme.Diretores)
{
if (diretor.Nome.Contains(ValueFiltro))
{
novaLista.Add(filme);
}
}
}
break;
case "NOME":
lista = lista.Where(a =>
a.Nome.Contains(ValueFiltro))
.OrderBy(a => a.Nome).ToList();
break;
case "GENERO":
foreach (var filme in lista)
{
foreach (var genero in filme.Generos)
{
if (genero.Nome.Contains(ValueFiltro))
{
novaLista.Add(filme);
}
}
}
break;
case "ATORES":
foreach (var filme in lista)
{
foreach (var atores in filme.Atores)
{
if (atores.Nome.Contains(ValueFiltro))
{
novaLista.Add(filme);
}
}
}
break;
}
lista = novaLista;
}
else
{
lista = lista.OrderBy(a => a.Id).ToList();
}
if (TipoOrdenação == "NOTA")
{
lista.OrderBy(a => a.MediaNota);
}
else
{
lista.OrderBy(a => a.Nome);
}
var dados = Paginacao.GetPage <Filme, FilmeDTO>(_ctx.Filme, lista.AsQueryable(), QtdPorPagina, PagAtual);
return(new Retorno(true, "Dados Paginados", dados));
}
catch (Exception ex)
{
_log.GerarLogDisc("Erro ao Paginar Usuarios", ex: ex);
throw new Exception("Erro ao Paginar Usuarios", ex);
}
}
public Resultados <DestinatarioListarResultado> Filtrar(DestinatarioListarFiltro destinatarioListarFiltro, Paginacao paginacao)
{
try
{
Filtro <DestinatarioListarFiltro> filtro = new Filtro <DestinatarioListarFiltro>(destinatarioListarFiltro, paginacao);
Resultados <DestinatarioListarResultado> resultados = _da.Filtrar(filtro);
if (resultados.Quantidade < 1)
{
Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
}
return(resultados);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public async Task <PaginacaoResultadoDto <ProfessorCursosCadastradosDto> > Executar(FiltroObterProfessoresCursosCadastradosDto filtro)
{
var paginacao = new Paginacao(filtro.PaginaNumero, filtro.RegistrosQuantidade);
return(await mediator.Send(new ObterProfessoresCursosGoogleQuery(paginacao, filtro.Rf, filtro.TurmaId, filtro.ComponenteCurricularId)));
}
public async Task <PaginacaoResultadoDto <ProfessorEol> > ObterProfessoresParaInclusaoAsync(DateTime dataReferencia, Paginacao paginacao, string rf, ParametrosCargaInicialDto parametrosCargaInicialDto)
{
using var conn = ObterConexao();
var aplicarPaginacao = paginacao.QuantidadeRegistros > 0;
var dataReferenciaAnoLetivo = parametrosCargaInicialDto.AnoLetivo.HasValue ? new DateTime(parametrosCargaInicialDto.AnoLetivo.Value, 1, 1) : dataReferencia;
var query = MontaQueryProfessorParaInclusao(aplicarPaginacao, dataReferenciaAnoLetivo, rf, parametrosCargaInicialDto);
var parametros = new
{
anoLetivo = dataReferencia.Year,
dataReferencia = dataReferencia.Date,
paginacao.QuantidadeRegistros,
paginacao.QuantidadeRegistrosIgnorados,
rf,
TiposUes = parametrosCargaInicialDto.TiposUes,
parametrosCargaInicialDto.Ues,
parametrosCargaInicialDto.Turmas,
};
using var multi = await conn.QueryMultipleAsync(query, parametros);
var retorno = new PaginacaoResultadoDto <ProfessorEol>();
retorno.Items = multi.Read <ProfessorEol>();
retorno.TotalRegistros = multi.ReadFirst <int>();
retorno.TotalPaginas = aplicarPaginacao ? (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros) : 1;
return(retorno);
}
public async Task <PaginacaoResultadoDto <RemoverAtribuicaoProfessorCursoEolDto> > ObterProfessoresParaRemoverCursoPaginado(string turmaId, DateTime dataInicio, DateTime dataFim, Paginacao paginacao)
{
try
{
var query = new StringBuilder();
query.AppendLine(MontaQueryProfessorParaRemoverCurso(turmaId, false, true));
query.AppendLine(MontaQueryProfessorParaRemoverCurso(turmaId, true));
var parametros = new
{
turmaId,
dataInicio,
dataFim,
paginacao.QuantidadeRegistros,
paginacao.QuantidadeRegistrosIgnorados
};
using var conn = ObterConexao();
using var multi = await conn.QueryMultipleAsync(query.ToString(), parametros);
var retorno = new PaginacaoResultadoDto <RemoverAtribuicaoProfessorCursoEolDto>();
retorno.Items = multi.Read <RemoverAtribuicaoProfessorCursoEolDto>();
retorno.TotalRegistros = multi.ReadFirst <int>();
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
catch (Exception ex)
{
throw ex;
}
}
public override async Task <Resposta <Paginacao <DisciplinaTipo> > > ListarPorPaginacao(Paginacao <DisciplinaTipo> entidadePaginada)
{
var query = GetDbSet().AsNoTracking();
if (entidadePaginada.Entidade == null)
{
entidadePaginada.Entidade = new List <DisciplinaTipo>();
}
var entidade = entidadePaginada.Entidade.FirstOrDefault();
if (entidade.Codigo > 0)
{
query = query.Where(lnq => lnq.Codigo == entidade.Codigo);
}
if (!string.IsNullOrEmpty(entidade.Descricao))
{
query = query.Where(lnq => lnq.Descricao.Contains(entidade.Descricao));
}
return(await PaginacaoHelper <DisciplinaTipo> .Paginar(entidadePaginada, query));
}
public Resultados <SolicitacaoListarResultados> Filtrar(SolicitacaoListarFiltro filtrosListar, Paginacao paginacao)
{
try
{
if (!_validar.Buscar(filtrosListar))
{
return(null);
}
if (filtrosListar.IsSolicitacaoNumero)
{
filtrosListar.SolicitacaoNumero = int.Parse(filtrosListar.SolicitacaoTituloNumero);
}
else
{
filtrosListar.EmpreendimentoCodigo = Convert.ToInt32(filtrosListar.SolicitacaoTituloNumero);
filtrosListar.ResponsavelEmpreendimentoCPFCNPJ = filtrosListar.DeclaranteCPFCNPJ;
filtrosListar.DeclaranteCPFCNPJ = null;
}
Filtro <SolicitacaoListarFiltro> filtro = new Filtro <SolicitacaoListarFiltro>(filtrosListar, paginacao);
Resultados <SolicitacaoListarResultados> resultados = _da.Filtrar(filtro);
if (resultados.Quantidade < 1)
{
Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
}
return(resultados);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public async Task <PaginacaoResultadoDto <FuncionarioGoogle> > Executar(FiltroObterFuncionariosCadastradosDto filtro)
{
var paginacao = new Paginacao(filtro.PaginaNumero, filtro.RegistrosQuantidade);
return(await mediator.Send(new ObterFuncionariosGoogleQuery(paginacao, filtro.Rf, filtro.Email)));
}
public async Task <PaginacaoResultadoDto <CursoUsuarioRemovidoConsultaDto> > Executar(FiltroObterUsuariosRemovidosCursosDto filtro)
{
var paginacao = new Paginacao(filtro.PaginaNumero, filtro.RegistrosQuantidade);
return(await mediator.Send(new ObterProfessoresRemovidosCursosPorIdQuery(paginacao, filtro.CursoId)));
}
public static IQueryable <T> Paginar <T> (this IQueryable <T> queryable, Paginacao paginacao)
{
return(queryable.
Skip((paginacao.Pagina - 1) * paginacao.QuantidadePorPagina)
.Take(paginacao.QuantidadePorPagina));
}
public async Task <PaginacaoResultadoDto <RegistroPoa> > ListarPaginado(string codigoRf, string dreId, int bimestre, string ueId, string titulo, int anoLetivo, Paginacao paginacao)
{
var retorno = new PaginacaoResultadoDto <RegistroPoa>();
var sql = MontaQueryCompleta(paginacao, titulo, bimestre);
var parametros = new { codigoRf, bimestre, ueId, dreId, titulo = $"%{titulo?.ToLower()}%", anoLetivo };
using (var multi = await database.Conexao.QueryMultipleAsync(sql, parametros))
{
retorno.Items = multi.Read <RegistroPoa>().ToList();
retorno.TotalRegistros = multi.ReadFirst <int>();
}
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
public Paginacao <UsuarioPerfilUnidade> Buscar(UsuarioPerfilUnidadeFiltro filtro)
{
var retorno = new Paginacao <UsuarioPerfilUnidade>();
var query = DbSet.AsQueryable();
if (filtro.IncludeUsuario)
{
query.Include("Usuario");
}
if (filtro.IncludePerfil)
{
query.Include("Perfil");
}
if (filtro.IncludeUnidade)
{
query.Include("Unidade");
}
if (filtro.IdUsuarioPerfilUnidade.HasValue)
{
query = query.Where(x => x.Id == filtro.IdUsuarioPerfilUnidade);
}
if (filtro.IdUsuario.HasValue)
{
query = query.Where(x => x.IdUsuario == filtro.IdUsuario);
}
if (filtro.SomenteNaoExcluidos)
{
query = query.Where(x => !x.Excluido);
}
retorno.QtRegistros = query.Count();
if (filtro.Skip.HasValue && filtro.Take.HasValue)
{
var primeiraPagina = filtro.Skip.Value == 0;
if (primeiraPagina)
{
var perfilSolicitante = query.FirstOrDefault(x => x.IdPerfil == (int)Domain.Enums.Perfil.Solicitante);
if (perfilSolicitante != null)
{
retorno.Lista.Add(perfilSolicitante);
}
}
query = query.Where(x => x.IdPerfil != (int)Domain.Enums.Perfil.Solicitante);
retorno.Lista.AddRange(filtro.OrdenarDescendente
? query.OrderByDescending(filtro.OrdenarPor).Skip(!primeiraPagina ? filtro.Skip.Value - 1 : filtro.Skip.Value).Take(primeiraPagina ? filtro.Take.Value - 1 : filtro.Take.Value).ToList()
: query.OrderBy(filtro.OrdenarPor).Skip(!primeiraPagina ? filtro.Skip.Value - 1 : filtro.Skip.Value).Take(primeiraPagina ? filtro.Take.Value - 1 : filtro.Take.Value).ToList());
}
else
{
retorno.Lista = query.ToList();
}
return(retorno);
}
public Paginacao <Unidade> Buscar(UnidadeFiltro filtro)
{
var retorno = new Paginacao <Unidade>();
var query = DbSet.AsQueryable();
if (filtro.IncludeUnidadeSuperior)
{
query.Include("UnidadeSuperior");
}
if (filtro.IncludeUnidadePerfisUnidades)
{
query.Include("UsuariosPerfisUnidades");
}
if (filtro.IncludeUnidadesFilhas)
{
query.Include("Unidades");
}
if (filtro.IncludeUnidadeTiposPactos)
{
query.Include("UnidadesTiposPactos");
}
if (!string.IsNullOrWhiteSpace(filtro.Sigla))
{
query = query.Where(x => x.Sigla.ToLower().Contains(filtro.Sigla.ToLower()));
}
if (!string.IsNullOrWhiteSpace(filtro.Nome))
{
query = query.Where(x => x.Nome.ToLower().Contains(filtro.Nome.ToLower()));
}
if (!string.IsNullOrWhiteSpace(filtro.NomeOuSigla))
{
query = query.Where(x => x.Nome.ToLower().Contains(filtro.NomeOuSigla.ToLower()) ||
x.Sigla.ToLower().Contains(filtro.NomeOuSigla.ToLower()));
}
if (filtro.IdUnidadeSuperior.HasValue)
{
query = query.Where(x => x.IdUnidadeSuperior == filtro.IdUnidadeSuperior);
}
if (filtro.Id.HasValue)
{
query = query.Where(x => x.IdUnidade == filtro.Id);
}
if (filtro.IdUsuario.HasValue)
{
query = query.Where(x => x.UsuariosPerfisUnidades.Any(y => !y.Excluido && y.IdUsuario == filtro.IdUsuario));
}
if (filtro.IdTipoPacto.HasValue)
{
query = query.Where(x => x.UnidadesTiposPactos.Any(y => y.IdTipoPacto == filtro.IdTipoPacto));
}
if (!filtro.BuscarExcluidos)
{
query = query.Where(x => !x.Excluido);
}
if (filtro.IdsPactos != null && filtro.IdsPactos.Any())
{
var idsUnidades = Db.Set <Pacto>().Where(y => filtro.IdsPactos.Contains(y.IdPacto))
.Select(y => y.UnidadeExercicio).Distinct();
query = query.Where(x => idsUnidades.Contains(x.IdUnidade));
}
retorno.QtRegistros = query.Count();
if (filtro.Skip.HasValue && filtro.Take.HasValue)
{
retorno.Lista = filtro.OrdenarDescendente
? query.OrderByDescending(filtro.OrdenarPor).Skip(filtro.Skip.Value).Take(filtro.Take.Value).ToList()
: query.OrderBy(filtro.OrdenarPor).Skip(filtro.Skip.Value).Take(filtro.Take.Value).ToList();
}
else
{
retorno.Lista = query.ToList();
}
return(retorno);
}
public Resultados <SolicitacaoListarResultados> Filtrar(SolicitacaoListarFiltro filtrosListar, Paginacao paginacao)
{
try
{
Filtro <SolicitacaoListarFiltro> filtro = new Filtro <SolicitacaoListarFiltro>(filtrosListar, paginacao);
Resultados <SolicitacaoListarResultados> resultados = _da.Filtrar(filtro);
if (resultados.Quantidade < 1)
{
Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
}
return(resultados);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public RequestVendaRangeData WithPagination(int quantidadeTotal)
{
this.Paginacao = Paginacao.New(quantidadeTotal, this.QuantidadePorPagina, this.PaginaAtual);
return this;
}
public Resultados <Requerimento> Filtrar(RequerimentoListarFiltro filtrosListar, Paginacao paginacao)
{
try
{
RequerimentoCredenciadoBus busRequerimentoCredenciado = new RequerimentoCredenciadoBus();
Resultados <Requerimento> resultados = busRequerimentoCredenciado.Filtrar(filtrosListar, paginacao);
if (resultados.Quantidade < 1)
{
Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
}
return(resultados);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public Resultados <Cred.PragaHabilitarEmissao> Filtrar(Cred.ListarFiltro filtrosListar, Paginacao paginacao)
{
try
{
//Seta o id do usuário logado
filtrosListar.Id = User.UsuarioId.ToString();
var filtros = new Filtro <Cred.ListarFiltro>(filtrosListar, paginacao);
var resultados = _da.Filtrar(filtros);
if (resultados.Quantidade < 1)
{
Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
}
return(resultados);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public Resultados <AtividadeListarFiltro> Filtrar(AtividadeListarFiltro FiltrosListar, Paginacao paginacao)
{
try
{
Filtro <AtividadeListarFiltro> filtros = new Filtro <AtividadeListarFiltro>(FiltrosListar, paginacao);
return(_da.Filtrar(filtros));
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public async Task <PaginacaoResultadoDto <AtribuicaoProfessorCursoEol> > ObterAtribuicoesDeCursosDoProfessorAsync(DateTime dataReferencia, Paginacao paginacao, string rf,
long?turmaId, long?componenteCurricularId, ParametrosCargaInicialDto parametrosCargaInicialDto)
{
using var conn = ObterConexao();
var aplicarPaginacao = paginacao.QuantidadeRegistros > 0;
var query = MontaQueryAtribuicoesDeCursosDosProfessores(aplicarPaginacao, rf, turmaId, componenteCurricularId, parametrosCargaInicialDto);
var parametros = new
{
anoLetivo = dataReferencia.Year,
dataReferencia = dataReferencia.Date,
rf,
turmaId,
componenteCurricularId,
paginacao.QuantidadeRegistros,
paginacao.QuantidadeRegistrosIgnorados,
TiposUes = parametrosCargaInicialDto.TiposUes,
parametrosCargaInicialDto.Ues,
parametrosCargaInicialDto.Turmas,
};
using var multi = await conn.QueryMultipleAsync(query, parametros);
var retorno = new PaginacaoResultadoDto <AtribuicaoProfessorCursoEol>();
retorno.Items = multi.Read <AtribuicaoProfessorCursoEol>();
retorno.TotalRegistros = multi.ReadFirst <int>();
retorno.TotalPaginas = aplicarPaginacao ? (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros) : 1;
return(retorno);
}
public ObterAlunosQueSeraoInativadosPorAnoLetivoQuery(Paginacao paginacao, int anoLetivo, DateTime dataReferencia)
{
AnoLetivo = anoLetivo;
Paginacao = paginacao;
DataReferencia = dataReferencia;
}
public ActionResult GerarRelatorio(int?txtConta, DateTime txtDataInicio, DateTime txtDataFim, TipoLancamento?txtTipo, int?pagina)
{
try
{
CarregarContaContabil();
var dateDiff = txtDataFim.Date - txtDataInicio.Date;
if (txtDataInicio.Date == DateTime.MinValue || txtDataFim.Date == DateTime.MinValue)
{
throw new ArgumentException("O intervalo de datas é obrigatório");
}
if (dateDiff.Days > 90)
{
throw new ArgumentException("Intervalo máximo de 90 dias");
}
if (txtDataFim.Date < txtDataInicio.Date)
{
throw new ArgumentException("A Data Fim não pode ser menor que a Data Inicio");
}
var relatorio = _lancamento.ObterTodos().Where(x => x.LancamentoID == 0);
if (txtConta != null && txtDataInicio != null && txtDataFim != null && txtTipo == null)
{
relatorio = _lancamento.ObterTodos().Where(x => x.ContaContabilID == txtConta && x.DataLancamento >= txtDataInicio && x.DataLancamento <= txtDataFim);
}
if (txtConta == null && txtDataInicio != null && txtDataFim != null && txtTipo != null)
{
relatorio = _lancamento.ObterTodos().Where(x => x.DataLancamento >= txtDataInicio && x.DataLancamento <= txtDataFim && x.TipoLancamento == txtTipo);
}
if (txtConta == null && txtDataInicio != null && txtDataFim != null && txtTipo == null)
{
relatorio = _lancamento.ObterTodos().Where(x => x.DataLancamento >= txtDataInicio && x.DataLancamento <= txtDataFim);
}
if (txtConta != null && txtDataInicio != null && txtDataFim != null && txtTipo != null)
{
relatorio = _lancamento.ObterTodos().Where(x => x.ContaContabilID == txtConta && x.DataLancamento >= txtDataInicio && x.DataLancamento <= txtDataFim && x.TipoLancamento == txtTipo);
}
ViewData["ValorCredito"] = relatorio.Where(x => x.TipoLancamento == TipoLancamento.Credito).Select(x => x.Valor).Sum().ToString("C");
ViewData["ValorDebito"] = relatorio.Where(x => x.TipoLancamento == TipoLancamento.Debito).Select(x => x.Valor).Sum().ToString("C");
TempData["txtConta"] = txtConta;
TempData["txtDataInicio"] = txtDataInicio;
TempData["txtDataFim"] = txtDataFim;
TempData["txtTipo"] = txtTipo;
int pageSize = 200000000;
return(View(Paginacao <Lancamento> .Create(relatorio, pagina ?? 1, pageSize)));
}
catch (Exception ex)
{
Mensagem = ex.Message.ToString();
ModelState.AddModelError(String.Empty, Mensagem);
CarregarContaContabil();
var relatorio = _lancamento.ObterTodos().Where(x => x.ClienteID == 0);
return(View(Paginacao <Lancamento> .Create(relatorio, pagina ?? 1, 20)));
}
}
public ListarVM()
{
Filtros = new PapelListarFiltro();
Paginacao = new Paginacao();
Resultados = new List <Papel>();
}
public Resultados <Empreendimento> Filtrar(ListarEmpreendimentoFiltro filtrosListar, Paginacao paginacao, bool validarEncontrouRegistros = true)
{
try
{
filtrosListar.Credenciado = User.FuncionarioId;
if (!string.IsNullOrEmpty(filtrosListar.AreaAbrangencia))
{
filtrosListar.Coordenada.Datum.Sigla = ListaCredenciadoBus.Datuns.SingleOrDefault(x => Equals(x.Id, filtrosListar.Coordenada.Datum.Id)).Sigla;
}
Filtro <ListarEmpreendimentoFiltro> filtro = new Filtro <ListarEmpreendimentoFiltro>(filtrosListar, paginacao);
Resultados <Empreendimento> resultados = _da.Filtrar(filtro);
if (validarEncontrouRegistros && resultados.Quantidade <= 0)
{
Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
}
foreach (var item in resultados.Itens)
{
item.SegmentoTexto = (ListaCredenciadoBus.Segmentos.SingleOrDefault(x => x.Id == item.Segmento.ToString()) ?? new Segmento()).Texto;
}
if (filtro.OdenarPor == 1)
{
resultados.Itens.OrderBy(x => x.SegmentoTexto);
}
return(resultados);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public Resultados <Requerimento> Filtrar(RequerimentoListarFiltro filtrosListar, Paginacao paginacao)
{
try
{
Filtro <RequerimentoListarFiltro> filtro = new Filtro <RequerimentoListarFiltro>(filtrosListar, paginacao);
Resultados <Requerimento> resultados = _da.Filtrar(filtro);
if (resultados.Quantidade < 1)
{
Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
}
else
{
foreach (var item in resultados.Itens)
{
item.SituacaoTexto = ListaCredenciadoBus.SituacoesRequerimento.SingleOrDefault(x => x.Id == item.SituacaoId).Texto;
}
}
return(resultados);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public override async Task <Resposta <Paginacao <Usuario> > > ListarPorPaginacao(Paginacao <Usuario> entidadePaginada)
{
var query = GetDbSet()
.AsNoTracking();
if (entidadePaginada.Entidade == null)
{
entidadePaginada.Entidade = new List <Usuario>();
}
var entidade = entidadePaginada.Entidade.FirstOrDefault();
if (entidade.Codigo > 0)
{
query = query.Where(lnq => lnq.Codigo == entidade.Codigo);
}
if (!string.IsNullOrEmpty(entidade.Email))
{
query = query.Where(lnq => lnq.Email.Contains(entidade.Email));
}
if (!string.IsNullOrEmpty(entidade.Login))
{
query = query.Where(lnq => lnq.Login.Contains(entidade.Login));
}
if (!string.IsNullOrEmpty(entidade.Nome))
{
query = query.Where(lnq => lnq.Nome.Contains(entidade.Nome));
}
if (!string.IsNullOrEmpty(entidade.Telefone))
{
query = query.Where(lnq => lnq.Telefone.Contains(entidade.Telefone));
}
if (entidade.PerfilCodigo > 0)
{
query = query.Where(lnq => lnq.PerfilCodigo == entidade.PerfilCodigo);
}
return(await PaginacaoHelper <Usuario> .Paginar(entidadePaginada, query));
}
public ActionResult Listar(int? pagina)
{
var mercadorias = Mapper.Map<IEnumerable<Mercadoria>, IEnumerable<MercadoriaViewModel>>(repositorioDeMercadorias.ObterTodos());
var paginacao = new Paginacao<MercadoriaViewModel>(mercadorias, 5);
paginacao.VaParaPagina(pagina);
return View(paginacao);
}
public ActionResult Mercadorias(Guid id,int? pagina)
{
var mercadoriasViewModel = new List<MercadoriaViewModel>();
var categoria = repositorioDeCategorias.Obter(id);
if (categoria != null)
{
foreach (var mercadoria in categoria.Mercadorias)
{
mercadoriasViewModel.Add(Mapper.Map<Mercadoria, MercadoriaViewModel>(mercadoria));
}
}
var paginacao = new Paginacao<MercadoriaViewModel>(mercadoriasViewModel, 5);
paginacao.VaParaPagina(pagina);
ViewData[MercadoriasViewModel.Mercadorias] = new MercadoriasViewModel(repositorioDeCategorias.ObterTodos());
return View(paginacao);
}
public Resultados <SolicitacaoListarResultados> Filtrar(SolicitacaoListarFiltro filtrosListar, Paginacao paginacao)
{
try
{
filtrosListar.AutorCPFCNPJ = new CredenciadoBus().Obter(User.FuncionarioId, simplificado: true).Pessoa.CPFCNPJ;
Filtro <SolicitacaoListarFiltro> filtro = new Filtro <SolicitacaoListarFiltro>(filtrosListar, paginacao);
Resultados <SolicitacaoListarResultados> resultados = _da.Filtrar(filtro);
if (resultados.Quantidade < 1)
{
Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
}
return(resultados);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public ObterCursosArquivadosPorDataArquivamentoPaginadoQuery(DateTime dataArquivamento, Paginacao paginacao)
{
DataArquivamento = dataArquivamento;
Paginacao = paginacao;
}
public async Task <PaginacaoResultadoDto <CursoGsaDto> > ObterCursosComparativosAsync(Paginacao paginacao, string secao, string nome, string descricao)
{
var queryCompleta = new StringBuilder();
queryCompleta.AppendLine(MontaQueryObterCursosComparativos(false, paginacao, secao, nome, descricao));
queryCompleta.AppendLine(MontaQueryObterCursosComparativos(true, paginacao, secao, nome, descricao));
var retorno = new PaginacaoResultadoDto <CursoGsaDto>();
using var conn = ObterConexao();
var parametros = new
{
paginacao,
secao
};
using var multi = await conn.QueryMultipleAsync(queryCompleta.ToString(), parametros);
retorno.Items = multi.Read <CursoGsaDto>();
retorno.TotalRegistros = multi.ReadFirst <int>();
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
public ObterGradesAtuaisDeCursosQuery(DateTime ultimaDataExecucao, Paginacao paginacao)
{
UltimaDataExecucao = ultimaDataExecucao;
Paginacao = paginacao;
}
public Resultados <ChecagemPendencia> Filtrar(ListarFiltroChecagemPendencia filtrosListar, Paginacao paginacao)
{
try
{
Filtro <ListarFiltroChecagemPendencia> filtro = new Filtro <ListarFiltroChecagemPendencia>(filtrosListar, paginacao);
Resultados <ChecagemPendencia> resultados = _da.Filtrar(filtro);
if (resultados.Quantidade < 1)
{
Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
}
return(resultados);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
