Exemple #1
0
        /// <summary>
        /// Obtém uma lista de pedidos 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 <PedidoDto> retornoDto)
        {
            if (!base.ObterListaFiltrada(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

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

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

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

            // Aplicar os filtros
            foreach (var filtro in requisicaoDto.ListaFiltros)
            {
                switch (filtro.Key)
                {
                case "JUSTIFICATIVA":
                    query = query.Where(p => p.JustificativaCancelamento.Contains(filtro.Value));
                    break;

                case "TOTALMAIOR":
                    float totalMaior;
                    if (!float.TryParse(filtro.Value, out totalMaior))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de total (maior que).";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.Total >= totalMaior);
                    break;

                case "TOTALMENOR":
                    float totalMenor;
                    if (!float.TryParse(filtro.Value, out totalMenor))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de total (menor que).";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.Total <= totalMenor);
                    break;

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

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

                    query = query.Where(p => p.Total == preco);
                    break;

                case "TAXAENTREGA":
                    float taxa;
                    if (!float.TryParse(filtro.Value, out taxa))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de taxa de entrega.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.TaxaEntrega == taxa);
                    break;

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

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

                    query = query.Where(p => p.Troco == troco);
                    break;

                case "IDCLIENTE":
                    Guid idCliente;
                    if (!Guid.TryParse(filtro.Value, out idCliente))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de id do cliente.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.IdCliente == idCliente);
                    break;

                case "RECEBIDOCARTAOCREDITO":

                    query = query.Where(p => p.RecebidoCredito > 0);
                    break;

                case "RECEBIDOCARTAODEBITO":

                    query = query.Where(p => p.RecebidoDebito > 0);
                    break;

                case "RECEBIDODINHEIRO":

                    query = query.Where(p => p.RecebidoDinheiro > 0);
                    break;

                case "TIPO":

                    int tipo;
                    if (!int.TryParse(filtro.Value, out tipo))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de tipo.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.Tipo == (TipoPedido)tipo);
                    break;

                case "PEDIDOIFOOD":

                    bool filtroifood;
                    if (!bool.TryParse(filtro.Value, out filtroifood))
                    {
                        retornoDto.Mensagem = $"Fala ao converter o filtro de 'pedido ifood'.";
                        retornoDto.Retorno  = false;

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

                    query = query.Where(p => p.Inativo == filtroifood);
                    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.ObterListaPedido, 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.ObterListaPedido, Guid.Empty, retornoDto.Mensagem);
                        return(false);
                    }

                    query = query.Where(p => DbFunctions.TruncateTime(p.DataInclusao) <= dataFim);
                    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.ObterListaPedido, 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.ObterListaPedido, 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.Tipo).ThenBy(p => p.Total);
                break;

            case "TOTAL":
                query = query.OrderBy(p => p.Total).ThenBy(p => p.DataInclusao).ThenBy(p => p.Tipo);
                break;

            case "TIPO":
                query = query.OrderByDescending(p => p.Tipo).ThenBy(p => p.DataInclusao).ThenBy(p => p.Total);
                break;

            default:
                query = query.OrderBy(p => p.DataInclusao).ThenBy(p => p.Tipo).ThenBy(p => p.Total);
                break;
            }

            double totalItens = query.Count();

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

            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);

            List <PedidoVo>        listaVo    = query.ToList();
            ClienteBll             clienteBll = new ClienteBll(false);
            IQueryable <ClienteVo> queryCliente;

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

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

            List <Guid?>     listaIds     = listaVo.Where(p => p.IdCliente != null && p.IdCliente != Guid.Empty).Select(p => p.IdCliente).ToList();
            List <ClienteVo> listaCliente = queryCliente.Where(p => listaIds.Contains(p.Id)).ToList();

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

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

                if (pedidoDto.IdCliente != null && pedidoDto.IdCliente != Guid.Empty)
                {
                    ClienteVo cliente = listaCliente.Where(p => p.Id == pedidoDto.IdCliente).FirstOrDefault();
                    pedidoDto.NomeCliente = cliente == null ? "Cliente não encontrado" : cliente.Nome;
                }
                else
                {
                    pedidoDto.NomeCliente = "Cliente não identificado";
                }

                retornoDto.ListaEntidades.Add(pedidoDto);
            }

            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Exemple #2
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);
        }
Exemple #3
0
        /// <summary>
        /// Obtém um pedido pelo ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <PedidoDto> retornoDto)
        {
            if (!base.Obter(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            string   mensagemErro = "";
            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);
            }

            PedidoDto pedidoDto = new PedidoDto();

            if (!ConverterVoParaDto(pedidoVo, ref pedidoDto, ref mensagemErro))
            {
                retornoDto.Mensagem = "Erro ao converter o pedido: " + mensagemErro;
                retornoDto.Retorno  = false;

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

            retornoDto.Entidade = pedidoDto;

            //Obter itens
            PedidoItemBll           pedidoItemBll      = new PedidoItemBll(true);
            RequisicaoObterListaDto requisicaoItensDto = new RequisicaoObterListaDto()
            {
                CampoOrdem         = "DESCRICAOPRODUTO",
                NaoPaginarPesquisa = true,
                Identificacao      = requisicaoDto.Identificacao,
                IdUsuario          = requisicaoDto.IdUsuario
            };

            requisicaoItensDto.ListaFiltros.Add("IDPEDIDO", requisicaoDto.Id.ToString());
            RetornoObterListaDto <PedidoItemDto> retornoItemDto = new RetornoObterListaDto <PedidoItemDto>();

            if (!pedidoItemBll.ObterListaFiltrada(requisicaoItensDto, ref retornoItemDto))
            {
                return(false);
            }

            retornoDto.Entidade.ListaItens = retornoItemDto.ListaEntidades;

            //Obter entrega
            if (pedidoDto.Tipo == TipoPedido.Entrega)
            {
                PedidoEntregaDto entregaDto       = new PedidoEntregaDto();
                PedidoEntregaBll pedidoEntregaBll = new PedidoEntregaBll(pizzaByteContexto, false);
                if (!pedidoEntregaBll.ObterEntregaPorIdPedido(requisicaoDto, ref entregaDto, ref mensagemErro))
                {
                    retornoDto.Mensagem = "Erro ao obter a entrega do pedido: " + mensagemErro;
                    retornoDto.Retorno  = false;

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

                pedidoDto.Entrega = entregaDto;
            }

            //Obter cliente
            if (pedidoDto.IdCliente != null && pedidoDto.IdCliente != Guid.Empty)
            {
                requisicaoDto.Id = pedidoDto.IdCliente.Value;
                ClienteBll clienteBll = new ClienteBll(false);

                RetornoObterDto <ClienteDto> retornoClienteDto = new RetornoObterDto <ClienteDto>();
                if (!clienteBll.Obter(requisicaoDto, ref retornoClienteDto) && retornoClienteDto.Mensagem != "Erro ao obter o cliente: Cadastro não encontrado")
                {
                    retornoDto.Mensagem = retornoClienteDto.Mensagem;
                    retornoDto.Retorno  = false;

                    return(false);
                }

                if (retornoClienteDto.Mensagem == "Erro ao obter o cliente: Cadastro não encontrado")
                {
                    pedidoDto.Cliente.Nome = "Cadastro não encontro";
                }
                else
                {
                    pedidoDto.Cliente = retornoClienteDto.Entidade;
                }
            }

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