CrisDev - Cristian Medeiros » PHP

PDO e MySQL com UTF-8

cristianmedeiros — Thu, 13 Nov 2008 11:49:31 +0000

Se você esta usando PDO, esta tendo dificuldades com UTF-8 no seu MySQL, mesmo com tudo setado para UTF-8, você pode tentar isso:

$pdo = new PDO(
    ‘mysql:host=localhost;dbname=nomedobanco’,
    "user",
    "pass",
    array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));

O último parametro do construtor do PDO é um array com as opções específicas do driver, no caso, do driver od MySQL. Este parametro é alimentado no velho estilo "array" chave=>valor.

Observem que o parametro (PDO::MYSQL_ATTR_INIT_COMMAND) não se trata de uma configuração de charset, mas sim de um comando que é executado todas as vezes que você conecta no banco. Neste caso, todas as vezes que ele se conecta no banco, ele executa a query "SET NAMES utf8" (acho que é específica do MySQL) que diz para o MySQL utilizar UTF-8 como charset para nossa conexão.

Para saber mais:

Fonte:
http://www.laszlo.nu/post/34159352/how-to-use-utf-8-with-mysql-and-php-data-objects-pdo

Tags BlogBlogs: php, pdo, mysql, utf8, unicode

PHP – Criando e tratando exceptions

cristianmedeiros — Fri, 07 Nov 2008 17:36:24 +0000

Não é novidade, mas vale o registro. O PHP 5, possui uma funcionalidade bem interessante, similar a outras linguagens orientadas a objeto, Exceção. Quando algo altera o fluxo de execução do sistema ele dispara uma Exceção. Uma exceção pode ser disparada ou capturada, depende do que você pretende. Você pode customizar um série de tratamentos de erros que irão facilitar o desenvolvimento do seu sistema, com essa custimização você pode saber exatamente o que está sendo tratado e se algo fugir desse controle é algo anormal e fica mais facil a rastreabilidade.

Dentro de uma exceção, você pode disparar um log, ou um alert, ou registrar algo no banco, é um fluxo de erro sob controle.

Eu costumo tratar as exceções para tudo, campo em branco, tipo de dado inválido, e-mail inválido, ou se alguma fórmula não foi validada. Para isso uso um conjunto de classes que constituem as mensagens e os testes para que as exceções sejam disparadas:

Uma classe Main para controlar as requisições de Exception:

MainException.php:

    /**
    * Declaração da classe para tratamento de erros
    * A classe deve ser extendida da classe Exception do PHP
    * Ela irá realizar a sobrescrita da classe Exception do PHP
    */
    class MainException extends Exception {
        //Faço a declaração das variávis que vou utilizar no corpo da classe
        private    $cod          = 0;
        private    $msg          = "";
        private    $erromsg      = "";

        /**
        * Aqui faço a declaração do método construtor de classe
        * Esse método recebe os seguintes parametros:
        * @param $cod – Código de erro
        * @param $msg – Uma mensagem de erro personalizada
        * @param $erromsg – Uma mensagem de erro padrão
        */

        public function __construct( $cod = 0 , $msg = "" , $erromsg = "" ) {

            //Sobreescrevo as propiedades da classe passando os parametros
            $this->cod = $cod;
            $this->msg = "Ocorreu um erro não identificado";
            $this->erromsg = $erromsg;

            //Aqui eu chamo o construtor da classe pai
            parent::__construct( $this->msg , $this->cod );

        }

        /**
        * Este método irá salvar nossos erros em um log
        */
        public function _Log() {

            //Define o arquivo que será criado ou gravado caso exista, o nome do arquivo irá ser o nome da classe

            $log = __CLASS__ . "_log_" . date("dmY") . "txt";

            //Se não existe arquivo, cria
            if( !file_exists($log)){

                $msg = "/************************************************** " .
                " * Arquivo de log " .
                " * " .
                " * ClassName: " . __CLASS__ . " " .
                " * Data Criação: " . date("d/m/Y H:i") . " " .
                " *************************************************/ " .
                "——————————————————————- ";

            }else
                $msg = "";

                //Abre o arquivo
                if($fp = fopen( $txt , "a+")) {

                //Arquivo
                $msg .=    __CLASS__ . " hora: ".date("H:i") . " " .
                "Erro [ {$this->cod} ]: linha ( {$this->line} ) " .
                "{$this->msg} " .
                "{$this->erromsg} " .
                "——————————————————————- ";

                //Grava
                fwrite($fp, $msg);
                fclose($fp);
            }

        }

    }
?>

A classe abaixo estende MainException e a customiza para Exceções de texto:

textException.php:

/**
* Esta classe é responsável por disparar exceções relacionadas a texto
*/
class textException extends MainException {

      public function __construct( ) {
          //Sobrescrita do construtor de MainException, com os valores que queremos
          parent::__construct( 1, "Tipo de caracter inválido", PHPSELF);

          $this->_Log();

      }

}
?>

A classe abaixo faz a verificação do texto e dispara a exceção:

verificaTexto.php:

class verificaTexto
{
    public function __construct($texto)
    {
        if(!is_int($texto))
        {
            echo $texto;
        }
        else
        {
            throw new textException();
        }
    }

}

?>

A classe abaixo faz o teste para números e caso falhe, dispara MainException, ou seja sem customizar o tipo de exceção que será disparada, então irá enviar a mensagem padrão:

verificaValor.php:

class verificaValor
{
    public function __construct($val)
    {
        if($val == 1)
        {
            echo $val;
        }
        else
        {
            throw new MainException();
        }
    }

}

?>

Apenas para teste:

include ("autoload.php");

try
{

    //$b = new verificaTexto(1);
    $b1 = new verificaValor(1123);

}
Catch(textException $te)
{
    echo $te->getMessage();
}
catch(Exception $e)
{
    echo $e->getMessage();
}

?>

E o autoload se alguém quiser:

function __autoload($class_name) {
require_once $class_name . ‘.php’;
}

?>

Como podem ver, a classe MainException é que faz todo o trabalho, nela temos o método principal que realiza o disparo das exceptions, em textException, sobrespcrevemos a classe MainException e fazemos ela se comportar como queremos para disparar apenas uma mensagem de erro para textos.

Ainda existe a possibilidade de disparar uma Exception genérica, caso nosso tratamento não seja para textos. Se observarem com calma verão que se trata apenas de sobrescritas de métodos algo que seria perfeitamente possível sem Exception, porém desta forma temos mais controle (fora a elegancia do código).

Bom é isso, qualquer dúvida comentem.

Para saber mais:

Exceptions no manual: http://www.php.net/manual/en/language.exceptions.php
Classe MainException original de José Roberto Gomes da Silva: http://www.plugmasters.com.br/sys/materias/914/1/Exception-com-php

Tags BlogBlogs: php, exception, oo

PHP Conference 2008

cristianmedeiros — Fri, 22 Aug 2008 13:33:55 +0000

O PHP Conference deste ano irá se chamar CONAPHP (Congresso Nacional de PHP) e será abrigado pelo CONISLI.

Diferente do ano passado, o evento será realizado em São Paulo (ainda bem, porque Osasco é longe demais) na faculdade FIAP que fica na Av. Lins de Vasconcelos, 1264, bairro Aclimação, nos dias 18 e 19 de outubro. Os valores vão (iam) de R$ 30,00 à R$ 100,00 se você deixar para o último dia.

Mais uma vez, como no ano passado, a programação das palestras ainda não foi divulgada (pelo menos não até a data deste post), e quem esteve esperando para ver se valia a pena ir ao evento pelo conteúdo, não poderá mais aproveitar o preço de abertura, ou seja, os organizadores apostam que todos dêem um tiro no escuro para se inscrever em um evento que não se sabe a programção… well wathever…

As palestras internacionais já estão definidas, teremos Andrei Zmievski, que falará sobre o Unicode do PHP6 (exatamente a mesma coisa que o Lucas Smith veio falar ano passado) e o meu bom amigo Cesar Rodas que irá falar sobre seu projeto no GSoC2008 para o worpress.

Não alimento grande expectativa para esse evento… mas vamos aguardar, talvez a organização venha com alguma surpresa

Tags BlogBlogs: php, conaphp, php conference, conisli

Passar sessões entre subdomínos

cristianmedeiros — Fri, 02 May 2008 21:03:04 +0000

Me questionaram sobre isso recentemente, como recuperar uma sessão em um subdomínio. Temos duas soluções:

Alterar o php.ini :

session.cookie_domain = .meudominio.com.br

Porém isso nem sempre é possível, para tanto podemos setar a configuração direto dentro do nosso php:

Antes do session_start() e antes de qualquer cookie:

ini_set(”session.cookie_domain”, “.meudominio.com.br”);

Pronto, bem simples.

PDO e BEAN no PHP

cristianmedeiros — Fri, 02 May 2008 19:53:47 +0000

PDO é uma extensão nativa no PHP a partir dar versão 5.1, com ela conseguimos trabalhar com diversos bancos de dados sem precisar alterar as as querys feitas (claro que devemos usar SQL ANSI para isso). Para os acostumados com ADODB ou MDB2, o PDO é um facilitador e tanto, pois é nativo do PHP e trabalha a uma velocidade muito superior à essas duas classes.

Implementa cache de query em nível de código (o mesmo que o bind do oracle) e permite uma flexibilidade na manipulação dos resultados tanto como arrays ou objetos.

Por se tratar de uma feature relativamente nova, ela não esta completamente finalizada pelo time do PHP e algumas funções estão disponíveis apenas no cvs.

Um pequeno exemplo de como utilizar o PDO:

^?View Code PHP

prepare("select contenttype, imagedata from images where id=?");
  $stmt->execute(array($_GET['id']));
  $stmt->bindColumn(1, $type, PDO::PARAM_STR, 256);
  $stmt->bindColumn(2, $lob, PDO::PARAM_LOB);
  $stmt->fetch(PDO::FETCH_BOUND);
 
  header("Content-Type: $type");
?>

Eu tenho utilizado PDO com grande sucesso em meus projetos e cada vez mais me acostumo a utiliza-la no lugar de ADODB/MDB2, tenho trabalhado 100% orientado a objetos no padrão BEAN igual ao do java (gosto de manter os dados protegidos dentro do meu código).

Abaixo um pequeno exemplo de como utilizao PDO em meus projetos. O código está comentado, porém se surgirem dúvidas me mande um e-mail ou comente abaixo que eu dou uma força.

Conexao.php:

^?View Code PHP

persistencia = true; }
  }
 
  public function getConnection(){
    try{
      $this->con = new PDO(
          $this->dbType.":host=".$this->host.";
          dbname=".$this->db,$this->user,
          $this->pass,
          array(PDO::ATTR_PERSISTENT=> $this->persistencia)
          );
 
      /*ESTA PROPRIEDADE INDICA COMO O PDO VAI RETORNAR OS
        ERROS SQL NO MODO PDO::ERRMODE_WARNING O RETORNO DO
        ERRO É IGUAL AO QUE VEMOS SEM A UTILIZAÇÃO DO PDO*/
    $this->con->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
      return $this->con;
    }catch(PDOException $ex){
      echo "ERRO:".$ex->getMessage();
    }
  }
 
  public function Close(){
    if($this->con != NULL){
      $this->con = NULL;
    }
  }
}
?>

cliente.php:

^?View Code PHP

id_cliente = $id_cliente;
  }
 
  public function getIdCliente(){
    return $this->id_cliente;
  }
 
  public function setEmail($email){
    $this->email = $email;
  }
 
  public function getEmail(){
    return $this->email;
  }
 
  public function setTelefone($telefone){
    $this->telefone = $telefone;
  }
 
  public function getTelefone(){
    return $this->telefone;
  }
}
?>

clienteModel.php:

^?View Code PHP

con = Conexao::getConnection();
  }  
 
  public function Insert($cliente){
    $query = "insert into cliente (id_cliente, nome, email, telefone)
	          values (:id_cliente,:nome,:email,:telefone)";
    try{
      $stmt = $this->con->prepare($query);
      $stmt->bindValue(':id_cliente',$cliente->getIdCliente());
      $stmt->bindValue(':nome',$cliente->getNome());
      $stmt->bindValue(':email',$cliente->getEmail());
      $stmt->bindValue(':telefone',$cliente->getTelefone());
      return $stmt->execute();
    }catch(PDOException $ex){
      echo $ex->getMessage();
    }
  }
 
  public function Update($cliente){
    $query = "update users set nome=:nome, email=:email,
	          telefone=:telefone where id_cliente=:id_cliente";
    try{
      $stmt = $this->con->prepare($query);
      $stmt->bindValue(':nome',$user->getNome());
      $stmt->bindValue(':email',$user->getEmail());
      $stmt->bindValue(':telefone',$user->getTelefone());
      $stmt->bindValue(':id_cliente',$user->getIdCliente());
      $stmt->execute();
    }catch(PDOException $ex){
      echo $ex->getMessage();
    }
  }
 
  public function Select($query = NULL){
 
    if(trim($query) == NULL){
      $query = "select * from clientes";
      try{
        $stmt = $this->con->prepare($query);
        $stmt->execute();
 
        /*
          ESSE AQUI É O PULO DO GATO: fetchObject(nome_da_classe)
          COM fetchObject COLOCAMOS O RETORNO DO BANCO DE DADOS EM
		  UMA CLASSE COM O NOME ESPECIFICADO NO PARAMETRO
          NO ARQUIVO EM QUE UTILIZAMOS A CONSULTA, TEMOS UM INCLUDE
		  DO ARQUIVO cliente.php QUE POSSUI A DEFINIÇÃO
          DA CLASSE cliente. LOGO, QUANDO A QUERY FOR EXECUTADA,
		  TEREMOS COMO RETORNO UMA CLASSE cliente COM TODOS OS
          ATRIBUTOS PREENCHIDOS PODENDO UTILIZAR OS SET´S E GET´S AUTOMATICAMENTE.
        */
 
        $stmt->fetchObject('cliente');
 
      }catch(PDOException $ex){
        echo $ex->getMessage();
      }
    }else{
      try{
        $stmt = $this->con->prepare($query);
        $stmt->setFetchMode(PDO::FETCH_CLASS, 'cliente');
        $stmt->execute();
 
        /*
          AQUI TEMOS UMA IMPLEMENTAÇÃO DIFERENTE, NÃO TEMOS COMO GARANTIR QUE
		  A QUERY PASSADA RETORNARÁ EXATAMENTE OS ATRIBUTOS DA CLASSE cliente,
		  PORTANTO, SETAMOS O RETORNO PARA A CLASSE cliente, SE O RESULTADO
		  PREENCHER OS ATRIBUTOS, TEREMOS UMA CLASSE cliente COM OS
		  ATRIBUTOS PREENCHIDOS E PODENDO SER MANIPULADA PELOS GET´S E SET´S
		  CASO NÃO, ELE RETORNA UMA CLASSE ONDE OS DADOS PODEM SER
		  ACESSADOS COMO ATRIBUTOS.
        */
 
      return $users = $stmt->fetch(PDO::FETCH_CLASS);  
 
      }catch(PDOException $ex){
        echo $ex->getMessage();
      }
    }
  }
}
?>

operacao.php:

^?View Code PHP

clienteValid();
 
  //CONSULTA
 
  $query = "select * from cliente where id_cliente=".$_REQUEST['cliente'];
  $cliente = $clienteModel->Select($query);
 
  echo $cliente->getNome();
  echo $cliente->getEmail();
 
  //ATUALIZAÇÃO
 
  $cliente->setIdCliente($cliente->getIdCliente());
  $cliente->setNome($cliente->getNome());
  $cliente->setEmail($cliente->getEmail());
  $cliente->setTelefone($_REQUEST['telefone']);
 
  $clienteModel->Update($cliente);
 
  //INSERT
 
  $cliente->setNome($_REQUEST['nome']);
  $cliente->setEmail($_REQUEST['email']);
  $cliente->setTelefone($_REQUEST['telefone']);
 
  $clienteModel->Insert($cliente);
?>

Este código é bem simples, mas é o que tenho utilizado, ele vêm evoluindo com o tmepo, e para minhas necessidades é bem eficiente. O PDO2 está por vir e promente melhorar muito toda essa interface e suporte a outra bancos.

Algumas referências que me ajudaram a entender a utilização do PDO:

Qualquer sugestão me mande, ainda estou aprendendo a trabalhar com PDO.

Edit

Conforme as observações do Dimas Gomez, acertei o código exibido e aproveito para disponibilizar os fontes aqui.

Quanto ao erro “could not find driver” você pode deve habilitar o driver para seu banco de dados em seu php.ini. Como fazer isso está bem descrito no manual do php em http://php.net/pdo.

Tags BlogBlogs: php, pdo, php5, oo

Smarty

cristianmedeiros — Tue, 29 Apr 2008 21:47:59 +0000

A utilização das ferramentas de template estão um tanto quanto sendo crucificadas, um tanto por serem uma “linguagem” paralela ao PHP para se absorver, outro tanto por ser PHP gerando PHP ou HTML, independente da sua teoria, utilizar o HTML fora do código PHP é fundamental. Eu por escolha, gosto do Smarty e o utilizo já a um bom tempo. Gosto também de trabalhar com PHP puro substituindo as tags, mas acho mais trabalhoso, pois preciso escrever os loops e outros condicionais, coisas que o Smarty já faz por mim.

Vou falar um pouco dos casos que mais utilizo Smarty e dar alguns exemplos. Não vou comentar sobre a instalação, pois a mesma é bem simples e bem descrita no site do Smarty.

Algo que já ouvi muito “com Smarty não dá para escrever html padrão”, dá sim, html e smarty são coisas distintas e, apesar do Smarty manipular o html, ele não muda a estrutura já criada, ou seja, se o w3c não valida o html gerado pelo Smarty, é porque o html foi mal escrito.

Para se criar um template, basta pegar um arquivo html e renomeá-lo para .tpl e coloca-lo na pasta template, simples assim? sim, simples assim, a partir desse instante, você tem um template pronto para ser utiizado no seu código.

Exemplo1.tpl:


	
		Teste Smarty
	
	
		TESTE

Salve o código acima na pasta template.

Exemplo1.php:

template_dir = 'templates';
	$smarty->compile_dir = 'templates_c';
	$smarty->cache_dir = 'cache';
	$smarty->config_dir = 'configs';

	$smarty->display('exemplo1.tpl');

?>

E para adicionar algum conteúdo a este template faremos:

Exemplo2.tpl:


	
		Teste Smarty
	
	
		{$conteudo}

Salve o código acima na pasta template.

Exemplo2.php:

template_dir = 'templates';
	$smarty->compile_dir = 'templates_c';
	$smarty->cache_dir = 'cache';
	$smarty->config_dir = 'configs';

	$smarty->assign('conteudo',"VALOR QUE VAI APARECER NA CHAVE");

	$smarty->display('exemplo2.tpl');

?>

Eu costumo “modularizar” meus templates, geralmente em menu e conteudo, pode-se quebrar em mais pedaços, pode-se utilizar um único template para tudo, eu faço assim para facilitar minha vida. O designer sempre esquece algum item do menu ou o analista esquece alguma funcionalidade… e assim vai, separando as peças eu acho mais organizado.

Então com duas partes do layout eu faço assim:

Exemplo3.tpl:


	
		Teste Smarty
	
	
		

			Home
			Cadastro
			Consulta
		

		{$conteudo}

Exemplo3a.tpl:


	
	

	
	

	

{$email_contato}

Exemplo3.php:

template_dir = 'templates';
	$smarty->compile_dir = 'templates_c';
	$smarty->cache_dir = 'cache';
	$smarty->config_dir = 'configs';

	$smarty->assign('conteudo',"VALOR QUE VAI APARECER NA CHAVE");

	$smarty->assign('email_contato','emailcontato@contato.com.br');

	$conteudo = $smarty->fetch('exemplo3a.tpl'); //arquivo que vai montar o "miolo"

	$smarty->assign('conteudo',$conteudo);//processo normal para atribuir um conteudo a uma variável

	$smarty->display('exemplo3.tpl');

?>

Dessa forma podemos separar os conteúdos de cada página em um template sem que isso afete nosso menu. Existem diversas formas de se separar o site com smarty, essa é uma delas

Podemos em nosso template utilizar condicionais para controlar os dados. O comportamento é o mesmo que em qualquer outra linguagem.

Exemplo4.tpl:


	
	

	
	

	

{if $email_contato != NULL}
	{$email_contato}
{/if}

Quando utilizamos template sempre vem aquela pergunta: “mas e se eu tiver uma tabela? com varias linhas? eu gero o html no php e substituo a chave?” bom esta seria uma opção, mas fugiria bastante da idéia de manter o html longe do seu php. Com Smarty podemos realizar um loop em um array de duas formas com foreach e com section:

foreach: usado em arrays associativos ex: $array['nome']
section: usado em arrays indexados ex: $array[1]

Exemplo5.php:

template_dir = 'templates';
	$smarty->compile_dir = 'templates_c';
	$smarty->cache_dir = 'cache';
	$smarty->config_dir = 'configs';

	$dados = array();
	$dados['nome'] = "Zé da Silva";
	$dados['email'] = "ze@dasilva.com.br";

	$infos = array();
	$infos['alerta'] = "Preencha todos os campos.";
	$infos['notificacao'] = "Sua mensagem será respondida em breve.";
	$infos['agradecimento'] = "Obrigado pelo contao.";

	$smarty = new Smarty();

	$smarty->assign('dados',$dados);
	$smarty->assign('infos',$infos);

	$smarty->display('Exemplo5.tpl');

?>

Exemplo5.tpl:

{foreach from=$infos item=informacao}
	{$informacao}

{/foreach}