A solução que eu usei pra resolver um problema de impressão de notas fiscais foi usar uma classe do PEAR chamada File_PDF, que como o próprio nome já deixa claro, serve para gerar arquivos PDF.

Como todos sabemos, o formato PDF é ideal para situações em que precisamos ter certeza de que ele sempre será impresso da mesma forma, independente da máquina onde é aberto. O problema em usar outros formatos (DOC do Word, por exemplo), é que as informações necessárias para a impressão não ficam no arquivo. Detalhes como as fontes usadas, os tamanhos, acabam dependendo de configurações de cada máquina.

Voltando ao problema, eu tinha um formulário de 10 páginas para testes, com um tamanho não muito usual, e os campos da nota fiscal que eu precisaria preencher.

Pra resolver o problema do posicionamento, não tem outro jeito, tem que medir com régua mesmo. A idéia é anotar as posições X e Y de cada campo, usando milímetros pra evitar números fracionários. O tamanho do papel também se mede com régua, não tem muito mistério.

Tendo o tamanho do papel e o posicionamento de cada campo, o grande truque é gerar um PDF dinamicamente, com “páginas” do tamanho da nossa nota fiscal, e depois posicionar os textos dentro dessa página.

No fim do script, teremos um PDF já todo pronto pra ser mandado para a impressora, tudo já formatado com o tamanho e posição corretas.

Segue o código, por partes.

<?php
require_once 'File/PDF.php';
 
$pdf = File_PDF::factory(Array('orientation' => 'P',
                               'unit' => 'mm',
                               'format' => Array(206,165)
                        ));
$pdf->setFont('Courier','',10);
?>

Até aqui, sem muitos mistérios. Incluí o arquivo da classe File_PDF, e instanciei um objeto em $pdf. A orientação do documento é P (de Portrait, ou “em pé”), a unidade que eu vou usar será milímetros, e o formato da minha folha é de 206 mm de altura por 165 mm de largura. Depois disso, eu escolho a fonte Courier 10 para o documento inteiro.

<?php
foreach ($venda as $item) {
$pdf->addPage('P');
$pdf->text(171,44,$item['nome_cliente']);
$pdf->text(171,49,'Prest. Serv.');
$pdf->text(171,57,$item['data']);
...
 
}
?>

Agora, eu percorro um vetor ($venda) já criado com as informações que eu precisarei colocar na nota fiscal. Para cada entrada desse vetor, eu crio uma nova página com a mesma orientação (em pé). A partir daí, é só posicionar cada texto. Em 171 x 44, coloco o nome do cliente, em 171 x 49, a natureza da operação, em 171 x 57, a data da venda, e por aí vai.

<?php
header("Content-type: application/pdf");
$pdf->output('notas.pdf',false);
?>

Para terminar, dou a saída do documento. Marco o tipo da saída para “application/pdf”, e mando o objeto soltar o documento para o navegador com o nome de “notas.pdf”. O segundo parâmetro é se a saída é inline ou como um arquivo para download. Passamos false para que o navegador entenda que o PDF é para ser baixado.

Se tudo deu certo, o navegador vai perguntar se você quer abrir ou salvar o PDF. Se abrir em algum programa como o Adobe Reader, basta imprimir diretamente do programa, e bingo. Resolvida a questão.

Artigos relacionados

• XML no PHP com XML_Serializer, parte 2 de 2
• XML no PHP com XML_Serializer, parte 1 de 2
• Validação de dados em PHP
• Agendando eventos no WordPress
• Removendo o “generator” do Wordpress
• Escrevendo plugins para o Wordpress
• Evitando SQL injection em PHP
• Criando CAPTCHAs em PHP
• Pegadinhas no PHP
• Otimização em PHP, parte 1: Minify
• Precedência no PHP
• Envio de emails em PHP
• Segurança no envio de emails em PHP

Nesta segunda parte, veremos como fazer o inverso, ou seja, transformar um documento XML em uma variável no PHP.

Um pequeno problema

Um problema que podemos ter é em relação ao mapeamento de dados do XML para classes no PHP. Como o XML normalmente não possui a informação de qual classe do PHP corresponde a quais entidades do XML, isto precisará ser informado por nós, caso queiramos fazer este mapeamento. Caso contrário, teremos arrays ou instâncias de StdClass, a classe genérica do PHP, para descrever os objetos. Veremos como resolver isto mais adiante.

Isto não se aplica ao nosso exemplo, pois utilizamos type hints na geração do XML, para não termos a informação perdida.

O script

Assumindo que gravamos o XML gerado pelo exemplo anterior em um arquivo chamado doc.xml, o seguinte script irá ler e traduzir o XML:

<?php
require 'XML/Unserializer.php';
 
$unserializer = new XML_Unserializer();
$unserializer->unserialize("erro.xml", true);
$erro = $unserializer->getUnserializedData();
print_r($erro);
?>

O segundo parâmetro passado para o método unserialize() especifica que o primeiro parâmetro é o nome de um arquivo, e não uma string com o XML. A saída deste script é a variável com o erro original.

PEAR_Error Object
(
    [error_message_prefix] => 
    [mode] => 1
    [level] => 1024
    [code] => 999
    [message] => rah!
    [userinfo] => 
    [backtrace] => Array
        (
            [0] => Array
                (
                    [file] => /usr/share/php/PEAR.php
                    [line] => 576
                    [function] => PEAR_Error
                    [class] => PEAR_Error
                    [type] => ->
                    [args] => Array
                        (
                            [0] => rah!
                            [1] => 999
                            [2] => 1
                            [3] => 1024
                            [4] => 
                        )
 
                )
 
            [1] => Array
                (
                    [file] => /home/lustosa/xml.php
                    [line] => 4
                    [function] => raiseError
                    [class] => PEAR
                    [type] => ::
                    [args] => Array
                        (
                            [0] => rah!
                            [1] => 999
                        )
 
                )
 
        )
 
    [callback] => 
)

O objeto só foi retornado exatamente ao estado original por causa das type hints que colocamos ao gerar o XML. Caso não tivéssemos colocado, teríamos problemas nesse ponto, pois as informações do tipo de dado original teriam sido perdidas, e precisaríamos dar algum tratamento extra para termos exatamente o objeto original.

Normalmente, ao desenvolver, nós temos que fazer ou uma parte ou outra. Ou precisamos disponibilizar dados em XML para alguém, ou precisamos processar dados em XML gerados por alguém.

Caso a necessidade seja a geração, muito provavelmente os programadores que irão tratar o XML não precisarão dessas informações extras de tipo, pois são pertinentes apenas ao sistema de origem, onde o XML foi gerado.

E da mesma forma, caso precisemos apenas processar um XML gerado, a informação do tipo original nem sempre é útil para nós. Porém, dependendo da estrutura do XML, pode ser útil fazer o mapeamento de algumas estruturas do XML para classes no PHP preparadas para receber a informação do XML.

Existem diversas opções que podem ser passadas para o Unserializer, de forma a fazer este mapeamento. Temos, por exemplo:

• complexType, que deve ser setado ou para ‘array’ ou para ‘object’, dependendo de como se deseja receber os dados do XML. Por padrão, a conversão é feita para arrays.
• tagMap, que recebe um array associativo, com as chaves correspondendo às entidades do XML, e os valores correspondendo à classe no PHP.

Assim, se no XML temos uma tag <util> e queremos mapeá-la a um objeto do tipo XML_Util, poderíamos passar para o Unserializer um array como o seguinte:

$opt = Array('complexType' => 'object',
             'tagMap' => Array('util' => 'XML_Util');

Pronto, teremos objetos no lugar de arrays, que por padrão serão objetos genéricos, do tipo StdClass, mas que no caso das tags ‘util’, serão mapeados para objetos do tipo XML_Util.

Existem muitas outras opções que podem ser usadas, dependendo to nível de customização necessário.

Conclusão

O PHP disponibiliza várias opções para mexermos com XML, e embora o SimpleXML e o DOM sejam opções bem populares, a classe XML_Serializer do PEAR pode ser uma opção bastante versátil, dependendo do que se deseja fazer.

Artigos relacionados

• XML no PHP com XML_Serializer, parte 1 de 2
• Imprimindo em formulários contínuos em PHP
• Validação de dados em PHP
• Agendando eventos no WordPress
• Removendo o “generator” do Wordpress
• Escrevendo plugins para o Wordpress
• Evitando SQL injection em PHP
• Criando CAPTCHAs em PHP
• Pegadinhas no PHP
• Otimização em PHP, parte 1: Minify
• Precedência no PHP
• Envio de emails em PHP
• Segurança no envio de emails em PHP

Uma das formas é tratar o documento como uma grande string, e ir “fatiando” as tags para se conseguir buscar os valores desejados. De todos, acredito que este seja o método menos flexível, pois ignora toda a estrutura do documento. Além disso, fica bastante complexo extrair informações de objetos compostos codificados em XML (um Array de objetos, por exemplo). Porém, é uma forma simples, e que não requer muito conhecimento (apenas as funções de tratamento de string, ou expressões regulares).

O PHP disponibiliza outras formas de se trabalhar com XML, como as funções para leitura de XML usando a API de DOM, e também a bastante conhecida SimpleXML.

Como mais uma alternativa, apresentarei as classe XML_Serializer e XML_Unserializer do PEAR.

PEAR XML_Serializer

Esta classe do PEAR transforma tipos de dados complexos, como arrays e objetos, em um documento XML. Seu uso é bastante simples, e para ilustrar com um objeto um pouco complexo, vou usar o método raiseError da classe PEAR para gerar um objeto de erro.

<?php
require 'XML/Serializer.php';
 
$erro = PEAR::raiseError('rah!', 999);
print_r($erro); // Imprime a estrutura do objeto na tela
 
// Serializa o erro em um documento XML
$opt = Array('indent'  => '  ',
             'addDecl' => true,
             'typeHints' => true);
$serializer = new XML_Serializer($opt);
$serializer->serialize($erro);
print $serializer->getSerializedData();
?>

Executando-se este script, primeiro temos impressa a estrutura do erro gerado, com a função print_r():

PEAR_Error Object
(
    [error_message_prefix] => 
    [mode] => 1
    [level] => 1024
    [code] => 999
    [message] => rah!
    [userinfo] => 
    [backtrace] => Array
        (
            [0] => Array
                (
                    [file] => /usr/share/php/PEAR.php
                    [line] => 576
                    [function] => PEAR_Error
                    [class] => PEAR_Error
                    [type] => ->
                    [args] => Array
                        (
                            [0] => rah!
                            [1] => 999
                            [2] => 1
                            [3] => 1024
                            [4] => 
                        )
 
                )
 
            [1] => Array
                (
                    [file] => /home/lustosa/xml.php
                    [line] => 4
                    [function] => raiseError
                    [class] => PEAR
                    [type] => ::
                    [args] => Array
                        (
                            [0] => rah!
                            [1] => 999
                        )
 
                )
 
        )
 
    [callback] => 
)

E em seguida, fazemos a conversão deste objeto usando o XML Serializer. Existem várias opções que podem ser passadas para o construtor, mas no exemplo só passei o parâmetro que especifica o que deve ser usado para indentar o código (no caso, escolhi 2 espaços em branco), e o parâmetro addDecl, que coloca o prólogo XML no início do documento. O prólogo XML é a declaração que inicia todo documento XML (<?xml version=”1.0″ ?>).

Além disso, como pretendo usar a saída em XML deste exemplo na segunda parte deste artigo, também passei a opção typeHints, que coloca atributos nas tags com “dicas” sobre o tipo original do dado. Isto é necessário para que a decodificação seja feita com sucesso, pois sem ela, as informações de qual tipo o dado é (objeto, de qual classe, ou array, etc) são perdidas.

A saída do método getSerializedData() já é o documento XML formatado:

<?xml version="1.0"?>
<PEAR_Error _class="PEAR_Error" _type="object">
  <error_message_prefix _type="string" />
  <mode _type="integer">1</mode>
  <level _type="integer">1024</level>
  <code _type="integer">999</code>
  <message _type="string">rah!</message>
  <userinfo _type="NULL" />
  <backtrace _type="array">
    <XML_Serializer_Tag _originalKey="0" _type="array">
      <file _type="string">/usr/share/php/PEAR.php</file>
      <line _type="integer">576</line>
      <function _type="string">PEAR_Error</function>
      <class _type="string">PEAR_Error</class>
      <type _type="string">-&gt;</type>
      <args _type="array">
        <XML_Serializer_Tag _originalKey="0" _type="string">rah!</XML_Serializer_Tag>
        <XML_Serializer_Tag _originalKey="1" _type="integer">999</XML_Serializer_Tag>
        <XML_Serializer_Tag _originalKey="2" _type="integer">1</XML_Serializer_Tag>
        <XML_Serializer_Tag _originalKey="3" _type="integer">1024</XML_Serializer_Tag>
        <XML_Serializer_Tag _originalKey="4" _type="NULL" />
      </args>
    </XML_Serializer_Tag>
    <XML_Serializer_Tag _originalKey="1" _type="array">
      <file _type="string">/home/lustosa/xml.php</file>
      <line _type="integer">4</line>
      <function _type="string">raiseError</function>
      <class _type="string">PEAR</class>
      <type _type="string">::</type>
      <args _type="array">
        <XML_Serializer_Tag _originalKey="0" _type="string">rah!</XML_Serializer_Tag>
        <XML_Serializer_Tag _originalKey="1" _type="integer">999</XML_Serializer_Tag>
      </args>
    </XML_Serializer_Tag>
  </backtrace>
  <callback _type="NULL" />
</PEAR_Error>

Pronto! Transformamos o objeto em um XML válido. Você talvez tenha notado várias tags XML_Serializer_Tag espalhadas pelo XML. Isto acontece quando temos um array de índices numéricos. Os atributos ‘_type’ e ‘_originalKey’ são as dicas mencionadas anteriormente, e ajudarão o XML Unserializer a retornar o XML para o objeto original.

Na parte 2 deste artigo, veremos a classe XML_Unserializer, que faz justamente o trabalho inverso, transformando um documento XML em uma variável no PHP.

Artigos relacionados

• XML no PHP com XML_Serializer, parte 2 de 2
• Imprimindo em formulários contínuos em PHP
• Validação de dados em PHP
• Agendando eventos no WordPress
• Removendo o “generator” do Wordpress
• Escrevendo plugins para o Wordpress
• Evitando SQL injection em PHP
• Criando CAPTCHAs em PHP
• Pegadinhas no PHP
• Otimização em PHP, parte 1: Minify
• Precedência no PHP
• Envio de emails em PHP
• Segurança no envio de emails em PHP

A validação é importantíssima, pois sem ela, o programa pode trabalhar com dados inválidos, e muitos problemas podem acontecer:

Resultados inesperados

Se o programa pede, por exemplo, um número entre 1 e 100, o usuário entra com 200, e o programa não faz essa checagem, pode acabar utilizando o número em alguma conta e terminando com um resultado inválido.

Segurança

Um dos problemas mais graves da falta de checagem, quando por exemplo a entrada do usuário é utilizado diretamente em uma query SQL ou como parâmetro de um comando. Os dados entrados pelo usuário podem manipular a query ou o comando e conseguir acesso não autorizado ao banco de dados ou ao servidor.

Dados inconsistentes

Se, por exemplo, em um campo onde deveria se entrar um CEP, o usuário coloca números inválidos, letras, ou deixa em branco, o a empresa terá problemas, por exemplo, para enviar uma mala direta postal para seus clientes.

No caso de aplicações em PHP, com a saída via web, a validação ainda deve ser feita, preferencialmente, duas vezes: uma do lado do cliente (em Javascript) para se evitar que os dados inválidos sejam enviados, e outra do lado do servidor (em PHP), para evitar que dados inválidos tenham sido enviados por um navegador sem Javascript (ou com o Javascript desligado), ou maliciosamente por alguem. A validação em Javascript foge do escopo deste artigo, que irá tratar da validação dos dados em PHP.

A classe PEAR Validate

Sempre que possível, devemos evitar reescrever código já disponível, principalmente quando o código já disponível é de qualidade, como acontece com a maioria das classes disponíveis no PEAR, que devem seguir uma padronização de código bem rigorosa para serem aceitas.

Uma das classes disponíveis no PEAR é a Validate, que é uma classe genérica para validação de dados. A classe pode validar os seguintes tipos de dados:

• Números, podendo-se especificar valor mínimo e máximo, e número de casas decimais;
• Emails, checando a sintaxe do email, se o domínio é válido, e se o email está no formato da RFC 822;
• Strings, com constantes pré-definidas para facilitar a validação de maiúsculas e minúsculas, tamanho da string, entre outras;
• Datas, com checagem de data mínima e máxima, e se o formato é RFC 822;
• URLs, checando se o formato é válido (de acordo com a RFC 2396).

A utilização é bastante simples. Uma vez instalada (é apenas um arquivo, chamado Validate.php), basta chamar estaticamente seus métodos, passando o dado a ser validado como primeiro parâmetro, e as opções de validação (quando aplicáveis) como segundo parâmetro. Os métodos retornam true ou false, indicando se a validação passou ou não.

Por exemplo, para validar um número em $num como sendo um número de 0 a 100 com no máximo 2 casas decimais, a chamada seria a seguinte:

<?php
$opt = Array('decimal' => '.',
             'dec_prec' => 2,
             'min' => 0,
             'max' => 100);
if (Validate::number($num, $opt)) {
    // validação ok!
}
?>

Os outros métodos são semelhantes, e para se saber quais são as opções que podem ser passadas, basta olhar os métodos disponíveis diretamente na documentação da classe, ou então diretamente dentro do arquivo da classe.

A classe PEAR Validate_ptBR

Assim como a classe Validate provê métodos úteis para a validação de dados genéricos, temos também disponível a classe Validate_ptBR, que disponibiliza métodos para validação de dados específicos do Brasil. A classe valida os seguintes tipos de dados:

• CEP, com 8 dígitos;
• CPF, checando se os dígitos verificadores correspondem ao restante do número;
• CNPJ e PIS, também usando a checagem de dígitos verificadores;
• Estados brasileiros (siglas);
• Números telefônicos, com ou sem código de área;
• Placas de carros, com 3 letras e 4 dígitos.

A utilização da classe é semelhante à classe Validate, bastando chamadas estáticas aos seus métodos. Assim como na classe Validate, para saber os métodos disponíveis e seus parâmetros, basta examinar a documentação da classe.

Artigos relacionados

• Imprimindo em formulários contínuos em PHP
• XML no PHP com XML_Serializer, parte 2 de 2
• XML no PHP com XML_Serializer, parte 1 de 2
• Agendando eventos no WordPress
• Removendo o “generator” do Wordpress
• Escrevendo plugins para o Wordpress
• Evitando SQL injection em PHP
• Criando CAPTCHAs em PHP
• Pegadinhas no PHP
• Otimização em PHP, parte 1: Minify
• Precedência no PHP
• Envio de emails em PHP
• Segurança no envio de emails em PHP