Tag Archives

3 Articles
Utiliser un serveur SMTP externe dans WordPress 3.2+

Utiliser un serveur SMTP externe dans WordPress 3.2+

by Throrïn 3 Comments

Bon, cet article sera fait à chaud après avoir bataillé entre WordPress et un tutoriel existant mais pas à jour. Nous allons donc voir comment utiliser un serveur SMTP externe pour l’envoi d’emails avec WordPress.

Pourquoi faire cela quand WordPress doit normalement tout gérer seul (en théorie). Et bien car parfois, il arrive qu’un serveur n’ai pas de serveur de messagerie installé. Dans ce cas, il se peut que WordPress ne vous renvoie pas d’erreur lors de l’envoie du mail et que celui-ci soit perdu avant d’avoir quitté le serveur.

Pour ce faire, il est possible de modifier le comportement de WordPress et de lui obliger de passer par un serveur SMTP externe à votre serveur Web. Après les explications de base, ouvrez votre WordPress et rendez-vous dans le dossier /wp-includes/. Nous allons enfin mettre les mains dans le cambouis.

Tout d’abord ouvrez le fichier pluggable.php et allez jusqu’à la ligne 462. Vous devriez avoir ceci :

$phpmailer->IsMail();

Nous allons la remplacer par cela :

$phpmailer->IsSMTP();

Cette modification va tout simplement changer la méthode d’envoie des mails par WordPress. Nous lui indiquons ici de passer par les réglages SMTP.

Maintenant, nous allons toucher au fichier class-phpmailer.php. Ce fichier contient la classe PhpMailer qui s’occupe d’envoyer les e-mails. Qu’allons-nous faire dans ce fichier ? Juste renseigner les informations de notre serveur. Tout ceci se déroule entre la ligne 180 et la ligne 217 :

public $Host          = 'adresse de votre serveur';

/**
 * Sets the default SMTP server port.
 * @var int
 */
public $Port          = 25; //port de votre serveur

/**
 * Sets the SMTP HELO of the message (Default is $Hostname).
 * @var string
 */
public $Helo          = ''; //perso je ne m'en sers pas

/**
 * Sets connection prefix.
 * Options are "", "ssl" or "tls"
 * @var string
 */
public $SMTPSecure    = ''; //Si vous avez besoin d'une authentification SSL ou TLS, renseignez le.

/**
 * Sets SMTP authentication. Utilizes the Username and Password variables.
 * @var bool
 */
public $SMTPAuth      = false; //Metre à true si vous devez vous identifier dessus

/**
 * Sets SMTP username.
 * @var string
 */
public $Username      = ''; //login du serveur SMTP

/**
 * Sets SMTP password.
 * @var string
 */
public $Password      = ''; //Mot de passe du serveur SMTP

Voilà, normalement avec tout ceci, vous pouvez maintenant envoyer convenablement des e-mails avec WordPress via un serveur SMTP externe.

Introduction au Framework Zend – Partie 3

Comme promis, voici la suite du tutoriel mais, avant de vous faire l’intégration du Layout, j’aimerais corriger un oubli et pas n’importe lequel car, il est de taille.

J’ai oublié de vous parler de l’ErrorController. Ce contrôleur, d’une importance cruciale, sert à capturer toutes les erreurs Apache que génère votre projet. Il n’existe qu’un seul contrôleur d’erreur pour tout le site et il se trouve dans le module default. Je vais donc vous passer le controller officiel.

Certains le personnalisent afin d’avoir des informations supplémentaires et des fonctions de plus (ajout dans un log, …).

/application/modules/default/controllers/ErrorController.php :

class ErrorController extends Zend_Controller_Action
{
    public function errorAction()
    {
        $errors = $this->_getParam('error_handler');

        switch ($errors->type) { 
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
                // 404 error -- controller or action not found
                $this->view->title = "Erreur 404: Page non trouvée";
                $this->getResponse()->setHttpResponseCode(404);
                $this->view->message = 'Erreur 404 : Page non trouvée';
                break;
            default:
                // application error 
                $this->view->title = "Erreur 500 : Problème d'Application";
                $this->getResponse()->setHttpResponseCode(500);
                $this->view->message = "Erreur 500 : Problème d'Application";
                break;
        } 
        $this->view->exception = $errors->exception;
        $this->view->request   = $errors->request;
    }
}

Et la vue associée /application/modules/default/views/scripts/error/error.phtml :

<h1>Une erreur est apparue</h1> 
<h2><?php echo $this->message; ?></h2> 

<h3>Exception information:</h3> 
<p>
    <b>Message:</b> 
    <?php echo $this->exception->getMessage(); ?> 
</p> 
<h3>Stack trace:</h3> 
<pre>
    <?php echo $this->exception->getTraceAsString(); ?> 
</pre> 
<h3>Request Parameters:</h3> 
<pre>
    <?php var_dump($this->request->getParams()); ?> 
</pre>

Comme ceci, nous aurons plus de facilité pour débugger notre application en cas d’erreur. Bien, maintenant que cet oubli est réparé, nous allons pouvoir commencer à nous occuper du Layout.

Pour cette partie sachez que nous aurons un nouveau dossier. Le dossier application/layouts qui contiendra tous nos fichiers composant la structure du site. J’ai pour habitude de séparer le header, footer et structure globale afin de me faciliter les parties de maintenance du site.

La partie CSS sera stockée dans le dossier /public/styles, la partie JS sera stockée dans /public/scripts et les images du site seront stockées dans /public/images.

Tout d’abord, vous voudrez peut-être voir le rendu final du layout, le voici :

Ensuite je vous passe le CSS : /public/styles/styleprincipal.css

a{
    text-decoration: none;
    color: #FFFFFF;
}
a:visited{}
a:hover{
    color: #724C2A;
}
input{
    border: 1px solid #4083A4;
    font-size: 12px;
    font-family:Arial, Helvetica, sans-serif;
    color: #0A0A0A;
}
#page{
    width: 950px;
    margin-left: auto;
    margin-right: auto;
    overflow: auto;
    font-size: 12px;
    font-family:Arial, Helvetica, sans-serif;
    border: 1px solid #4083A4;
    text-align: left;
}
#header{
    background-color: #4083A4;
    color: #FDFDFD;
    text-align: center;
    padding-top: 40px;
    font-size: 25px;
    height: 105px;
}
#liensheader{
    background-color: #4083A4;
    font-size: 15px;
    padding-bottom: 5px;
    color: #FDFDFD;
}
#liensheader span
{
    margin-left: 15px;
}
#contenu
{
    overflow: hidden;
    padding-left: 10px;
    padding-right: 10px;
    padding-top: 5px;
    padding-bottom: 15px;
    font-size: 12px;
    font-family:Arial, Helvetica, sans-serif;
    position: relative;
}
#contenu a{
    text-decoration: none;
    color: #000000;
}
#contenu a:visited{}
#contenu a:hover{
    color: #724C2A;
}
#piedpage{
    padding-top: 5px;
    padding-bottom: 5px;
    text-align: center;
    border-top: 1px solid #4083A4;
}

Pour finir voici le Layout composé des fichiers : /application/layouts/layout.phtml

<?php echo '<?xml version="1.0" encoding="UTF-8"?>'; ?>
<html xmlns="http://www.w3.org/1999/xhtml">
    <body>
        <div id="page">
            <?php echo $this->partial('header.phtml'); ?>
            <div id="contenu">
                <?php 
                    //cette fonction permet de récupérer la vue de l'action appelée
                    echo $this->layout()->content; 
                ?>
            </div>
            <div id="piedpage">
                Ignoti posticas pervadendoque vero pervadendoque.
            </div>
        </div>
    </body>
</html>

/application/layouts/meta.phtml

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /></code> 

/application/layouts/styles.phtml

<link rel="stylesheet" type="text/css" href="<?php echo $this->BaseUrl(); ?>/styles/styleprincipal.css" />

/application/layouts/header.phtml

<div id="header">Tutoriel ZF</div>
<div id="liensheader">
    <a href="#"><span>Accueil</span></a>
    <a href="#"><span>Identifiez-vous</span></a>
</div>
Le fichier /application/layouts/scripts.phtml est vide car il n’y a pas encore de fichiers Javascripts. Quand à la fonction $this->BaseUrl(); elle retourne le répertoire de base du site. Ici il retournera /tutosite.com. Cela permet à Zend de savoir qu’il faut chercher ces fichiers dans le répertoire public et non dans les actions (sauf si vous avez créer des routes pour sa).

Après tout ceci, il ne nous reste plus qu’à rajouter les lignes suivantes dans le fichier /application/configurations/app.ini à la fin de la partie [production].

; ADD THE FOLLOWING LINES
resources.layout.layout = "layout"
resources.layout.layoutPath = APPLICATION_PATH "/layouts"

Maintenant, si vous allez sur le site http://localhost/tutosite.com, vous devriez tomber sur le même rendu que moi. Après, libre à vous d’en créer de nouveaux et pourquoi pas, de les faire partager ici. Si votre thème est vraiment bien fait, je pourrais l’intégrer pour la suite du tutoriel.

La semaine prochaine, nous allons commencer le module admin avec l’authentification à travers la base de données. Bon week-end à tous.

Création du Bootstrap

Aujourd’hui, on va s’attaquer à une partie très importante du framework. D’ailleurs depuis la 1.8, cette partie a évolué. Je veux bien évidemment parler des fichiers d’amorçages de Zend et plus particulièrement de la classe bootstrap. Je vais vous parler ici des étapes à mettre en œuvre pour pouvoir mener son projet à travers une architecture modulaire. Attention tout de même, je vous parlerai de la partie fonctionnelle du site, pas de celle réservée aux tests unitaires.

A vous de voir après comment découper votre site. Donc voici tout d’abord l’architecture du site que je vais vous commenter + en détail : – Application : contient toute la partie applicative du site : contrôleurs, bootstrap, modules, fichiers de configuration, … – Library : dossier contenant votre bibliothèque personnelle, la library Zend et ZendX. J’y ai aussi placé la Library html2pdf pour générer mes propres pdf. – Public : contient tous les fichiers d’apparence et de confort du site, entre autre vous trouverz vos images, feuilles de style, fichiers à télécharger, scripts javascript, … Deux des fichiers qu’il contient sont importants : index.php permettant d’amorcer le site et le fichier .htaccess contenant les règles de redirection pour le bon fonctionnement du framework Zend. Maintenant que j’ai survolé les dossiers principaux, je vais continuer avec les dossiers à l’intérieur d’application. L’organisation de cette partie est un choix personnel, vous pouvez le modifier : – Configurations : contient tous mes fichiers de configuration .ini pour le bon fonctionnement du site. – Layouts : contient le gabarit (layout) du site. – Modules : contient les différents modules du site. Chaque module contient un fichier bootstrap que je vous expliquerai plus bas et est organisé comme un dossier application standard (dossier controller, forms, models et view). – Le fichier le plus important du site : Bootstrap.php que je vais vous commenter juste en dessous. Maintenant que vous avez eu une présentation de l’organisation choisie pour le site, il faut s’attaquer au fichier public/index.php qui ressemble à ceci :
/**
* Fichier index.php permettant de lancer le bootstrap
*
*/

//Définition du chemin vers le dossier application
defined('APPLICATION_PATH')
|| define('APPLICATION_PATH',
realpath(dirname(__FILE__) . '/../application'));

//Définition de la variable de d'application (utile pour les fichiers de configuration
defined('APPLICATION_ENV')
|| define('APPLICATION_ENV',
(getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV')
: 'production'));

//Partie permettant d'inclure les différentes librairies
//du dossier library (en théorie).
//Nécessite un complément côté bootstrap.
set_include_path(implode(PATH_SEPARATOR, array(
dirname(dirname(__FILE__)) . '/library',
get_include_path(),
)));

/** Zend_Application */
require_once 'Zend/Application.php';

// Créer l'application, le bootstrap et démarre
$application = new Zend_Application(
APPLICATION_ENV,
APPLICATION_PATH . '/configurations/app.ini'
);
$application->bootstrap()
->run();

Ensuite on s’attaque au fichier .htaccess:
php_value include_path "./../library/"
php_value max_execution_time 36000
php_value memory_limit 128M

# The rules below basically say that if the file exists in the tree, just
# serve it; otherwise, go to index.php. This is more future-proof for your
# site, because if you start adding more and more content types, you don't
# need to alter the .htaccess to accomodate them.
# This is an important concept for the Front Controller Pattern which the
# ZF MVC makes use of.
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} -s [OR]
RewriteCond %{REQUEST_FILENAME} -l [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^.*$ - [NC,L]
RewriteRule ^.*$ /toithistoire/index.php [NC,L]

Comme vous pouvez le constater, on voit que l’on inclut ici aussi le dossier Library. Effectivement, sans cette ligne, le fichier index.php n’arrive pas à le trouver et nous retourne une Exception comme quoi Zend/Application.php ne peut être trouvé. Les lignes du temps d’exécution et de la mémoire allouée ne sont pas obligatoires. Elles ont été rajoutées pour éviter les erreurs de surcharge de la mémoire sur le serveur. Maintenant on s’attaque à la partie la plus importante du projet : la classe Bootstrap. Elle se présente tout d’abord comme ceci :
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
}

Que met-on dedans ? Et bien tout ce qui doit être initialisé. C’est-à-dire la base de donnée, les aides d’action, la vue, la pagination, la partie Zend_Config et le chargement des modules. Ceci n’est pas une liste exhaustive, par la suite vous pouvez rajouter le lancement de Zend_Log, Zend_Translate, …

Les fonctions utilisées sont toutes de cette forme :
protected function _initXXX() //XXX le nom de la fonction
Ces fonctions sont toutes exécutées automatiquement à la création du bootstrap. Malgré tout, je vais vous présenter deux fonctions presque obligatoires : _initAutoLoad() et _initView(). La première permettant d’initialiser ce qui se charge automatiquement à savoir ici les modules et ensuite la vue avec tout ce qui y est associé

Pour que votre bibliothèque soit rajoutée dans les classes chargées automatiquement par Zend, vous devez l’indiquer. Moi j’utiliser la fonction _initNamespaces() mais vous pouvez l’appeler autrement ou indiquer son contenu dans _initAutoLoad().. Après avoir rajouté tout ceci, voici à quoi devrai ressembler votre Bootstrap :
/**
* Classe de bootstrap
*
*/
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
/**
* Fonction de chargement
*/
protected function _initAutoload()
{
//on configure le module par défaut avec son namespace,
//son chemin et les ressources associées
$moduleLoader = new Zend_Application_Module_Autoloader(array(
'namespace' => 'Default_',
'basePath' => APPLICATION_PATH . '/modules/default'));
$moduleLoader->addResourceType('Models', 'models', 'Models');
$moduleLoader->addResourceType('Forms', 'forms', 'Forms');
Zend_Session::start();
return $moduleLoader;
}

/**
* Fonction servant à initialiser la vue
*/
protected function _initView()
{
// Initialize view
$view = new Zend_View();
$view->doctype('XHTML1_STRICT');
$view->addHelperPath('Zend/Dojo/View/Helper/', 'Zend_Dojo_View_Helper');
$view->addHelperPath('App/View/Helper/', 'App_View_Helper');
$view->addHelperPath('ZendX/JQuery/View/Helper', 'ZendX_JQuery_View_Helper');
Zend_Dojo::enableView($view);
Zend_View_Helper_PaginationControl::setDefaultViewPartial('pagination.phtml');
// Add it to the ViewRenderer
$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer');
$viewRenderer->setView($view);
ZendX_JQuery_View_Helper_JQuery::enableNoConflictMode();
// Return it, so that it can be stored by the bootstrap
return $view;
}

protected static function _initNamespaces()
{
$autoloader = Zend_Loader_Autoloader::getInstance();
$autoloader->registerNamespace('App_');
}
}

Ceci ne suffit pas à tout faire marcher, vous devez toucher aux fichiers de configuration. Ils sont rangés dans le dossier configuration. Il devra contenir le code suivant pour faire fonctionner un minimum votre application (architecture modulaire et lancement du site) :
[production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"

; Configuration de la gestion des modules
resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"
resources.modules[] = ""

; ADD THE FOLLOWING LINES
resources.layout.layout = "layout"
resources.layout.layoutPath = APPLICATION_PATH "/layouts"

; Base de donnée
resources.db.adapter = PDO_MYSQL
resources.db.params.charset = UTF8
resources.db.params.host = localhost
resources.db.params.username = root
resources.db.params.password =
resources.db.params.dbname = nombdd
resources.db.isDefaultTableAdapter = true

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

Vous devrez ensuite initialiser la lecture de ces fichiers. Pour ce faire, j’utilise la fonction _initconfigs(). Ensuite, je met dans une variable globale au bootstrap toutes les données de la base de donnée pour l’initialiser dans la fonction _initDatabase(). Après ceci, vous devriez avoir le bootstrap suivant. La partie _initRouter elle sert à initialiser la route pour aller au sitemap.xml expliqué dans un articlé précédent.
/**
* Classe de bootstrap
*
*/
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
public static $registry;
public static $db;

/**
* Fonction de chargement
*/
protected function _initAutoload()
{
//on configure le module par défaut avec son namespace, son chemin et les ressources associées
$moduleLoader = new Zend_Application_Module_Autoloader(array(
'namespace' => 'Default_',
'basePath' => APPLICATION_PATH . '/modules/default'));
$moduleLoader->addResourceType('Models', 'models', 'Models');
$moduleLoader->addResourceType('Forms', 'forms', 'Forms');
Zend_Session::start();
return $moduleLoader;
}

/**
* Fonction servant à initialiser la vue
*/
protected function _initView()
{
// Initialize view
$view = new Zend_View();
$view->doctype('XHTML1_STRICT');
$view->addHelperPath('Zend/Dojo/View/Helper/', 'Zend_Dojo_View_Helper');
$view->addHelperPath('App/View/Helper/', 'App_View_Helper');
$view->addHelperPath('ZendX/JQuery/View/Helper', 'ZendX_JQuery_View_Helper');
Zend_Dojo::enableView($view);
Zend_View_Helper_PaginationControl::setDefaultViewPartial('pagination.phtml');
// Add it to the ViewRenderer
$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer');
$viewRenderer->setView($view);
ZendX_JQuery_View_Helper_JQuery::enableNoConflictMode();
// Return it, so that it can be stored by the bootstrap
return $view;
}

/**
* Fonction d'initialisation du Routeur
*/
protected function _initRouter()
{
$this->bootstrap('frontController');
$front = $this->getResource('frontController');

$router = $front->getRouter();
$router->addRoute(
'manageSitemap',
new Zend_Controller_Router_Route('sitemap.xml', array('module' => 'sitemap', 'controller'=>'index','action'=>'index'))
);
return $router;
}

/**
* Fonction servant à charger le fichier de configuration
*/
protected static function _initConfig()
{
$config = new Zend_Config_Ini(APPLICATION_PATH . '/configurations/app.ini',APPLICATION_ENV);
self::$db = $config->resources->toArray();
}

/**
* Fonction servant à initialiser la base de donnée
*/
protected static function _initDatabase()
{
$config = self::$db;
$db = Zend_Db::factory($config["db"]["adapter"], $config["db"]["params"]);
Zend_Db_Table::setDefaultAdapter($db);
}

protected static function _initNamespaces()
{
$autoloader = Zend_Loader_Autoloader::getInstance();
$autoloader->registerNamespace('App_');
}
}

Attention, le travail ne s’arrête pas là, dans chaque module (mis à par le module default), il vous faut un bootstrap pour initialiser les ressources du module.

Ce bootstrap est dérivé de Zend_Application_Module_Bootstrap. Vous n’avez besoin ici de redefinir que _initAutoLoad(). Tout le reste est hérité de votre bootstrap principal. Voici le contenu type du bootstrap d’un module :
/**
* Classe de bootstrap
*
*/
class Sitemap_Bootstrap extends Zend_Application_Module_Bootstrap
{
protected function _initAutoload()
{
$moduleLoader = new Zend_Application_Module_Autoloader(array(
'namespace' => 'Sitemap_',
'basePath' => APPLICATION_PATH . '/modules/sitemap'));
$moduleLoader->addResourceType('Models', 'models', 'Models');
$moduleLoader->addResourceType('Forms', 'forms', 'Forms');
return $moduleLoader;
}
}

Voilà, maintenant vous avez tout en main pour lancer votre projet Zend. Si vous avez un problème n’hésitez pas à poser des questions, j’y répondrait le plus rapidement possible.