WordPress: per un approccio object-oriented nella gestione del codice
Un esempio pratico su come usare un approccio object-oriented nella gestione del codice di WordPress.
Quasi tutti i temi di WordPress che ho visto sinora trattano le pagine dei contatti e i form dei contatti nel modo sbagliato. Mi spiego: essi tendono ad inserire le procedure di validazione del form e l’invio e-mail direttamente nel template della pagina. In realtà, il template della pagina dovrebbe essere il più snello possibile, evitando quello che a buon diritto può essere considerato come “spaghetti code”. PHP 5 dispone di potenti funzionalità orientate agli oggetti, quindi seguiremo un approccio OOP per separare la logica dalla struttura in un form di contatti.
La classe dei contatti
La seguente classe Contact svolge due compiti:
- valida i dati
- invia l’e-mail
Ecco il suo codice:
|
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 |
class Contact
{
const TO = 'cliente@sito.it;
protected $name;
protected $lastname;
protected $address;
protected $phone;
protected $fax;
protected $email;
protected $vat;
protected $request;
public $message;
public function __construct()
{
$this->name = $_POST['name'];
$this->lastname = $_POST['surname'];
$this->address = $_POST['address'];
$this->phone = $_POST['phone'];
$this->fax = $_POST['fax'];
$this->email = $_POST['email'];
$this->vat = $_POST['vat'];
$this->request = $_POST['request'];
}
protected function send()
{
$headers = "From: " . $this->name . " " . $this->lastname . " " . "<". $this->email . ">" . "\r\n";
$text = 'Nome: ' . $this->name . "\n";
$text .= 'Cognome: ' . $this->lastname . "\n";
$text .= 'Indirizzo: ' . $this->address . "\n";
$text .= 'Telefono: ' . $this->phone . "\n";
$text .= 'Fax: ' . $this->fax . "\n";
$text .= 'E-mail: ' . $this->email . "\n";
$text .= 'Codice fiscale/Partita IVA: ' . $this->vat . "\n\n";
$text .= 'Richiesta: ' . "\n" . $this->request . "\n";
$subject = '[Sito Cliente]: Richiesta';
if(@mail(self::TO, $subject, $text, $headers)) {
$this->message = '<div class="success">E-mail inviata con successo.</div>';
} else {
$this->message = '<div class="error">' . "Errore durante l'invio. Riprova in seguito." . '</div>';
}
}
protected function validate()
{
$errors = array();
$patterns = array(
'nome' => '/^[a-z\s]+$/i',
'cognome' => '/^[a-z\s]+$/i',
'indirizzo' => '/^[a-z0-9\s\(\),]+$/i',
'tel' => '/^\d+$/',
'fax' => '/^\d+$/',
'email' => '/^[a-z-0-9_+.-]+\@([a-z0-9-]+\.)+[a-z0-9]{2,7}$/i',
'fiscale' => '/^[a-z0-9]+$/i'
);
$messages = array(
'nome' => '[Nome]: Solo caratteri alfabetici e spazi.',
'cognome' => '[Cognome]: Solo caratteri alfabetici e spazi.',
'indirizzo' => '[Indirizzo]: Solo caratteri alfanumerici e spazi.',
'tel' => '[Tel]: Solo numeri.',
'fax' => '[Fax]: Solo numeri.',
'email' => '[E-mail]: Formato e-mail non valido.',
'fiscale' => '[Codice fiscale o Partita IVA]: Solo caratteri alfanumerici.',
'richiesta' => '[Richiesta]: Il campo non deve essere vuoto.'
);
if(empty($this->name) || !preg_match($patterns['nome'], $this->name)) {
$errors[] = '<div class="error" rel="name">' . $messages['nome'] . '</div>';
}
if(empty($this->lastname) || !preg_match($patterns['cognome'], $this->lastname)) {
$errors[] = '<div class="error" rel="surname">' . $messages['cognome'] . '</div>';
}
if(empty($this->address) || !preg_match($patterns['indirizzo'], $this->address)) {
$errors[] = '<div class="error" rel="address">' . $messages['indirizzo'] . '</div>';
}
if(empty($this->phone) || !preg_match($patterns['tel'], $this->phone)) {
$errors[] = '<div class="error" rel="phone">' . $messages['tel'] . '</div>';
}
if(!empty($this->fax)) {
if(!preg_match($patterns['fax'], $this->fax)) {
$errors[] = '<div class="error" rel="fax">' . $messages['fax'] . '</div>';
}
}
if(!preg_match($patterns['email'], $this->email)) {
$errors[] = '<div class="error" rel="email">' . $messages['email'] . '</div>';
}
if(empty($this->vat) || !preg_match($patterns['fiscale'], $this->vat)) {
$errors[] = '<div class="error" rel="vat">' . $messages['fiscale'] . '</div>';
}
if(empty($this->request)) {
$errors[] = '<div class="error" rel="request">' . $messages['richiesta'] . '</div>';
}
return $errors;
}
public function output()
{
$errors = $this->validate();
if(count($errors)) {
$this->message = implode('', $errors);
} else {
$this->send();
}
return $this->message;
}
} |
La classe ha un metodo pubblico, Contact::output(), e una proprietà pubblica, Contact::message. Il metodo serve appunto a visualizzare il messaggio destinato all’utente, che può essere sia un messaggio di conferma dell’avvenuto invio dell’e-mail sia una lista di errori di validazione.
Potete inserire il codice della classe in un file che chiamerete NomeTemaContact.php e che andrete ad inserire in una directory apposita all’interno del vostro tema (per esempio includes o scripts).
Usare la classe dei contatti
Quindi dovete includere la classe nel vostro template della pagina contatti. Usate il seguente codice all’inizio del file:
|
1 2 3 4 5 |
<?php
require_once(WP_CONTENT_DIR . '/themes/nometema/includes/NomeTemaContact.php');
$contact = new Contact();
//...
?> |
A questo punto dovete intercettare l’invio del form. Assegnate un attributo name all’elemento input di tipo submit del form e quindi inserite il seguente codice nel punto del template in cui volete che compaia l’output della classe Contact:
|
1 2 3 4 5 6 7 8 |
<?php
if(isset($_POST['invio'])) {
echo $contact->output();
}
?> |
Come potete notare, abbiamo evitato di inquinare il template della pagina con del codice che invece può essere inserito in una classe apposita.
Nota finale
La marcatura generata dal metodo pubblico della classe può anche essere gestita con l’uso di un sistema di template (per esempio tramite file PHTML). Consiglio questo approccio quando ci si trova a dover gestire considerevoli quantità di contenuti HTML.
Nessun commento
Trackback
I commenti sono chiusi.