Beispiel #1
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);
        }
Beispiel #2
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);
        }
Beispiel #3
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 #4
0
        /// <summary>
        /// Exclui uma conta 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 a conta é necessário " +
                                      $"logar com um usuário administrador. {mensagemErro}";

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

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

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

            logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirContaReceber, requisicaoDto.Id, "Conta a receber excluída.");
            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Beispiel #5
0
        /// <summary>
        /// Exclui os endereços de um cliente pelo seu ID
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public bool ExcluirPorIdCliente(RequisicaoObterDto requisicaoDto, ref RetornoDto retornoDto)
        {
            if (requisicaoDto.Id == Guid.Empty)
            {
                retornoDto.Mensagem = "Informe o ID do cliente para excluir seus endereços.";
                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, requisicaoDto.Id, retornoDto.Mensagem);
                return(false);
            }

            string mensagemErro = "";

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

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

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

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

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

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

            query = query.Where(p => p.IdCliente == requisicaoDto.Id);
            List <ClienteEnderecoVo> enderecosEncontrados = query.ToList();

            // Excluir os endereços encontrados
            foreach (var enderecoVo in enderecosEncontrados)
            {
                if (!ExcluirBd(enderecoVo.Id, ref mensagemErro))
                {
                    retornoDto.Mensagem = $"Houve um problema ao excluir o endereço do cliente: {mensagemErro}";
                    retornoDto.Retorno  = false;

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

                if (salvar)
                {
                    // Salva as alterações
                    if (!pizzaByteContexto.Salvar(ref mensagemErro))
                    {
                        retornoDto.Retorno  = false;
                        retornoDto.Mensagem = "Houve um problema ao excluir o endereço do cliente: " + mensagemErro;
                        logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, requisicaoDto.Id, mensagemErro);
                        return(false);
                    }
                }

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, requisicaoDto.Id, "endereço excluído.");
            }

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

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

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

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

            // Não deixar incluir um cep repetido
            CepVo cepVo = new CepVo();

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

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

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

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

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

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

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

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

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

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

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

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarCep, 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.EditarCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
                    return(false);
                }
            }

            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Beispiel #7
0
        /// <summary>
        /// Exclui um pedido 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)
        {
            string mensagemErro = "";

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

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

            if (!base.Excluir(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            //Excluir itens
            PedidoItemBll pedidoItemBll = new PedidoItemBll(pizzaByteContexto, false);

            if (!pedidoItemBll.ExcluirItensPedido(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            //Excluir entregas, se houver
            PedidoEntregaBll pedidoEntregaBll = new PedidoEntregaBll(pizzaByteContexto, false);

            if (!pedidoEntregaBll.ExcluirPorIdPedido(requisicaoDto, ref retornoDto))
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = mensagemErro;

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

            // Excluir as contas
            ContaReceberBll contaReceberBll = new ContaReceberBll(pizzaByteContexto, false);

            if (!contaReceberBll.ExcluirContasPedido(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

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

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

            logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirPedido, requisicaoDto.Id, "Pedido excluído.");
            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Beispiel #8
0
        /// <summary>
        /// Altera o funcionário responsável pela entrega
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public bool AlterarFuncionarioEntrega(RequisicaoAlterarFuncionarioEntregaDto requisicaoDto, ref RetornoDto retornoDto)
        {
            string mensagemErro = "";

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

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

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.Id, retornoDto.Mensagem);
            }

            // Validar o id da entrega
            if (requisicaoDto.Id == Guid.Empty || requisicaoDto.Id == null)
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = "O id da entrega não foi preenchido.";
                logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.Id, mensagemErro);
                return(false);
            }

            // Validar o id do funcionário
            if (requisicaoDto.IdFuncionario == Guid.Empty || requisicaoDto.IdFuncionario == null)
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = "O funcionário não foi informado.";
                logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.Id, mensagemErro);
                return(false);
            }

            PedidoEntregaVo entregaVo;

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

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

            // Preencher os dados da conferência
            entregaVo.IdFuncionario = requisicaoDto.IdFuncionario;

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

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.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.AlterarFuncionarioEntrega, requisicaoDto.Id, retornoDto.Mensagem);
                    return(false);
                }
            }

            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Beispiel #9
0
        /// <summary>
        /// Edita uma entrega
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Editar(RequisicaoEntidadeDto <PedidoEntregaDto> requisicaoDto, ref RetornoDto retornoDto)
        {
            if (!base.Editar(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

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

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

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

            PedidoEntregaVo pedidoEntregaVo = new PedidoEntregaVo();

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

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

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

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

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

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoEntrega, 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.EditarPedidoEntrega, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
                    return(false);
                }
            }

            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Beispiel #10
0
        /// <summary>
        /// Inclui uma movimentação de caixa no banco de dados
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Incluir(RequisicaoEntidadeDto <MovimentoCaixaDto> requisicaoDto, ref RetornoDto retornoDto)
        {
            // Valida a requisição
            if (!base.Incluir(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

            // Converte para VO a ser incluída no banco de dados
            string mensagemErro = "";

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

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

            MovimentoCaixaVo movimentoCaixaVo = new MovimentoCaixaVo();

            if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref movimentoCaixaVo, ref mensagemErro))
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = "Falha ao converter a movimentação de caixa para VO: " + mensagemErro;

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

            // Prepara a inclusão no banco de dados
            if (!IncluirBd(movimentoCaixaVo, ref mensagemErro))
            {
                retornoDto.Retorno  = false;
                retornoDto.Mensagem = "Falha ao converter a movimentação de caixa para VO: " + mensagemErro;

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

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

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

            logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirMovimentoCaixa, movimentoCaixaVo.Id, retornoDto.Mensagem);

            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Beispiel #11
0
        /// <summary>
        /// Edita uma movimentação de caixa
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool Editar(RequisicaoEntidadeDto <MovimentoCaixaDto> requisicaoDto, ref RetornoDto retornoDto)
        {
            if (!base.Editar(requisicaoDto, ref retornoDto))
            {
                return(false);
            }

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

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

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

            // Não deixar incluir uma movimentação de caixa repetido
            MovimentoCaixaVo movimentoCaixaVo;

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

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

            if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref movimentoCaixaVo, ref mensagemErro))
            {
                retornoDto.Mensagem = "Problemas ao converter a movimentação de caixa para Vo: " + mensagemErro;
                retornoDto.Retorno  = false;

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

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

                logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarMovimentoCaixa, 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.EditarMovimentoCaixa, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
                    return(false);
                }
            }

            retornoDto.Retorno  = true;
            retornoDto.Mensagem = "OK";
            return(true);
        }
Beispiel #12
0
        /// <summary>
        /// Obtém uma lista de usuários com filtros aplicados, podendo ser paginada (não traz a senha nos objetos)
        /// </summary>
        /// <param name="requisicaoDto"></param>
        /// <param name="retornoDto"></param>
        /// <returns></returns>
        public override bool ObterListaFiltrada(RequisicaoObterListaDto requisicaoDto, ref RetornoObterListaDto <UsuarioDto> retornoDto)
        {
            if (!base.ObterListaFiltrada(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.ObterListaUsuario, Guid.Empty, retornoDto.Mensagem);
                return(false);
            }

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

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

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

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

                case "NOME":
                    query = query.Where(p => p.Nome.Contains(filtro.Value));
                    break;

                case "ADMINISTRADOR":

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

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

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

            requisicaoDto.CampoOrdem = string.IsNullOrWhiteSpace(requisicaoDto.CampoOrdem) ? "" : requisicaoDto.CampoOrdem.ToUpper().Trim();
            switch (requisicaoDto.CampoOrdem)
            {
            case "NOME":
                query = query.OrderBy(p => p.Nome);
                break;

            case "EMAIL":
                query = query.OrderBy(p => p.Email);
                break;

            default:
                query = query.OrderBy(p => p.Nome);
                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 <UsuarioVo> listaVo = query.ToList();

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

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

                usuarioDto.Senha = "";
                retornoDto.ListaEntidades.Add(usuarioDto);
            }

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