예제 #1
0
        public async Task <PessoaTipoTransfer> ConsultarPorId(int id)
        {
            PessoaTipoService  pessoaTipoService;
            PessoaTipoTransfer pessoaTipo;
            AutenticaModel     autenticaModel;
            string             autorizacao;

            try {
                pessoaTipoService = new PessoaTipoService();
                autenticaModel    = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                pessoaTipo = await pessoaTipoService.ConsultarPorId(id, autorizacao);
            } catch (Exception ex) {
                pessoaTipo = new PessoaTipoTransfer();

                pessoaTipo.Validacao = false;
                pessoaTipo.Erro      = true;
                pessoaTipo.IncluirMensagem("Erro em PessoaTipoModel ConsultarPorId [" + ex.Message + "]");
            } finally {
                pessoaTipoService = null;
                autenticaModel    = null;
            }

            return(pessoaTipo);
        }
예제 #2
0
        public async Task <TelefoneTipoTransfer> Excluir(int id)
        {
            TelefoneTipoService  telefoneTipoService;
            TelefoneTipoTransfer telefoneTipo;
            AutenticaModel       autenticaModel;
            string autorizacao;

            try {
                telefoneTipoService = new TelefoneTipoService();
                autenticaModel      = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                telefoneTipo = await telefoneTipoService.Excluir(id, autorizacao);
            } catch (Exception ex) {
                telefoneTipo = new TelefoneTipoTransfer();

                telefoneTipo.Validacao = false;
                telefoneTipo.Erro      = true;
                telefoneTipo.IncluirMensagem("Erro em TelefoneTipoModel Excluir [" + ex.Message + "]");
            } finally {
                telefoneTipoService = null;
                autenticaModel      = null;
            }

            return(telefoneTipo);
        }
예제 #3
0
        public async Task <ContaBancariaTransfer> ConsultarPorId(int id)
        {
            ContaBancariaService  contaBancariaService;
            ContaBancariaTransfer contaBancaria;
            AutenticaModel        autenticaModel;
            string autorizacao;

            try {
                contaBancariaService = new ContaBancariaService();
                autenticaModel       = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                contaBancaria = await contaBancariaService.ConsultarPorId(id, autorizacao);
            } catch (Exception ex) {
                contaBancaria = new ContaBancariaTransfer();

                contaBancaria.Validacao = false;
                contaBancaria.Erro      = true;
                contaBancaria.IncluirMensagem("Erro em ContaBancariaModel ConsultarPorId [" + ex.Message + "]");
            } finally {
                contaBancariaService = null;
                autenticaModel       = null;
            }

            return(contaBancaria);
        }
예제 #4
0
        public async Task <CorTransfer> Excluir(int id)
        {
            CorService     corService;
            CorTransfer    cor;
            AutenticaModel autenticaModel;
            string         autorizacao;

            try {
                corService     = new CorService();
                autenticaModel = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                cor = await corService.Excluir(id, autorizacao);
            } catch (Exception ex) {
                cor = new CorTransfer();

                cor.Validacao = false;
                cor.Erro      = true;
                cor.IncluirMensagem("Erro em CorModel Excluir [" + ex.Message + "]");
            } finally {
                corService     = null;
                autenticaModel = null;
            }

            return(cor);
        }
예제 #5
0
        public async Task <GeneroSocialTransfer> Excluir(int id)
        {
            GeneroSocialService  generoSocialService;
            GeneroSocialTransfer generoSocial;
            AutenticaModel       autenticaModel;
            string autorizacao;

            try {
                generoSocialService = new GeneroSocialService();
                autenticaModel      = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                generoSocial = await generoSocialService.Excluir(id, autorizacao);
            } catch (Exception ex) {
                generoSocial = new GeneroSocialTransfer();

                generoSocial.Validacao = false;
                generoSocial.Erro      = true;
                generoSocial.IncluirMensagem("Erro em GeneroSocialModel Excluir [" + ex.Message + "]");
            } finally {
                generoSocialService = null;
                autenticaModel      = null;
            }

            return(generoSocial);
        }
예제 #6
0
        public async Task <UsuarioTipoTransfer> Excluir(int id)
        {
            UsuarioTipoService  usuarioTipoService;
            UsuarioTipoTransfer usuarioTipo;
            AutenticaModel      autenticaModel;
            string autorizacao;

            try {
                usuarioTipoService = new UsuarioTipoService();
                autenticaModel     = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                usuarioTipo = await usuarioTipoService.Excluir(id, autorizacao);
            } catch (Exception ex) {
                usuarioTipo = new UsuarioTipoTransfer();

                usuarioTipo.Validacao = false;
                usuarioTipo.Erro      = true;
                usuarioTipo.IncluirMensagem("Erro em UsuarioTipoModel Excluir [" + ex.Message + "]");
            } finally {
                usuarioTipoService = null;
                autenticaModel     = null;
            }

            return(usuarioTipo);
        }
예제 #7
0
        public async Task <ContaBancariaTransfer> Alterar(ContaBancariaTransfer contaBancariaTransfer)
        {
            ContaBancariaService  contaBancariaService;
            ContaBancariaTransfer contaBancaria;
            AutenticaModel        autenticaModel;
            string autorizacao;

            try {
                contaBancariaService = new ContaBancariaService();
                autenticaModel       = new AutenticaModel(httpContext);

                contaBancariaTransfer.ContaBancaria.Alteracao = DateTime.Today;

                autorizacao = autenticaModel.ObterToken();

                contaBancaria = await contaBancariaService.Alterar(contaBancariaTransfer, autorizacao);
            } catch (Exception ex) {
                contaBancaria = new ContaBancariaTransfer();

                contaBancaria.Validacao = false;
                contaBancaria.Erro      = true;
                contaBancaria.IncluirMensagem("Erro em ContaBancariaModel Alterar [" + ex.Message + "]");
            } finally {
                contaBancariaService = null;
                autenticaModel       = null;
            }

            return(contaBancaria);
        }
예제 #8
0
        public async Task <PessoaTipoTransfer> Alterar(PessoaTipoTransfer pessoaTipoTransfer)
        {
            PessoaTipoService  pessoaTipoService;
            PessoaTipoTransfer pessoaTipo;
            AutenticaModel     autenticaModel;
            string             autorizacao;

            try {
                pessoaTipoService = new PessoaTipoService();
                autenticaModel    = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                pessoaTipoTransfer.PessoaTipo.Alteracao = DateTime.Today;

                pessoaTipo = await pessoaTipoService.Alterar(pessoaTipoTransfer, autorizacao);
            } catch (Exception ex) {
                pessoaTipo = new PessoaTipoTransfer();

                pessoaTipo.Validacao = false;
                pessoaTipo.Erro      = true;
                pessoaTipo.IncluirMensagem("Erro em PessoaTipoModel Alterar [" + ex.Message + "]");
            } finally {
                pessoaTipoService = null;
                autenticaModel    = null;
            }

            return(pessoaTipo);
        }
예제 #9
0
        public async Task <SexoTransfer> Excluir(int id)
        {
            SexoService    sexoService;
            SexoTransfer   sexo;
            AutenticaModel autenticaModel;
            string         autorizacao;

            try {
                sexoService    = new SexoService();
                autenticaModel = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                sexo = await sexoService.Excluir(id, autorizacao);
            } catch (Exception ex) {
                sexo = new SexoTransfer();

                sexo.Validacao = false;
                sexo.Erro      = true;
                sexo.IncluirMensagem("Erro em SexoModel Excluir [" + ex.Message + "]");
            } finally {
                sexoService    = null;
                autenticaModel = null;
            }

            return(sexo);
        }
예제 #10
0
        public async Task <EnderecoTipoTransfer> Alterar(EnderecoTipoTransfer enderecoTipoTransfer)
        {
            EnderecoTipoService  enderecoTipoService;
            EnderecoTipoTransfer enderecoTipo;
            AutenticaModel       autenticaModel;
            string autorizacao;

            try {
                enderecoTipoService = new EnderecoTipoService();
                autenticaModel      = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                enderecoTipoTransfer.EnderecoTipo.Alteracao = DateTime.Today;

                enderecoTipo = await enderecoTipoService.Alterar(enderecoTipoTransfer, autorizacao);
            } catch (Exception ex) {
                enderecoTipo = new EnderecoTipoTransfer();

                enderecoTipo.Validacao = false;
                enderecoTipo.Erro      = true;
                enderecoTipo.IncluirMensagem("Erro em EnderecoTipoModel Alterar [" + ex.Message + "]");
            } finally {
                enderecoTipoService = null;
                autenticaModel      = null;
            }

            return(enderecoTipo);
        }
예제 #11
0
        public async Task <ProfissaoTransfer> Excluir(int id)
        {
            ProfissaoService  profissaoService;
            ProfissaoTransfer profissao;
            AutenticaModel    autenticaModel;
            string            autorizacao;

            try {
                profissaoService = new ProfissaoService();
                autenticaModel   = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                profissao = await profissaoService.Excluir(id, autorizacao);
            } catch (Exception ex) {
                profissao = new ProfissaoTransfer();

                profissao.Validacao = false;
                profissao.Erro      = true;
                profissao.IncluirMensagem("Erro em ProfissaoModel Excluir [" + ex.Message + "]");
            } finally {
                profissaoService = null;
                autenticaModel   = null;
            }

            return(profissao);
        }
예제 #12
0
        public async Task <UsuarioTransfer> AlterarSenha(UsuarioTransfer usuarioTransfer)
        {
            UsuarioService  usuarioService;
            UsuarioTransfer usuario;
            AutenticaModel  autenticaModel;
            string          autorizacao;

            try {
                usuarioService = new UsuarioService();
                autenticaModel = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                usuarioTransfer.Usuario.Alteracao = DateTime.Today;

                usuario = await usuarioService.AlterarSenha(usuarioTransfer, autorizacao);
            } catch (Exception ex) {
                usuario = new UsuarioTransfer();

                usuario.Validacao = false;
                usuario.Erro      = true;
                usuario.IncluirMensagem("Erro em UsuarioModel AlterarSenha [" + ex.Message + "]");
            } finally {
                usuarioService = null;
                autenticaModel = null;
            }

            return(usuario);
        }
예제 #13
0
        public async Task <EstadoCivilTransfer> Excluir(int id)
        {
            EstadoCivilService  estadoCivilService;
            EstadoCivilTransfer estadoCivil;
            AutenticaModel      autenticaModel;
            string autorizacao;

            try {
                estadoCivilService = new EstadoCivilService();
                autenticaModel     = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                estadoCivil = await estadoCivilService.Excluir(id, autorizacao);
            } catch (Exception ex) {
                estadoCivil = new EstadoCivilTransfer();

                estadoCivil.Validacao = false;
                estadoCivil.Erro      = true;
                estadoCivil.IncluirMensagem("Erro em EstadoCivilModel Excluir [" + ex.Message + "]");
            } finally {
                estadoCivilService = null;
                autenticaModel     = null;
            }

            return(estadoCivil);
        }
예제 #14
0
        public async Task <TelefoneTipoTransfer> Consultar(TelefoneTipoTransfer telefoneTipoListaTransfer)
        {
            TelefoneTipoService  telefoneTipoService;
            TelefoneTipoTransfer telefoneTipoLista;
            AutenticaModel       autenticaModel;
            string autorizacao;
            int    dif      = 0;
            int    qtdExibe = 5;

            try {
                telefoneTipoService = new TelefoneTipoService();
                autenticaModel      = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                telefoneTipoLista = await telefoneTipoService.Consultar(telefoneTipoListaTransfer, autorizacao);

                if (telefoneTipoLista != null)
                {
                    if (telefoneTipoLista.Paginacao.TotalRegistros > 0)
                    {
                        if (telefoneTipoLista.Paginacao.RegistrosPorPagina < 1)
                        {
                            telefoneTipoLista.Paginacao.RegistrosPorPagina = 30;
                        }
                        else if (telefoneTipoLista.Paginacao.RegistrosPorPagina > 200)
                        {
                            telefoneTipoLista.Paginacao.RegistrosPorPagina = 30;
                        }

                        telefoneTipoLista.Paginacao.PaginaAtual  = (telefoneTipoLista.Paginacao.PaginaAtual < 1 ? 1 : telefoneTipoLista.Paginacao.PaginaAtual);
                        telefoneTipoLista.Paginacao.TotalPaginas =
                            Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(telefoneTipoLista.Paginacao.TotalRegistros)
                                                         / @Convert.ToDecimal(telefoneTipoLista.Paginacao.RegistrosPorPagina)));
                        telefoneTipoLista.Paginacao.TotalPaginas = (telefoneTipoLista.Paginacao.TotalPaginas < 1 ? 1 : telefoneTipoLista.Paginacao.TotalPaginas);

                        qtdExibe = (qtdExibe > telefoneTipoLista.Paginacao.TotalPaginas ? telefoneTipoLista.Paginacao.TotalPaginas : qtdExibe);

                        telefoneTipoLista.Paginacao.PaginaInicial = telefoneTipoLista.Paginacao.PaginaAtual - (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        telefoneTipoLista.Paginacao.PaginaFinal   = telefoneTipoLista.Paginacao.PaginaAtual + (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        telefoneTipoLista.Paginacao.PaginaFinal   = ((qtdExibe % 2) == 0 ? (telefoneTipoLista.Paginacao.PaginaFinal - 1) : telefoneTipoLista.Paginacao.PaginaFinal);

                        if (telefoneTipoLista.Paginacao.PaginaInicial < 1)
                        {
                            dif = 1 - telefoneTipoLista.Paginacao.PaginaInicial;
                            telefoneTipoLista.Paginacao.PaginaInicial += dif;
                            telefoneTipoLista.Paginacao.PaginaFinal   += dif;
                        }

                        if (telefoneTipoLista.Paginacao.PaginaFinal > telefoneTipoLista.Paginacao.TotalPaginas)
                        {
                            dif = telefoneTipoLista.Paginacao.PaginaFinal - telefoneTipoLista.Paginacao.TotalPaginas;
                            telefoneTipoLista.Paginacao.PaginaInicial -= dif;
                            telefoneTipoLista.Paginacao.PaginaFinal   -= dif;
                        }

                        telefoneTipoLista.Paginacao.PaginaInicial = (telefoneTipoLista.Paginacao.PaginaInicial < 1 ? 1 : telefoneTipoLista.Paginacao.PaginaInicial);
                        telefoneTipoLista.Paginacao.PaginaFinal   = (telefoneTipoLista.Paginacao.PaginaFinal > telefoneTipoLista.Paginacao.TotalPaginas ?
                                                                     telefoneTipoLista.Paginacao.TotalPaginas : telefoneTipoLista.Paginacao.PaginaFinal);
                    }
                }
            } catch (Exception ex) {
                telefoneTipoLista = new TelefoneTipoTransfer();

                telefoneTipoLista.Validacao = false;
                telefoneTipoLista.Erro      = true;
                telefoneTipoLista.IncluirMensagem("Erro em TelefoneTipoModel Consultar [" + ex.Message + "]");
            } finally {
                telefoneTipoService = null;
                autenticaModel      = null;
            }

            return(telefoneTipoLista);
        }
예제 #15
0
        public async Task <CorTransfer> Consultar(CorTransfer corListaTransfer)
        {
            CorService     corService;
            CorTransfer    corLista;
            AutenticaModel autenticaModel;
            string         autorizacao;
            int            dif      = 0;
            int            qtdExibe = 5;

            try {
                corService     = new CorService();
                autenticaModel = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                corLista = await corService.Consultar(corListaTransfer, autorizacao);

                if (corLista != null)
                {
                    if (corLista.Paginacao.TotalRegistros > 0)
                    {
                        if (corLista.Paginacao.RegistrosPorPagina < 1)
                        {
                            corLista.Paginacao.RegistrosPorPagina = 30;
                        }
                        else if (corLista.Paginacao.RegistrosPorPagina > 200)
                        {
                            corLista.Paginacao.RegistrosPorPagina = 30;
                        }

                        corLista.Paginacao.PaginaAtual  = (corLista.Paginacao.PaginaAtual < 1 ? 1 : corLista.Paginacao.PaginaAtual);
                        corLista.Paginacao.TotalPaginas =
                            Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(corLista.Paginacao.TotalRegistros)
                                                         / @Convert.ToDecimal(corLista.Paginacao.RegistrosPorPagina)));
                        corLista.Paginacao.TotalPaginas = (corLista.Paginacao.TotalPaginas < 1 ? 1 : corLista.Paginacao.TotalPaginas);

                        qtdExibe = (qtdExibe > corLista.Paginacao.TotalPaginas ? corLista.Paginacao.TotalPaginas : qtdExibe);

                        corLista.Paginacao.PaginaInicial = corLista.Paginacao.PaginaAtual - (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        corLista.Paginacao.PaginaFinal   = corLista.Paginacao.PaginaAtual + (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        corLista.Paginacao.PaginaFinal   = ((qtdExibe % 2) == 0 ? (corLista.Paginacao.PaginaFinal - 1) : corLista.Paginacao.PaginaFinal);

                        if (corLista.Paginacao.PaginaInicial < 1)
                        {
                            dif = 1 - corLista.Paginacao.PaginaInicial;
                            corLista.Paginacao.PaginaInicial += dif;
                            corLista.Paginacao.PaginaFinal   += dif;
                        }

                        if (corLista.Paginacao.PaginaFinal > corLista.Paginacao.TotalPaginas)
                        {
                            dif = corLista.Paginacao.PaginaFinal - corLista.Paginacao.TotalPaginas;
                            corLista.Paginacao.PaginaInicial -= dif;
                            corLista.Paginacao.PaginaFinal   -= dif;
                        }

                        corLista.Paginacao.PaginaInicial = (corLista.Paginacao.PaginaInicial < 1 ? 1 : corLista.Paginacao.PaginaInicial);
                        corLista.Paginacao.PaginaFinal   = (corLista.Paginacao.PaginaFinal > corLista.Paginacao.TotalPaginas ?
                                                            corLista.Paginacao.TotalPaginas : corLista.Paginacao.PaginaFinal);
                    }
                }
            } catch (Exception ex) {
                corLista = new CorTransfer();

                corLista.Validacao = false;
                corLista.Erro      = true;
                corLista.IncluirMensagem("Erro em CorModel Consultar [" + ex.Message + "]");
            } finally {
                corService     = null;
                autenticaModel = null;
            }

            return(corLista);
        }
예제 #16
0
        public async Task <GeneroSocialTransfer> Consultar(GeneroSocialTransfer generoSocialListaTransfer)
        {
            GeneroSocialService  generoSocialService;
            GeneroSocialTransfer generoSocialLista;
            AutenticaModel       autenticaModel;
            string autorizacao;
            int    dif      = 0;
            int    qtdExibe = 5;

            try {
                generoSocialService = new GeneroSocialService();
                autenticaModel      = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                generoSocialLista = await generoSocialService.Consultar(generoSocialListaTransfer, autorizacao);

                if (generoSocialLista != null)
                {
                    if (generoSocialLista.Paginacao.TotalRegistros > 0)
                    {
                        if (generoSocialLista.Paginacao.RegistrosPorPagina < 1)
                        {
                            generoSocialLista.Paginacao.RegistrosPorPagina = 30;
                        }
                        else if (generoSocialLista.Paginacao.RegistrosPorPagina > 200)
                        {
                            generoSocialLista.Paginacao.RegistrosPorPagina = 30;
                        }

                        generoSocialLista.Paginacao.PaginaAtual  = (generoSocialLista.Paginacao.PaginaAtual < 1 ? 1 : generoSocialLista.Paginacao.PaginaAtual);
                        generoSocialLista.Paginacao.TotalPaginas =
                            Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(generoSocialLista.Paginacao.TotalRegistros)
                                                         / @Convert.ToDecimal(generoSocialLista.Paginacao.RegistrosPorPagina)));
                        generoSocialLista.Paginacao.TotalPaginas = (generoSocialLista.Paginacao.TotalPaginas < 1 ? 1 : generoSocialLista.Paginacao.TotalPaginas);

                        qtdExibe = (qtdExibe > generoSocialLista.Paginacao.TotalPaginas ? generoSocialLista.Paginacao.TotalPaginas : qtdExibe);

                        generoSocialLista.Paginacao.PaginaInicial = generoSocialLista.Paginacao.PaginaAtual - (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        generoSocialLista.Paginacao.PaginaFinal   = generoSocialLista.Paginacao.PaginaAtual + (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        generoSocialLista.Paginacao.PaginaFinal   = ((qtdExibe % 2) == 0 ? (generoSocialLista.Paginacao.PaginaFinal - 1) : generoSocialLista.Paginacao.PaginaFinal);

                        if (generoSocialLista.Paginacao.PaginaInicial < 1)
                        {
                            dif = 1 - generoSocialLista.Paginacao.PaginaInicial;
                            generoSocialLista.Paginacao.PaginaInicial += dif;
                            generoSocialLista.Paginacao.PaginaFinal   += dif;
                        }

                        if (generoSocialLista.Paginacao.PaginaFinal > generoSocialLista.Paginacao.TotalPaginas)
                        {
                            dif = generoSocialLista.Paginacao.PaginaFinal - generoSocialLista.Paginacao.TotalPaginas;
                            generoSocialLista.Paginacao.PaginaInicial -= dif;
                            generoSocialLista.Paginacao.PaginaFinal   -= dif;
                        }

                        generoSocialLista.Paginacao.PaginaInicial = (generoSocialLista.Paginacao.PaginaInicial < 1 ? 1 : generoSocialLista.Paginacao.PaginaInicial);
                        generoSocialLista.Paginacao.PaginaFinal   = (generoSocialLista.Paginacao.PaginaFinal > generoSocialLista.Paginacao.TotalPaginas ?
                                                                     generoSocialLista.Paginacao.TotalPaginas : generoSocialLista.Paginacao.PaginaFinal);
                    }
                }
            } catch (Exception ex) {
                generoSocialLista = new GeneroSocialTransfer();

                generoSocialLista.Validacao = false;
                generoSocialLista.Erro      = true;
                generoSocialLista.IncluirMensagem("Erro em GeneroSocialModel Consultar [" + ex.Message + "]");
            } finally {
                generoSocialService = null;
                autenticaModel      = null;
            }

            return(generoSocialLista);
        }
예제 #17
0
        public async Task <SexoTransfer> Consultar(SexoTransfer sexoListaTransfer)
        {
            SexoService    sexoService;
            SexoTransfer   sexoLista;
            AutenticaModel autenticaModel;
            string         autorizacao;
            int            dif      = 0;
            int            qtdExibe = 5;

            try {
                sexoService    = new SexoService();
                autenticaModel = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                sexoLista = await sexoService.Consultar(sexoListaTransfer, autorizacao);

                if (sexoLista != null)
                {
                    if (sexoLista.Paginacao.TotalRegistros > 0)
                    {
                        if (sexoLista.Paginacao.RegistrosPorPagina < 1)
                        {
                            sexoLista.Paginacao.RegistrosPorPagina = 30;
                        }
                        else if (sexoLista.Paginacao.RegistrosPorPagina > 200)
                        {
                            sexoLista.Paginacao.RegistrosPorPagina = 30;
                        }

                        sexoLista.Paginacao.PaginaAtual  = (sexoLista.Paginacao.PaginaAtual < 1 ? 1 : sexoLista.Paginacao.PaginaAtual);
                        sexoLista.Paginacao.TotalPaginas =
                            Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(sexoLista.Paginacao.TotalRegistros)
                                                         / @Convert.ToDecimal(sexoLista.Paginacao.RegistrosPorPagina)));
                        sexoLista.Paginacao.TotalPaginas = (sexoLista.Paginacao.TotalPaginas < 1 ? 1 : sexoLista.Paginacao.TotalPaginas);

                        qtdExibe = (qtdExibe > sexoLista.Paginacao.TotalPaginas ? sexoLista.Paginacao.TotalPaginas : qtdExibe);

                        sexoLista.Paginacao.PaginaInicial = sexoLista.Paginacao.PaginaAtual - (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        sexoLista.Paginacao.PaginaFinal   = sexoLista.Paginacao.PaginaAtual + (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        sexoLista.Paginacao.PaginaFinal   = ((qtdExibe % 2) == 0 ? (sexoLista.Paginacao.PaginaFinal - 1) : sexoLista.Paginacao.PaginaFinal);

                        if (sexoLista.Paginacao.PaginaInicial < 1)
                        {
                            dif = 1 - sexoLista.Paginacao.PaginaInicial;
                            sexoLista.Paginacao.PaginaInicial += dif;
                            sexoLista.Paginacao.PaginaFinal   += dif;
                        }

                        if (sexoLista.Paginacao.PaginaFinal > sexoLista.Paginacao.TotalPaginas)
                        {
                            dif = sexoLista.Paginacao.PaginaFinal - sexoLista.Paginacao.TotalPaginas;
                            sexoLista.Paginacao.PaginaInicial -= dif;
                            sexoLista.Paginacao.PaginaFinal   -= dif;
                        }

                        sexoLista.Paginacao.PaginaInicial = (sexoLista.Paginacao.PaginaInicial < 1 ? 1 : sexoLista.Paginacao.PaginaInicial);
                        sexoLista.Paginacao.PaginaFinal   = (sexoLista.Paginacao.PaginaFinal > sexoLista.Paginacao.TotalPaginas ?
                                                             sexoLista.Paginacao.TotalPaginas : sexoLista.Paginacao.PaginaFinal);
                    }
                }
            } catch (Exception ex) {
                sexoLista = new SexoTransfer();

                sexoLista.Validacao = false;
                sexoLista.Erro      = true;
                sexoLista.IncluirMensagem("Erro em SexoModel Consultar [" + ex.Message + "]");
            } finally {
                sexoService    = null;
                autenticaModel = null;
            }

            return(sexoLista);
        }
예제 #18
0
        public async Task <EstadoCivilTransfer> Consultar(EstadoCivilTransfer estadoCivilListaTransfer)
        {
            EstadoCivilService  estadoCivilService;
            EstadoCivilTransfer estadoCivilLista;
            AutenticaModel      autenticaModel;
            string autorizacao;
            int    dif      = 0;
            int    qtdExibe = 5;

            try {
                estadoCivilService = new EstadoCivilService();
                autenticaModel     = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                estadoCivilLista = await estadoCivilService.Consultar(estadoCivilListaTransfer, autorizacao);

                if (estadoCivilLista != null)
                {
                    if (estadoCivilLista.Paginacao.TotalRegistros > 0)
                    {
                        if (estadoCivilLista.Paginacao.RegistrosPorPagina < 1)
                        {
                            estadoCivilLista.Paginacao.RegistrosPorPagina = 30;
                        }
                        else if (estadoCivilLista.Paginacao.RegistrosPorPagina > 200)
                        {
                            estadoCivilLista.Paginacao.RegistrosPorPagina = 30;
                        }

                        estadoCivilLista.Paginacao.PaginaAtual  = (estadoCivilLista.Paginacao.PaginaAtual < 1 ? 1 : estadoCivilLista.Paginacao.PaginaAtual);
                        estadoCivilLista.Paginacao.TotalPaginas =
                            Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(estadoCivilLista.Paginacao.TotalRegistros)
                                                         / @Convert.ToDecimal(estadoCivilLista.Paginacao.RegistrosPorPagina)));
                        estadoCivilLista.Paginacao.TotalPaginas = (estadoCivilLista.Paginacao.TotalPaginas < 1 ? 1 : estadoCivilLista.Paginacao.TotalPaginas);

                        qtdExibe = (qtdExibe > estadoCivilLista.Paginacao.TotalPaginas ? estadoCivilLista.Paginacao.TotalPaginas : qtdExibe);

                        estadoCivilLista.Paginacao.PaginaInicial = estadoCivilLista.Paginacao.PaginaAtual - (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        estadoCivilLista.Paginacao.PaginaFinal   = estadoCivilLista.Paginacao.PaginaAtual + (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        estadoCivilLista.Paginacao.PaginaFinal   = ((qtdExibe % 2) == 0 ? (estadoCivilLista.Paginacao.PaginaFinal - 1) : estadoCivilLista.Paginacao.PaginaFinal);

                        if (estadoCivilLista.Paginacao.PaginaInicial < 1)
                        {
                            dif = 1 - estadoCivilLista.Paginacao.PaginaInicial;
                            estadoCivilLista.Paginacao.PaginaInicial += dif;
                            estadoCivilLista.Paginacao.PaginaFinal   += dif;
                        }

                        if (estadoCivilLista.Paginacao.PaginaFinal > estadoCivilLista.Paginacao.TotalPaginas)
                        {
                            dif = estadoCivilLista.Paginacao.PaginaFinal - estadoCivilLista.Paginacao.TotalPaginas;
                            estadoCivilLista.Paginacao.PaginaInicial -= dif;
                            estadoCivilLista.Paginacao.PaginaFinal   -= dif;
                        }

                        estadoCivilLista.Paginacao.PaginaInicial = (estadoCivilLista.Paginacao.PaginaInicial < 1 ? 1 : estadoCivilLista.Paginacao.PaginaInicial);
                        estadoCivilLista.Paginacao.PaginaFinal   = (estadoCivilLista.Paginacao.PaginaFinal > estadoCivilLista.Paginacao.TotalPaginas ?
                                                                    estadoCivilLista.Paginacao.TotalPaginas : estadoCivilLista.Paginacao.PaginaFinal);
                    }
                }
            } catch (Exception ex) {
                estadoCivilLista = new EstadoCivilTransfer();

                estadoCivilLista.Validacao = false;
                estadoCivilLista.Erro      = true;
                estadoCivilLista.IncluirMensagem("Erro em EstadoCivilModel Consultar [" + ex.Message + "]");
            } finally {
                estadoCivilService = null;
                autenticaModel     = null;
            }

            return(estadoCivilLista);
        }