Beispiel #1
0
        /// <summary>
        /// Exclui um produto 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 produtos é necessário " +
                                      $"logar com um usuário administrador. {mensagemErro}";

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirProduto, requisicaoDto.Id, retornoDto.Mensagem);
                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.ExcluirProduto, requisicaoDto.Id, retornoDto.Mensagem + " (Produto promoção)");
                return(false);
            }

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

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

            logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirProduto, requisicaoDto.Id, "Produto excluído.");
            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Beispiel #2
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);
        }
Beispiel #3
0
        /// <summary>
        /// Obtém uma lista de pedidoItems 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 <PedidoItemDto> retornoDto)
        {
            if (!base.ObterListaFiltrada(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

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

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

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

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

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

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

                    query = query.Where(p => p.PrecoProduto >= precoMaior);
                    break;

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

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

                    query = query.Where(p => p.PrecoProduto <= precoMenor);
                    break;

                case "PRECO":
                    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.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
                        return(false);
                    }

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

                case "TIPOPRODUTO":

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

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

                    query = query.Where(p => p.TipoProduto == (TipoProduto)tipo);
                    break;

                case "IDPEDIDO":

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

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

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

                case "IDPRODUTO":

                    Guid idProduto;
                    if (!Guid.TryParse(filtro.Value, out idProduto))
                    {
                        retornoDto.Mensagem = $"Problema ao converter o filtro de id do produto.";
                        retornoDto.Retorno  = false;

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

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

            requisicaoDto.CampoOrdem = string.IsNullOrWhiteSpace(requisicaoDto.CampoOrdem) ? "" : requisicaoDto.CampoOrdem.ToUpper().Trim();
            switch (requisicaoDto.CampoOrdem)
            {
            case "DESCRICAOPRODUTO":
                query = query.OrderBy(p => p.DescricaoProduto).ThenByDescending(p => p.PrecoProduto);
                break;

            case "PRECOCRESCENTE":
                query = query.OrderBy(p => p.PrecoProduto).ThenBy(p => p.DescricaoProduto);
                break;

            case "PRECODESCRESCENTE":
                query = query.OrderByDescending(p => p.PrecoProduto).ThenBy(p => p.DescricaoProduto);
                break;

            default:
                query = query.OrderBy(p => p.DescricaoProduto).ThenByDescending(p => p.PrecoProduto);
                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);
            }

            List <PedidoItemVo> listaVo = query.ToList();

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

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

                if (pedidoItem.IdProduto == UtilitarioBll.RetornaIdProdutoPromocao())
                {
                    retornoDto.ListaEntidades.Insert(0, pedidoItemDto);
                }
                else
                {
                    retornoDto.ListaEntidades.Add(pedidoItemDto);
                }
            }

            retornoDto.Mensagem = "Ok";
            retornoDto.Retorno  = true;
            return(true);
        }
Beispiel #4
0
        /// <summary>
        /// Edita um produto
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Editar(RequisicaoEntidadeDto <ProdutoDto> requisicaoDto, ref RetornoDto retornoDto)
        {
            if (!base.Editar(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            // Apenas usuários ADM podem editar produtoes
            string mensagemErro = "";

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

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

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

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

            // Não deixar incluir um produto repetido
            ProdutoVo produtoVo = new ProdutoVo();

            if (!VerificarProdutoExistente(requisicaoDto.EntidadeDto, ref produtoVo, ref mensagemErro))
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = "Falha ao validar o produto: " + mensagemErro;

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

            if (produtoVo != null && produtoVo.Excluido == true)
            {
                if (!ExcluirDefinitivoBd(produtoVo.Id, ref mensagemErro))
                {
                    mensagemErro = $"Houve um erro ao deletar o produto duplicado.";
                    return(false);
                }

                if (!pizzaByteContexto.Salvar(ref mensagemErro))
                {
                    retornoDto.Retorno  = false;
                    retornoDto.Mensagem = "Falha ao excluir o produto duplicado: " + mensagemErro;

                    logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarProduto, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
                    return(false);
                }
            }
            else if (produtoVo != null && produtoVo.Excluido == false)
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = "Esse cadastro (produto) já existe, não é possível incluir cadastros duplicados";

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

            if (!ObterPorIdBd(requisicaoDto.EntidadeDto.Id, out produtoVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Problemas para encontrar o produto: " + mensagemErro;
                retornoDto.Retorno  = false;

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

            if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref produtoVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Problemas ao converter o produto para Vo: " + mensagemErro;
                retornoDto.Retorno  = false;

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

            if (!EditarBd(produtoVo, ref mensagemErro))
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = "Falha ao editar os novos dados do produto: " + mensagemErro;

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

            if (salvar)
            {
                // Salva as alterações
                if (!pizzaByteContexto.Salvar(ref mensagemErro))
                {
                    retornoDto.Retorno  = false;
                    retornoDto.Mensagem = "Erro ao salvar os novos dados: " + mensagemErro;

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

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