Esempio n. 1
0
        /// <summary>
        /// Obtém uma movimentação de caixa pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <MovimentoCaixaDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string           mensagemErro = "";
            MovimentoCaixaVo movimentoCaixaVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out movimentoCaixaVo, ref mensagemErro, true))
            {
                retornoDto.Mensagem = "Erro ao obter o movimentoCaixa: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterMovimentoCaixa, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            MovimentoCaixaDto movimentoCaixaDto = new MovimentoCaixaDto();

            if (!ConverterVoParaDto(movimentoCaixaVo, ref movimentoCaixaDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter a movimentação de caixa: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterMovimentoCaixa, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            retornoDto.Entidade = movimentoCaixaDto;
            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Esempio n. 2
0
        /// <summary>
        /// Obtém uma conta pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <ContaPagarDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string       mensagemErro = "";
            ContaPagarVo contaPagarVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out contaPagarVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter a conta: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterContaPagar, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            ContaPagarDto contaPagarDto = new ContaPagarDto();

            if (!ConverterVoParaDto(contaPagarVo, ref contaPagarDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter a conta: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterContaPagar, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            if (contaPagarDto.IdFornecedor != null && contaPagarDto.IdFornecedor != Guid.Empty)
            {
                requisicaoDto.Id = contaPagarDto.IdFornecedor.Value;
                RetornoObterDto <FornecedorDto> retornoFornecedorDto = new RetornoObterDto <FornecedorDto>();

                FornecedorBll fornecedorBll = new FornecedorBll(pizzaByteContexto, false);
                if (!fornecedorBll.Obter(requisicaoDto, ref retornoFornecedorDto))
                {
                    retornoDto.Mensagem = retornoFornecedorDto.Mensagem;
                    retornoDto.Retorno  = false;

                    return(false);
                }

                if (retornoFornecedorDto.Mensagem == "Erro ao obter o fornecedor: Cadastro não encontrado")
                {
                    contaPagarDto.NomeFornecedor = "Cadastro não encontro";
                }
                else
                {
                    contaPagarDto.NomeFornecedor = retornoFornecedorDto.Entidade.NomeFantasia + " (CNPJ: " + UtilitarioBll.RetornarCnpjFormatado(retornoFornecedorDto.Entidade.Cnpj) + ")";
                }
            }


            retornoDto.Entidade = contaPagarDto;
            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Esempio n. 3
0
        /// <summary>
        /// Obtém um funcionario pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <FuncionarioDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string        mensagemErro = "";
            FuncionarioVo funcionarioVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out funcionarioVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter o funcionario: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterFuncionario, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            FuncionarioDto funcionarioDto = new FuncionarioDto();

            if (!ConverterVoParaDto(funcionarioVo, ref funcionarioDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter o funcionario: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterFuncionario, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            retornoDto.Entidade = funcionarioDto;
            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Esempio n. 4
0
        /// <summary>
        /// Obtém um cep pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <CepDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string mensagemErro = "";
            CepVo  cepVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out cepVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter o cep: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCep, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            CepDto cepDto = new CepDto();

            if (!ConverterVoParaDto(cepVo, ref cepDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter o cep: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCep, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            retornoDto.Entidade = cepDto;
            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Esempio n. 5
0
        /// <summary>
        /// Obtem um cep e converte em Model
        /// </summary>
        /// <param name="id"></param>
        /// <param name="model"></param>
        /// <param name="mensagemErro"></param>
        /// <returns></returns>
        private bool ObterCep(Guid id, ref CepModel model, ref string mensagemErro)
        {
            //Preparar a requisição e o retorno
            RetornoObterDto <CepDto> retorno       = new RetornoObterDto <CepDto>();
            RequisicaoObterDto       requisicaoDto = new RequisicaoObterDto()
            {
                Id            = id,
                Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
                IdUsuario     = SessaoUsuario.SessaoLogin.IdUsuario
            };

            //Consumir o serviço
            CepBll cepBll = new CepBll(true);

            cepBll.Obter(requisicaoDto, ref retorno);

            //Tratar o retorno
            if (retorno.Retorno == false)
            {
                mensagemErro = retorno.Mensagem;
                return(false);
            }
            else
            {
                //Converter para Model
                return(model.ConverterDtoParaModel(retorno.Entidade, ref mensagemErro));
            }
        }
        /// <summary>
        /// Obtem um endereço por id
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public string Obter(Guid id)
        {
            //Preparar a requisição e o retorno
            RetornoObterDto <ClienteEnderecoDto> retornoDto = new RetornoObterDto <ClienteEnderecoDto>();

            if (id == Guid.Empty)
            {
                retornoDto.Mensagem = "O id do endereço é obrigatório para obter o endereço.";
                retornoDto.Retorno  = false;
            }
            else
            {
                RequisicaoObterDto requisicaoDto = new RequisicaoObterDto()
                {
                    Id            = id,
                    Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
                    IdUsuario     = SessaoUsuario.SessaoLogin.IdUsuario
                };

                //Consumir o serviço
                ClienteEnderecoBll clienteBll = new ClienteEnderecoBll(true);
                clienteBll.Obter(requisicaoDto, ref retornoDto);
            }

            string retorno = new JavaScriptSerializer().Serialize(retornoDto);

            return(retorno);
        }
Esempio n. 7
0
        /// <summary>
        /// Obtém um suporte pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <SuporteDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string    mensagemErro = "";
            SuporteVo suporteVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out suporteVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter o suporte: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterSuporte, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            SuporteDto suporteDto = new SuporteDto();

            if (!ConverterVoParaDto(suporteVo, ref suporteDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter o suporte: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterSuporte, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            retornoDto.Entidade = suporteDto;
            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Esempio n. 8
0
 /// <summary>
 /// Obtém um pedidoItem pelo ID
 /// </summary>
 /// <param name="requisicaoDto"></param>
 /// <param name="retornoDto"></param>
 /// <returns></returns>
 public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <PedidoItemDto> retornoDto)
 {
     retornoDto.Retorno  = false;
     retornoDto.Mensagem = "Método não implementado para esta entidade";
     logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterPedidoItem, Guid.Empty, retornoDto.Mensagem);
     return(false);
 }
Esempio n. 9
0
        public void CrudUsuario()
        {
            RequisicaoEntidadeDto <UsuarioDto> requisicaoDto = new RequisicaoEntidadeDto <UsuarioDto>()
            {
                EntidadeDto = RetornarNovoUsuario()
            };

            string senhaCrip = "";

            UtilitarioBll.CriptografarSenha(requisicaoDto.EntidadeDto.Senha, ref senhaCrip);

            requisicaoDto.EntidadeDto.Senha = senhaCrip;

            Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
            UsuarioBll usuarioBll = new UsuarioBll(true);

            // Incluir
            RetornoDto retornoDto = new RetornoDto();

            usuarioBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Editar
            requisicaoDto.EntidadeDto.Nome = "Usuario atualizado " + DateTime.Now;
            usuarioBll.Editar(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Obter
            RetornoObterDto <UsuarioDto> retornoObterDto    = new RetornoObterDto <UsuarioDto>();
            RequisicaoObterDto           requisicaoObterDto = new RequisicaoObterDto()
            {
                Id            = requisicaoDto.EntidadeDto.Id,
                IdUsuario     = requisicaoDto.IdUsuario,
                Identificacao = requisicaoDto.Identificacao
            };

            usuarioBll.Obter(requisicaoObterDto, ref retornoObterDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Obter lista
            RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
            {
                CampoOrdem           = "NOME",
                IdUsuario            = requisicaoDto.IdUsuario,
                Identificacao        = requisicaoDto.Identificacao,
                NumeroItensPorPagina = 2,
                Pagina = 1
            };

            RetornoObterListaDto <UsuarioDto> retornoObterListaDto = new RetornoObterListaDto <UsuarioDto>();

            usuarioBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Excluir
            usuarioBll.Excluir(requisicaoObterDto, ref retornoDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);
        }
Esempio n. 10
0
        /// <summary>
        /// Obtém um fornecedor pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <FornecedorDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string       mensagemErro = "";
            FornecedorVo fornecedorVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out fornecedorVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter o fornecedor: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterFornecedor, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            FornecedorDto fornecedorDto = new FornecedorDto();

            if (!ConverterVoParaDto(fornecedorVo, ref fornecedorDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter o fornecedor: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterFornecedor, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            if (fornecedorDto.Endereco.Id != Guid.Empty)
            {
                RequisicaoObterDto requisicaoObterCep = new RequisicaoObterDto()
                {
                    Id            = fornecedorDto.Endereco.Id,
                    IdUsuario     = requisicaoDto.IdUsuario,
                    Identificacao = requisicaoDto.Identificacao
                };

                RetornoObterDto <CepDto> retornoCepDto = new RetornoObterDto <CepDto>();
                CepBll cepBll = new CepBll(true);

                if (!cepBll.Obter(requisicaoObterCep, ref retornoCepDto))
                {
                    retornoDto.Mensagem = "Erro ao obter o endereço: " + mensagemErro;
                    retornoDto.Retorno  = false;
                    return(false);
                }

                fornecedorDto.Endereco = (retornoCepDto.Entidade == null ? new CepDto() : retornoCepDto.Entidade);
            }

            retornoDto.Entidade = fornecedorDto;
            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "Ok";
            return(true);
        }
Esempio n. 11
0
        /// <summary>
        /// Obtém um endereço de cliente pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <ClienteEnderecoDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string mensagemErro = ""; ClienteEnderecoVo clienteEnderecoVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out clienteEnderecoVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter o endereço do cliente: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterClienteEndereco, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            ClienteEnderecoDto clienteEnderecoDto = new ClienteEnderecoDto();

            if (!ConverterVoParaDto(clienteEnderecoVo, ref clienteEnderecoDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter o endereço do cliente: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterClienteEndereco, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            if (clienteEnderecoDto.IdCep != Guid.Empty)
            {
                RequisicaoObterDto requisicaoObterCep = new RequisicaoObterDto()
                {
                    Id            = clienteEnderecoDto.IdCep,
                    IdUsuario     = requisicaoDto.IdUsuario,
                    Identificacao = requisicaoDto.Identificacao
                };

                RetornoObterDto <CepDto> retornoCepDto = new RetornoObterDto <CepDto>();
                CepBll cepBll = new CepBll(true);

                if (!cepBll.Obter(requisicaoObterCep, ref retornoCepDto))
                {
                    retornoDto.Mensagem = $"Erro ao obter o endereço: {retornoCepDto.Mensagem}";
                    retornoDto.Retorno  = false;
                    return(false);
                }

                clienteEnderecoDto.Endereco = (retornoCepDto.Entidade == null ? new CepDto() : retornoCepDto.Entidade);
            }

            retornoDto.Entidade = clienteEnderecoDto;
            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Esempio n. 12
0
        public void CrudClienteComErro()
        {
            RequisicaoEntidadeDto <ClienteDto> requisicaoDto = new RequisicaoEntidadeDto <ClienteDto>()
            {
                EntidadeDto = RetornarNovoCliente()
            };

            Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
            ClienteBll clienteBll = new ClienteBll(true);

            // Incluir
            requisicaoDto.EntidadeDto.Nome = "";
            RetornoDto retornoDto = new RetornoDto();

            clienteBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(false, retornoDto.Retorno);
            Assert.AreEqual("O nome do cliente é obrigatório! Por favor, informe o nome do cliente " +
                            "no campo indicado para continuar. ", retornoDto.Mensagem);

            requisicaoDto.EntidadeDto.Nome = "Te";
            retornoDto = new RetornoDto();
            clienteBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(false, retornoDto.Retorno);
            Assert.AreEqual("O nome do cliente deve ter, ao menos, 3 caracteres! Por favor, informe um nome " +
                            "válido para continuar. ", retornoDto.Mensagem);

            requisicaoDto.EntidadeDto.Nome = "Testes";
            retornoDto = new RetornoDto();
            clienteBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Editar
            requisicaoDto.EntidadeDto.Nome = "";
            clienteBll.Editar(requisicaoDto, ref retornoDto);
            Assert.AreEqual(false, retornoDto.Retorno);
            Assert.AreEqual("O nome do cliente é obrigatório! Por favor, informe o nome do cliente " +
                            "no campo indicado para continuar. ", retornoDto.Mensagem);

            // Obter
            RetornoObterDto <ClienteDto> retornoObterDto    = new RetornoObterDto <ClienteDto>();
            RequisicaoObterDto           requisicaoObterDto = new RequisicaoObterDto()
            {
                Id            = Guid.Empty,
                IdUsuario     = requisicaoDto.IdUsuario,
                Identificacao = requisicaoDto.Identificacao
            };

            clienteBll.Obter(requisicaoObterDto, ref retornoObterDto);
            Assert.AreEqual(false, retornoObterDto.Retorno);

            // Excluir
            clienteBll.Excluir(requisicaoObterDto, ref retornoDto);
            Assert.AreEqual(false, retornoObterDto.Retorno);
        }
Esempio n. 13
0
        public void CrudFornecedor()
        {
            RequisicaoEntidadeDto <FornecedorDto> requisicaoDto = new RequisicaoEntidadeDto <FornecedorDto>()
            {
                EntidadeDto = RetornarNovoFornecedor()
            };

            Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
            FornecedorBll fornecedorBll = new FornecedorBll(true);

            // Incluir
            RetornoDto retornoDto = new RetornoDto();

            fornecedorBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Editar
            requisicaoDto.EntidadeDto.NomeFantasia = "Fornecedor atualizado " + DateTime.Now;
            fornecedorBll.Editar(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Obter
            RetornoObterDto <FornecedorDto> retornoObterDto = new RetornoObterDto <FornecedorDto>();
            RequisicaoObterDto requisicaoObterDto           = new RequisicaoObterDto()
            {
                Id            = requisicaoDto.EntidadeDto.Id,
                IdUsuario     = requisicaoDto.IdUsuario,
                Identificacao = requisicaoDto.Identificacao
            };

            fornecedorBll.Obter(requisicaoObterDto, ref retornoObterDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Obter lista
            RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
            {
                CampoOrdem           = "NOMEFANTASIA",
                IdUsuario            = requisicaoDto.IdUsuario,
                Identificacao        = requisicaoDto.Identificacao,
                NumeroItensPorPagina = 2,
                Pagina = 1
            };

            RetornoObterListaDto <FornecedorDto> retornoObterListaDto = new RetornoObterListaDto <FornecedorDto>();

            fornecedorBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Excluir
            fornecedorBll.Excluir(requisicaoObterDto, ref retornoDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);
        }
Esempio n. 14
0
        public void CrudMovimentoCaixa()
        {
            RequisicaoEntidadeDto <MovimentoCaixaDto> requisicaoDto = new RequisicaoEntidadeDto <MovimentoCaixaDto>()
            {
                EntidadeDto = RetornarNovoMovimentoCaixa()
            };

            Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
            MovimentoCaixaBll movimentoCaixaBll = new MovimentoCaixaBll(true);

            // Incluir
            RetornoDto retornoDto = new RetornoDto();

            movimentoCaixaBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Editar
            requisicaoDto.EntidadeDto.Justificativa = "Teste atualizado " + DateTime.Now;
            movimentoCaixaBll.Editar(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Obter
            RetornoObterDto <MovimentoCaixaDto> retornoObterDto = new RetornoObterDto <MovimentoCaixaDto>();
            RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
            {
                Id            = requisicaoDto.EntidadeDto.Id,
                IdUsuario     = requisicaoDto.IdUsuario,
                Identificacao = requisicaoDto.Identificacao
            };

            movimentoCaixaBll.Obter(requisicaoObterDto, ref retornoObterDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Obter lista
            RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
            {
                CampoOrdem           = "JUSTIFICATIVA",
                IdUsuario            = requisicaoDto.IdUsuario,
                Identificacao        = requisicaoDto.Identificacao,
                NumeroItensPorPagina = 2,
                Pagina = 1
            };

            RetornoObterListaDto <MovimentoCaixaDto> retornoObterListaDto = new RetornoObterListaDto <MovimentoCaixaDto>();

            movimentoCaixaBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Excluir
            movimentoCaixaBll.Excluir(requisicaoObterDto, ref retornoDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);
        }
Esempio n. 15
0
        public void CrudTaxaEntrega()
        {
            RequisicaoEntidadeDto <TaxaEntregaDto> requisicaoDto = new RequisicaoEntidadeDto <TaxaEntregaDto>()
            {
                EntidadeDto = RetornarNovoTaxaEntrega()
            };

            Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
            TaxaEntregaBll taxaEntregaBll = new TaxaEntregaBll(true);

            // Incluir
            RetornoDto retornoDto = new RetornoDto();

            taxaEntregaBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Editar
            requisicaoDto.EntidadeDto.BairroCidade = "Outro bairro";
            taxaEntregaBll.Editar(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Obter
            RetornoObterDto <TaxaEntregaDto> retornoObterDto = new RetornoObterDto <TaxaEntregaDto>();
            RequisicaoObterDto requisicaoObterDto            = new RequisicaoObterDto()
            {
                Id            = requisicaoDto.EntidadeDto.Id,
                IdUsuario     = requisicaoDto.IdUsuario,
                Identificacao = requisicaoDto.Identificacao
            };

            taxaEntregaBll.Obter(requisicaoObterDto, ref retornoObterDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Obter lista
            RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
            {
                CampoOrdem           = "BAIRRO",
                IdUsuario            = requisicaoDto.IdUsuario,
                Identificacao        = requisicaoDto.Identificacao,
                NumeroItensPorPagina = 2,
                Pagina = 1
            };

            RetornoObterListaDto <TaxaEntregaDto> retornoObterListaDto = new RetornoObterListaDto <TaxaEntregaDto>();

            taxaEntregaBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Excluir
            taxaEntregaBll.Excluir(requisicaoObterDto, ref retornoDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);
        }
Esempio n. 16
0
        public void CrudProduto()
        {
            RequisicaoEntidadeDto <ProdutoDto> requisicaoDto = new RequisicaoEntidadeDto <ProdutoDto>()
            {
                EntidadeDto = RetornarNovoProduto()
            };

            Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
            ProdutoBll produtoBll = new ProdutoBll(true);

            // Incluir
            RetornoDto retornoDto = new RetornoDto();

            produtoBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Editar
            requisicaoDto.EntidadeDto.Descricao = "Produto atualizado " + DateTime.Now;
            produtoBll.Editar(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Obter
            RetornoObterDto <ProdutoDto> retornoObterDto    = new RetornoObterDto <ProdutoDto>();
            RequisicaoObterDto           requisicaoObterDto = new RequisicaoObterDto()
            {
                Id            = requisicaoDto.EntidadeDto.Id,
                IdUsuario     = requisicaoDto.IdUsuario,
                Identificacao = requisicaoDto.Identificacao
            };

            produtoBll.Obter(requisicaoObterDto, ref retornoObterDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Obter lista
            RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
            {
                CampoOrdem           = "DESCRICAO",
                IdUsuario            = requisicaoDto.IdUsuario,
                Identificacao        = requisicaoDto.Identificacao,
                NumeroItensPorPagina = 2,
                Pagina = 1
            };

            RetornoObterListaDto <ProdutoDto> retornoObterListaDto = new RetornoObterListaDto <ProdutoDto>();

            produtoBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Excluir
            produtoBll.Excluir(requisicaoObterDto, ref retornoDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);
        }
Esempio n. 17
0
        public string ObterPorCep(string cep)
        {
            RequisicaoObterCepPorCepDto requisicaoDto = new RequisicaoObterCepPorCepDto()
            {
                Cep           = cep,
                IdUsuario     = SessaoUsuario.SessaoLogin.IdUsuario,
                Identificacao = SessaoUsuario.SessaoLogin.Identificacao
            };

            CepBll cepBll = new CepBll(true);
            RetornoObterDto <CepDto> retornoDto = new RetornoObterDto <CepDto>();

            cepBll.ObterPorCep(requisicaoDto, ref retornoDto);

            // Se não encontrar nada no banco, pesquisar online
            if (retornoDto.Entidade == null)
            {
                HttpClient client = new HttpClient()
                {
                    BaseAddress = new Uri("https://viacep.com.br/ws/")
                };

                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                HttpResponseMessage response = client.GetAsync($"{cep}/json").Result;

                if (response.IsSuccessStatusCode)
                {
                    try
                    {
                        retornoDto.Entidade = response.Content.ReadAsAsync <CepDto>().Result;
                        if (string.IsNullOrWhiteSpace(retornoDto.Entidade.Logradouro))
                        {
                            retornoDto.Entidade = null;
                        }
                        else
                        {
                            // Compatibilizar os campos
                            retornoDto.Entidade.Cidade = retornoDto.Entidade.Localidade;
                        }
                    }
                    catch (Exception)
                    {
                        retornoDto.Entidade = null;
                    }
                }
            }

            string retorno = new JavaScriptSerializer().Serialize(retornoDto);

            return(retorno);
        }
Esempio n. 18
0
        /// <summary>
        /// Obtém uma entrega pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <PedidoEntregaDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string          mensagemErro = "";
            PedidoEntregaVo pedidoEntregaVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out pedidoEntregaVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter a entrega: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterPedidoEntrega, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            // Converter para DTO
            PedidoEntregaDto pedidoEntregaDto = new PedidoEntregaDto();

            if (!ConverterVoParaDto(pedidoEntregaVo, ref pedidoEntregaDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter a entrega: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterPedidoEntrega, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            // Obter o endereço de entrega
            ClienteEnderecoBll clienteEnderecoBll = new ClienteEnderecoBll(pizzaByteContexto, false);

            requisicaoDto.Id = pedidoEntregaDto.IdEndereco;

            RetornoObterDto <ClienteEnderecoDto> retornoEnderecoDto = new RetornoObterDto <ClienteEnderecoDto>();

            if (!clienteEnderecoBll.Obter(requisicaoDto, ref retornoEnderecoDto))
            {
                retornoDto.Mensagem = "Erro ao obter o endereço: " + retornoEnderecoDto.Mensagem;
                retornoDto.Retorno  = false;
            }

            pedidoEntregaDto.ClienteEndereco = retornoEnderecoDto.Entidade;

            retornoDto.Entidade = pedidoEntregaDto;
            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "Ok";
            return(true);
        }
Esempio n. 19
0
        /// <summary>
        /// Obtém um usuário pelo ID (não traz a senha no objeto)
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <UsuarioDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string mensagemErro = "";

            if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = "Este usuário não é administrador. Para consultar os usuários é necessário " +
                                      $"logar com um usuário administrador. {mensagemErro}";

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterUsuario, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            UsuarioVo usuarioVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out usuarioVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter o usuario: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterUsuario, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            UsuarioDto usuarioDto = new UsuarioDto();

            if (!ConverterVoParaDto(usuarioVo, ref usuarioDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter o usuário: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterUsuario, usuarioVo.Id, retornoDto.Mensagem);
                return(false);
            }

            retornoDto.Entidade       = usuarioDto;
            retornoDto.Entidade.Senha = "";
            retornoDto.Mensagem       = "Ok";
            retornoDto.Retorno        = true;
            return(true);
        }
Esempio n. 20
0
        public void CrudSuporte()
        {
            RequisicaoEntidadeDto <SuporteDto> requisicaoDto = new RequisicaoEntidadeDto <SuporteDto>()
            {
                EntidadeDto = RetornarNovoSuporte()
            };

            Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
            SuporteBll suporteBll = new SuporteBll(true);

            // Incluir
            RetornoDto retornoDto = new RetornoDto();

            suporteBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Obter
            RetornoObterDto <SuporteDto> retornoObterDto    = new RetornoObterDto <SuporteDto>();
            RequisicaoObterDto           requisicaoObterDto = new RequisicaoObterDto()
            {
                Id            = requisicaoDto.EntidadeDto.Id,
                IdUsuario     = requisicaoDto.IdUsuario,
                Identificacao = requisicaoDto.Identificacao
            };

            suporteBll.Obter(requisicaoObterDto, ref retornoObterDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Obter lista
            RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
            {
                CampoOrdem           = "DATADECRESCENTE",
                IdUsuario            = requisicaoDto.IdUsuario,
                Identificacao        = requisicaoDto.Identificacao,
                NumeroItensPorPagina = 2,
                Pagina = 1
            };

            RetornoObterListaDto <SuporteDto> retornoObterListaDto = new RetornoObterListaDto <SuporteDto>();

            suporteBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Excluir
            suporteBll.Excluir(requisicaoObterDto, ref retornoDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);
        }
Esempio n. 21
0
        /// <summary>
        /// Obtém um taxaEntrega pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <TaxaEntregaDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string        mensagemErro = "";
            TaxaEntregaVo taxaEntregaVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out taxaEntregaVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter a taxa de entrega: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterTaxaEntrega, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            TaxaEntregaDto taxaEntregaDto = new TaxaEntregaDto();

            if (!ConverterVoParaDto(taxaEntregaVo, ref taxaEntregaDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter a taxa de entrega: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterTaxaEntrega, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            CepBll cepBll = new CepBll(false);
            string cidade = "";

            if (!cepBll.ObterCidadePorBairro(requisicaoDto, taxaEntregaDto.BairroCidade, ref cidade, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter a cidade que a taxa se refere: " + mensagemErro;
                retornoDto.Retorno  = false;
            }

            taxaEntregaDto.Cidade = cidade;
            retornoDto.Entidade   = taxaEntregaDto;

            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Esempio n. 22
0
        /// <summary>
        /// Obtem uma entrega por ID do pedido
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="entregaDto"></param>
        /// <param name="mensagemErro"></param>
        /// <returns></returns>
        internal bool ObterEntregaPorIdPedido(RequisicaoObterDto requisicaoDto, ref PedidoEntregaDto entregaDto, ref string mensagemErro)
        {
            if (requisicaoDto.Id == Guid.Empty || requisicaoDto.Id == null)
            {
                mensagemErro = "Preencha o id do pedido para obter a sua entrega.";
                return(false);
            }

            // Obter a query primária
            IQueryable <PedidoEntregaVo> query;

            if (!this.ObterQueryBd(out query, ref mensagemErro))
            {
                mensagemErro = $"Houve um problema ao obter a entrega: {mensagemErro}";
                return(false);
            }

            PedidoEntregaVo entregaVo = query.Where(p => p.IdPedido == requisicaoDto.Id).FirstOrDefault();

            if (entregaVo != null)
            {
                if (!ConverterVoParaDto(entregaVo, ref entregaDto, ref mensagemErro))
                {
                    return(false);
                }

                // Obter o endereço
                RetornoObterDto <ClienteEnderecoDto> retornoDto = new RetornoObterDto <ClienteEnderecoDto>();
                ClienteEnderecoBll clienteEnderecoBll           = new ClienteEnderecoBll(pizzaByteContexto, false);

                requisicaoDto.Id = entregaDto.IdEndereco;
                if (!clienteEnderecoBll.Obter(requisicaoDto, ref retornoDto))
                {
                    mensagemErro = retornoDto.Mensagem;
                    return(false);
                }

                entregaDto.ClienteEndereco = retornoDto.Entidade;
                return(true);
            }
            else
            {
                mensagemErro = "Entrega não encontrada";
                return(false);
            }
        }
Esempio n. 23
0
        public void CrudPedidoSimples()
        {
            RequisicaoEntidadeDto <PedidoDto> requisicaoDto = new RequisicaoEntidadeDto <PedidoDto>()
            {
                EntidadeDto = RetornarNovoPedidoSimples()
            };

            Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
            PedidoBll pedidoBll = new PedidoBll(true);

            // Incluir pedido
            RetornoDto retornoDto = new RetornoDto();

            pedidoBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            RetornoObterDto <PedidoDto> retornoObterDto    = new RetornoObterDto <PedidoDto>();
            RequisicaoObterDto          requisicaoObterDto = new RequisicaoObterDto()
            {
                Id            = requisicaoDto.EntidadeDto.Id,
                IdUsuario     = requisicaoDto.IdUsuario,
                Identificacao = requisicaoDto.Identificacao
            };

            // Obter pedido
            pedidoBll.Obter(requisicaoObterDto, ref retornoObterDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            requisicaoDto.EntidadeDto = retornoObterDto.Entidade;
            requisicaoDto.EntidadeDto.ListaItens[0].PrecoProduto = 28;
            requisicaoDto.EntidadeDto.ListaItens.RemoveAt(1);
            requisicaoDto.EntidadeDto.Total            = 28;
            requisicaoDto.EntidadeDto.RecebidoDebito   = 28;
            requisicaoDto.EntidadeDto.RecebidoDinheiro = 0;

            // Editar pedido
            retornoDto = new RetornoDto();
            pedidoBll.Editar(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Excluir pedido
            retornoDto = new RetornoDto();
            pedidoBll.Excluir(requisicaoObterDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);
        }
Esempio n. 24
0
        /// <summary>
        /// Obtém um produto pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <ProdutoDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            if (requisicaoDto.Id == UtilitarioBll.RetornaIdProdutoPromocao())
            {
                retornoDto.Mensagem = "Erro ao obter o produto: Cadastro não encontrado";
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterProduto, requisicaoDto.Id, retornoDto.Mensagem + " (Produto promoção)");
                return(false);
            }

            string    mensagemErro = "";
            ProdutoVo produtoVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out produtoVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter o produto: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterProduto, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            ProdutoDto produtoDto = new ProdutoDto();

            if (!ConverterVoParaDto(produtoVo, ref produtoDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter o produto: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterProduto, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            retornoDto.Entidade = produtoDto;
            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Esempio n. 25
0
        /// <summary>
        /// Obtem a taxa de entrega de um bairro
        /// </summary>
        /// <param name="bairro"></param>
        /// <returns></returns>
        public string ObterTaxaPorBairro(string bairroCidade)
        {
            RequisicaoObterTaxaPorBairroDto requisicaoDto = new RequisicaoObterTaxaPorBairroDto()
            {
                IdUsuario     = SessaoUsuario.SessaoLogin.IdUsuario,
                Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
                BairroCidade  = bairroCidade
            };

            // Consumir o serviço
            RetornoObterDto <TaxaEntregaDto> retornoDto = new RetornoObterDto <TaxaEntregaDto>();
            TaxaEntregaBll taxaEntregaBll = new TaxaEntregaBll(true);

            taxaEntregaBll.ObterTaxaPorBairro(requisicaoDto, ref retornoDto);

            string retorno = new JavaScriptSerializer().Serialize(retornoDto);

            return(retorno);
        }
Esempio n. 26
0
        /// <summary>
        /// Obtem uma listra filtrada de pedidos
        /// </summary>
        /// <param name="filtros"></param>
        /// <returns></returns>
        public string ObterPedidoResumido(Guid idPedido)
        {
            //Requisição para obter
            RequisicaoObterDto requisicaoDto = new RequisicaoObterDto()
            {
                IdUsuario     = SessaoUsuario.SessaoLogin.IdUsuario,
                Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
                Id            = idPedido
            };

            //Consumir o serviço
            PedidoBll pedidoBll = new PedidoBll(true);
            RetornoObterDto <PedidoResumidoDto> retornoDto = new RetornoObterDto <PedidoResumidoDto>();

            pedidoBll.ObterPedidoResumido(requisicaoDto, ref retornoDto);

            string retorno = new JavaScriptSerializer().Serialize(retornoDto);

            return(retorno);
        }
Esempio n. 27
0
        /// <summary>
        /// Obtém os detalhes do pedido de uma entrega
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public bool ObterPedidoResumido(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <PedidoResumidoDto> retornoDto)
        {
            string mensagemErro = "";

            if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = mensagemErro;
                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterPedidoResumido, requisicaoDto.Id, mensagemErro);
                return(false);
            }

            PedidoVo pedidoVo;

            if (!ObterPorIdBd(requisicaoDto.Id, out pedidoVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao obter o pedido: " + mensagemErro;
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterPedido, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            retornoDto.Entidade = new PedidoResumidoDto()
            {
                PedidoIfood      = pedidoVo.PedidoIfood,
                RecebidoCredito  = pedidoVo.RecebidoCredito,
                RecebidoDebito   = pedidoVo.RecebidoDebito,
                RecebidoDinheiro = pedidoVo.RecebidoDinheiro,
                TaxaEntrega      = pedidoVo.TaxaEntrega,
                Troco            = pedidoVo.Troco,
                Total            = pedidoVo.Total,
                Tipo             = pedidoVo.Tipo,
                Id = pedidoVo.Id
            };

            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Esempio n. 28
0
        /// <summary>
        /// Obtém uma entidade do banco de dados
        /// </summary>
        /// <param name="BaseRequisicaoDto"></param>
        /// <param name="retornoDto"></param>
        public virtual bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <Y> retornoDto)
        {
            string mensagemErro = "";

            if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = mensagemErro;
                logBll.ResgistrarLog(requisicaoDto, LogRecursos.BaseObter, requisicaoDto.Id, mensagemErro);
                return(false);
            }

            if (requisicaoDto.Id == Guid.Empty)
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = "O id é obrigatório para obter uma entidade.";
                logBll.ResgistrarLog(requisicaoDto, LogRecursos.BaseObter, requisicaoDto.Id, mensagemErro);
                return(false);
            }

            return(true);
        }
Esempio n. 29
0
        public void CrudCliente()
        {
            RequisicaoEntidadeDto <ClienteDto> requisicaoDto = new RequisicaoEntidadeDto <ClienteDto>()
            {
                EntidadeDto = RetornarNovoCliente()
            };

            Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
            ClienteBll clienteBll = new ClienteBll(true);

            // Incluir
            RetornoDto retornoDto = new RetornoDto();

            clienteBll.Incluir(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Editar
            requisicaoDto.EntidadeDto.Nome = "Cliente atualizado " + DateTime.Now;
            clienteBll.Editar(requisicaoDto, ref retornoDto);
            Assert.AreEqual(true, retornoDto.Retorno);

            // Obter
            RetornoObterDto <ClienteDto> retornoObterDto    = new RetornoObterDto <ClienteDto>();
            RequisicaoObterDto           requisicaoObterDto = new RequisicaoObterDto()
            {
                Id            = requisicaoDto.EntidadeDto.Id,
                IdUsuario     = requisicaoDto.IdUsuario,
                Identificacao = requisicaoDto.Identificacao
            };

            clienteBll.Obter(requisicaoObterDto, ref retornoObterDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);

            // Excluir
            clienteBll.Excluir(requisicaoObterDto, ref retornoDto);
            Assert.AreEqual(true, retornoObterDto.Retorno);
        }
Esempio n. 30
0
        /// <summary>
        /// Obtem o endereço pelo CEP
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public bool ObterPorCep(RequisicaoObterCepPorCepDto requisicaoDto, ref RetornoObterDto <CepDto> retornoDto)
        {
            string mensagemErro = "";

            if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
            {
                retornoDto.Mensagem = mensagemErro;
                return(false);
            }

            if (string.IsNullOrWhiteSpace(requisicaoDto.Cep))
            {
                retornoDto.Mensagem = $"Informe um CEP para obter o endereço";
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCepPorCep, Guid.Empty, retornoDto.Mensagem);
                return(false);
            }

            // Obter a query primária
            IQueryable <CepVo> query;

            if (!this.ObterQueryBd(out query, ref mensagemErro))
            {
                retornoDto.Mensagem = $"Houve um problema ao listar os CEPs: {mensagemErro}";
                retornoDto.Retorno  = false;

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCepPorCep, Guid.Empty, retornoDto.Mensagem);
                return(false);
            }

            requisicaoDto.Cep = requisicaoDto.Cep.Replace("-", "");
            query             = query.Where(p => p.Cep == requisicaoDto.Cep.Trim());
            CepVo cepVo = query.FirstOrDefault();

            if (cepVo == null)
            {
                retornoDto.Retorno  = true;
                retornoDto.Mensagem = "CEP não encontrado";
                retornoDto.Entidade = null;

                return(true);
            }
            else
            {
                CepDto cepDto = new CepDto();
                if (!ConverterVoParaDto(cepVo, ref cepDto, ref mensagemErro))
                {
                    retornoDto.Retorno  = false;
                    retornoDto.Mensagem = $"Erro ao converter o CEP para DTO: {mensagemErro}";

                    logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCepPorCep, Guid.Empty, retornoDto.Mensagem);
                    return(false);
                }

                retornoDto.Retorno  = true;
                retornoDto.Mensagem = "Ok";
                retornoDto.Entidade = cepDto;

                return(true);
            }
        }