Image Image Image Image Image
Scroll to Top

Topo

código

16

maio
2012

Sem Comentários

Em Blog

Por Allison

7 dicas para ter um site fácil de usar

Em 16, maio 2012 | Sem Comentários | Em Blog | Por Allison

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.

Tags | , ,

14

maio
2012

Sem Comentários

Em Blog
Dados
Wordpress

Por Allison

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

Em 14, maio 2012 | Sem Comentários | Em Blog, Dados, Wordpress | Por Allison

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á!

Tags | , , ,

12

maio
2012

Sem Comentários

Em Blog
PHP

Por Allison

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

Em 12, maio 2012 | Sem Comentários | Em Blog, PHP | Por Allison

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!

Tags | , , ,

07

maio
2012

Sem Comentários

Em Blog
Ruby

Por Allison

Manipulando arquivos com Ruby

Em 07, maio 2012 | Sem Comentários | Em Blog, Ruby | Por Allison

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

Tags | , ,

05

maio
2012

Sem Comentários

Em Blog
PHP

Por Allison

Falha crítica de segurança é encontrada no PHP

Em 05, maio 2012 | Sem Comentários | Em Blog, PHP | Por Allison

Fonte: IMasters

Por Paulo Graveheart

Uma falha recente encontrada no PHP e liberada para o público por engano pode deixar qualquer página no servidor aberta para inserção de código malicioso. A vulnerabilidade, que afeta apenas servidores rodando o PHP em modo CGI, foi descoberta por um time de hackers durante uma competição.

A essência da falha é que hoje é 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 também permite inserir código malicioso no arquivo e executá-lo.

Descobertas desse tipo normalmente são enviadas para os desenvolvedores que primeiro resolvem o problema e lançam uma atualização para só então os veículos anunciarem a falha e a correção, mas por uma falha humana o bug foi acidentalmente enviado como “público” no sistema de bugs do PHP.

Embora o time de desenvolvedores já tenha liberado uma correção, há informações de que elas não resolvem totalmente o problema. O ideal é usar o PHP de outra forma que não em modo CGI (em modo FastCGI essa falha não acontece) ou incluir uma regra para que o Apache bloqueie URLs com “-” no arquivo .htaccess, evitando assim o uso de parâmetros do PHP. A regra é esta abaixo:

 
RewriteCond %{QUERY_STRING} ^(%2d|-)[^=]+$ [NC]
RewriteRule ^(.*) $1? [L]

Uma nova atualização deve sair em breve, já com uma correção mais eficiente. Até lá, todo cuidado é pouco.

Tags | , ,

03

maio
2012

Sem Comentários

Em Blog
Código
Wordpress

Por Allison

Como adicionar scroll infinito a um template WordPress

Em 03, maio 2012 | Sem Comentários | Em Blog, Código, Wordpress | Por Allison

Fonte: Paulo Faustino/IMasters

Para quem trabalha com desenvolvimento de temas WordPress, introduzir constantemente novas funcionalidades é primordial – não só para tornar seus templates mais atrativos, mas acima de tudo, mais funcionais. O scroll infinito é uma forma muito popular de carregar conteúdo de forma dinâmica no seu site, sendo necessário apenas que o usuário faça scroll na tela, para o conteúdo ir carregando e aparecendo de forma dinâmica.

Sites populares, como o Twitter e Facebook usam esta funcionalidade há um bom tempo e ela pode ser facilmente adaptada para um template WordPress, dependendo logicamente das suas necessidades. Nem todos os tipos de sites e blogs se encaixam bem em um scroll infinito, portanto, ao usar a funcionalidade, tenha isso em mente. Para colocar o scroll infinito no seu WordPress, siga os passos deste artigo, baseado no código dos colegas do wptheming.

Para quem trabalha com desenvolvimento de temas WordPress, introduzir constantemente novas funcionalidades é primordial – não só para tornar seus templates mais atrativos, mas acima de tudo, mais funcionais. O scroll infinito é uma forma muito popular de carregar conteúdo de forma dinâmica no seu site, sendo necessário apenas que o usuário faça scroll na tela, para o conteúdo ir carregando e aparecendo de forma dinâmica.

Sites populares, como o Twitter e Facebook usam esta funcionalidade há um bom tempo e ela pode ser facilmente adaptada para um template WordPress, dependendo logicamente das suas necessidades. Nem todos os tipos de sites e blogs se encaixam bem em um scroll infinito, portanto, ao usar a funcionalidade, tenha isso em mente. Para colocar o scroll infinito no seu WordPress, siga os passos deste artigo, baseado no código dos colegas do wptheming.

Baixe o JavaScript

Faça o download de uma cópia do arquivo “jquery.infinitescroll.min.js”, que está no repositório do GitHub, e coloque-o na pasta de scripts ou arquivos JavaScript do seu template WordPress. Se não tem uma pasta “scripts” ou “js” no seu template, você poderá criar uma apenas para organizar todos os arquivos e funcionalidades do seu tema.

Se desejar, pode ainda escolher uma das imagens para o efeito de loading do script. Veja aqui. Carregue a imagem para a pasta “imagens” do seu template.

Carregar o script

Vai ser necessário registar e carregar o script para dentro do arquivo functions.php do seu template. Copie e cole o seguinte código para dentro do arquivo functions.php do seu tema. Se o seu tema não tiver um arquivo com esse nome, deverá criar um e colar o seguinte código:

/**
* Load javascripts used by the theme
*/
function custom_theme_js(){
wp_register_script( 'infinite_scroll',  get_template_directory_uri() . '/js/jquery.infinitescroll.min.js', array('jquery'),null,true );
if( ! is_singular() ) {
wp_enqueue_script('infinite_scroll');
}
}
add_action('wp_enqueue_scripts', 'custom_theme_js');.

Inicializar o script

No código seguinte, estão listados diferentes parâmetros usados no template. Provavelmente, você precisará alterar alguns deles para se ajustarem corretamente ao seu template. Veja:

  • img: O caminho para o URL da imagem de loading;
  • nextSelector: Selector do link “artigos antigos”;
  • navSelector: Selector dos links de navegação anterior/próximo;
  • itemSelector: Selector para posts. Poderá ser .hentry, .post, .etc;
  • contentSelector: Contém divs para os seus posts.
/**
* Infinite Scroll
*/
function custom_infinite_scroll_js() {
if( ! is_singular() ) { ?>
<script>
var infinite_scroll = {
loading: {
img: "<?php echo get_template_directory_uri(); ?>/images/ajax-loader.gif",
msgText: "<?php _e( 'Loading the next set of posts...', 'custom' ); ?>",
finishedMsg: "<?php _e( 'All posts loaded.', 'custom' ); ?>"
},
"nextSelector":"#nav-below .nav-previous a",
"navSelector":"#nav-below",
"itemSelector":"article",
"contentSelector":"#content"
};
jQuery( infinite_scroll.contentSelector ).infinitescroll( infinite_scroll );
</script>
<?php
}
}
add_action( 'wp_footer', 'custom_infinite_scroll_js',100 );

Nota: Não esqueça de traduzir as mensagens de carregamento para a língua desejada.

Testar o script

Ao carregar o conteúdo da homepage ou de uma categoria, o scroll infinito deverá estar funcionando. Caso não esteja, verifique se o script não está carregando corretamente, ou se por ventura está dando algum erro de JavaScript. Verifique também se os seletores estão todos funcionando corretamente.

Se você fizer scroll diversas vezes, é provável que a determinada altura comece a dar erros 404, pelo que você deverá aplicar o seguinte patch ao arquivo functions.php:

/**
* If we go beyond the last page and request a page that doesn't exist,
* force WordPress to return a 404.
* See http://core.trac.wordpress.org/ticket/15770
*/
function custom_paged_404_fix( ) {
global $wp_query;
if ( is_404() || !is_paged() || 0 != count( $wp_query->posts ) )
return;
$wp_query->set_404();
status_header( 404 );
nocache_headers();
}
add_action( 'wp', 'quimby_paged_404_fix' );

É isso, pessoal! Até mais.

Tags | , , ,

03

maio
2012

Sem Comentários

Em Blog

Por Allison

Red Hat abre o código do OpenShift

Em 03, maio 2012 | Sem Comentários | Em Blog | Por Allison

Fonte: IMasters

Com informações de The H

A Red Hat anunciou que abriu o código da Platform-as-a-Service (PaaS) OpenShift. A versão pública do produto, que recebeu o nome OpenShift Origin, pode ser baixada como um live CD baseado no Fedora, que pode ser utilizado para configurar uma instância do OpenShift em uma máquina usando o VirtualBox.

Anunciado há pouco menos de um ano, o OpenShift é baseado na tecnologia da Makara, uma empresa que a Red Hat adquiriu em 2010. A plataforma usa vários aplicativos de código aberto no background e, com o anúncio, a Red Hat abriu o código da interface do usuário e dos componentes que colocam tudo isso junto. A pilha do software do OpenShift é escrita em Ruby e usa YAML para definir os conteiners para aplicativos hospedados na plataforma.

Há várias edições diferentes do OpenShift, que abrangem desde a versão Express, que roda aplicativos escritos em PHP, Ruby e Python, até a versão Flex, que executa aplicativos mais complexos em Java e PHP e os liga ao middleware JBoss da Red Hat. A versão mais completa do OpenShift Power pode rodar qualquer aplicativo que compila no Red Hat Enterprise Linux (RHEL) 4 ou superior. O OpenShift possui opções que unem esses aplicativos em vários bancos de dados, como MySQL, PostgreSQL e MongoDB. Para fazer o deploy na plataforma, os desenvolvedores podem usar Git para colocar seu código na nuvem, e o OpenShift vai lidar com escalonamento e com gerenciamento num segundo plano.

A Red Hat declarou que planeja desenvolver o OpenShift de uma forma parecida com a distribuição Fedora, com o OpenShift Origin sendo o projeto upstream de seu próprio produto comercial. Nessa linha, a empresa está oferecendo facilidades para rastreamento de bugs, hospedagem de projeto e outros suportes para o OpenShift público, como já faz com o Fedora.

O código do projeto OpenShift Origin está disponível no GitHub sob a licença Apache 2.

Tags | , , ,

27

abr
2012

Sem Comentários

Em Blog
Python

Por Allison

Introdução aos “decorators” do Python

Em 27, abr 2012 | Sem Comentários | Em Blog, Python | Por Allison

Fonte: IMasters

Texto original disponível em: http://www.artima.com/weblogs/viewpost.jsp?thread=240808

Este recurso incrível apareceu na linguagem quase se desculpando, e com preocupações de que poderia não ser tão útil. Eu, por minha vez, acredito que em tempo ele será visto como um dos recursos mais poderosos na linguagem. O problema é que todas as introduções à decorators que eu já vi foram bastante confusas, então vou tentar consertar isso neste artigo.

Decorators vs. decorators pattern

Primeiro, você precisa entender que a palavra “decorator” foi usada com certo receio, porque existia uma preocupação em que confundissem o decorator pattern do livro Design Patterns. Outros termos foram considerados para substituí-lo, mas “decorator” parece ser o escolhido.

Na verdade, você pode utilizar os decorators do Python para implementar um decorator pattern, mas esse é um uso muito limitado dele. Os decorators do Python, acredito, se equivalem mais aos macros.

História dos macros

O macro tem uma longa história, mas a maioria das pessoas provavelmente tiveram experiências com os macro processadores C. Os problemas com os macros C eram os seguintes: eles estavam em uma linguagem diferente da C, e o comportamento deles, às vezes, era bizarro e inconsistente com o comportamento do resto do C.

Tanto o Java, quanto o C# adicionaram anotações, que permitem que você faça algumas coisas para os elementos da linguagem. Ambos têm problemas para fazer o que você quer. Às vezes você tem que pular através de um círculo grande e complexo. Há também o fato de que esse recurso de anotações tem suas mãos atadas pela escravidão e disciplina (ou como Martin Fowler gentilmente coloca: “Direcionamento”) natural dessas linguagens.

Muitos programadores C++ (inclusive eu) notaram as habilidades geradoras de templates C++ e utilizaram esse recurso de uma maneira macro.

Muitas outras linguagens incorporaram os macros. Eu, ainda sem saber muito sobre eles, ouso a dizer que os decoradores do Python são parecidos com os macros do Lips em poder e em possibilidades.

O objetivos dos macros

Acredito que seja certo dizer que o objetivo dos marcos em uma linguagem é fornecer uma maneira de modificar os elementos da mesma. É isso que os decorators fazem no Python: eles modificam funções. É por isso que eles normalmente fornecem uma alternativa mais simples para metaclasses.

As maiores falhas da maioria das abordagens de modificações próprias das linguagens são que elas são muito restritivas e que precisam de uma linguagem diferente (posso dizer que as anotações Java compreendem uma “linguagem diferente”, ainda que com todos os problemas pelos quais você deve passar para produzir uma anotação interessante).

O Python cai na categoria de Fowler de “habilitar” linguagens, então se você quiser fazer modificações, por que criar uma linguagem diferente, ou restrita? Por que simplesmente não usar o Python? E é isso que os decorators de Python fazem.

O que você pode fazer com decorators?

Decorators permitem que você insira, ou modifique o código em funções, ou classes. Parece um pouco como Aspect-Oriented Programming (AOP) em Java, não? Exceto que é muito mais simples e poderoso. Por exemplo, suponha que você gostaria de fazer algo nos pontos de entrada e saída de uma função (como executar algum tipo de segurança, rota, bloqueio, etc – todos os argumentos padrões para AOP). Com decorators, fica assim:

@entryExit
def func1():
print "inside func1()"
 
@entryExit
def func2():
print "inside func2()"
O @ indica a aplicação do decorator.

Decorators de funções

O decorator de uma função é aplicado a uma definição de função ao ser colocado na linha antes da que começa a definição da função. Por exemplo:

@myDecorator
def aFunction():
print "inside aFunction"

Quando o compilador passa por este código, a aFunction() é compilada e o objeto da função resultante é passado para o código myDecorator, que faz algo para produzir um objeto do tipo função, que é, então, substituído pelo original aFunction().

Com o que o código myDecorator se parece? Bom, a maior parte dos exemplos introdutórios o mostra como uma função, mas eu achei mais fácil começar a compreender os decorators usando classes como mecanismos de decoração, ao invés de funções. Além disso, é mais poderoso.

O único lado ruim de um objeto retornado por um decorator é que ele pode ser usado como uma função – o que basicamente significa que ele deve ser chamável. Assim, quaisquer classes que usarmos como descoradores devem implementar __call__.

O que um decorator faz? Bem, ele pode fazer qualquer coisa, mas normalmente você espera que o código da função original seja usado em algum ponto. Isso não é necessário, no entanto:

class myDecorator(object):
 
def __init__(self, f):
print "inside myDecorator.__init__()"
f() # Prove that function definition has completed
 
def __call__(self):
print "inside myDecorator.__call__()"
 
@myDecorator
def aFunction():
print "inside aFunction()"
 
print "Finished decorating aFunction()"
 
aFunction()

Quando você rodar esse código, o verá assim:

inside myDecorator.__init__()
inside aFunction()
Finished decorating aFunction()
inside myDecorator.__call__()

Note que o construtor para myDecorator é executado no ponto da decoração da função. Como podemos chamar f() dento de __init__(), isso mostra que a criação de f() está completa antes do decorator ser chamado. Note, também, que o construtor do decorator recebe o objeto da função sendo decorado. Normalmente, você irá capturar o objeto da função no construtor e depois utilizá-lo no método __call__() (o fato de que decoração e chamado são duas fases claras quando se utiliza classes, é o motivo pelo qual eu argumento que esse é o modo mais fácil e mais poderoso).

Quando aFunction() é chamada depois de ter sido decorada, temos um comportamento completamente diferente; o método myDecorator.__call__() é chamado, ao invés do código original. Isso acontece porque o ato da decoração substitui o objeto da função original com o resutlado da decoração – no nosso caso, o objeto myDecorator substitui aFunction. De fato, antes dos decorators serem adicionados, você tinha que fazer algo muito menos elegante para alcançar a mesma coisa:

def foo(): pass
foo = staticmethod(foo)

Com a adição do operador de decoração @, agora você tem o mesmo resultado dizendo:

@staticmethod
def foo(): pass

Esse é o motivo pelo qual as pessoas argumentam contra os decorators, porque o @ é apenas uma sintaxe simplificada, que significa “passar um objeto de função, através de outra função, e atribuir o resultado à função original”.

Acredito que a razão pela qual os decorators sentem tanto o impacto é porque essa maneira mais fácil, também conhecida como “syntactic sugar“, muda o modo como você pensa programação. Certamente, ele traz a ideia de “aplicar código a outro código”(por exemplo, macros) no pensamento dominante ao formalizá-lo como um construtor de linguagem.

Levemente mais útil

Agora, vamos voltar e implementar o primeiro exemplo. Aqui, vamos fazer a coisa mais comum e de fato utilizar o código nas funções decoradoras:

class entryExit(object):
 
def __init__(self, f):
self.f = f
 
def __call__(self):
print "Entering", self.f.__name__
self.f()
print "Exited", self.f.__name__
 
@entryExit
def func1():
print "inside func1()"
 
@entryExit
def func2():
print "inside func2()"
 
func1()
func2()
A saída é:
 
Entering func1
inside func1()
Exited func1
Entering func2
inside func2()
Exited func2

Você pode ver que as funções decoradoras agora tem as declarações das linha “Entering” e “Exited” em volta do chamado.

O construtor armazena o argumento, que é o objeto da função. No chamado, usamos o atributo da função __name__ para exibir o nome da função, e então chamá-la.

Usando funções como decorators

A única restrição no resultado de um decorator é que ele é chamável, então ele pode substituir propriamente a função decoradora. Nos exemplos acima, eu substitui a função original com um objeto de classe que tem um método __call__(). Mas um objeto de função também é chamável, então podemos reescrever o exemplo anterior usando uma função, ao invés de uma classe, assim:

def entryExit(f):
def new_f():
print "Entering", f.__name__
f()
print "Exited", f.__name__
return new_f
 
@entryExit
def func1():
print "inside func1()"
 
@entryExit
def func2():
print "inside func2()"
 
func1()
func2()
print func1.__name__

A new_f() é definida dentro do corpo de entryExit(), então ela é criada e retornada quando a entryExit() é chamada. Note que new_f() é um encerramento, porque ela captura o valor real de f.

Uma vez que a new_f() tenha sido definida, ela é retornada a partir de entryExit(), de modo que o mecanismo do decorator possa determinar o resultado como uma função decoradora.

O output da linha print func1.__name__ é new_f, porque a função new_f foi substituída pela função original durante a decoração. Se isso for um problema, você pode mudar o nome da função antes de retorná-la:

def entryExit(f):
def new_f():
print "Entering", f.__name__
f()
print "Exited", f.__name__
new_f.__name__ = f.__name__
return new_f

A informação que você consegue obter dinamicamente sobre as funções, e as modificações que você consegue fazer nelas são bastante poderosas no Python.

Mais exemplos

Agora que você sabe o básico, você pode dar uma olhada em mais exemplos de decorators aqui. Observe o número de exemplos que usam classes, ao invés de funções como decorators.

Neste artigo eu intencionalmente evitei lidar com os argumentos da função decoradora, mas farei isso em um próximo. Arguardem!

Tags | , ,

27

abr
2012

Sem Comentários

Em Blog
Python

Por Allison

Threads em Python

Em 27, abr 2012 | Sem Comentários | Em Blog, Python | Por Allison

Fonte: IMasters

artigo publicado originalmente no developerWorks Brasil, por Breno Leitão

Breno Leitão é engenheiro de software pela IBM onde atua como kernel hacker.


Python é uma linguagem bem genérica e fácil de ser utilizada. Qualquer usuário pode aprender a programar em Python de uma maneira bem fácil, principalmente porque a linguagem encapsula conceitos difíceis em implementações fáceis.

Neste artigo vamos tratar da utilização de threads em Python. Threads são fluxos de programas que executam em paralelo dentro de uma aplicação, isto é, uma ramificação de uma parte da aplicação que é executada de forma independente e escalonada independentemente do fluxo inicial da aplicação.

Imaginemos, por exemplo, uma aplicação que mede, de tempos em tempos, a condição de determinados sensores. Supondo que cada sensor precisa ser medido com uma frequência diferente, isto é, um a cada 30 segundos, outro a cada 45 segundos e, por fim, um terceiro a cada 75 segundos.

Implementar isto de maneira sequencial é trabalhoso. Um jeito fácil, porém, é a implementação de uma thread independente para a leitura em cada um dos sensores. Desta forma a thread espera o tempo determinado para a leitura do sensor a que ela está ligada, sem se preocupar, ou mesmo saber, sobre os outros sensores.

Assim, neste caso, bastaria fazer uma classe por tipo de sensor, sendo que cada classe seria uma thread. Para transformar uma classe em thread, são necessárias duas modificações na classe:

  • A classe em questão estender à classe Thread do pacote threading
  • Implementar o método run(), que será chamado quando a thread iniciar

Em Python, o pacote que providencia as funcionalidades de thread é chamado threading, e deve ser importado no começo do seu programa: from threading import Thread.

Segue um exemplo básico, de uma classe chamada Th que implementa Thread e o método run(). O conteúdo do método run será executado em uma thread separada sempre que o método start, definido na classe Thread e herdado pela classe Th no nosso exemplo, for chamado:

from threading import Thread

class Th(Thread):

def __init__ (self, num):
Thread.__init__(self)
self.num = num

def run(self):

print "Hello "
print self.num

a = Th(1)
a.start()

Apesar de, no exemplo acima, o conteúdo do método run ser executado em uma thread separada, não é possível comprovar isto apenas pela saída do programa.

Afim de comprovarmos que cada thread é executada de forma independente e escalonada independentemente do fluxo inicial da aplicação, vamos analisar o próximo exemplo. Nele criamos várias threads simples Th, como as do exemplo acima, porém ao invés de simplesmente imprimirmos uma mensagem na thread ela vai executar um número definido de vezes COUNTDOWN antes de finalizar sua execução:

from threading import Thread
import sys

COUNTDOWN = 5

class Th(Thread):

def __init__ (self, num):
sys.stdout.write("Making thread number " + str(num) + "n")
sys.stdout.flush()
Thread.__init__(self)
self.num = num
self.countdown = COUNTDOWN

def run(self):

while (self.countdown):
sys.stdout.write("Thread " + str(self.num) +
" (" + str(self.countdown) + ")n")
sys.stdout.flush()
self.countdown -= 1

for thread_number in range (5):

                    thread = Th(thread_number)
                    thread.start()


Uma das possíveis saídas para o programa acima é a seguinte:

Making thread number 0
Thread 0 (5)
Thread 0 (4)
Thread 0 (3)
Thread 0 (2)
Thread 0 (1)
Making thread number 1
Thread 1 (5)
Making thread number 2
Making thread number 3
Thread 2 (5)
Thread 1 (4)
Thread 1 (3)
Thread 2 (4)
Thread 1 (2)
Thread 2 (3)
Thread 1 (1)
Thread 2 (2)
Making thread number 4
Thread 2 (1)
Thread 3 (5)
Thread 4 (5)
Thread 4 (4)
Thread 3 (4)
Thread 4 (3)
Thread 3 (3)
Thread 4 (2)
Thread 3 (2)
Thread 4 (1)
Thread 3 (1)

Caso você rode o programa acima, a saída não necessariamente será igual a esta, já que a alocação das threads para execução no processador não é um processo determinado. Mesmo rodando múltiplas vezes, o mesmo programa em um mesmo computador as saídas irão variar de uma execução para outra.

Um ponto interessante de se notar no exemplo acima é que, em vez de usarmos print para imprimir na saída padrão, utilizamos sys.stdout.write seguido de uma chamada a sys.stdout.flush.

Isto foi feito para garantir que as mensagems fossem impressas em ordem, já que chamadas a print por diversas threads simultaneamente não garantem a ordem de impressão dos caracteres.

Sincronização de threads

Nos exemplos citados anteriormente, usou-se threads para efetuar processamento paralelos distintos e sem ligação entre si. No entanto, no mundo real muitas vezes as diversas linhas de execução representada pelas threads de um programa precisam, eventualmente, comunicar-se entre si.

Uma forma simples de comunicação é aquela que precisa ocorrer no final do processamento das threads. Exemplos típicos deste tipo de necessidade são programas que processam dados em vetores ou matrizes.

Se estes vetores ou matrizes forem muito grandes e os cálculos efetuados em cada elemento relativamente demorados e independentes até certo ponto, a utilização de threads pode acelerar bastante este tipo de cálculo, já que o trabalho é de alguma forma dividido entre as diversas threads.

Ao final do processo, basta realizarmos um cálculo mais simples que agrega os sub-totais calculados pelas threads. Este tipo de sincronização no final da execução de uma thread pode ser feito através do método join da classe Thread.

Por exemplo, imaginemos um programa que soma os valores de um vetor de inteiros com 1000 elementos cujos valores variam de 0 a 100. Para fins deste exemplo, este vetor será criado com valores randômicos.

Serão criadas quatro threads que calcularão a soma de 250 elementos cada uma. Ao fim do processamento, os sub-totais gerados pelas quatro threads serão somados para gerar um único valor total referente à soma de todos os elementos do vetor.

from threading import Thread
import random
import sys

NUM_VALUES = 1000
values = []
sequential_total = 0
threaded_total = 0
threads = []
NUM_THREADS = 4

class Th(Thread):
subtotal = 0

def __init__ (self, num):
sys.stdout.write("Making thread number " + str(num) + "n")
sys.stdout.flush()
Thread.__init__(self)
self.num = num

def run(self):

range_start = self.num * NUM_VALUES / NUM_THREADS
range_end = ((self.num + 1) * NUM_VALUES / NUM_THREADS) - 1

for i in range(range_start, range_end):
self.subtotal += values[i]
sys.stdout.write("Subtotal for thread " + str(self.num) +
": " + str(self.subtotal)
+ " (from " + str(range_start)

+ " to " + str(range_end) + ")n");

sys.stdout.flush()

def get_subtotal(self):
return self.subtotal

#### O programa comeca aqui #####

for i in range(NUM_VALUES):
values.append(random.randint(0,100))

for i in range(NUM_VALUES):
sequential_total += values[i]

print("Sequential total: " + str(sequential_total))

for thread_number in range(NUM_THREADS):
threads.insert(thread_number, Th(thread_number))
threads[thread_number].start()

for thread_number in range(NUM_THREADS):
threads[thread_number].join()
threaded_total += threads[thread_number].get_subtotal()

print("Threaded total: " + str(threaded_total))

Um exemplo de saída para o programa acima seria o seguinte:

Sequential total: 49313
Making thread number 0
Making thread number 1
Subtotal for thread 0: 12365 (from 0 to 249)
Making thread number 2
Subtotal for thread 1: 12568 (from 250 to 499)
Making thread number 3
Subtotal for thread 2: 11742 (from 500 to 749)
Subtotal for thread 3: 12638 (from 750 to 999)
Threaded total: 4931

Note que o valor total calculado pela versão sequencial da soma dos elementos do vetor é igual à soma calculada através das quatro threads criadas no programa para fazer o mesmo trabalho de forma dividida.

Uma outra forma de sincronização pode ser necessária quando há necessidade de se acessar variáveis cujos valores são compartilhados por várias threads rodando simultaneamente. Para isso, é necessário lançar mão da utilização de locks (threading.Lock) ou semáforos (threading.Semaphore). Um artigo a parte descreverá os locks e semáforos, é só aguardar pelo próximo post.

Conclusão

Este artigo fez uma introdução a programação com Thread em python, mostrando o que é uma thread, com deve ser construida classes que tornam-se thread e como sincronizar o fim das threads.

Recursos

Tags | , ,

22

abr
2012

Sem Comentários

Em Blog
Dados

Por Allison

O que é e como usar o MySQL?

Em 22, abr 2012 | Sem Comentários | Em Blog, Dados | Por Allison

Fonte: Pedro Pisa/TechTudo


O MySQL é um sistema gerenciador de banco de dados relacional de código aberto usado na maioria das aplicações gratuitas para gerir suas bases de dados. O serviço utiliza a linguagem SQL (Structure Query Language – Linguagem de Consulta Estruturada), que é a linguagem mais popular para inserir, acessar e gerenciar o conteúdo armazenado num banco de dados.

Na criação de aplicações web abertas e gratuitas, o conjunto de aplicações mais usado é o LAMP, um acrônimo para Linux, Apache, MySQL e Perl/PHP/Python. Nesse conjunto de aplicações, inclui-se, respectivamente, um sistema operacional, um servidor web, um sistema gerenciador de banco de dados e uma linguagem de programação. Assim, o MySQL é um dos componentes centrais da maioria das aplicações públicas da Internet.

O sistema foi desenvolvido pela empresa sueca MySQL AB e publicado, originalmente, em maio de 1995. Após, a empresa foi comprada pela Sun Microsystems e, em janeiro de 2010, integrou a transação bilionária da compra da Sun pela Oracle Corporation. Atualmente, a Oracle, embora tenha mantido a versão para a comunidade, tornou seu uso mais restrito e os desenvolvedores criaram, então, o projeto MariaDB para continuar desenvolvendo o código da versão 5.1 do MySQL, de forma totalmente aberta e gratuita. O MariaDB pretende manter compatibilidade com as versões lançadas pela Oracle.

Como usar o MySQL

Para utilizar o MySQL, é necessário instalar um servidor e uma aplicação cliente. O servidor é o responsável por armazenar os dados, responder às requisições, controlar a consistência dos dados, bem como a execução de transações concomitantes entre outras. O cliente se comunica com o servidor através da SQL. A versão gratuita do MySQL é chamada de Edição da Comunidade e possui o servidor e uma interface gráfica cliente.

Interface inicial do MySQL Workbench

O servidor deve ser instalado e configurado para receber conexões dos clientes. No MySQL, o principal cliente é a interface gráfica cliente fornecida pela Oracle, denominada MySQL Workbench. Através do MySQL Workbench, pode-se executar consultas SQL, administrar o sistema e modelar, criar e manter a base de dados através de um ambiente integrado. O MySQL Workbench está disponível para Windows, Linux e Mac OS.

Na interface de modelagem de base de dados do MySQL Workbench, pode-se definir as entidades da base de dados, seus atributos e relacionamentos. Em banco de dados, deve-se definir configurações importantes para os bancos de dados, como as chaves primárias e estrangeiras e os atributos que devem ser indexados. Todas essas configuras são definidas nessa interface.

Interface de modelagem da base de dados do MySQL Workbench

Na figura abaixo, apresenta-se a interface de administração do aplicativo, a qual consiste de informações sobre o status do sistema, como uso de processamento, memória e conexões simultâneas, e de configurações do sistema de gerenciamento e das bases de dados.

Configurações do sistema gerenciador consistem, entre outras mais complexas, da porta TCP, que deve ser conectada, e da pasta onde os arquivos das bases de dados são salvos no disco. As configurações específicas das bases de dados consistem na codificação dos dados, nas permissões de acesso, por exemplo.

Interface de administração do MySQL Workbench

No editor genérico de consultas, ilustrado na imagem abaixo, o administrador pode executar consultas para buscar informações especificas ou testes. Basta inserir a consulta SQL, na parte superior da janela, e os resultados são exibidos na guia “Output” da metade inferior da janela. Na guia “Overview”, o administrador pode obter os nomes das tabelas, visões e rotinas de cada base de dados criada no sistema.

Editor genérico de consultas SQL do MySQL Workbench

Tags | , ,

21

abr
2012

Sem Comentários

Em Blog

Por Allison

Como criar um blog de testes no Blogger

Em 21, abr 2012 | Sem Comentários | Em Blog | Por Allison

Fonte: Adelson Smania/gerenciandoblog


Há diversas alterações que você pode realizar em seu blog que apresentam riscos ao seu funcionamento (como os apresentados na séries SEO no Blogger: novidades fantásticas) – sendo alguns riscos maiores e outros menores. Por isso, é uma boa estratégia manter, além do blog principal, um blog de testes onde você pode realizar experimentos à vontade, sem o risco de prejudicar o funcionamento de seu blog oficial. Veja neste artigo algumas dicas para facilitar o trabalho de ter um blog de testes.

Introdução

É natural que você encontre templates, plugins, gadgets e outros recursos que você gostaria de utilizar em seu blog. No entanto, é uma estratégia bastante arriscada colocar esses recursos diretamente em seu blog de produção, pois isso pode lhe trazer diversos problemas:

  • Seu blog pode ficar desconfigurado, com o layout estranho, confundindo seus visitantes.
  • Você pode querer avaliar o recurso antes de colocá-lo no ar, justamente para saber se ele será ou não interessante.
  • O gadget ou plugin pode trazer um código malicioso, o que fará com seu blog seja bloqueado pelos navegadores ou serviços de proteção.
  • Na pior das hipóteses, o seu blog pode ficar fora do ar, devido a um erro de configuração ou mesmo um erro no recurso que você quer utilizar.

Todos esses pontos constituem uma justificativa mais do que razoável para que você possua um blog de testes. Trata-se de um blog que não ficará disponível ao público externo, com um endereço que apenas você conhece, e onde você poderá realizar todas as suas experiências antes de colocar um recurso em seu blog oficial. Caso algo dê errado, seu blog oficial não será impactado e seus visitantes nem ficarão sabendo. No pior dos cenários, se tudo der errado você pode simplesmente deletar seu blog de testes e criar um novo.

Como criar um blog de testes no Blogger

Criar um blog de testes no Blogger é muito simples. Há duas opções: você pode criar um novo blog na própria conta que você já possui hoje ou criar uma nova conta para o blog de testes.

Minha recomendação é que você crie o seu blog de testes na mesma conta que você já utilizada atualmente, para facilitar o seu gerenciamento. Neste caso, basta seguir os passos deste tutorial. Caso você deseje criar uma nova conta, basta acessar o endereço http://www.blogger.com e criar a conta do zero, como você fez da primeira vez que criou seu blog.

Vamos às instruções para criar seu blog de testes:

1. Acesse http://www.blogger.com e entre com seu usuário e senha.

2. Clique no botão “Novo blog”, na coluna esquerda da tela.

3. Defina um nome e endereço para o novo blog, escolha um modelo (pode ser qualquer um, pois você o alterará depois) e clique em “Criar um blog”.

4. Seu novo blog aparecerá em sua lista de blogs. É necessário agora ajustar algumas configurações nele. Para isso, clique em seu nome.

5. Acesse “Configurações” / “Básico”. Na opção “Privacidade”, clique em “Editar”.

6. Modifique as opções para que elas fique conforme abaixo. Isso garantirá que seu blog de testes não seja mostrado nas pesquisas do Google nem nas listas do Blogger. Ao terminar, clique em “Salvar alterações”.

7. Nessa mesma página, em “Permissões”, clique em “Editar” na opção “Leitores do blog”.

8. Modifique-a para “Somente autores do blog”. Isso impedirá que outras pessoas vejam seu blog de testes.

Pronto! O seu blog de testes já está criado e configurado para que outras pessoas não consigam encontrá-lo ou mesmo visitá-lo. Se você for utilizá-lo para testar um novo template, já pode fazer isso da forma como ele está. Mas, se pretende utilizá-lo para testar novos gadgets ou mudanças em seu template atual, é interessante colocar nele o mesmo template do seu blog oficial. Isso é feito seguindo os passos seguintes:

9. Ainda dentro do Blogger, você precisará acessar o seu blog oficial. Para isso, clique na opção “Meus blogs”, no canto superior esquerdo da tela.

10. Clique agora no nome de seu blog oficial.

11. Clique na opção “Modelo”, na coluna esquerda.

12. Clique agora no botão “Fazer backup/Restaurar”, no canto superior direito da tela, abaixo de seu nome.

13. Clique em “Fazer download do modelo completo” e escolha um local de seu computador para salvar seu template oficial. Após salvá-lo, clique no botão “Fechar”.

14. Volte agora ao seu blog de testes, novamente clicando em “Meus blogs” e depois sobre o nome dele.

15. Acesse também a opção “Modelo”, na coluna esquerda, e clique no botão “Fazer backup/Restaurar”.

16. Desta vez, clique no botão “Escolher arquivo” e indique o arquivo que você salvou no item 12. Depois, clique em “Fazer upload”.

Pronto! Agora você terá uma cópia do seu blog, com o mesmo template e os mesmos gadgets do seu blog oficial. Alerto que a cópia não é 100% fiel, especialmente no caso dos gadgets do tipo “HTML/JavaScript”. Para eles, você precisará fazer a cópia dos códigos manualmente e colá-los nos gadgets de seu blog de testes.

Agora, você poderá realizar testes à vontade neste blog, e só aplicar as mudanças em seu blog oficial quando estiver certo do resultado que elas trarão.

Conclusão

Ter um blog de testes é essencial. Sem ele, você corre o risco desnecessário de desestabilizar o seu blog oficial e prejudicar as visitas de seus leitores. É uma ótima forma para você não apenas testar novos recursos, mas também para “treinar” antes de realizar alterações importantes em seu blog oficial.

Tags | , , ,

16

abr
2012

Sem Comentários

Em Blog
Código
Wordpress

Por Allison

Novos hacks para usar no painel de administração do WordPress

Em 16, abr 2012 | Sem Comentários | Em Blog, Código, Wordpress | Por Allison

Fonte: IMasters/Paulo Faustino

O WordPress tem atualmente mais de 70 milhões de usuários, sendo uma das plataformas mais populares do mundo. Por isso mesmo dispensa apresentações. Com a chegada da versão 3.3.1, já é tempo de implementar alguns novos hacks – especialmente no painel administrativo do WordPress, que sofreu bastantes alterações.

O Codex do WordPress continua sendo um dos melhores locais para se aprender a mexer nessas funcionalidades, embora a sua abordagem seja focada no usuário simples e não no desenvolvedor que pretende explorar ao máximo as competências do sistema.

Por isso mesmo, trazemos uma nova listagem de novos hacks para usar no painel de administração do WordPress que encontramos lá no instantshift. Com esses hacks, é possível alterar a dinâmica do painel de administração de forma fácil e introduzir novas funcionalidades que até então você não tinha disponíveis.

1. Desativar arrastamento de janelas

Se você pretender desativar a funcionalidade de arrastamento de janelas no seu painel de administração do WordPress, você terá de desativar a funcionalidade de JavaScript que o faz. Vá no seu arquivo functions.php do seu template e adicione o seguinte código:

function disable_drag_metabox() {
wp_deregister_script('postbox');
}
add_action( 'admin_init', 'disable_drag_metabox' );

2. Mostrar uma mensagem urgente no painel

Quando você trabalha em blogs colaborativos ou blogs com vários administradores, você provavelmente gostaria de avisar os seus usuários ou os seus colaboradores de alterações importantes que está realizando. Para conseguir fazê-lo, copie e cole o seguinte código para dentro do arquivo functions.php do seu template. Não se esqueça de mudar a mensagem de erro na linha 14 do código.

function showMessage($message, $errormsg = false)
{
if ($errormsg) {
echo '<div id="message" class="error">';
}
else {
echo '<div id="message" class="updated fade">';
}
echo "<p><strong>$message</strong></p></div>";
}
 
function showAdminMessages()
{
showMessage("Mensagem de erro da EscolaWP.com.", true);
}
add_action('admin_notices', 'showAdminMessages');

3. Mostrar barra de admin apenas para administradores

Adicione o seguinte código ao seu arquivo functions.php, assim, a barra de administração apenas será mostrada para quem é administrador do site:

if (!current_user_can('manage_options')) {
add_filter('show_admin_bar', '__return_false');
}

4. Como remover itens da barra de admin

Este hack lhe dá a flexibilidade de remover itens do menu da sua barra de admin do WordPress. Copie e cole o seguinte código para dentro do arquivo functions.php do seu template.

function wps_admin_bar() {
global $wp_admin_bar;
$wp_admin_bar->remove_menu('wp-logo');
$wp_admin_bar->remove_menu('about');
$wp_admin_bar->remove_menu('wporg');
$wp_admin_bar->remove_menu('documentation');
$wp_admin_bar->remove_menu('support-forums');
$wp_admin_bar->remove_menu('feedback');
$wp_admin_bar->remove_menu('view-site');
}
add_action( 'wp_before_admin_bar_render', 'wps_admin_bar' );

5. Esconder o separador ajuda no painel de admin

Se você não usa o separador “Ajuda”, que se encontra no canto superior direito do seu painel administrativo do WordPress, saiba que poderá removê-lo. Vá no seu arquivo functions.php e adicione o seguinte código:

function hide_help() {
echo '<style type="text/css">
#contextual-help-link-wrap { display: none !important; }
</style>';
}
add_action('admin_head', 'hide_help');

6. Como adicionar novos itens na barra de admin

Adicione o seguinte código ao seu arquivo functions.php e poderá adicionar novos itens facilmente:

function wp_admin_bar_new_item() {
global $wp_admin_bar;
$wp_admin_bar->add_menu(array(
'id' => 'wp-admin-bar-new-item',
'title' => __('EscolaWP'),
'href' => 'http://www.escolawp.com/'
));
}
add_action('wp_before_admin_bar_render', 'wp_admin_bar_new_item');

7. Remover itens do dashboard

O painel de administração do WordPress tem diversas opções no menu lateral esquerdo, mas caso você pretenda remover algumas delas, também é possível. Este hack dá-lhe flexibilidade na hora de remover itens do painel. Simplesmente copie e cole o seguinte código no arquivo functions.php do seu template:

add_action( 'admin_menu', 'remove_links_menu' );
function remove_links_menu() {
remove_menu_page('index.php'); // Dashboard
remove_menu_page('edit.php'); // Posts
remove_menu_page('upload.php'); // Media
remove_menu_page('link-manager.php'); // Links
remove_menu_page('edit.php?post_type=page'); // Pages
remove_menu_page('edit-comments.php'); // Comments
remove_menu_page('themes.php'); // Appearance
remove_menu_page('plugins.php'); // Plugins
remove_menu_page('users.php'); // Users
remove_menu_page('tools.php'); // Tools
remove_menu_page('options-general.php'); // Settings

8. Remover editor no menu de navegação

Se pretende remover um item do menu de navegação não é tão simples quanto parece. No entanto, com este hack, você pode remover os itens que desejar do seu menu, sem problemas. Coloque-o no seu arquivo functions.php.

function remove_editor_menu() {
remove_action('admin_menu', '_add_themes_utility_last', 101);
}
 
add_action('_admin_menu', 'remove_editor_menu', 1);

9. Remover versão do WordPress do rodapé

Adicione o seguinte código ao seu arquivo functions.php para remover a versão do WordPress do seu rodapé.

function change_footer_version() {
return 'Version 1.0.0';
}
add_filter( 'update_footer', 'change_footer_version', 9999 );

10. Mudar o texto de rodapé no painel de admin

Adicione o seguinte código ao seu arquivo functions.php e coloque nele o texto que bem desejar. Não se esqueça de alterar o que texto pré-definido.

function remove_footer_admin () {
echo 'Visite a Escola WordPress.';
}
add_filter('admin_footer_text', 'remove_footer_admin');

11. Mostrar o dashboard em uma coluna

Adicione o seguinte código ao arquivo functions.php do seu WordPress para forçar a sua dashboard a funcionar em apena uma coluna:

function single_screen_columns( $columns ) {
$columns['dashboard'] = 1;
return $columns;
}
add_filter( 'screen_layout_columns', 'single_screen_columns' );
function single_screen_dashboard(){return 1;}
add_filter( 'get_user_option_screen_layout_dashboard', 'single_screen_dashboard' );

12. Desligar a notificação de update de browser

Provavelmente já ouviu falar da notificação/atualização de browser que acontece no novo painel de administração do WordPress 3.3.1. Se desejar desligar essa notificação, basta copiar e colar o seguinte código no arquivo functions.php do seu tema:

function disable_browser_upgrade_warning() {
remove_meta_box( 'dashboard_browser_nag', 'dashboard', 'normal' );
}
add_action( 'wp_dashboard_setup', 'disable_browser_upgrade_warning' );

13. Adicionar balões personalizados de ajuda

Provavelmente você já reparou que o novo WordPress inclui diversos balões de notificação. Esses balões são extremamente úteis se você quiser dar direções aos seus clientes ou usuários, por exemplo, para que eles compreendam como usar o WordPress.

Adicione o seguinte código ao arquivo functions.php para adicionar um novo balão ao seu painel de administração. Não se esqueça de escrever o texto que desejar nas linhas 8 e 9 do código.

Não se esqueça de atualizar o ID do jquery para colocar o balão no local desejado #menu-appearance na linha 14. Por exemplo, se você quiser o balão sobre o campo Media na barra lateral esquerda, use o ID #menu-media em vez do ID #menu-appearance.

add_action( 'admin_enqueue_scripts', 'my_admin_enqueue_scripts' );
function my_admin_enqueue_scripts() {
wp_enqueue_style( 'wp-pointer' );
wp_enqueue_script( 'wp-pointer' );
add_action( 'admin_print_footer_scripts', 'my_admin_print_footer_scripts' );
}
function my_admin_print_footer_scripts() {
$pointer_content = '<h3>Balão de Notificação</h3>';
$pointer_content .= '<p>Edite este texto para dar uma descrição ao seu balão de notificações.</p>';
?>
<script type="text/javascript">
//<![CDATA[
jQuery(document).ready( function($) {
$('#menu-appearance').pointer({
content: '<?php echo $pointer_content; ?>',
position: 'top',
close: function() {
// Once the close button is hit
}
}).pointer('open');
});
//]]>
</script>
<?php
}

14. Mostrar número de anexos junto ao post

Adicione o seguinte código ao seu arquivo functions.php do seu tema WordPress para mostrar uma coluna com o número de anexos de cada artigo.

add_filter('manage_posts_columns', 'posts_columns_attachment_count', 5);
add_action('manage_posts_custom_column', 'posts_custom_columns_attachment_count', 5, 2);
function posts_columns_attachment_count($defaults){
$defaults['wps_post_attachments'] = __('Att');
return $defaults;
}
function posts_custom_columns_attachment_count($column_name, $id){
if($column_name === 'wps_post_attachments'){
$attachments = get_children(array('post_parent'=>$id));
$count = count($attachments);
if($count !=0){echo $count;}
}
}

15. Mostrar Thumbnail junto ao post

Adicione o seguinte código ao seu arquivos functions.php do seu tema WordPress para mostrar uma coluna com o thumbnail de cada artigo. Tenha em consideração que este hack apenas funciona com temas que aceitam “imagem em destaque”.

// Add the posts and pages columns filter. They can both use the same function.
add_filter('manage_posts_columns', 'tcb_add_post_thumbnail_column', 5);
add_filter('manage_pages_columns', 'tcb_add_post_thumbnail_column', 5);
 
// Add the column
function tcb_add_post_thumbnail_column($cols){
$cols['tcb_post_thumb'] = __('Featured');
return $cols;
}
 
// Hook into the posts an pages column managing. Sharing function callback again.
add_action('manage_posts_custom_column', 'tcb_display_post_thumbnail_column', 5, 2);
add_action('manage_pages_custom_column', 'tcb_display_post_thumbnail_column', 5, 2);
 
// Grab featured-thumbnail size post thumbnail and display it.
function tcb_display_post_thumbnail_column($col, $id){
switch($col){
case 'tcb_post_thumb':
if( function_exists('the_post_thumbnail') )
echo the_post_thumbnail( 'admin-list-thumb' );
else
echo 'Not supported in theme';
break;
}
}
 

16. Esconder painéis de dados no editor de posts

Se você usa o WordPress para trabalhar com seus clientes, provavelmente irá necessitar mostrar uma interface simples de usar. Com este hack, você pode esconder os painéis de dados do editor de posts, como as caixas de categorias, tags etc. Adicione o seguinte código ao arquivo functions.php do seu template.

add_action( 'admin_menu', 'remove_meta_boxes' );
function remove_meta_boxes() {
remove_meta_box( 'submitdiv', 'post', 'normal' ); // Publish meta box
remove_meta_box( 'commentsdiv', 'post', 'normal' ); // Comments meta box
remove_meta_box( 'revisionsdiv', 'post', 'normal' ); // Revisions meta box
remove_meta_box( 'authordiv', 'post', 'normal' ); // Author meta box
remove_meta_box( 'slugdiv', 'post', 'normal' ); // Slug meta box
remove_meta_box( 'tagsdiv-post_tag', 'post', 'side' ); // Post tags meta box
remove_meta_box( 'categorydiv', 'post', 'side' ); // Category meta box
remove_meta_box( 'postexcerpt', 'post', 'normal' ); // Excerpt meta box
remove_meta_box( 'formatdiv', 'post', 'normal' ); // Post format meta box
remove_meta_box( 'trackbacksdiv', 'post', 'normal' ); // Trackbacks meta box
remove_meta_box( 'postcustom', 'post', 'normal' ); // Custom fields meta box
remove_meta_box( 'commentstatusdiv', 'post', 'normal' ); // Comment status meta box
remove_meta_box( 'postimagediv', 'post', 'side' ); // Featured image meta box
remove_meta_box( 'pageparentdiv', 'page', 'side' ); // Page attributes meta box
}

17. Esconder opção de cor nos perfis

Adicione o seguinte código ao arquivo functions.php do seu template para esconder a opção de cor azul e cinza nos perfis de usuário.

function admin_color_scheme() {
global $_wp_admin_css_colors;
$_wp_admin_css_colors = 0;
}
add_action('admin_head', 'admin_color_scheme');

Tags | , , ,