Todos os posts de Allison

Sparks: abrindo novos horizontes para o CodeIgniter

Fonte: Ademir Cristiano Gabardo/IMaster

O assunto não é tão novo assim, mas vem se tornando popular a cada dia e é provável que, daqui a algum tempo, tudo o que você precisar acoplar ao seu framework seja feito pelo sparks.

O CodeIgniter está se popularizando muito desde a mudança da metodologia de atualizações e da aceitação da comunidade internacional de desenvolvedores como parte colaboradora para novas funcionalidades. A velocidade com que o framework cresce e se estrutura vem ganhando proporções mais atraentes para profissionais e empresas desenvolvedoras de software.

Aplicativos que consomem serviços, uso da soluções REST, do SOAP, ORMs, sistemas de templates e, é claro, muitos “módulos” de terceiros fazem parte deste caminho. É possível encontrar bibliotecas para quase tudo, desde autenticação de usuários a templates. Essa evolução trouxe a necessidade de gerenciar a instalação desses módulos. E, com isso, surgiu o sparks.

Mas, então, o que é sparks?

Segundo o website sparks.org, “sparks é um sistema de gestão de pacotes para CodeIgniter que lhe permitirá instalar bibliotecas de alta qualidade em seus aplicativos instantaneamente”.

Que tal entender melhor na prática? Para isso, vamos criar um aplicativo capaz de exibir a sua timeline do Twitter:

1. Comece baixando a última versão do CodeIgniter. Descompacte em um caminho que possa ser acessado pelo seu servidor web. Eu escolhi uma pasta chamada “sparks”. Desse modo, posso acessar em http://localhost/sparks/. Até esse ponto, nada de diferente foi feito e nesse momento você deverá ver a tela de boas vindas do CodeIgniter.

2. Na pasta raíz do seu projeto, crie uma pasta chamada “tools”. Então, vamos seguir os passos encontrados neste artigo.

3. Baixe o arquivo spark-manager.zip aqui.

4. Descompacte o conteúdo do arquivo que você acabou de baixar. Você deverá ter na pasta “tools” um arquivo chamado spark sem nenhuma extensão.

5. Agora será necessário criar uma classe Loader, estendendo a classe Loader do CodeIgniter. Acesse aqui para obter o código fonte; copie-o para o seu editor e salve-o em “applicatton/core” com o nome de arquivo MY_Loader.php.

6. Estamos prontos para começar! Agora vamos utilizar o prompt de comando para obter os sparks seguindo os passos “Get Sparks” aqui.

Abra o seu prompt do DOS (Iniciar->Executar e digite CMD). Navegue até a pasta do projeto. No meu caso, CD C:/Webs/2012/Sparks. Obedeçam ao caminho de acordo com a instalação do seu servidor web. Você deverá ver algo como a tela a seguir:

Obs: Usuários do Linux provavelmente já sabem o que têm que fazer no Terminal.

Então, vamos utilizar o PHP via linha de comando para instalar um spark de exemplo, digitando o seguinte:

php tools\spark install -v1.0.0 example-spark

Embora apresentando um erro, o comando foi executado com sucesso exibindo ao final a mensagem “You´re on Fire!”, indicando que o conteúdo foi baixado e descompactado de acordo com o esperado.

Agora que o sparks “example” foi baixado e adicionado à pasta do projeto, você deverá ver na raíz do projeto uma pasta “sparks” com uma subpasta “example-spark” e a estrutura dos arquivos partindo da versão do spark instalado.

Para testar, abra o controlador e adicione o seguinte código ao método index da classe Welcome (estou presumindo que você não alterou nada além em seu projeto):

public function index(){      $this->load->spark('example-spark/1.0.0');
$this->example_spark->printHello(); }

Se tudo correr bem, ao acessar a URL no navegador, você deverá visualizar algo semelhante à figura a seguir:

Se você chegou até este ponto, tudo foi feito corretamente e poderemos prosseguir para nosso aplicativo.

Obtenha o CURL instalando via sparks com o seguinte comando no prompt:

php tools\spark install –v1.2.1 curl

E você deverá ver algo como a tela a seguir:

O próximo passo será, então, obter o RestClient. Do mesmo modo, digite no prompt de comando:

php tools\spark install –v2.1.0 restclient

Se tudo correr bem, ao final da operação, algo semelhante a tela a seguir será exibido:

Pronto, agora temos CURL e um cliente REST disponíveis, vamos aproveitar e utilizar para obter a timeline do Twitter. Precisamos alterar o método index da classe welcome para o seguinte código fonte:

public function index(){    $this->load->spark('curl/1.2.1');
$this->load->spark('restclient/2.1.0');
// Carregando a biblioteca Rest    $this->load->library('rest');
// Inicializando apontando o servidor do Twitter.
$this->rest->initialize(array('server'=> 'http://twitter.com/'));
// Recebendo os twitters do usuário agabardo, troque para o seu usuário.
$tweets = $this->rest->get('statuses/user_timeline/agabardo.xml');

//Exibindo na tela para propositos de teste.
echo "<pre>";    print_r($tweets);    echo "</pre>";
}

E, se tudo correr bem, você deverá visualizar a array com o conteúdo da sua timeline:

E como diriam meus amigos do Rio Grande: “mais simples que painel de Jipe”! Por isso acredito que muita coisa nova e boa deverá surgir empacotada com sparks.

Se você não tem afinidade com a linha de comando, existem outras alternativas, mas, convenhamos, digitar três ou quatro linhas no prompt do DOS ou terminal do Linux não é assim tão dolorido.

Não funcionou? Baixe os arquivos do projeto aqui.

***

Artigo original disponível em: http://codeigniter.com/news/a_quick_look_at_sparks

Abraços a todos!

Como implementar uma aplicação Cliente-Servidor com Sockets em Ruby

Fonte: Samuel Vinicius/IMasters

Este é primeiro de vários artigos que irei publicar sobre Sockets em Ruby. Mas, antes de qualquer coisa, é conveniente dizer o que são Sockets:

A grosso modo, são as extremidades de um canal de comunicação bidirecional. Ou seja, você pode utilizar Sockets para fazer comunicação entre processos de uma máquina, entre máquinas diferentes e entre processos de máquinas diferentes.

O que iremos fazer?

Como este é o primeiro artigo sobre o tema, pretendo ir direto ao ponto, mostrando de forma simples como implementar uma aplicação Cliente-Servidor. Nessa aplicação, o cliente envia uma mensagem para o servidor e este responde, sendo a comunicação entre cliente e servidor realizada via Socket através do protocolo TCP.

Então, sem mais delongas, vamos aos códigos:

  • Servidor
 
# file server.rb
require 'socket'
 
server = TCPServer.open(3001)  # Abre socket em escuta na porta 3001
loop { # o servidor nunca morre, fica sempre executando
client = server.accept      # aceita conexão do cliente
msg_cliente = client.recvfrom( 10000 ) # recebe mensagem - 10000 bytes - do cliente
 
puts  "Mensagem do cliente: #{msg_cliente}" # imprime a mensagem do cliente no servidor
client.puts "Ola cliente eu, o servidor, recebi sua mensagem" #envia uma mensagem ao cliente
client.close # fecha conexão
}
  • Cliente
# file client.rb
require 'socket'
 
server = TCPSocket.open('localhost', 3001) # conecta ao servidor na porta 3001
server.puts "Ola servidor eu, o cliente, estou enviando uma mensagem" # envia mensagem para o servidor
 
resp = server.recvfrom( 10000 ) # recebe a mensagem -10000 bytes - do servidor
puts resp
 
server.close # Fecha a conexão com o servidor

Como rodar a aplicação?

Primeiro, salve o código do servidor em um arquivo .rb (por exemplo server.rb) e execute o arquivo – ruby server.rb. Nesse ponto, o servidor está esperando a conexão de um cliente. Agora salve o código do cliente de forma análoga e execute em outro terminal, de modo que cliente e servidor sejam rodados ao mesmo tempo. A partir de então, o cliente envia uma mensagem ao servidor e o servidor responde.

Este é um exemplo simples do que pode ser feito com Sockets. Espero que te ajude em algo.

***

Referência: http://www.tutorialspoint.com/ruby/ruby_socket_programming.htm

Utilizando corretamente Marcadores no Blogger

Fonte: GerenciadoBlog/Adelson Smania

Os marcadores dos artigos são extremamente importante. Utilizando-os de forma correta, você conseguirá apresentar ao seu leitor outros artigos tratando o mesmo tema, facilitando a localização de outros artigos que possam interessar a ele. Apesar de se tratarem de um conceito simples, há alguns aspectos importantes que você pode seguir para tornar os marcadores ainda mais eficiente. Neste artigo, você encontrará dicas importantes para dominar o seu uso correto.

Introdução

Independente da experiência que você tem com blogs, já deve ter notado que é possível definir “Marcadores” ou “Categorias” para os artigos que você escreve. Veja, por exemplo, o ponto que destaquei no último artigo que escrevi aqui no Gerenciando Blog:

Quem lê essa informação, sabe que esse artigo é referente a uma promoção. Ao clicar no marcador, ele será levado para o endereço http://www.gerenciandoblog.com.br/search/label/promoções, onde poderá ler todos os artigos que já escrevi sobre esse tema. É uma forma simples para o visitante encontrar outros artigos sobre o tema que está lendo.

Você não é obrigado a utilizar marcadores – embora eu recomende que você os utilize em todos os seus artigos. Você pode associar um ou mais marcadores a cada artigo, dependendo de sua necessidade.

Ao longo deste artigo, você verá orientações simples para utilizar os marcadores da forma correta e mais eficiente possível.

1. Como associar marcadores a um artigo?

Utilizar um marcador é muito simples. Basta que, ao escrever um artigo, você defina quais são os marcadores que estarão associados a ele.

No Blogger, isso é feito diretamente no editor de artigos. Basta você clicar na opção “Marcadores”, na barra lateral direita.

Será aberta uma caixa onde você pode digitar os marcadores desejados ou simplesmente clicar nos marcadores existentes para que eles sejam utilizados. Se você for utilizar mais de um marcador, eles devem ser separados por vírgula. Não devem ser utilizadas outras pontuações (como ponto final, ponto e vírgula etc.), pois elas serão entendidas como parte do texto. Após escolher os marcadores desejados, basta clicar no botão “Concluído”.

Se você utiliza o Windows Live Writer para escrever seus artigos, verá que os marcadores são chamados de “Categorias”. A utilização é feita de forma um pouco diferente. Você deve clicar na caixa “Definir categorias” e marcar as categorias desejadas para seu artigo.

Tanto no Blogger quanto no Windows Live Writer, você pode adicionar um novo marcador ao escrever um artigo. Ele será automaticamente adicionado à lista dos marcadores disponíveis quando você for escrever seu próximo artigo.

2. Como definir os marcadores que você utilizará em seu blog?

Este é o ponto mais importante para trabalhar bem com marcadores. Deve-se tomar cuidado para não escolher marcadores genéricos demais nem específicos demais. Tomando como exemplo o próprio Gerenciando Blog:

  • Um marcador chamado “Dicas” seria uma má escolha por ser muito genérico, pois haveria centenas de artigos que receberiam esse marcador, por se um dos temas principais do blog. Se um visitante visitasse essa categoria, dificilmente encontraria o que procura.
  • Já um marcador chamado “Wufoo” seria ruim por ser específico demais. Até hoje, escrevi um único artigo sobre esse serviço específico, e esse marcador dificilmente seria utilizado em artigos futuros.

Uma boa ideia para você definir bem os marcadores necessários ao seu blog é revisar os seus artigos (inclusive aqueles que você planeja escrever) e anotar quais seriam os marcadores úteis para eles. Uma boa forma para fazer isso é utilizando uma planilha Excel, em que você liste seus artigos na primeira coluna e os possíveis marcadores nas demais colunas. Dessa forma, basta você marcar um “X” nos marcadores para cada artigo. Ao final, você terá a visão da quantidade de vezes que cada marcador foi utilizado.

É uma planilha bem simples, mas você pode clicar na figura acima caso deseje fazer download para utilizá-la para planejar os marcadores de seu blog.

Ao final, compare o número de vezes que cada marcador foi utilizado com o seu total de artigos. Se houver marcadores utilizados apenas uma vez, isso pode indicar que trata-se de um marcador específico demais. Neste caso, é melhor eliminar esse marcador e colocar outro que possa ser utilizado em outro artigo. Se houver outros que foram utilizados em metade ou mais de seus artigos, pode indicar que ele é genérico demais e deve ser dividido em outros.

3. Como definir em que posição os marcadores serão exibidos no artigo?

Algo que muitos desconhecer é que o Blogger permite que você mesmo configure em que posição os marcadores serão exibidos em seus artigos. Você pode definir que eles sejam exibidos no cabeçalho ou rodapé do artigo – ou mesmo escolher para que ele não seja exibido.

Essa definição é feita na área de “Configurações”/”Layout” do blog, clicando em “Editar” no gadget “Postagens no Blog”.

É necessário que a caixa “Marcadores” esteja marcada e que, na área inferior dessa tela, ela seja arrastada para o local desejado.

Em caso de dúvidas, o artigo Defina o que Será Mostrado com seus Artigos mostra mais detalhes sobre este assunto.

4. É interessante exibir a lista de marcadores no blog?

Esta pergunta não tem uma resposta unânime. Há autores que defendem que deve ser exibida uma lista de marcadores aos leitores, enquanto outros acham que isso é desnecessário pelo fato dos marcadores já estarem acessíveis pelos próprios artigos.

Particularmente, prefiro exibir os marcadores. Acredito que seja mais uma forma útil para o visitante encontrar o artigo que procura (ou mesmo encontrar mais informações sobre um determinado assunto).

O Blogger oferece um gadget pronto exibir os Marcadores, justamente com esse nome. Caso você tenha dúvida para inserir um gadget, sugiro a leitura do artigo Como Adicionar Gadgets em seu Blog.

Na tela seguinte, você deve definir as configurações desejadas para a exibição de seus Marcadores. Veja após a figura a explicação e minhas considerações sobre cada item:

  • Mostrar (Todos os marcadores / Marcadores selecionados) – Nesta opção, você informará se quer mostrar todos os seus marcadores, ou apenas alguns deles. Eu prefiro a opção para mostrar todos.
  • Classificação (Em ordem alfabética / Por frequência) – Aqui, você define se os marcadores serão exibidos em ordem alfabética ou de acordo com o seu uso. Se você escolher a segunda opção, serão exibidos primeiro os mais utilizados.
  • Exibir (Lista / Cloud) – A exibição de lista é a forma tradicional, um embaixo do outro. A exibição em “cloud” (ou “nuvem”) é a forma que prefiro utilizar. Ela mostra os marcadores em um único grupo, deixando em fonte em tamanho maior os utilizados com maior frequência. Como exemplo, veja meu gadget, na coluna lateral direita.
  • Mostra o número de postagens por marcador – Marcando esta opção, será exibido o número total de artigos na frente de cada marcador. É uma opção interessante, especialmente para você validar se escolheu bem seus marcadores e se não há marcadores específicos demais.

5. Onde mais posso utilizar os marcadores?

Além de exibir os marcadores nos artigos e no gadget, há ainda outros locais em que você pode utilizá-los. Isso porque o endereço para cada marcador do seu blog é bem simples e segue uma mesma ideia: Clique em qualquer marcador e você notará que sua estrutura é sempre a mostrada abaixo:

endereço_seu_blog/search/label/marcador

Por exemplo: os artigos com o marcador SEO no Gerenciando Blog podem ser acessados pelo link http://www.gerenciandoblog.com.br/search/label/SEO.

Assim, você pode utilizar os marcadores onde achar conveniente, de acordo com sua necessidade e criatividade:

Você pode citar os artigos de um mesmo marcador durante o texto de seu artigo. Por exemplo: “Veja todos os artigos que já escrevi sobre SEO”.

Você também pode criar itens no menu do seu blog para dar acesso rápido ao seu visitante a artigos sobre marcadores importantes. Se você ainda não tem um menu, sugiro a leitura do artigo Como adicionar um menu ao seu blog.

Conclusão

Espero ter conseguido mostrar com este artigo a importância que os marcadores têm para a organização dos seus artigos e a melhor forma para você utilizá-los em seu blog. Seu uso correto será muito importante para que os visitantes encontrem artigos interessantes em seu blog, fidelizando-os e diminuindo sua Taxa de Rejeição.

PostgreSQL 9.2 beta melhora escalabilidade e adiciona JSON

Fonte: IMasters

Com informações de The H

O beta da versão 9.2 do PostgreSQL foi liberado. A promessa é de que a nova versão traga melhorias em desempenho que habilitem melhor escalabilidade horizontal e vertical. Além disso, uma nova otimização – varredura apenas de índex permite que pesquisas evitem a leitura de tabelas subjacentes e apenas busque pelos índices. A nova funcionalidade acontece automaticamente, mas há vários problemas para sua efetividade.

De acordo com os desenvolvedores, melhorias em lidar com cargas de trabalho somente de leitura permitiram que o banco de dados escalasse usando 64 cores e atuasse em 300 mil consultas por segundo. Também houve mudanças para reduzir o consumo de energia do CPU e melhorias em escalabilidade horizontal incluem suporte para replicação em cascata, considerando cadeias de servidores de replicação e reduzindo requerimentos de transferência de dados entre data centers.

Novas funcionalidades foram adicionadas, incluindo suporte para JSON data type, levando em conta bancos de dados relacionais híbridos que podem armazenar documentos em JSON, e JSON functions, que pode converter array e dados de fila em JSON.

O uso do beta não é recomendado em ambientes de produção e em sistemas de missão crítica. Aqueles dispostos a testá-lo são encorajados a fornecer feedback e a reportar bugs. De acordo com o cronograma do projeto, a versão final do PostgreSQL 9.2 será lançada no terceiro trimestre deste ano.

Mais informações sobre o beta podem ser encontradas nas notas de lançamento de na documentação atualizada. Ele está disponível para download para Windows, Mac OS X, Linux, FreeBSD e Solaris.

7 dicas para ter um site fácil de usar

Fonte: CriarSites

Este é um guest post escrito por Tiago Azevedo que bloga no Internetar.

Construir um site útil pode parecer difícil em tempos de tantos sites que vão na contramão. Aqui está um guia rápido para ajudá-lo em seu trabalho.

1. Conteúdo é quase tudo

Para ter seu site listado adequadamente nos mecanismos de buscas (leia: Google) o conteúdo precisa ser útil e otimizado. Desta forma, ele é lido pelos motores de busca. Seu conteúdo também precisa ser único.

2. Use corretamente o título e as tags

Estas são as duas marcas mais importantes quando se trata de referenciar o conteúdo da página. Palavras chaves podem ajudar e muito no bom posicionamento da página nos resultados de busca. As tags que falo não são aquelas das quais muitos abusam beirando ou ultrapassando os limites do Black Hat SEO, mas sim as palavras-chave usadas normalmente no texto, mas com mais atenção do que o normal.

3. Boa formatação

É muito importante usar em seu conteúdo itálico, negrito, listas, etc. Conteúdo bem formatado faz suas páginas mais acessíveis aos visitantes, mas aos motores de busca também. Visitantes verão sua página por completo (ok, nem todos), em vez de lê-la, por isso faz sentido formatar sua página para que ela possa ser pesquisado, lida sem complicações e ainda assim transmitir a sua mensagem.

4. Código limpo

Padrões da Web mudaram substancialmente ao longo dos anos e é importante se certificar de que suas páginas possuem HTML e CSS válidos. Pense nisso desta maneira. Qual a eficácia que você poderia obter – no seu ponto de vista – se você estivesse falando em hebraico pra leitores brasileiros? Seu código não é diferente. Por que tornar difícil a busca e a leitura dos robôs para indexar seu conteúdo?

5. Não usar flash

Animação em flash serve apenas para distrair os visitantes e dificultar que eles encontrem seu site na web. Leitores geralmente não querem imagens piscantes, sons e efeitos visuais em 3D logo de cara. O Flash também cria grandes problemas para ser corretamente indexado. Não há caminho para que os motores de busca possam extrair o conteúdo de seu site quanto tudo está contido em swf. Se você absolutamente deve ter uma página flash é imperativo oferecer uma versão html também.

6. Conteúdo agradável aos olhos

Os elementos gráficos desempenham um grande papel em um design de site também. Você precisa ter certeza de não expor quaisquer contrastes extremos entre as cores e nunca use cores muito brilhantes que chegam a fazer os olhos doerem. Seu logotipo ou marca deve ser claramente visível na página inicial e em mais de um lugar.

7. Facilidade de encontrar páginas básicas

Garanta que seja fácil para o visitante do seu site encontrar páginas básicas de qualquer site como políticas de privacidade, página de contato, Sobre e etc. Deve ser muito fácil entrar em contato com você para fazer todas as perguntas que seus visitantes possam ter.

Puxar informações de comentários do banco de dados do WordPress

Fonte: IMasters/Paulo Faustino

Uma das melhores formas de coletar e-mails dos usuários é através do formulário de comentários do WordPress. Ao invés de usar um plugin, é possível criar uma função customizada para criar uma listagem de e-mails a partir dos dados submetidos pelos usuários. O truque é conseguir puxar a informação dos comentários do banco de dados do WordPress e fornecer, por exemplo, uma caixa de submissão de comentário com subscrição por e-mail.

Essa tática pode ser usada para várias funcionalidades além de coletar e-mails dos usuários, como puxar a informação dos comentários, a data, o URL do comentador, e basicamente toda a informação que esteja na tabela wp_comments do WordPress. Recentemente, os colegas do blog digwp realizaram alguns testes interessantes com essa tabela, e você poderá fazer o mesmo, caso pretenda puxar informações de comentários do banco de dados do seu WordPress.

Você pode puxar e mostrar qualquer tipo de informação dessa tabela em qualquer página ou artigo do seu site. O que você necessita é uma página não-pública (ou outra localização) para mostrar os resultados (“não-pública” especialmente se você quiser puxar e-mails dos usuários). O ideal é você criar uma página privada ou selecionar um template customizado que tenha disponível. Ao carregar a página, aparecem todos os e-mails dos usuários, por exemplo.

Puxar informações do banco de dados

Se você tem uma página com formulário de captura de e-mails e pretende coletar a informação num local específico, para depois contatar esses usuários por e-mail, terá forçosamente que usar algumas funções customizadas do WordPress. Para puxar a informação, teremos que realizar algumas queries no banco de dados do WordPress, selecionar as nossas colunas da tabela wp_comments e depois mostrar essas informações em uma página personalizada/privada.

A respeito das queries SQL, puxar informações da tabela de comentários é muito básico e simples, mas puxar informações de comentários de um artigo em específico, por exemplo, já é bem mais complexo. Para fazê-lo, iremos necessitar da seguinte query:

SELECT DISTINCT comment_author, comment_author_email, comment_author_IP
FROM (
SELECT DISTINCT comment_author, comment_author_email, comment_author_IP
FROM wp_comments WHERE comment_post_ID = 1
) AS WHATEVER

Como pode ver, com essa query podemos puxar qualquer coluna da tabela wp_comments. Na query de exemplo, estamos selecionando as colunas comment_author, comment_author_email, e comment_author_IP.

Se você tiver acesso ao seu banco de dados, você pode usar programas como o phpMyAdmin para executar a query automaticamente. Caso não tenha acesso, teremos que usar uma página privada do WordPress para o efeito. Abra um template de página do WordPress e coloque o seguinte código depois da função the_content():

<?php //grab the data
$comment_info = $wpdb->get_results("SELECT DISTINCT comment_author, comment_author_email, comment_author_IP
FROM (SELECT DISTINCT comment_author, comment_author_email, comment_author_IP
FROM wp_comments
WHERE comment_post_ID = 1
) AS WHATEVER");
// display the results
echo '<ul>';
foreach($comment_info as $info) {
echo '<li><strong>'. $info->comment_author .'</strong> - '. $info->comment_author_email .' - <small>'. $info->comment_author_IP .'</small></li>';
}
echo '</ul>';
?>

Selecione apenas o ID do artigo e voilá! Quando você visita a sua página privada no browser, você irá ver uma listagem similar a esta:

  • Guilherme – gui@hotmail.com – 123.456.789
  • Antônio – max@gmail.com – 987.654.321
  • Salvador Dali – dali@email.com – 456.789.123

Até já!

Como destravar o painel do WordPress após a instalação de um plugin com problema?

Fonte: Celso Lemes/CriarSites


Se você é um blogueiro assim como eu, pode acontecer de um belo dia você tentar acessar o painel de controle do WordPress para escrever mais um post e perceber que o painel não está acessível, exibindo uma mensagem de erro ou uma página em branco.

Eu mesmo já tive este tipo de problema algumas vezes e penei para descobrir a solução, inclusive a ideia de escrever este artigo veio depois que um comentarista pediu ajuda sobre isso nos comentários recentemente.

Esse tipo de problema geralmente acontece depois da instalação de algum plugin ou mesmo após algum tipo de configuração no blog. Pode ser que o plugin seja incompatível com outro plugin já instalado, com a versão do WordPress, com o template ou mesmo com a hospedagem, fazendo com que o painel de administração ou o blog todo deixe de ser carregado ou apresente erros no carregamento.

Como resolver o problema

A solução para isso é relativamente simples, basta acessar o servidor em que o blog está instalado via FTP e renomear o a pasta do plugin suspeito ou da pasta plugins, fazendo com que todos sejam desativados automaticamente.

Abaixo você pode conferir a pasta plugins sendo renomeada com a ajuda do FileZilla.

Feito isso, basta acessar novamente o painel de administração e ir até a aba plugins, que irá mostrar uma mensagem dizendo que os plugins foram desativados. Depois é só voltar o nome da pasta para o que era antes e ativar os plugins, menos o que estava dando problema.

Não sei qual era o plugin com problema, o que faço agora?

Muita calma nesta hora. Uma boa forma de descobrir o plugin incompatível é ativar um dos plugins que você acha ser o suspeito e fazer um teste para ver se está tudo ok, se não tiver problema, ative outro e continue o processo até descobrir qual deles não se deu bem com seu blog.

Depois que descobrir o plugin problemático, verifique se ele não tem alguma atualização no próprio painel do WordPress. Pode ser que com a atualização o problema se resolva, mas caso não tenha, recomendo que você procure por um plugin alternativo.

Gostou deste artigo? Então deixe um comentário e não se esqueça de divulgar nas redes sociais.

Criando uma biblioteca para controle de acesso por usuário com CodeIgniter

Fonte: Ademir Cristiano Gabardo/IMasters

As aplicações PHP estão se tornando a cada dia mais complexas. Aplicações de uso comercial, acadêmico e das mais diversas finalidades fazem necessário um controle mais apurado de acesso.

No CodeIgniter, estamos, obrigatoriamente, sempre acessando uma classe e um método de um controlador. Dessa forma, é possível mapear todas as possíveis ações e/ ou caminhos disponíveis em uma aplicação e adicionar o controle de acesso aos métodos que desejamos controlar.

Eu desenvolvi uma biblioteca (library) para controlar o acesso dos usuários. O seu funcionamento se dá da seguinte forma: em uma tabela no banco de dados (sys_metodos), ficam guardados os nomes de classe e os métodos, mapeando todos os possíveis caminhos. Em outra tabela (sys_permissoes), ficam as ids dos usuários com os respectivos métodos a que eles têm acesso. Essa segunda tabela está relacionada à tabela de cadastro de usuários (tb_usuarios).

Figura 01: Estrutura das tabelas necessárias ao sistema de autenticação.

Seria bastante trabalhoso ter que popular a tabela de métodos manualmente, ou criar um Admin para ela. Dessa forma, inclui uma rotina na própria biblioteca, para que quando um método invocado por ela não seja encontrado na tabela sys_metodos, ele seja automaticamente criado. Assim, na primeira vez em que um método for acessado, ninguém terá permissão de acesso, sendo, então, necessário parametrizar o sistema uma única vez no primeiro acesso. Depois pode-se construir uma área de administração para varrer a tabela de métodos e adicionar ou remover as permissões dos usuários.

O CodeIgniter provê uma maneira de checarmos “onde estamos”, ou seja, em que classe e em que método. Para verificar o nome da classe, utilize a seguinte linha de código.

$this->router->class

E para recuperar o nome do método utilize:

$this->router->method

Podemos passar para a biblioteca o caminho completo de onde estamos da seguinte forma:

$this->auth->check_logged($this->router->class , $this->router->method);

Auth é o nome da biblioteca e check_logged é o método que estamos acessando. Como essa biblioteca será acessada em muitas classes e métodos, é preferível carregar no autoload para que ela esteja sempre disponível em qualquer parte da aplicação. Para proteger um método, basta incluir a linha de código:

<?php
class AreaRestrita extends Controller {
function __construct(){
parent::Controller();
}
function index(){
$this->auth->check_logged($this->router->class , $this->router->method);
}
}
?>

Vejamos, então, como fica o código fonte da biblioteca. Salve-o com o nome de arquivo auth.php na pasta system/application/libraries:

<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
class Auth
{
private $ci;
public function __construct(){
$this->ci = &get_instance();
}
 
function check_logged($classe,$metodo)
{
/*
* Criando uma instância do CodeIgniter para poder acessar
* banco de dados, sessionns, models, etc...
*/
$this->CI =& get_instance();
 
/**
* Buscando a classe e metodo da tabela sys_metodos
*/
$array = array('classe' => $classe, 'metodo' => $metodo);
$this->CI->db->where($array);
$query = $this->CI->db->get('sys_metodos');
$result = $query->result();
 
// Se este metodo ainda não existir na tabela sera cadastrado
if(count($result)==0){
$data = array(
'classe' => $classe ,
'metodo' => $metodo ,
'apelido' => $classe .  '/' . $metodo,
'privado' => 1
);
$this->CI->db->insert('sys_metodos', $data);
redirect(base_url(). $classe . '/' . $metodo, 'refresh');
}
//Se ja existir tras as informacoes de publico ou privado
else{
if($result[0]->privado==0){
// Escapa da validacao e mostra o metodo.
return false;
}
else{
// Se for privado, verifica o login
$nome = $this->ci->session->userdata('nome');
$logged_in = $this->ci->session->userdata('logged_in');
$data = $this->ci->session->userdata('data');
$email = $this->ci->session->userdata('email');
$id_usuario =  $this->ci->session->userdata('id_usuario');
 
$id_sys_metodos = $result[0]->id;
 
// Se o usuario estiver logado vai verificar se tem permissao na tabela.
if($nome && $logged_in && $id_usuario){
 
$array = array('id_metodo' => $id_sys_metodos, 'id_usuario' => $id_usuario);
$this->CI->db->where($array);
$query2 = $this->CI->db->get('sys_permissoes');
$result2 = $query2->result();
 
// Se não vier nenhum resultado da consulta, manda para página de
// usuario sem permissão.
if(count($result2)==0){
redirect(base_url().'home/sempermissao', 'refresh');
}
else{
return true;
}
}
// Se não estiver logado, sera redirecionado para o login.
else{
redirect(base_url().'home/login', 'refresh');
}
}
}
}
 
/**
* Método auxiliar para autenticar entradas em menu.
* Não faz parte do plugin como um todo.
*/
function check_menu($classe,$metodo){
$this->CI =& get_instance();
$sql = "SELECT SQL_CACHE
count(sys_permissoes.id) as found
FROM
sys_permissoes
INNER JOIN sys_metodos
ON sys_metodos.id = sys_permissoes.id_metodo
WHERE id_usuario = '" . $this->ci->session->userdata('id_usuario') . "'
AND classe = '" . $classe . "'
AND metodo = '" . $metodo . "'";
$query = $this->CI->db->query($sql);
$result = $query->result();
return $result[0]->found;
}
}

Note que a biblioteca se encarrega de inserir os dados de métodos e classes que ainda não estão cadastrados na tabela sys_metodos.

Quando um usuário tentar acessar uma área do site ou sistema no qual ele não tenha privilégios, ele será redirecionado para uma página específica:

redirect(base_url().'home/sempermissao', 'refresh');
 

E, quando ele não estiver logado, será redirecionado para a página de login:

redirect(base_url().'home/login', 'refresh');

Incluí também um método na biblioteca para checar se o usuário logado no sistema tem permissão para acessar um determinado método de uma classe chamado check_menu. Para utilizar a autenticação no menu, basta checar se o usuário tem permissão para o caminho. Isso pode ser feito diretamente na view do menu:

 
<?php
if($this->auth->check_menu('home','index')==1){
echo "<li><a href='". base_url() ."home'>Home</a></li>";                }
?>

Observe também que na tabela sys_metodos existe um campo chamado privado, que tem por objetivo liberar o acesso de métodos que estejam protegidos; caso você construa um sistema de admin para gerenciar essa tabela, quando um método estiver com o campo privado definido como 1, ele estará com seu acesso restrito somente a usuários com permissão de acesso. Quando estiver ajustado como 0, estará liberado como método público.

Outro detalhe dessa tabela é um “apelido”. Ele é cadastrado em um primeiro momento como classe/método, mas poderá ser alterado para qualquer nome amigável e mais compreensível para os usuários, como, por exemplo, Home/login poderia ser substituído por Acesso à tela de login.

Para autenticar um usuário no sistema, crie um formulário com os campos usuário, cnpj e senha, e aponte para uma classe de sua preferência (eu uso a classe de nome home) com os seguintes métodos:

<?php
class Home extends Controller {
 
function __construct(){
parent::Controller();
$this->load->helper('logs');
$this->load->helper('cookie');
}
 
function index(){
redirect(base_url().'home/login', 'refresh');
}
 
function void(){
$data['js_to_load'] = null;
$this->load->view('libs/html-header',$data);
$this->load->view('libs/menu');
$this->load->view('libs/html-footer');
}
function sempermissao(){
 
echo "<html>";
echo "<title>Acesso Negado</title>";
echo "<body bgcolor='#EEEEEE'>";
echo "    <div style='padding:20px;background-color:#FFCC00;'>";
echo "<h2>Você não tem permissão para acessar esta funcionalidade.</h2>
echo "</div>";
echo "</body>";
echo "</html>";
exit();
}
 
function login(){
$this->load->view('login',$data);
}
 
function dologin(){
$usuario = $this->input->post('usuario');
$cnpj = $this->input->post('cnpj');
$senha = md5($this->input->post('senha'));
 
if($usuario=="" || $cnpj=="" || $this->input->post('senha')==""){
redirect(base_url().'home/login', 'refresh');
exit();
}
 
if(isset($_POST['lembrar'])){
setcookie("usuario", $usuario);
setcookie("cnpj", $cnpj);
setcookie("lembrar", "checked");
}
 
$sql = "SELECT id,cnpj,login,nome,email
FROM tb_usuarios
WHERE login ='" . $usuario . "'
AND cnpj ='" . $cnpj . "'
AND senha ='" . $senha . "'";
 
$query = $this->db->query($sql);
$result = $query->result();
if(count($result)<1){
redirect(base_url().'home/login', 'refresh');
exit();
}
else{
$login = array(
'id_usuario'   =>     $result[0]->id,
'cnpj'   =>     $result[0]->cnpj,
'usuario'   =>     $result[0]->login,
'nome'      =>    $result[0]->nome,
'email'     =>     $result[0]->email,
'logged_in' => TRUE,
'data' => date("d/m/Y h:i:s")
);
 
$data['ip'] = getenv("REMOTE_ADDR");
$data['usuario'] = $result[0]->id;
$this->db->insert('tb_acessos',$data);
 
$this->session->set_userdata($login);
redirect(base_url().'home/void', 'refresh');
}
}
 
function logout()
{
$this->session->sess_destroy();
$this->login();
}
}

Com isso, concluímos nosso sistema de autenticação com controle de nível de acesso por classe e método. Não é exatamente a coisa mais simples do mundo, mas também não é a mais complicada. É importante ressaltar que estou guardando as sessões do codeIgniter no banco de dados. As demais funções de cadastro de usuário e o cadastro de usuários na tabela de permissão devem ser construídos separadamente.

Implementações futuras estão previstas e um inconveniente deste sistema é que, quando você altera um nome de classe ou método, será necessário ajustar a tabela sys_metodos.

Código fonte da biblioteca disponível aqui.

Espero que o artigo lhes tenha sido útil!

Equipe do PHP libera nova correção para falha de segurança na linguagem

Fonte: IMasters

Com informações de The H

A equipe de desenvolvimento do PHP fez outra tentativa para corrigir a vulnerabilidade crítica que afeta servidores rodando o PHP em modo CGI. O problema é que, no modo CGI, é possível chamar parâmetros do PHP direto pela URL.

Por exemplo, ao acessar o endereço http://localhost/index.php?-s, o servidor executaria o PHP com o parâmetro -s, que exibe o código-fonte do arquivo, e não o HTML gerado por ele. Só isso já seria problema suficiente (afinal, é comum inserir dados como senhas do banco de dados no código fonte), mas o time que descobriu a falha também percebeu que ela permite inserir código malicioso no arquivo e executá-lo.

Os detalhes da vulnerabilidade foram revelados publicamente por engano. Originalmente, o problema teria sido corrigido nas versões 5.3.12 e 5.4.2 do PHP, que foram liberadas na semana passada. Mas logo foi descoberto que as atualizações forneciam uma solução incompleta e outras maneiras de explorar a falha apareceram.

Agora, os desenvolvedores liberaram as versões 5.3.13 e 5.4.3, que, segundo eles, corrige o problema. Os primeiros testes realizados pelo especialista em PHP Christopher Kunz indicam que a solução deu certo desta vez.

Além disso, um buffer overflow na função apache_request_headers também foi corrigido no branch 5.4.

Dicas de organização para gerenciar diversos Blogs

Fonte: CriarSites

Este é um guest post que foi escrito por Vinicius Horta do blog Dinheiro Web.

Se trabalha com mais de um blog possivelmente já deve ter notado que além do fator tempo, o fator organização também é extremamente importante para que tenha condições de gerenciar diversos blogs simultaneamente. Aqui vou passar algumas dicas que eu utilizo em meu dia a dia e que estão funcionando muito bem, claro que deverá adequar estas dicas a sua rotina, afinal o que funciona para mim talvez não funcione para você.

Rotina, esta é uma palavra que assusta muitas pessoas, mas se pretende manter diversos projetos de sucesso online vai ter que não apenas gostar de rotina, mas a ver como uma grande solução para seu dia a dia!

É fundamental estabelecer uma série de rotinas que devem ser feitas dentro de determinados horários, tais como checar e-mails, responder comentários, fazer pesquisas, escrever novos conteúdos, etc. Monte sua rotina, ESCREVA sua rotina em algum lugar que fique fácil de ver e a siga!

Controle de Tarefas nos Blogs

Quando se possui 1 blog já da para notar a quantidade de tarefas que este gera, agora imagine cuidar de 6, 7, 8…. 12 … 16 blogs? É realmente muita coisa a ser feita e sem um controle rigoroso a chance de tudo se desorganizar é muito grande, tudo deve ter seu controle, principalmente as atualizações, quando se está gerando conteúdo para diversos blogs é muito fácil simplesmente esquecer de algum blog. (eu já fiz isso 🙁 ).

Tenha uma planilha (pode ser a do Google Docs que é ótima), nesta planilha crie uma coluna para cada blog, cada uma das linhas deve representar um dia, com isto fica muito fácil visualizar como andam as atualizações dos blogs, fica algo como a imagem a seguir:

Para manter uma tabela como esta é importante sempre que publicar (ou agendar) um novo artigo em algum blog imediatamente já atualizar a tabela e aproveitar para ver qual será o próximo blog a ser atualizado. Claro que não estou dizendo para fazer exatamente como está nesta tabela com 6 artigos por dia, mas poderá ir intercalando, o que é importante na tabela é que terá como visualizar de forma clara como andam as publicações e ter um controle exato.

SEO para diversos Blogs

Esta é mais uma das vantagens de se ter diversos projetos, é possível traçar estratégias de SEO (Search Engine Optimization) tanto de forma individual em seus blogs como também é possível traçar algumas estratégias de forma global, mesmo que os blogs sejam de nichos diferentes.

Mais uma vez poderá utilizar uma planilha para lhe ajudar a traçar a estratégia de forma global, para isso mais uma vez crie a tabela com uma coluna para cada blog, nas linhas deverá fazer a distribuição de palavras-chave âncora.

Certamente já possui uma lista com as principais palavras chave do blog e de alguns artigos de maior destaque, o que precisa fazer aqui é olhar em quais outros blogs cada uma destas palavras talvez possa ser utilizada em artigos mantendo a naturalidade dos textos. Com esta lista em mãos poderá até mesmo utilizar algum plugin para gerar os links de forma automática!

Isto tudo da muito trabalho para ser feito, mas se feito com paciência certamente terá ótimos resultados com seus blogs e mais facilidade para trabalhar com diversos blogs simultaneamente.

Como fazer seus comentários aparecem destacados no WordPress

Fonte: Celso Lemes/CriarSites

Na maioria dos templates para WordPress é possível o administrador do blog publique comentários destacados, que aparecem em uma cor diferente dos demais comentários, geralmente na cor azul claro, o que permite que os leitores escaneiem rapidamente para saber quais são os comentários do administrador/dono do blog.

Além de destacar os comentários do administrador, isso ajuda a dar mais credibilidade e reforçar sua imagem, o que pode trazer bons resultados a longo prazo. Confira a imagem abaixo que mostra como os comentários destacados aparecem aqui no CriarSites.com

Se no seu blog os seus comentários não estão aparecendo destacados, pode ser que esteja cometendo o mesmo erro que eu. Acontece que eu sempre respondo aos comentários deixados no meu blog a partir do próprio gerenciador de comentários do WordPress e não sei porque cargas d’água eles não são exibidos destacados.

No entanto, quando eu deixo um comentário diretamente no post, como se fosse um visitante qualquer, eles aparecem em destaque. Portanto, a solução é simples, basta comentar diretamente no post.

É claro que este problema também pode estar relacionado ao template que pode ser muito antigo e ainda não tem o recurso de destaque nos comentários. Se este for o seu caso, a melhor solução será mesmo trocar o template por um mais novo, que pode oferecer este e outros recursos interessantes, como ser mais amigável para os buscadores.

Manipulando arquivos com Ruby

Fonte: Samuel Vinicius/IMasters

Fonte Original: http://www.techotopia.com/index.php/Working_with_Files_in_Ruby

O Ruby tem um modo muito fácil para manipular arquivos. Neste artigo, vamos ver os principais métodos para manipular arquivos de texto plano.

  • Abrindo arquivos:
arq = File.new("arquivo.txt", "modo_de_abertura") # abri o arquivo em modo "modo_de_abertura
  • Modos de abertura:

r – Abre o arquivo para leitura;

w – Abre o arquivo para escrita;

a – Anexa ao final do arquivo, caso você queira escrever no final do arquivo;

r+ – Abre o arquivo para leitura e escrita;

w+ – Cria um arquivo vazio para leitura e escrita;

a+ – Abre o arquivo para leitura e anexação, ou seja, você pode ler qualquer parte do arquivo, mas só pode escrever no final do arquivo.

  • Lendo arquivos:
a = File.readlines("arquivo.txt") # => ["Blog sobre Ruby on Rails.\n", "\n", "Possui tutoriais, dicas, criticas e muito mais sobre o framework mais comentado da atualidade!\n"

Como pode ver, esse código devolve um vetor possuindo em cada elemento uma linha do arquivo.

  • Lendo os caracteres do arquivo:
arq = File.open("arquivo.txt")
arq.getc.chr #=> "B"
arq.getc.chr #=> "l"
arq.getc.chr #=> "o"
arq.getc.chr #=> "g"
arq.getc.chr #=> " "
  • Escrevendo em arquivos:
arq = File.new("arquivo.txt", "w") # abri o arquivo em modo de escrita
arq.write "Rails Open" # escreve no arquivo e retorna quantos caracters exitem neste
arq.puts " - Ruby on Rails" # escreve no arquivo
arq.close unless file.closed? # se o arquivo não foi fechado: fechamos

O “unless file.closed?” foi colocado apenas para demonstrar o método “close?”. O “arq.close” já bastava para que ele funcionasse normalmente.

  • Renomeando arquivos:
File.rename("arquivo.txt", "arquivo_novo.txt")
  • Descobrindo a extensão do arquivo:
extensao = File.extname("arquivo_novo.txt") # => ".txt"
  • Informações sobre o arquivo

O arquivo realmente existe?

File.exists?("arquivo_novo.txt") #=> true

Ele pertence a determinado diretório?

File.directory?("/home/samuelvinicius") # => true

Qual o tamanho do arquivo em bytes?

File.size("arquivo_novo.txt") # => 24

O arquivo está vazio?

File.zero?("arquivo_novo.txt") #=> false

Qual a data de criação, de última modificação e de último acesso ao arquivo?

File.ctime("arquivo_novo.txt") #=> Tue Jan 26 16:20:36 -0300 2010
File.mtime("arquivo_novo.txt") #=> Tue Jan 26 16:27:41 -0300 2010
File.atime("arquivo_novo.txt") #=> Tue Jan 26 16:27:42 -0300 2010

Posiciona em um ponto do arquivo:

arq = File.open('local_filename', 'r') # abri o arquivo em modo de leitura
arq.seek(2, IO::SEEK_SET)  # aponta pra o byte 2 do arquivo
puts f.readline # imprime os caracteres da linha a partir do byte 2