Monthly Archives

7 Articles

Xenocode

Il y a quelques jours, un ami m’a parlé d’un addon pour Firefox qui permettait de virtualiser la plupart des navigateurs internet.

L’extension s’appelle Xenocode et vous pouvez la télécharger chez l’éditeur du même nom. Comme je vous l’ai dit, cette extension sert à virtualiser la plupart des navigateurs internet mais aussi des jeux, lecteurs multimédias, programmes, …

Ce module est très utile pour les développeurs web qui veulent voir comment se comportent les navigateurs avec votre projet. Par contre, et c’est fort dommage, ce module est compatible qu’avec Windows donc messieurs les appleiste et linuxiens vous ne pouvez pas en profiter.

Si vous voulez tester cette extension, allez sur cette page.

Création d’URL valides

Dans l’article d’aujourd’hui je vais vous montrer comment créer une URL valide dans vos vues.

Pourquoi vous l’expliquer ? Et bien car un ami est venu me voir pour ça hier.

D’ailleurs la création d’une url en soit n’est pas très compliquée, voici la syntaxe à utiliser :
$this->url(array('module' => 'nommodule', 'controller' => 'nomcontroller', 'action' => 'nomaction', 'nomparam1' => 'valeurparam1', ...);
Comme on peut voir pour la partie module, controller, action il faut dire d’abord lequel des 3 on veut, puis leur nom. Pour les paramètres c’est différent, on donne le nom du paramètre puis ensuite sa valeur. Vous pouvez voir dans l’url que je suis dans le module blog, le controller index et l’action article. Je passe en paramètre idarticle qui contient l’id de l’article. Si vous modifiez la valeur de cette id, vous aurez un autre article si celui-ci existe.

Pour récupérer vos paramètres dans vos actions, rien de plus simple, vous pouvez utiliser cette méthode :
$this->_request->getParam('nomparam', 'valeurdefaut');
La valeur par défaut est très utile pour éviter des erreurs si vous avez absolument besoin du paramètre.

Voilà, je pense avoir tout dit sur cette partie là et j’espère avoir répondu à vos questions.

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.

Digsby Nouveau MSN ?

De plus en plus de système de messageries instantanées arrivent sur la toile (MSN, jabber, facebook, aim, …). Mais pour chacun, on doit le plus souvent avoir un programme particulier (Windows Live Messenger, Jabber, AIM, Yahoo Messenger).

Un ami est venu me parler de ce problème et m’a montré un client de messagerie instantanée vraiment bien : Digsby. Effectivement, Digsby permet de communiquer sur ses différentes adresses (MSN, Yahoo, Jabber, …) directement. Il peut aussi permettre d’accéder à ses différentes boites e-mail d’un clic et, cerise sur le gâteau, de pouvoir voir les nouveautés sur ses réseaux sociaux favoris (Facebook, twitter, …).

Le seul bémol qui peut en freiner plus d’un est qu’il est en anglais. Mais, il est multi plateforme. Comme sa les personnes qui sont sous Windows, mac et linux pourront en profiter.

Digsby est entièrement personnalisable. On peut changer l’apparence de la liste de contacts ainsi que la fenêtre de conversation.

Pour ma par, l’ayant testé, j’ai tout d’abord été perdu. Mais après 1 journée on prend ses repères et on peut enfin profiter pleinement de ce bijou.

Voici d’ailleurs les thèmes que j’ai appliqués à ma liste de contact et à ma fenêtre de conversation histoire de vous montrer que l’on peut revenir à un environnement familier :

Si vous êtes intéressés par ce client de messagerie, allez directement sur son site : http://www.digsby.com/

Plus loin dans Zendx JQuery Dialog

Bonjours,

après un bref tutorial sur l’utilisation des dialog avec l’extension ZendX JQuery, je vais maintenant expliquer pas à pas quelles sont les options que l’on peut mettre dedans. Si vous voulez, toutes les informations sont disponibles sur le site de JQueryUI.

Comme vous vous en doutez, tout doit être instancié dans cette ligne:
echo $this->dialogContainer($id, $content, $params, $attribs);
Et cela, devrait être instancié dans un tableau $params. Voici la liste des principales options:

  • autoOpen (boolean): permet de savoir si vous voulez que votre fenêtre s’ouvre automatiquement après le chargement de la page ou non. Par défaut est à true. Si vous voulez ouvrir votre fenêtre à partir d’un lien ou d’un bouton vous devrez appeler cette fonction javascript (marche dans un onclick):
    $j('#iddialog').dialog('open');
  • bgiframe (boolean): permet de fixer des erreurs et autres bugs graphiques avec IE6. Je vous conseil fortement de l’activer. Par défaut est à false.
  • closeOnEscape (boolean): permet de fermer la fenêtre en appuyant sur la touche ESC. Par défaut est à true.
  • draggable (boolean): permet de déplacer la fenêtre avec la souris. Par défaut est à true.
  • height (int): permet de fixer la hauteur de votre fenêtre. Par défaut est à ‘auto’.
  • hide (string): Permet de donner un effet spécifique lors de la fermeture de la fenêtre. Par défaut est à NULL.
  • modal (boolean): Permet de faire que la fenêtre prend la main sur toute la page. Vous devez fermer la fenêtre pour reprendre la navigation sur le site. Par défaut est à false.
  • resizable (boolean): Permet de retailler la fenêtre. Par défaut est à true.
  • show (string): Permet de mettre un effet à la fenêtre lors de son ouverture.
  • title (string): Permet de donner un titre à sa fenêtre. Par défaut est à  »
  • width (int): permet de fixer une largeur à sa fenêtre. Par défaut est à 300.

Ensuite vient un paramètre bien particulier, que je vais vous expliquer en détail. Il s’agit de buttons.

Comme on l’a vu plus haut pour les boutons, on doit mettre une fonction comme ceci:
'buttons' => array('Annuler' => new Zend_Json_Expr('function() { $j(this).dialog(\'close\');}'))
Pour en revenir à quelque chose de simple:

  • buttons (array): Permet d’ajouter des boutons à sa fenêtre comme un bouton de fermeture ou un bouton de redirection.

Dans le tableau de boutons, vous devez mettre en premier le nom du bouton et ensuite la fonction qui sera exécutée lorsque l’on clique dessus.

Voilà, j’espère que ce petit complément vous aidera dans la création d’une fenêtre « dialog » en JQuery.