Page 1

Então você quer escrever um módulo? Introdução Sempre houve um pouco de Voodoo nos módulos associados ao Prestashop. Isso tem sido principalmente uma questão de falta de documentação disponível, mas nunca medo - esta série de tutoriais tem o objetivo de introduzir a escrita de módulo para os programadores PHP. Esta série vai ajudar a construir o nosso próprio módulo totalmente funcional que irá fornecer toda a funcionalidade padrão que é a base para muitos dos módulos mais comuns. Também irá fornecer uma estrutura básica que você pode usar como um modelo para o seu próprio código. Mais tarde artigos vão ajudar a criação de módulos de pagamento e ampliar a interface de administração, mas, inicialmente, vamos dar atenção para a classe de módulos que tratam, principalmente, com a inserção de conteúdo em suas páginas, este artigo demonstra os conceitos fundamentais básicos de desenvolvimento para PrestaShop. Antes de começar Estes artigos requerem, pelo menos, um conhecimento básico de PHP 5.xx e seus conceitos de programação orientada a objeto. É altamente recomendado, devido à forma como o Prestashop renderiza as páginas, que você faça um desenvolvimento de lojas Prestashop, se você não tiver feito (e se você não tiver, então por que não?). Para os efeitos destes artigos estaremos construindo os exemplos com base na versão de desenvolvimento atual (no momento da escrita 1.2.0.6), mas o código vai ser suficientemente genérico que deve funcionar com qualquer versão do PrestaShop, certamente, a partir da versão 1.1 . Você pode achar que é útil também para se familiarizar com as principais ferramentas de terceiros e bibliotecas que o Prestashop usa, e eu particularmente sugiro familiarizar-se com os fundamentos da Smarty. Note-se que o núcleo do Prestashop manipula a inicialização da classe de modelo, de modo a áreas específicas para se familiarizar com a atribuição de variáveis de modelo, a criação (e exibição) de arquivos de modelo, modificadores e funções do modelo. Arquitetura PrestaShop Fundamental para entender como funcionam os módulos do Prestashop é estar ciente de como as páginas do carrinho de compras foram feitas. A arquitetura global é baseado no princípio de um MVC "Model", um "View" e um "Controller". Enquanto o Prestashop não estritamente adere a essa filosofia, é um instrumento útil para usá-lo para visualizar como o aplicativo funciona. Modelos Modelos em Prestashop são fornecidos através de um conjunto de objetos estendidos de uma classe base "ObjectModel". A classe ObjectModel define o comportamento comum necessário para encapsular as tabelas que compõem a loja. Ele fornece a


funcionalidade CRUD(Create, Read, Update e Delete), bem como implementar a base de dados de validação e suporte multi-lingual. Por estender essa funcionalidade básica, classes específicas são criadas para gerenciar os dados utilizados pela loja. Os modelos para prestashop são definidos na pasta classes/ e gerenciam todos os dados contidos no banco de dados (por exemplo, Categoria, Produto, Ordem, configuração, etc.) A convenção é que cada classe é armazenada em um arquivo php cujo nome corresponde ao nome da classe contida, assim Order.php por exemplo, contém a classe Order. Visualizaçoẽs A apresentação dos dados do nosso aplicativo de carrinho de compras é tratado pelo Smarty. Usando uma visão que nos permite separar a lógica de negócio da apresentação. Em um ambiente MVC rigoroso, não deve haver tratamento de dados pela exibição, apenas a exibição de dados passados para ele de um controlador - e na maioria dos casos isso é verdade para o Prestashop, embora alguns Ajax Javascript/ são utilizados por padrão para executar o processamento de dados adicionais. Os arquivos de exibição para Prestashop são em geral armazenados na pasta themes/, com o conjunto específico de arquivos de modelo a ser utilizado sendo selecionáveis a partir da interface de administração. Muitos módulos também armazenam os seus próprios arquivos de modelo específico dentro de sua própria estrutura de diretórios. Controlador O controlador é a lógica do negócio principal para uma "página" ou coleção de páginas relacionadas a ser exibido. Eles são responsáveis por interagir com os "modelos" para recuperar dados, aplicar a lógica de negócio para os dados e enviar os resultados através de um ou mais "Views". No Prestashop estes estão contidos no diretório raiz da instalação da loja, e correspondem às "páginas" principais que compõem a loja virtual. OK, Então, onde os módulos se encaixam? Enquanto o texto acima descreve a funcionalidade central do prestashop, e é suficiente para produzir um carrinho de compras, é um pouco inflexível em termos de adição de novas funcionalidades. Se, por exemplo, você queria modificar a página inicial de sua loja apenas com a arquitetura acima, você teria que modificar a página controlador diretamente para implementar a alteração. Não só isso seria ruim em termos de manutenção do código (você teria que aplicar as alterações e correções de bugs manualmente para todas as suas páginas controlador modificadas quando uma nova versão é liberada), também exige um conhecimento bastante detalhado de programação para implementar as mudanças. A fim de criar um sistema de compras que seja facilmente extensível e de fácil manutenção por um proprietário da loja nãotécnicos, funcionalidades adicionais são inseridas ("HOOKED") na arquitetura acima através da inserção especial "HOOK" no código do


controlador, que podem ser explorados pelo usuário-instalador "plugins" (que o Prestashop se refere como "módulos"). Neste caso, esses módulos têm a capacidade de produção de conteúdos adicionais ou modificados, adicionar novas funcionalidades (lógica de negócio) para os controladores e recolher informações. Módulos de pagamento são uma classe específica de módulo, mas mesmo eles engancham também no padrão de controladores, a fim de fornecer caminhos alternativos de execução de código. Extensões do painel de Administração, operam de forma totalmente diferente e o processo é muito mais parecido com a adição de controladores adicionais, por isso deve ser discutido separadamente. Felizmente, a arquitetura do módulo em Prestashop nos fornece uma maneira bastante simples de adição de uma interface administrativa para todos os módulos, mas no mais complexo dos casos este é o melhor método a utilizar. Resumo Depois de ler este artigo você deve estar familiarizado com os blocos básicos que vão juntos para fazer o carrinho de compras Prestashop. Na próxima parte deste tutorial, vamos olhar para o nosso primeiro módulo de codificação usando esses conceitos e começar a estender o Prestashop.


Criando um módulo básico Introdução Nesta segunda parte da série, vamos procurar criar o nosso primeiro módulo Prestashop básico que pode ser controlado a partir do Back Office. A classe Módulo Similar à classe base ObjectModel, todos os módulos Prestashop são estendidos a partir de uma classe base comum usado para definir a sua funcionalidade básica. A classe "Module" fornece a interface entre as telas de administração e seu módulo, bem como o fornecimento e a internacionalização "HOOK" e a funcionalidade de gerenciamento. Convenções de codificação Antes de podermos escrever o nosso primeiro código, há mais um elemento que precisa ser considerado - o da classe, módulo de diretório e nomes de arquivos No Prestashop, os módulos devem estar localizados dentro do diretório modules/ abaixo do seu diretório base de instalação da loja. Além disso, o diretório do módulo e o arquivo de origem de classe deve ser chamado em letras minúsculas, com o mesmo nome que o módulo de classe que nós escolhemos. Observe que o nome do módulo de classe em si não tem que ser minúsculo (por convenção de nomes de classe usam "Camelcase"), mas é essencial que a pasta que reside no arquivo de origem siga essa convenção. Um módulo "vazio" Nesta parte do tutorial, vamos criar um módulo chamado "TutorialFirst", que demonstra os códigos obrigatórios exigidos para criar o nosso primeiro módulo. O primeiro passo é criar nosso diretório no servidor com o nome "tutorialfirst". Precisamos então criar o arquivo de classe principal do módulo dentro deste diretório e inserir o seguinte código: 01 02 03 04 05 06 07 08 09 10

<?php class TutorialFirst extends Module { function __construct() { $this->name = 'tutorialfirst'; parent::__construct(); $this->tab = 'eCartService.net Tutorials'; $this->version = '0.1.0';


11 $this->displayName = $this->l('First Tutorial Module'); $this->description = $this->l('Our very first module - it does 12 absolutely nothing at all.'); 13 } 14 } 15 // End of: tutorialfirst.php Nós salvamos esse arquivo como "tutorialfirst.php" no diretório do módulo e faremos o upload para o nosso servidor. Embora o código acima não parece muito, é realmente cheio de graças a funcionalidade para a classe base que se estende. Uma vez que você enviou para o seu site de desenvolvimento você será capaz de ver o módulo listadas sob o título de grupo "Tutoriais eCartService.net" e agora você pode instalar e desinstalar. Vamos olhar o que estamos fazendo neste código, e por quê. 1 $this->name = 'tutorialfirst'; 2 parent::__construct(); Estas duas primeiras linhas no construtor da classe estão preocupadas com a configuração das propriedades básicas do módulo e que garanta a adequada herança de funcionalidade exigida da classe base. Primeiro, precisamos definir o nome "interno" do módulo - note que este também segue a convenção de nomeação para o diretório do módulo e arquivo de definição de classe principal, e novamente é o nome da classe em letra minúscula. Uma vez feito isso nós podemos chamar o construtor da classe pai para lhe permitir configurar as outras propriedades internas necessárias do módulo para nós. Em seguida, definimos as propriedades que serão usadas na apresentação de nosso módulo de Back Office. 1 $this->tab = 'eCartService.net Tutorials'; 2 $this->version = '0.1.0'; 3 $this->displayName = $this->l('First Tutorial Module'); $this->description = $this->l('Our very first module - it does 4 absolutely nothing at all.'); A variável de membro $this->tab define como desejamos que o nosso módulo será classificado pelo Back Office na lista de módulos. Em geral, escolheria uma das categorias da norma ("Advertisement", por exemplo, 'Products', 'Tools', 'blocks', etc) no entanto, é inteiramente importante que você deseje usar essa propriedade, e, no caso de estes exemplos, eu escolhi para agrupálos sob o título "Tutoriais eCartservice.net". A variável membro $this->version nos permite exibir a versão atual do módulo na lista de módulos, que permitem aos usuários identificar visualmente qual a versão do nosso módulo que está usando. Isso também pode ser útil para que nos permitem


identificar versões velhas e ultrapassadas de módulo mais tarde, usando um site de distribuição externa do módulo. As duas últimas variáveis membro são usados para exibir informações sobre o nosso módulo na lista de módulos, e são bastante auto-explicativo. Note no entanto que estas estão sendo definidas usando o Módulo de função de classe $this->l() no entanto, ao invés de apenas ser designado diretamente como strings estáticas. A função de membro l() da (classe base) implementa o suporte ao idioma, e permite que o dono da loja possa fornecer traduções. A versão em Inglês do texto que queremos mostrar é passado para esta função e, quando definido desta forma o proprietário da loja pode usar a opção Ferramentas-> Traduções no Back Office para traduzi-las para a linguagem de sua escolha. O envolvimento de qualquer texto estático usado em nosso módulo com esta função permite que a funcionalidade de tradução deva ser usado para todo o texto estático dentro dos módulos que não é dependente da linguagem. Resumo Depois de ler este artigo você deve ser capaz de criar um novo módulo que pode ser listados e controlado a partir do Back Office e, opcionalmente, o Prestashop possa exibir essa informação na própria língua do dono da loja. Na próxima parte deste tutorial, vamos procurar expandir o nosso primeiro módulo para permitir a configuração, e com base nessa configuração, a saída de vídeo em uma área especificada de uma página.


Armazenamento de configuração do módulo Introdução Na terceira parte desta série vamos ver como podemos armazenar dados de configuração para os módulos no banco de dados do Prestashop, e como nós podemos permitir que os usuários interajam com esses dados para controlar o comportamento do módulo. Também vamos tocar brevemente sobre como podemos gerar a saída do nosso módulo para fornecer retorno visual das mudanças de configuração. Gerenciando as configurações de usuário Vamos chamar esse módulo de "TutorialSecond" para que possamos novamente necessitar de criar um novo diretório do módulo e arquivo de classe - que será nomeado "tutorialsecond" e "tutorialsecond.php", respectivamente. O arquivo de classe (tutorialsecond.php) deve conter o seguinte: 01 <?php 02 class Tutorialsecond extends Module 03 { 04 private $_html = ''; 05 06 function __construct() 07 { 08 $this->name = 'tutorialsecond'; 09 parent::__construct(); 10 11 $this->tab = 'eCartService.net Tutorials'; 12 $this->version = '0.1.0'; $this->displayName = $this->l('Second Tutorial 13 Module'); $this->description = $this->l('Our second module - A 14 "Hello world" redux'); 15 } 16 17 public function getContent() 18 { 19 20 } 21 22 private function _displayForm() 23 { 24 25 } 26


27 } 28 // End of: tutorialsecond.php Você vai perceber que temos implementado duas novas funções de membro ::getContent() e ::_displayForm(). Se você fizer o upload do arquivo para o servidor e instalar este módulo, nesta fase, você verá uma nova opção na tela da lista de módulos para o módulo “TutorialSecond”. Haverá agora um link ">>Configure" na entrada do módulo, clicando embora irá apenas retornar um Voltar a página Office. A presença da função de membro getContent() é responsável por isso, uma vez que fornece a interface entre o nosso módulo e o Back Office. Além dessas duas novas funções, temos também acrescentado a variável de membro privado $_html, que usaremos neste artigo para criar a produção necessária para exibir no Back Office. Armazenar e recuperar dados de configuração O Prestashop fornece uma "configuração" de classe que oferece várias funções de membro para manipular os dados de configuração, mas as duas funções-chave que serão os mais usados são: 1 Configuration::updateValue($key, $values, $html = false); 2 Configuration::get($key, $id_lang = NULL); A função configuration::updateValue() permite armazenar uma opção de configuração no banco de dados (opcionalmente em vários idiomas, caso em que o parâmetro $values serão uma matriz) e a função Configuration::get() permite recuperar dados de configuração para um idioma padrão selecionado ou loja. Vamos ignorar os parâmetros que possuem valores padrão por enquanto, mas vamos revisar o parâmetro $html na função configuration::updateValue() no próximo artigo, enquanto vemos o objecto de validação de formulário. Implementação da tela de configuração Em nosso arquivo de origem, criamos uma função de membro privado _displayForm(). Isto é totalmente opcional, como todo o código de interface pode ser colocada na função de membro getContent(), no entanto, é altamente recomendável que você separe isso por uma questão de fácil manutenção de código. Nós vamos criar um formulário simples dentro desta função a partir com a qual podemos capturar a entrada do proprietário da loja. 01 private function _displayForm() 02 { 03 $this->_html .= ' 04 <form action="'.$_SERVER['REQUEST_URI'].'" method="post"> 05 <label>'.$this->l('Message to the world').'</label> 06 <div class="margin-form">


07 08

<input type="text" name="our_message" /> </div> <input type="submit" name="submit" value="'.$this09 >l('Update').'" class="button" /> 10 </form>'; 11 } Você pode ver que a função _displayForm() simplesmente adiciona o código do formulário padrão html para a nossa variável de membro $_html, com o formulário alvo sendo $_SERVER['REQUEST_URI']. A arquitetura do Back Office dará a rota para a nossa função membro ::getContent da classe para nos assegurar quando o formulário for enviado. Estamos próximos de precisar adicionar o código ao nosso getContent() para realmente mostrar o form e asegurar o envio do formulário:. 01 public function getContent() 02 { 03 if (Tools::isSubmit('submit')) 04 { Configuration::updateValue($this->name.'_message', 05 Tools::getValue('our_message')); 06 } 07 08 $this->_displayForm(); 09 10 return $this->_html; 11 } Primeira a função getContent() usa a classe "Tools" do Prestashop para testar se estamos tratando a ação POST do formulário, ou se esta função está sendo chamada de outro modo isto é, um clique no link "Configure" na lista de módulo - o parâmetro é o nome que demos ao nosso botão "update" no formulário. Se a função está sendo chamada diretamente pelo Back Office (no qual Tools::isSubmit(’submit’) irá retornar false), então chamamos a função de renderização do form que criamos acima e retorna a saída, capturado na variável $this->_html, para o Back Office para mostrar. Se a função está sendo chamada como resultado da nossa publicação do form, então, podemos armazenar o nosso parâmetro de configuração no banco de dados com o valor inserido no nosso formulário. Voltamos a usar a classe Tools para obter o valor da variável de formulário usando Tools::getValue(‘our_message’) onde 'our_message' é o nome do campo de entrada no nosso formulário.


Você pode ver que eu adicionei o nome do nosso módulo para o início do nome do item de configuração - isto é para garantir que a chave de configuração é única, porque o espaço para essas chaves são compartilhados por toda a loja. Uma vez que temos dados armazenados, nossa configuração do formulário é exibido novamente, pronto para mais entrada, se necessário. Módulo de saída em uma página Nós agora temos um método de capturar entradas da própria loja e salvá-la no banco de dados, portanto, o próximo passo óbvio seria fazer algo com ele, por exemplo exibi-lo em uma página. Na parte 1 da série falamos de "hooks" em relação aos módulos, adicionando funcionalidade. Para poder utilizá-lo precisamos dizer que o nosso módulo PrestaShop gostaria de conectar com o front office e fazemos isso usando a seguinte função (definido na classe base Module): 1$this->registerHook($hook_name); O parâmetro $hook_name refere-se a um dos diversos pontos que o núcleo do Prestashop permite que os módulos retirem, inserem e/ou processem os dados, mas por enquanto vamos usar um em particular - "leftcolumn', o que nos permite adicionar conteúdo na coluna da esquerda de todas as páginas. A fim de inicializar o gancho precisamos adicionar o seguinte em nossa classe: 1 public function install() 2 { 3 parent::install(); 4 5 if (!$this->registerHook('leftColumn')) 6 return false; 7 } Isto diz ao Prestashop para executar nosso módulo gancho quando ele está retornando o conteúdo para a coluna da esquerda de todas as páginas. Estamos próximos da necessidade de adicionar uma função para lidar com o retorno de gancho. A convenção é o nome da função como o nome do gancho precedido de "hook": 1 public function hookLeftColumn() 2 { return '<div class="block"><h4>'. Configuration::get($this3 >name.'_message') . '</h4></div>'; 4 } No nosso exemplo simples, nós temos apenas o nosso envolvimento no parâmetro de configuração em uma marcação HTML


padrão, para que ele seja exibido corretamente em nossa página. Se você já tiver instalado o módulo, você deve desinstalar e reinstalar agora para garantir que o gancho será registrado corretamente com o núcleo Prestashop. Agora você pode inserir um valor na tela de configuração para o módulo - por exemplo, 'Olá Mundo', e será inserido como o título de uma caixa na coluna da esquerda de sua loja. O código completo para o segundo exemplo deve agora estar como: 01 <?php 02 class Tutorialsecond extends Module 03 { 04 private $_html = ''; 05 06 function __construct() 07 { 08 $this->name = 'tutorialsecond'; 09 parent::__construct(); 10 11 $this->tab = 'eCartService.net Tutorials'; 12 $this->version = '0.1.0'; $this->displayName = $this->l('Second Tutorial 13 Module'); $this->description = $this->l('Our second module - A 14 "Hello world" redux'); 15 } 16 17 public function install() 18 { 19 parent::install(); 20 21 if (!$this->registerHook('leftColumn')) 22 return false; 23 } 24 25 public function getContent() 26 { 27 if (Tools::isSubmit('submit')) 28 { Configuration::updateValue($this->name.'_message', 29 Tools::getValue('our_message')); 30 } 31 32 $this->_displayForm(); 33


34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

return $this->_html; } private function _displayForm() { $this->_html .= ' <form action="'.$_SERVER['REQUEST_URI'].'" method="post"> <label>'.$this->l('Message to the world').'</label> <div class="margin-form"> <input type="text" name="our_message" /> </div> <input type="submit" name="submit" value="'. $this->l('Update').'" class="button" /> </form>'; }

public function hookLeftColumn() { return '<div class="block"><h4>'. 51 Configuration::get($this->name.'_message') . '</h4></div>'; 52 } 53 54 } 55 // End of: tutorialsecond.php Resumo Neste artigo iremos estender o nosso primeiro módulo para incluir uma forma de configuração básica e usar uma função de gancho para mostrar a saída do nosso módulo na coluna da esquerda de nossas páginas. Na próxima parte desta série, vamos procurar melhorar a facilidade de configuração, em algo que poderia ser usada em uma implementação real do módulo. Isto incluirá a validação da entrada do usuário para o formulário, e preencher os campos do formulário conforme o caso com base na configuração atual e mostrar os erros do módulo e avisos nas telas de Back Office.


Validação de formulário e de Segurança Introdução Apesar de ser suficientemente funcional para aquilo que faz, o módulo que criamos na Parte 2 nos apresenta algumas questões a considerar na implementação real dos módulos para estender o Prestashop. Em determinada entrada do usuário que nós capturamos com nosso formulário, foi escrito diretamente para a entrada de configuração, sem qualquer verificação para determinar se ele era válido, nem levamos em conta o tipo de dados que está sendo digitado. Neste tutorial, vamos olhar para a questão geral de verificação de formulário de entrada e de segurança, tanto para o Back Office e Front Office e formas de entrada do usuário, bem como procurando melhorar o nosso código funcional e esteticamente. A classe Configuration revisitado Na Parte 3, que abordou superficialmente um parâmetro adicional que pode ser passado para o método da classe Configuration::updateValue() . Se você chamar a função terá a seguinte forma: 1updateValue($key, $values, $html = false); Na Parte 3, que ignorou o parâmetro $html e permitiu que a função usasse o valor padrão de "false". Ao fazer isso, realmente, inadvertidamente, acrescentou o primeiro elemento de segurança e validação para nosso código. Quando definido como "false" o método updateValue() realmente pré-processa o valor a ser escrito usando o seguinte código ($string is the input value passed to the function): 1$string = strip_tags(nl2br2($string)); Você pode testar inserindo um pouco de HTML na tela de configuração para o módulo que criamos na Parte 3. Você verá que todas as tags de html em sua entrada são removidos. Nós poderíamos modificar o módulo TutorialSecond para permitir a entrada de html no formulário, alterando a linha 29 no arquivo de origem para: 1

Configuration::updateValue($this->name.'_message', Tools::getValue('our_message', true));

Isto ilustra o princípio fundamental de que precisamos empregar todo o nosso próprio código para garantir que ele seja seguro e funcione de maneira previsível. Felizmente o Prestashop nos fornece algumas ferramentas que podemos usar em nosso código para torná-lo mais seguro e robusto.


Validação O Prestashop nos fornece uma classe chamada Validate, que podemos usar para determinar se qualquer entrada do usuário que aceitamos é válido ou não. A lista de funções de membro é bastante grande, mas vale a pena reproduzir alguns deles aqui para ilustrar o ponto - para obter uma lista completa você deve consultar o arquivo classes/Validate.php na sua distribuição Prestashop. 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15

isEmail($email); isFloat($float); isUnsignedFloat($float); isCleanHtml($html); isDate($date); isBool($bool); isPhoneNumber($phoneNumber); isPostCode($postcode); isInt($int); isUnsignedInt($int); isUnsignedId($id); isNullOrUnsignedId($id); isUrl($url); isAbsoluteUrl($url); isFileName($name);

Como exemplo, podemos usar a funcão isCleanHtml() a partir da lista acima como um teste para o módulo para prevenir XSS (cross site scripting) - de maneira que podemos permitir a entrada html com segurança. Validação dos dados do nosso formulário Como antes, vamos criar um novo módulo com base na versão anterior. Por que não tentar modificar a classe Tutorialsecond para criar o módulo Tutorialthird? Se você preferir não, então é só expandir e copiar o código abaixo, conforme apropriado! 01 <?php 02 class Tutorialthird extends Module 03 { 04 private $_html = ''; 05 06 function __construct() 07 { 08 $this->name = 'tutorialthird'; 09 parent::__construct(); 10 11 $this->tab = 'eCartService.net Tutorials';


12 13

$this->version = '0.1.0'; $this->displayName = $this->l('Third Tutorial Module'); $this->description = $this->l('Our third module 14 Security and Validation'); 15 } 16 17 public function install() 18 { 19 parent::install(); 20 21 if (!$this->registerHook('leftColumn')) 22 return false; 23 } 24 25 public function getContent() 26 { 27 if (Tools::isSubmit('submit')) 28 { Configuration::updateValue($this->name.'_message', 29 Tools::getValue('our_message')); 30 } 31 32 $this->_displayForm(); 33 34 return $this->_html; 35 } 36 37 private function _displayForm() 38 { 39 $this->_html .= ' <form action="'.$_SERVER['REQUEST_URI'].'" 40 method="post"> <label>'.$this->l('Message to the 41 world').'</label> 42 <div class="margin-form"> 43 <input type="text" name="our_message" /> 44 </div> <input type="submit" name="submit" value="'. 45 $this->l('Update').'" class="button" /> 46 </form>'; 47 } 48 49 public function hookLeftColumn() 50 {


return '<div class="block"><h4>'. Configuration::get($this->name.'_message') . '</h4></div>'; 52 } 53 54 } 55 // End of: tutorialthird.php 51

A primeira etapa do processo consiste em modificar a nossa getContent() para adicionar a etapa de validação: 01 public function getContent() 02 { 03 if (Tools::isSubmit('submit')) 04 { 05 $this->_postValidation(); 06 07 if (!sizeof($this->_postErrors)) 08 { Configuration::updateValue($this->name.'_message', 09 Tools::getValue('our_message')); $this->_html .= '<div class="conf confirm">'.$this10 >l('Settings updated').'</div>'; 11 } 12 else 13 { 14 foreach ($this->_postErrors AS $err) 15 { $this->_html .= '<div class="alert error">'. 16 $err.'</div>'; 17 } 18 } 19 } 20 21 $this->_displayForm(); 22 23 return $this->_html; 24 } Nós também precisamos adicionar uma declaração para a variável membro $_postErrors que nós introduzimos no início da nossa definição de classe, por exemplo 1 class Tutorialthird extends Module 2 { 3 private $_html = '';


4

private $_postErrors = array();

O fluxo de lógica quando postarmos dados por getContent() agora é nós chamarmos _Validation() para testar as áreas apresentadas e definir a nossa matriz $_postErrors com mensagens de erro. Se houver erros, podemos apresentá-los antes da reapresentação do formulário. Se as verificações de validação são passadas, então vamos mostrar uma mensagem "sucesso" para dar um feedback visual que a configuração foi atualizada. Um teste simples XSS na função _Validation() para o nosso exemplo poderia ser: 1 private function _postValidation() 2 { 3 if (!Validate::isCleanHtml(Tools::getValue('our_message'))) $this->_postErrors[] = $this->l('The message you entered 4 was not allowed, sorry'); 5 } Obviamente você não está limitado a usar os testes fornecidos pela classe Validate, e você também pode aplicar vários testes para cada campo apresentado - para testar comprimento etc. O princípio básico é o mesmo em todos os casos, não importa quão complexa seus requisitos validação são. Resumo Neste artigo, nós melhoramos a nossa forma de manipulação através da adição de validação de entrada do usuário para aumentar a segurança e/ou confiabilidade. Nós também adicionamos um feedback visual quando a configuração foi atualizada com êxito. Na parte final desta série, vamos adicionar alguns toques finais cosméticos a nossa forma de padronizar a interface e melhorar a usabilidade. Vamos também procurar melhorar e estender o "modelo" do módulo que criamos.

Fonte: http://www.ecartservice.net/24072009/writing-your-own-prestashopmodule-part-1/ http://www.ecartservice.net/24072009/writing-your-own-prestashopmodule-part-2/ http://www.ecartservice.net/24072009/writing-your-own-prestashopmodule-part-3/ http://www.ecartservice.net/24072009/writing-your-own-prestashopmodule-part-4/ tradução: Geraldo Sergio Silveira Elvira

Criar modulo  
Read more
Read more
Similar to
Popular now
Just for you