Example #1
0
        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()
            );
        }
Example #2
0
        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());
        }
Example #3
0
        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;
            }
        }
Example #9
0
        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));
        }
Example #10
0
        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);
        }
Example #11
0
        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)));
        }
Example #12
0
        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)));
        }
Example #13
0
 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);
        }
Example #16
0
        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);
        }
Example #17
0
        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);
        }
Example #20
0
        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);
        }
Example #21
0
 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)));
            }
        }
Example #25
0
 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);
        }
Example #27
0
        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);
        }
Example #28
0
        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);
        }
Example #34
0
 public ObterGradesAtuaisDeCursosQuery(DateTime ultimaDataExecucao, Paginacao paginacao)
 {
     UltimaDataExecucao = ultimaDataExecucao;
     Paginacao          = paginacao;
 }
Example #35
0
        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);
        }