Example #1
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);
        }
Example #2
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);
            }
        }
Example #3
0
        /// <summary>
        /// Exclui um cliente do banco de dados a partir do ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Excluir(RequisicaoObterDto requisicaoDto, ref RetornoDto retornoDto)
        {
            if (!base.Excluir(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 excluir clientes é necessário " +
                                      $"logar com um usuário administrador. {mensagemErro}";

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

            // Excluir os endereços
            ClienteEnderecoBll clienteEnderecoBll = new ClienteEnderecoBll(pizzaByteContexto, false);

            if (!clienteEnderecoBll.ExcluirPorIdCliente(requisicaoDto, ref retornoDto))
            {
                retornoDto.Retorno = false;
                return(false);
            }

            if (salvar)
            {
                // Salva as alterações
                if (!pizzaByteContexto.Salvar(ref mensagemErro))
                {
                    retornoDto.Retorno  = false;
                    retornoDto.Mensagem = mensagemErro;

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

            logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirCliente, requisicaoDto.Id, "Cliente excluído.");
            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Example #4
0
        /// <summary>
        /// Atualiza ou incluir dados de clientes, endereços e taxas
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        private bool AtualizarCadastros(RequisicaoEntidadeDto <PedidoDto> requisicaoDto, ref RetornoDto retornoDto)
        {
            string mensagemErro = "";

            // Incluir/editar cliente
            if (requisicaoDto.EntidadeDto.Cliente != null && requisicaoDto.EntidadeDto.Cliente.Id != Guid.Empty)
            {
                ClienteBll clienteBll = new ClienteBll(pizzaByteContexto, false);
                if (!clienteBll.IncluirEditar(requisicaoDto, requisicaoDto.EntidadeDto.Cliente, ref mensagemErro))
                {
                    retornoDto.Retorno  = false;
                    retornoDto.Mensagem = mensagemErro;
                    return(false);
                }

                // Verificar endereço
                if (requisicaoDto.EntidadeDto.Entrega.ClienteEndereco != null && requisicaoDto.EntidadeDto.Entrega.ClienteEndereco.Id != Guid.Empty)
                {
                    CepBll cepBll = new CepBll(pizzaByteContexto, false);
                    if (!cepBll.IncluirEditar(requisicaoDto, requisicaoDto.EntidadeDto.Entrega.ClienteEndereco.Endereco, ref mensagemErro))
                    {
                        retornoDto.Retorno  = false;
                        retornoDto.Mensagem = mensagemErro;
                        return(false);
                    }

                    // Incluir/editar endereço do cliente
                    requisicaoDto.EntidadeDto.Entrega.ClienteEndereco.IdCliente = requisicaoDto.EntidadeDto.Cliente.Id;
                    ClienteEnderecoBll clienteEnderecoBll = new ClienteEnderecoBll(pizzaByteContexto, false);
                    if (!clienteEnderecoBll.IncluirEditar(requisicaoDto, requisicaoDto.EntidadeDto.Entrega.ClienteEndereco, ref mensagemErro))
                    {
                        retornoDto.Retorno  = false;
                        retornoDto.Mensagem = mensagemErro;
                        return(false);
                    }

                    // Incluir/editar a taxa de entrega, se houver
                    if (requisicaoDto.EntidadeDto.TaxaEntrega > 0 && !string.IsNullOrWhiteSpace(requisicaoDto.EntidadeDto.Entrega.ClienteEndereco.Endereco.Bairro) &&
                        !string.IsNullOrWhiteSpace(requisicaoDto.EntidadeDto.Entrega.ClienteEndereco.Endereco.Cidade))
                    {
                        TaxaEntregaBll taxaEntregaBll = new TaxaEntregaBll(pizzaByteContexto, false);
                        TaxaEntregaDto taxaDto        = new TaxaEntregaDto()
                        {
                            BairroCidade = requisicaoDto.EntidadeDto.Entrega.ClienteEndereco.Endereco.Bairro.Trim() + "_" + requisicaoDto.EntidadeDto.Entrega.ClienteEndereco.Endereco.Cidade,
                            ValorTaxa    = requisicaoDto.EntidadeDto.TaxaEntrega
                        };

                        if (!taxaEntregaBll.IncluirEditar(requisicaoDto, taxaDto, ref mensagemErro))
                        {
                            retornoDto.Retorno  = false;
                            retornoDto.Mensagem = mensagemErro;
                            return(false);
                        }
                    }
                }
            }

            // Se for do tipo entrega
            if (requisicaoDto.EntidadeDto.Tipo == TipoPedido.Entrega)
            {
                requisicaoDto.EntidadeDto.Entrega.IdPedido   = requisicaoDto.EntidadeDto.Id;
                requisicaoDto.EntidadeDto.Entrega.IdEndereco = requisicaoDto.EntidadeDto.Entrega.ClienteEndereco.Id;

                PedidoEntregaBll pedidoEntregaBll = new PedidoEntregaBll(pizzaByteContexto, false);
                if (!pedidoEntregaBll.IncluirEditar(requisicaoDto, requisicaoDto.EntidadeDto.Entrega, ref mensagemErro))
                {
                    retornoDto.Retorno  = false;
                    retornoDto.Mensagem = mensagemErro;
                    return(false);
                }
            }

            return(true);
        }
Example #5
0
        /// <summary>
        /// Obtém uma lista de entregas com filtros aplicados, podendo ser paginada
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool ObterListaFiltrada(RequisicaoObterListaDto requisicaoDto, ref RetornoObterListaDto <PedidoEntregaDto> retornoDto)
        {
            if (!base.ObterListaFiltrada(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string mensagemErro = "";
            IQueryable <PedidoEntregaVo> query;

            // Obter a query primária
            if (!this.ObterQueryBd(out query, ref mensagemErro))
            {
                retornoDto.Mensagem = $"Houve um problema ao listar as entregas: {mensagemErro}";
                retornoDto.Retorno  = false;

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

            // Aplicar os filtros
            foreach (var filtro in requisicaoDto.ListaFiltros)
            {
                switch (filtro.Key)
                {
                case "IDENDERECO":
                    Guid idEndereco;
                    if (!Guid.TryParse(filtro.Value, out idEndereco))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de endereço.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.IdEndereco == idEndereco);
                    break;

                case "DATAINCLUSAOINICIO":

                    DateTime data;
                    if (!DateTime.TryParse(filtro.Value, out data))
                    {
                        retornoDto.Mensagem = $"Fala ao converter o filtro de 'data de inclusão'.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => DbFunctions.TruncateTime(p.DataInclusao) >= data);
                    break;

                case "DATAINCLUSAOFIM":

                    DateTime dataFim;
                    if (!DateTime.TryParse(filtro.Value, out dataFim))
                    {
                        retornoDto.Mensagem = $"Fala ao converter o filtro de 'data de inclusão'.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => DbFunctions.TruncateTime(p.DataInclusao) <= dataFim);
                    break;

                case "IDPEDIDO":
                    Guid idPedido;
                    if (!Guid.TryParse(filtro.Value, out idPedido))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de pedido.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.IdPedido == idPedido);
                    break;

                case "IDFUNCIONARIO":
                    Guid idFuncinario;
                    if (!Guid.TryParse(filtro.Value, out idFuncinario))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de pedido.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.IdFuncionario == idFuncinario);
                    break;

                case "VALORRETORNO":
                    float valor;
                    if (!float.TryParse(filtro.Value, out valor))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de preço.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.ValorRetorno == valor);
                    break;

                case "CONFERIDO":
                    bool conferido;
                    if (!bool.TryParse(filtro.Value, out conferido))
                    {
                        retornoDto.Mensagem = $"Fala ao converter o filtro de 'inativo'.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.Conferido == conferido);
                    break;

                case "INATIVO":
                    bool filtroInativo;
                    if (!bool.TryParse(filtro.Value, out filtroInativo))
                    {
                        retornoDto.Mensagem = $"Fala ao converter o filtro de 'inativo'.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.Inativo == filtroInativo);
                    break;

                default:
                    retornoDto.Mensagem = $"O filtro {filtro.Key} não está definido para esta pesquisa.";
                    retornoDto.Retorno  = false;

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

            requisicaoDto.CampoOrdem = string.IsNullOrWhiteSpace(requisicaoDto.CampoOrdem) ? "" : requisicaoDto.CampoOrdem.ToUpper().Trim();
            switch (requisicaoDto.CampoOrdem)
            {
            case "DATAINCLUSAO":
                query = query.OrderBy(p => p.DataInclusao).ThenBy(p => p.IdFuncionario);
                break;

            case "IDFUNCIONARIO":
                query = query.OrderBy(p => p.IdFuncionario).ThenBy(p => p.DataInclusao);
                break;

            case "DATAINCLUSAODESCRESCENTE":
                query = query.OrderByDescending(p => p.DataInclusao).ThenBy(p => p.IdFuncionario);
                break;

            default:
                query = query.OrderByDescending(p => p.DataInclusao).ThenBy(p => p.IdFuncionario);
                break;
            }

            double totalItens = query.Count();

            if (totalItens == 0)
            {
                retornoDto.Mensagem = "Nenhum resultado encontrado.";
                retornoDto.Retorno  = true;
                return(true);
            }

            if (!requisicaoDto.NaoPaginarPesquisa)
            {
                double paginas = totalItens <= requisicaoDto.NumeroItensPorPagina ? 1 : totalItens / requisicaoDto.NumeroItensPorPagina;
                retornoDto.NumeroPaginas = (int)Math.Ceiling(paginas);

                int pular = (requisicaoDto.Pagina - 1) * requisicaoDto.NumeroItensPorPagina;
                query = query.Skip(pular).Take(requisicaoDto.NumeroItensPorPagina);
            }

            // Obter entregas e os IDs dos endereços
            List <PedidoEntregaVo> listaVo  = query.ToList();
            List <Guid>            listaIds = listaVo.Select(p => p.IdEndereco).ToList();

            // Obter os endereços pelo ID
            RetornoObterListaDto <ClienteEnderecoDto> retornoEnderecoDto = new RetornoObterListaDto <ClienteEnderecoDto>();
            RequisicaoListaGuidsDto requisicaoEnderecoDto = new RequisicaoListaGuidsDto()
            {
                Identificacao = requisicaoDto.Identificacao,
                IdUsuario     = requisicaoDto.IdUsuario,
                ListaGuids    = listaIds
            };

            ClienteEnderecoBll clienteEnderecoBll = new ClienteEnderecoBll(false);

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

            // Converter da dto
            ClienteEnderecoDto enderedoNaoEncontrado = new ClienteEnderecoDto();

            enderedoNaoEncontrado.Endereco.Logradouro = "Endereço não encontrado";

            foreach (var pedidoEntrega in listaVo)
            {
                PedidoEntregaDto pedidoEntregaDto = new PedidoEntregaDto();
                if (!ConverterVoParaDto(pedidoEntrega, ref pedidoEntregaDto, ref mensagemErro))
                {
                    retornoDto.Mensagem = "Erro ao converter para DTO: " + mensagemErro;
                    retornoDto.Retorno  = false;

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

                ClienteEnderecoDto endereco = retornoEnderecoDto.ListaEntidades.Where(p => p.Id == pedidoEntregaDto.IdEndereco).FirstOrDefault();
                pedidoEntregaDto.ClienteEndereco = (endereco == null) ? enderedoNaoEncontrado : endereco;

                retornoDto.ListaEntidades.Add(pedidoEntregaDto);
            }

            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }