Com as técnicas de SEO sendo cada vez mais utilizadas, a tendência é que os sites utilizem cada vez mais url longas onde a mesma traz em sua estrutura informações relevante sobre o seu conteúdo visando maior organização e otimização para mecanismos de busca.

Isso gera um desconforto na divulgação dessas URL em redes sociais, principalmente o Twitter, porque vai exatamente na contra-mão. Como o microblog permite apenas 140 caracteres em cada atualização de status, talvez o espaço se torne insuficiente.

Felizmente existem ferramentas e sites que geram as famosas url encurtadas, como o http://migre.me. Url encurtadas são strings, geralmente com menos de 20 caracteres, que gerenciam o redirecionamento para uma URL considerada normal. Por exemplo, o link http://www.rafaelwendel.com se torna migre.me/7V9wO . Assim, mesmo você digitando o segundo link (nada sugestível) você chegará à página inicial do meu blog

Pois bem. Pensando na necessidade em se ter e gerar as URL encurtadas, resolvi entrar no blog oficial do migre.me na parte da API (http://migreme.com.br/blog/category/api/) e acabei verificando que sua utilização é ridícula de fácil.

Com o conhecimento adquirido, criei uma função php onde passo uma “URL normal” e ela, através da API do migre.me, retorna a URL encurtada da mesma.

Aí vai a função:

<?php
 
/**
    * Acessa a API do migre.me e gera uma URL encurtada
    * @author Rafael Wendel Pinheiro
    * @param  $url URL a ser encurtada
    * @return String URL encurtada ou informações do erro
*/	
function gera_url_encurtada($url){
    $url = urlencode($url);
    $xml =  simplexml_load_file("http://migre.me/api.xml?url=$url");
 
    if($xml->error != 0){
        return $xml->errormessage;
    }
    else{
        return $xml->migre;
    }
}
 
$url_encurtada_1 = gera_url_encurtada('http://www.rafaelwendel.com');
echo $url_encurtada_1;
// retorna http://migre.me/7VaFd
 
$url_encurtada_2 = gera_url_encurtada('http://www.rafaelwendel.com/2012/02/otimize-o-banco-de-dados-do-seu-wordpress-com-o-wp-optimize/');
echo $url_encurtada_2;
// retorna http://migre.me/7VaFe

Como você pode ver, para utilizar a função basta passar como parâmetro a URL que deseja encurtar. Em caso de sucesso ela te retornará a URL encurtada. Caso contrário ele te retorna informações sobre o erro ocorrido. A função trabalha com informações em XML e uso o simplexml_load_file (que já foi abordado em outros posts) para executar a API.

Antes de terminar vaí uma ressalta: existe um limite de 30 URLs por hora para usuários comuns (free) que é verificado através do IP. Então fique atento a esse limite.

Espero que tenham gostado.

Abs.

Siga-me no twitter: @rafaelwendel

Isso acontece porque a cada vez que você edita um determinado post, o wordpress ao invés de dar um update na entrada, ele cria uma nova entrada na tabela e apenas altera o status da entrada anterior para “rascunho”.

Assim, para cada edição de um post você terá um registro no banco de dados, gerando espaço desnecessário. Com o decorrer do tempo sua aplicação pode ficar mais lenta. E todos sabemos que isso traz alguns prejuízos.

É por isso que hoje vou falar a respeito de um plugin muito interessante chamado Wp-Optimize. Esse plugin nos permite de forma bem intuitiva excluir todos os posts de rascunho do banco de dados.

Outra vantagem do plugin: otimizar as tabelas do banco de dados. Tabelas com grande número de registros precisam periodicamente de uma otimizada para “re-organizar” os índices. Isso deixa o acesso ao banco mais rápido também.

Para baixar o plugin, acesse a página oficial: http://wordpress.org/extend/plugins/wp-optimize/

Depois de instalado, será adicionado um ítem no menu do wp-admin com o título “WP-Optimize”. Clicando nele, você já verá um relatório da atual situação do seu banco de dados e opções para já rodar os processos de otimização.

Dica: Dificilmente a execução de algum processo do WP-Optimize comprometerá a integridade da sua base de dados. Mas como precaução nunca é demais, sempre execute um backup antes de utilizar o plugin.

Espero que aproveitem a dica.

Abs

Siga-me no twitter: @rafaelwendel

Já imaginou você poder abrir e editar o código-fonte  dos arquivos de seu site a partir de qualquer lugar? Muito interessante né? Então aproveite essa vídeo-aula. E lembre-se: qualquer problema é só postar sua dúvida na caixa de comentários.

Siga-me no twitter: @rafaelwendel

Trata-se do: #1045 – Access denied for user ‘root’@'localhost’ (using password: NO)

Percebi que esse erro ocorre porque antes de instalar o pacote wamp (que dentre outros aplicativos instala o MySQL) eu já havia instalado e configurado o MySQL manualmente, inclusive definindo senhas e permisões para usuários.

E o wamp quando instala o phpMyAdmin gera um arquivo de configuração com o usuário master do MySQL (o root), porém não define uma senha para ele. E para resolver o problema #1045 teremos de ir nesse arquivo e alterá-lo manualmente.

Encontre o diretório onde está os arquivos do phpMyAdmin (Geralmente em C:\wamp\apps\). Abra o arquivo config.inc.php e procure a linha com o seguinte comando:

73

$cfg['Servers'][$i]['password']      = '';

Preencha dentro das aspas a senha do seu usuário “root”. Salve o arquivo e tente novamente.

Detalhe: dentro do diretório www há também um diretório phpMyAdmin com arquivos referentes ao aplicativo (inclusive o config.inc.php) mas pelo menos no meu caso a correção nesse local não surte efeito.

Espero ter ajudado

Abs.

Siga-me no twitter: @rafaelwendel

Pois bem, continuando com a série de posts utilizando a api do WHM hoje vou mostrar pra vocês como criar uma conta de hospedagem para um cliente em php de forma descomplicada.

Antes de começarmos ressalto aqui que a classe php que utilizarei não é a mesma dos outros dois posts. Agora vamos implementar nosso script com a API XML oferecida pelo próprio site oficial do CPANEL/WHM. Para fazer o download, clique aqui. (obs: não se esqueça de tirar a extensão txt no final do arquivo

Bom, então vamos lá.

Teremos de implementar 2 arquivos: Um com o formulário onde preencheremos as informações do cliente (domínio, usuário, senha, plano, etc) e outro onde vamos capturar esses dados e chamar a API para salvar.

Primeiro: index.php (formulário)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

<?php
require_once('xmlapi.php');
 
$whm = new xmlapi('dominio_no_whm', 'usuario', 'senha');
 
$planos = $whm->listpkgs();
 
?>
 
<html>
  <head>
    <title>WHM - Cadastrar conta de cliente</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  </head>
  <body>
  <h1>Cadastrar conta de hospedagem</h1>
 
  <form name="form1" method="post" action="cadastrar.php">
  <input type="hidden" name="acao" value="cadastrar" />
 
  <label>Domínio:</label><br />
  <input type="text" name="dominio" /><br /><br />
 
  <label>Email:</label><br />
  <input type="text" name="email" /><br /><br />
 
  <label>Usuário:</label><br />
  <input type="text" name="usuario" /><br /><br />
 
  <label>Senha:</label><br />
  <input type="password" name="senha" /><br /><br />
 
  <label>Plano:</label><br />
  <select name="plano">
    <?php if(count($planos) > 0): foreach($planos as $plano): ?>
        <option value="<?php echo $plano->name ?>"><?php echo $plano->name ?></option>
    <?php endforeach; endif; ?>
  </select>
  <br /><br />
  <input type="submit" value="Cadastrar" />
  </form>
  </body>
</html>

No formulário coloco os campos para as informaçoes do cliente (conta). Já nesse arquivo já chamos a classe xmlapi.php para poder listar os planos (pacotes). Esse formulário será submetido para o arquivo cadastrar.php (Obs: criei um campo hidden chamado ação com o valor cadastrar para verificar se realmente o formulário foi submetido)

Agora a implementação do arquivo cadastrar.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<?php
require_once('xmlapi.php');
 
if($_POST['acao'] == 'cadastrar'){
    $whm = new xmlapi('dominio_no_whm', 'usuario', 'senha');
 
    $acc['domain'] = $_POST['dominio'];
    $acc['username'] = $_POST['usuario'];
    $acc['password'] = $_POST['senha'];
    $acc['contactemail'] = $_POST['email'];
    $acc['msel'] = $_POST['plano'];
 
    $verifica = $whm->createacct($acc);
 
    if($verifica->result->status != 0){
        echo 'Conta para o domínio <strong>'. $acc['domain'] .'</strong> foi criado com sucesso!';
    }
    else{
        echo 'Erro ao tentar criar conta. Tente novamente! Erro: ' . $verifica->result->statusmsg;
    }
}

Mais uma vez importo o xmlapi.php. Verifico se o formulário foi submetido e em caso afirmativo eu crio um array ($acc) tendo como índice os parâmetros e nos valores as informações da conta a ser criada. Depois executo o método createacct passando o array $acc como parâmetro.

Por fim, faço uma verificação no status do retorno para ver se a conta foi criada ou se ocorreu algum erro.

E pronto!

Mais uma tarefa simples e fácil de ser utilizada através da API do WHM.

Espero que tenham gostado. Qualquer dúvida estou à disposição na caixa de comentários.

Abs

Siga-me no twitter: @rafaelwendel

E nada melhor para celebrar um novo ano do que uma vídeo-aula feita sobre medida para vocês que estão sempre por aqui.

E nessa vídeo-aula eu apresento uma classe php que criei e que tem como objetivo buscar informações de um determinado vídeo do Youtube, como descrição, tags, imagem, tipo e etc, tudo via CURL. Além dessas informações a classe é capaz de devolver o código de incorporação (embed) do vídeo.

Abaixo está o vídeo e logo a seguir o código da classe.

Obs: Peço desculpas pois na hora de converter o vídeo no camtasia ele cortou algumas partes nas laterais. Mas dá para acompanhar tranquilo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

<?php
/**
 * Classe de integração que importa as tags e o embed de um vídeo do Youtube
 *
 * @author Rafael Wendel Pinheiro <rafaelwendel@hotmail.com> <www.rafaelwendel.com>
 * @version 1.0
 */
class Youtube {
 
     /**
     * URL do vídeo no Youtube
     * @access private
     * @var String
     */
    private $link;
 
    /**
     * Armazena as tags referentes ao vídeo
     * @access private
     * @var array
     */
    private $tags = array();
 
    /**
     * Armazena informações referentes à erros
     * @access private
     * @var array
     */
    private $erro = array();
 
 
    /**
     * Método construtor da classe Youtube.
     * @access public
     * @param String $link URL do vídeo no Youtube (OBS: Não utilize URL encurtada)
     * @return void
     */
    public function __construct($link = '') {
        if($link != ''){
            $this->setLink($link);
            $this->loadTags();
        }
    }
 
    /**
     * Pegar a URL do vídeo que está sendo utilizado
     * @access public
     * @return String a URL do vídeo
     */
    public function getLink() {
        return $this->link;
    }
 
    /**
     * Definir a URL do vídeo no Youtube
     * @access public
     * @param String $link a URL do vídeo
     * @return mixed false em caso de URL inválida
     */
    public function setLink($link) {
        if(!strstr($link, "youtube.com")){
            $this->setErro('URL inválida');
            return false;
        }
        $this->link = $link;
    }
 
    /**
     * Capturar o(s) erro(s)
     * @access public
     * @return Array
     */
    public function getErro() {
        return $this->erro;
    }
 
 
    /**
     * Definir uma mensagem de erro
     * @access public
     * @param String $erro
     * @return void
     */
    public function setErro($erro) {
        $this->erro[] = $erro;
    }
 
    /**
     * Armazena as tags importadas na variável $tags
     * @access private
     * @param Array $tags
     * @return void
     */
    private function setTags($tags){
        if(is_array($tags)){
            foreach($tags as $prop => $value){
               $this->tags[$prop] = $value;
            }
            $this->repairTags();
        }
    }
 
    /**
     * Capturar as tags do vídeo
     * @access public
     * @return mixed Arrays com tags ou false em caso de array vazio
     */
    public function getTags() {
        if(count($this->tags) > 0){
            return $this->tags;
        }
        else{
            return false;
        }
    }
 
    /**
     * Chamar a execução da URL e setar as tags em caso de sucesso
     * @access private
     * @return mixed False em casso de erros
     */
    private function loadTags() {
        if(empty ($this->link)){
            $this->setErros('URL inválida');
            return false;
        }
        $propertys = $this->get_propertys_tags();
        if(in_array('noindex', $propertys)){
            $this->setErro('URL inválida');
            return false;
        }
        $this->setTags($propertys);
    }
 
    /**
     * Repara os nomes dos indices do array $tags
     * @access private
     * @return void
     */
    private function repairTags(){
        if(count($this->tags) > 0){
            $tags = $this->tags;
            foreach ($tags as $prop => $value){
                $nome = explode(':', $prop);
                $nome = $nome[count($nome) - 1];
 
                $new[$nome] = $value;
            }
            $this->tags = $new;
        }
    }
 
    /**
     * Pega o conteúdo do link do Youtube via CURL
     * @access private
     * @return String $data Conteúdo lido
     */
    private function file_get_contents_curl(){
        $ch = curl_init();
 
        curl_setopt($ch, CURLOPT_HEADER, 0);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($ch, CURLOPT_URL, $this->link);
 
        $data = curl_exec($ch);
        curl_close($ch);
 
        return $data;
    }
 
    /**
     * Lê o conteúdo recuperado e extrai as tags do vídeo
     * @access private
     * @return Array As Tags do vídeo
     */
    private function get_propertys_tags(){
        $html = $this->file_get_contents_curl();
 
        $doc = new DOMDocument();
        @$doc->loadHTML($html);
 
        $metas = $doc->getElementsByTagName('meta');
        for ($i = 0; $i < $metas->length; $i++){
            $meta = $metas->item($i);
            $prop_tags[$meta->getAttribute('property')] = $meta->getAttribute('content');
        }
        return $prop_tags;
    }
 
    /**
     * Retorna o código de incorporação do video
     * @param int $width largura do embed
     * @param int $height altura do embed
     * @return String Código embed do vídeo
     */
    public function get_embed_video($width = 396, $height = 297){
        $cod_video = explode('watch?v=', $this->link);
        $cod_video = $cod_video[1];
        return "<iframe width=\"$width\" height=\"$height\" src=\"http://www.youtube.com/embed/$cod_video\" frameborder=\"0\" allowfullscreen></iframe>";
    }
}

Siga-me no twitter: @rafaelwendel

Hoje o foco também é PDO. Veremos como fazer o controle de transações utilizando esse módulo.

Segundo a Wikipedia, “o controle de transações é um conjunto de procedimentos que é executado num banco de dados, que para o usuário é visto como uma única ação”. Em outras palavras podemos definir o controle de transações como sendo um processo do banco de dados onde mais de uma query deverá ser executada e todas elas deverão obter sucesso, caso contrário todas as outras terão suas execuções canceladas ou desfeitas.

Para ficar claro, suponha que em uma base de dados nós temos a entidade “conta” e uma outra entidade “movimentos”. Agora imagine que é em certo lugar da aplicação nós podemos lançar um movimento e que a partir das informações dessa movimentação a tabela conta sofrerá uma atualização no seu campo saldo. Até aí tudo bem. Porém é necessário ter uma garantia de que os dados da tabela movimentos foram inseridos sem problemas para que depois o saldo na tabela conta seja atualizado. Em contrapartida se na query de movimentos ocorrer tudo certo e o erro acontecer na segunda query (a da tabela conta) aí a execução de inserção em movimentos deverá ser cancelada (ou desfeita nesse caso).

Para trabalhar com controle de transações devemos levar em consideração que o SGBD deve estar apto à essa funcionalidade. Os mais famosos bancos de dados existentes têm suporte ao controle de transações.

Para implementar um controle de transações de forma correta você precisa entender um pouco mais os 3 comandos a seguir:

- Begin Transaction: comando para indicar onde uma transação será iniciada. A partir desse comando, todas as querys surtirão efeitos permanentes no banco de dados somente quando for executado o commit;

- Commit: comando para confirmar a execução de todas as querys executadas na transação. Após o commit não poderá ser desfeito as manipulações ocorridas. O commit deve ser executado depois de todas as verificações de erros.

- Rollback: comando para desfazer a ação todas as querys que foram executadas na transação. É utilizado sempre que algum erro ocorre.

Vamos a um exemplo prático agora da utilização de transações no PDO. Para isso utilizaremos a analogia dos movimentos e conta descritos anteriormente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<?php
$pdo = new PDO("mysql:host=localhost;dbname=nomeDoBanco", "root", "suaSenha");
if(!$pdo){
    die('Erro ao iniciar a conexão');
}
 
$pdo->beginTransaction();/* Inicia a transação */
$movimento = $pdo->query("INSERT INTO movimentos(idmovimento, data, valor, tipo, idconta) VALUES (1, '2011-12-08', 100, 'entrada', 1)");
 
if(!$movimento){
    die('Erro ao lancar movimento'); /*É disparado em caso de erro na inserção de movimento*/
}
 
$atualiza_saldo = $pdo->query("UPDATE conta SET saldo = saldo + 100 WHERE idconta = 1");
 
if(!$atualiza_saldo){
    $pdo->rollBack(); /* Desfaz a inserção na tabela de movimentos em caso de erro na query da tabela conta */
    die('Erro ao atualizar saldo');
}
 
$pdo->commit(); /* Se não houve erro nas querys, confirma os dados no banco */
echo 'Lançamento efetuado com sucesso!';

Repare que antes de qualquer query eu chamo o método beginTransaction() do objeto $pdo. Feito isso a minha transação está iniciada. Agora insiro os dados na tabela movimento, informando o id da movimentação, a data, o valor, o tipo e a qual conta esse movimento está associado.

Se der erro, uma mensagem será disparada e a aplicação “morre”. Caso contrário ele parte para a segunda query, que é a atualização do saldo na tabela conta que referenciou a movimentação. Se essa query falhar por algum motivo, o comando rollback() é utlizado para que a inserção na tabela de movimentos seja desfeita (cancelada). Se não ocorrer erros o commit() é executado, os dados das duas tabelas são confirmados permanentemente no banco de dados e a transação é finalizada.

Espero que esse post lhes sejam útil.

Até a próxima.

Abs

Siga-me no twitter: @rafaelwendel

Com o PDO é possível desenvolver aplicações mais seguras a nível de banco de dados. Dentre as funcionalidades que ele nos oferece podemos destacar o controle de transações e o uso de prepared statements.

Para ativar o módulo PDO no seu php basta ir ao arquivo de configuração php.ini, localizar as linhas php_pdo.dll e php_pdo_mysql.dll  e descomentá-las (retirar o ponto e viírgula “;” do início da linha ) . Nesse caso estaríamos aptos a utilizar PDO com MySQL. Se você utiliza outro SGBD, basta descomentar a linha referente à ele. Feito isso reinicie o seu servidor de aplicações.

Conexão com o banco de dados utilizando PDO

Bom. Veremos agora como utilizar o PDO, conectar com bancos de dados, executar querys e etc.

Veja como se conectar com um banco de dados via PDO:

1
2
3
4
5

<?php
   $pdo = new PDO("mysql:host=localhost;dbname=nome_banco", "root", "sua_senha");
   if(!$pdo){
       die('Erro ao criar a conexão');
   }

Tarefa simples. Basta informar o sgbd que será utilizado (mysql, mssql, pgsql, firebird, etc), o host, o nome do banco de dados, o usuário e a senha.

Já na conexão com o banco de dados já temos a nossa primeira vantagem com relação à utlização de PDO. Se a aplicação estiver com umas 20 tabelas e umas 200 queryes de manipulação e recuperação de dados  e for necessário mudar de SGBD por qualquer motivo, basta alterar os parâmetros de conexão e pronto!!! Sem a utilização de PDO talvez fosse necessário sair procurando todos os mysql_query e alterar por pg_query  ou msql_query.

Executar querys no banco de dados

Vamos a um exemplo agora de como executar querys via PDO no nosso banco de dados.

Primeiro uma query de inserção de dados.

6
7
8
9
10
11
12

   $executa = $pdo->query("INSERT INTO cliente(idcliente, nome) VALUES ('1', 'Rafael')");
   if($executa){
      echo 'Dados inseridos com sucesso!';
   }
   else{
      print_r($pdo->errorInfo());
   }

Agora um select:

15
16
17
18
19
20
21
22
23

   $rs = $pdo->query("SELECT idcliente, nome FROM cliente")->fetchAll();
   if(!$rs){
      print_r($pdo->errorInfo());
   }
 
   foreach ($rs as $reg){
      echo 'Código: ' . $reg['idcliente'] . '<br />';
      echo 'Nome: ' . $reg['nome'] . '<br /><br />';
   }

Nesse exemplo ele me retorna em forma de array todos os resultados gerados pela consulta. Com isto basta percorrer o array e exibir as informações.

Utilizar prepared statements e bind params

Prepared Statemens são consultas pré-preparadas onde dividimos em partes a inserção do código SQL a ser executado e os valores a serem utilizados (bind params). Com os prepareds statements utilizamos na query os marcadores de lugar e depois informamos quais serão os valores que deverão ser utilizados em cada um dos lugares. Isso fornece mais segurança ao nosso banco de dados e nos previne de ações maliciosas como o SQL Injection.

Temos duas formas de utilizar essa técnica. Primeiro através dos pontos de interrogação ou então através de pseudo-nomes que funcionam como variáveis.

Veja:

26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

   $idcliente = 100;
   $nome = "Rafael Wendel Pinheiro";
   try{
       $stmte = $pdo->prepare("INSERT INTO cliente(idcliente, nome) VALUES (?, ?)");
       $stmte->bindParam(1, $idcliente , PDO::PARAM_INT);
       $stmte->bindParam(2, $nome , PDO::PARAM_STR);
       $executa = $stmte->execute();
 
       if($executa){
           echo 'Dados inseridos com sucesso';
       }
       else{
           echo 'Erro ao inserir os dados';
       }
   }
   catch(PDOException $e){
      echo $e->getMessage();
   }

Preparamos a query e substituimos os valores pelo ponto de interrogação (?). Depois, obedecendo a ordem dos pontos, colocamos cada valor e o tipo de dado daquele atributo.

A outra forma:

46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

   $idcliente = 100;
   $nome = "Rafael Wendel Pinheiro";
   try{
       $stmte = $pdo->prepare("INSERT INTO cliente(idcliente, nome) VALUES (:idcliente, :nome)");
       $stmte->bindParam(":idcliente", $idcliente , PDO::PARAM_INT);
       $stmte->bindParam(":nome", $nome , PDO::PARAM_STR);
       $executa = $stmte->execute();
 
       if($executa){
           echo 'Dados inseridos com sucesso';
       }
       else{
           echo 'Erro ao inserir os dados';
       }
   }
   catch(PDOException $e){
      echo $e->getMessage();
   }

Nesse caso informamos o nome do parâmetro que utilizamos na query e também o valor e tipo de dado que ele deve receber.

Para finalizar vamos ver um exemplo onde o resultado da nossa query nos retorna os obejtos de cada resultado da consulta SQL (seria o equivalente ao mysql_fetch_object).

66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

   $nome = "Rafael Wendel Pinheiro";
   try{
       $stmte = $pdo->prepare("SELECT idcliente, nome FROM cliente WHERE nome = ?");
       $stmte->bindParam(1, $nome , PDO::PARAM_STR);
       $executa = $stmte->execute();
 
       if($executa){
           while($reg = $stmte->fetch(PDO::FETCH_OBJ)){ /* Para recuperar um ARRAY utilize PDO::FETCH_ASSOC */
                echo 'Código: ' . $reg->idcliente . '<br />';
                echo 'Nome: ' . $reg->nome . '<br /><br />';
           }
       }
       else{
           echo 'Erro ao inserir os dados';
       }
   }
   catch(PDOException $e){
      echo $e->getMessage();
   }

E é isso. Em breve escreverei um post mostrando como utilizar o controle de transações com PDO.

Qualquer dúvida utilize a caixa de comentários.

Abs

Siga-me no twitter: @rafaelwendel

Uma forma de se combater esses bots que são programados para ficar executando seus formulários de maneira automática é o CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart), que é uma técnica de verificação exatamente para distinguir humanos de máquinas.

Essa verificação consiste em exibir nos formulários uma imagem distorcida gerada aleatoriamente com alguns caracteres onde o usuário deve preencher um campo de texto informando esses caracteres, caso contrário o formulário não será submetido. Com isso conseguimos evitar quase que 100% a ação dos bots.

Certo. Agora que entendemos um pouco a funcionalidade do CAPTCHA, vamos à uma forma fácil de implementação dessa técnica em nossos formulários.

Para isso utilizaremos a classe Captcha, que pode ser baixada nesse link.

Após baixar e descompactar os arquivos você perceberá a seguinte estrutura de diretórios/arquivos:

Note que temos 3 diretórios e 1 arquivo (captcha.php) na raiz do nosso diretório. No diretório class estão as classes que geram os captchas. Em fonts estão as fontes que os caracteres serão gerados. Já temos a fonte arial mas sinta-se à vontade para adicionar nesse diretório outras fontes de sua preferência. Em gfx tem uma imagem padrão que será exibida caso a imagem do captcha não possa ser gerada por algum motivo. Por fim, o arquivo captcha.php tem como objetivo criar uma instância da classe Captcha e armazenar os caracteres em uma sessão.

Agora iremos criar na raiz mais 2 arquivos: o index.php e o verifica.php. O primeiro será a página onde o formulário estará implementado e o segundo é onde verificamos se o captcha foi digitado corretamente.

Arquivo index.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<html>
    <head>
        <title>Implementando Captchas</title>
        <meta http-equiv="content-type" content="text/html; charset=utf-8" />
    </head>
    <body>
        <h1>Implementando Captchas</h1>
        <form name="form1" method="post" action="verifica.php">
            <img src="captcha.php" alt="captcha" />
            <br />
            <input type="text" name="captcha" />
            <input type="submit" value="Enviar" />
        </form>
    </body>
</html>

Crio um formulário html com a action definida para o arquivo verifica.php e nele coloco uma imagem cuja propriedade src é o arquivo captcha.php. Depois crio um campo de texto com nome captcha que é onde deverá ser digitado pelo usuário o código de verificação da imagem de captcha.

Arquivo verifica.php

1
2
3
4
5
6
7
8
9

<?php
session_start();
 
if($_POST['captcha'] == $_SESSION['captcha']){
    echo 'Verificação OK!';
}
else{
    echo 'Código incorreto';
}

Nesse arquivo eu recupero o valor do campo captcha do formulário que veio via post e verifico se ele é igual à sessão criada lá no arquivo captcha.php. Se forem iguais significa que o código está correto. Caso contrário a verificação falha.

Cabe a você agora incrementar esses scripts de acordo com suas necessidades.

Espero que lhe seja útil

Abs

Siga-me no twitter: @rafaelwendel

Em uma classe implementada nos padrões convencionais, para cada atributo privado declarado e que seu valor necessita ser manipulado “fora da classe”, precisamos criar 2 métodos (o set e o get) para atribuir e recuperar informações nesse atributo

Com os métodos mágicos __set e __get fica mais fácil, porque basta que eu os implemente e eles poderão ser utilizados para todos os atributos que a classe possuir.

Veja um exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13

<?php
    class Pessoa {
      private $nome;
      private $sobrenome;
 
      public function __set($atrib, $value){
          $this->$atrib = $value;
      }
 
      public function __get($atrib){
          return $this->$atrib;
      }
    }

No método __set eu defini 2 parâmetros. No primeiro eu informo o atributo que deverá receber o valor e no segundo eu informo justamente o valor. Já no método __get eu informo apenas o atributo no qual eu desejo capturar o valor armazenado.

Agora vamos a um exemplo de utilização dessa classe:

1
2
3
4
5
6
7

<?php
   $Pessoa = new Pessoa();
   $Pessoa->nome = 'Rafael';
   $Pessoa->sobrenome = 'Pinheiro';
 
   echo 'Nome: ' . $Pessoa->nome . '<br />';
   echo 'Sobrenome: ' . $Pessoa->sobrenome;

Como os atributos são do tipo private, quando eu os invoco no objeto, na verdade o que está sendo executado são os métodos __set e __get. Essa técnica é chamada de overloading

Muito prático, fácil de entender e também de se utilizar.

Até a próxima.

Abs.

Siga-me no twitter: @rafaelwendel