Le célèbre moteur de Blog / CMS WordPress est de plus en plus utilisé dans des contextes de fortes charges (traffic important).

Contrairement à des CMS plus « professionnels » comme Drupal, eZPublish, WordPress de manière native est très peu abouti en terme de performances surtout au niveau de la gestion du cache.

Dans cet article, je vais vous présenter les éléments essentiels pour que votre instance de WordPress soit performante et pour qu’elle puisse supporter un trafic important en jouant sur la configuration de  Wordpress, l’utilisation de plugins d’optimisations, la configuration de PHP et l’utilisation de logiciels tiers.

1. Alléger au maximum votre WordPress

Zend vient de diffuser une première version de développement de Zend Framework 2.0 afin de faire découvrir les quelques nouveautés de la bibliothèque PHP5.

Au programme, tout comme Symfony 2, Zend Framework 2.0 sera entièrement conçu pour PHP 5.3 avec les « namespaces ».

Pas de nouvelle pour Zend Tool à l'heure actuelle

Toutefois rien de bien nouveau sur cette version de développement. Elle correspondant principalement aux librairies de ZF 1.10.

Les seuls nouveautés concernent apparemment les tests unitaires qui seraient plus simplifiés, une ré-écriture totale de Zend_Session ainsi que l’ajout d’une nouvelle librairie Zend_stdlib permettant d’appeller les librairies standard de PHP d’une façon plus orienté objet et plus harmonisée.

Structure identique à Zend Framework 1.10

WordPress 3.0 vient de sortir en version finale. Il est disponible sur le site officiel international de WordPress.org en anglais et également en version française sur le site wordpress-fr.org.

Les nouveautés sont nombreuses :

- Le compte administrateur par défaut peut être nommer autrement que « admin » et on saisit le mot de passe dès l’installation.
- Les posts personnalisés : on peut créer des types de posts personnalisés et les paramètres pour créer une sorte de contexte autour d’un article.
- La gestion des menus : on a plus à choisir entre les catégories du blog et les pages CMS. On peut complètement administrer le menu depuis un manager très ergonomique.
- Multi-sites : aurevoir WordPress MU et bonjour WordPress 3, vous l’aurez compris, WordPress 3.0 est nativement multi-site, plus besoin de passer par WordPress MU, un grand soulagement pour les développeurs de plugins qui étaient obligés de se soucier du cas de WordPress MU.
- Nouveau thème par défaut : le Twenty-Ten qui est entièrement paramétrable, il propose un header modifiable, un background modifiable, un menu dynamique, …

Télécharger WordPress 3.0 (version Française)

WordPress 3.0 vient de sortir en version finale. Il est disponible sur le site officiel international de WordPress.org en anglais et également en version française sur le site wordpress-fr.org.

Les nouveautés sont nombreuses :

- Le compte administrateur par défaut peut être nommer autrement que « admin » et on saisit le mot de passe dès l’installation.
- Les posts personnalisés : on peut créer des types de posts personnalisés et les paramètres pour créer une sorte de contexte autour d’un article.
- La gestion des menus : on a plus à choisir entre les catégories du blog et les pages CMS. On peut complètement administrer le menu depuis un manager très ergonomique.
- Multi-sites : aurevoir WordPress MU et bonjour WordPress 3, vous l’aurez compris, WordPress 3.0 est nativement multi-site, plus besoin de passer par WordPress MU, un grand soulagement pour les développeurs de plugins qui étaient obligés de se soucier du cas de WordPress MU.
- Nouveau thème par défaut : le Twenty-Ten qui est entièrement paramétrable, il propose un header modifiable, un background modifiable, un menu dynamique, …

Télécharger WordPress 3.0 (version Française)

Il est très utile dans une application Web d’avoir un système de navigation capable de cartographier les pages d’un site et d’en déduire des plan de site, fils d’arianes, menus, sitemap.xml, …

Zend_Navigation a été conçu dans cette optique, il propose un système de gestion de pages et des helpers pour générer des composants graphiques.

Nous allons voir dans ce tutoriel une façon simple de mettre en place Zend_Navigation :

Tout d’abord il nous faut définir la navigation et le conteneur de donnée. Dans notre cas, on stockera l’arborescence dans un fichier XML appellé ‘navigation.xml’ dans le répertoire « config ».

protected function _initNavigation() {
$this->bootstrap('layout');
$layout = $this->getResource('layout');
$view = $layout->getView();
$config = new Zend_Config_Xml(APPLICATION_PATH . '/configs/navigation.xml', 'nav');
$container = new Zend_Navigation($config);
$view->navigation($container);
}
<div>

Ensuite, on remplit le fichier « navigation.xml » pour créer notre navigation, on y indiquera la page d’accueil et une page de listing.
On se basera sur le système de routes pour donner le lien.

<configdata>
 <nav>
 <home>
 <label>Accueil</label>
 <route>index</route>
 <pages>
 <listing>
 <label>Liste CRUD</label>
 <route>listing</route>
 </listing>
</pages>
</home>
</nav>
</configdata>

Et voilà la mise en place de Zend_Navigation est fini. Il ne vous reste plus qu’à utiliser des helpers pour appeler vos composants :
Pour le breadcrumb par exemple :

$this->navigation()->breadcrumbs()->setSeparator(" -> ");

Il existe d’autres façon d’intégrer Zend_Navigation sur une application notamment en intervenant directement sur le code. Cette méthode reste très simple mais très fonctionnelle. On y pourra voir des améliorations comme mettre en place un cache pour augmenter les performances.

L’extension est téléchargeable à cette adresse : https://chrome.google.com/extensions/detail/kfiahljocaflpaiopilgpiochncgdnhd

Les résultats de recherche sont identiques à ceux du moteur de recherche de PHP.NET

Une rumeur circule depuis quelques temps, à propos d’une ré-inventation de PHP par Facebook pour optimiser les performances de leurs applications. Cette dernière a été désormais par la firme, un ingénieur a travaillé sur une refonte de la runtime de PHP afin d’avoir un résultat compilé et non plus interprété comme c’est le cas actuellement avec la runtime de Zend.

Le projet s’appelle HipHop et il s’appuie non pas sur un compilateur mais plutôt sur un transcodeur qui permet de passer d’un code PHP à un code C++ très optimisé et ce dernier pouvant être compilé avec g++.

Ce travail a mis plus de 2 ans avant de voir le jour et ce travail verra le jour très bientôt dans un projet Open Source sous licence Creative-Commons.

Voici le processus de HipPop pour optimiser une application PHP :

Il s’agit d’une transformation de code qui part de sources PHP, le code est parsé et ensuite optimisé avant d’être traduit en C++. Le code C++ est lui aussi optimiser et ensuite il est compilé via G++ en langage machine.

Certaines fonctions trop gourmande comme « eval() » ne seront pas supportées mais la globalité du langage est supportée.

Les essais de Facebook révèleraient un gain de performance de l’ordre de 80 % coté processeur et l’application Facebook elle-même devrait migrer sur cette technologie d’ici quelques semaines ou quelques mois. Ils devraient réduire de 50 % l’utilisation du CPU pour héberger Facebook ce qui constitue une économie intéressante puisqu’au dernières nouvelles Facebook, utiliserait plus 30 000 machines pour héberger son réseau social.

La preuve c’est qu’ il s’agit du 3ème point qui influe le plus le référencement d’une page. Et puis on peut également avoir besoin internationaliser ses urls.

Zend Framework possède un routeur, qui permet de manipuler plus facilement les liens entre les pages au sein d’une application et également de faire de la réécriture.

Cette étape se fait au sein du Bootstrap d’une application Zend Framework et grâce à Zend_Controller.

Il faut tout d’abord surcharger la méthode _initAutoLoad() du Bootstrap et récupérer l’instance de Zend_Controller

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

// Surcharge de _initAutoLoad
protected function _initAutoload()

{
$moduleLoader = new Zend_Application_Module_Autoloader(array('namespace'=>'', 'basePath'=>APPLICATION_PATH));

$frontController = Zend_Controller_Front::getInstance();
$router = $frontController->getRouter();

return $moduleLoader;
}

}

Ensuite il suffit simplement de créer ses routes et de les rajouter au routeur du contrôleur.
Pour cela on a plusieurs possibilités, on peut créer des routes statiques, des routes basées sur les modules, etc …
Le plus efficace est de créer des routes à partir d’URL pré-formatées grâce à des expressions régulières.
On devra donc créer des instances de la classe Zend_Controller_Router_Route_Regex.

On la construira avec les arguments suivants :

1) La route : sous forme d’expression régulière (exemple : ‘produits/(.+)/(.+)/article-(.+)-(.+).html’)
2) Le lien MVC : il faut donner les éléments statiques pour accéder à la page, c’est à dire le module, le contrôleur et l’action cible (exemple : array(‘module’ => ‘default’, ‘controller’ => ‘products’, ‘action’ => ‘showProduct’))
3)Le mapping des paramètre : on donne dans l’ordre le nom des paramètres que l’on passera dans l’Url (exemple : array(1 => ‘category’, 2=> ‘subcategory’, 3 => ‘product_title’, 4 => ‘product_ref’))
4) Le chemin inverse : une version de l’url interprétable par la fonction sprintf() de PHP (exemple : ‘produits/%s/%s/article-%s-%d.html’)

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

// Surcharge de _initAutoLoad
protected function _initAutoload()

{
$moduleLoader = new Zend_Application_Module_Autoloader(array('namespace'=>'', 'basePath'=>APPLICATION_PATH));

$frontController = Zend_Controller_Front::getInstance();
$router = $frontController->getRouter();

// Nouvelle route pour accéder à produit
$article = new Zend_Controller_Router_Route_Regex(
 'produits/(.+)/(.+)/article-(.+)-(.+).html',
 array('module' => 'default', 'controller' => 'products', 'action' => 'showProduct'),
 array(1 => 'category', 2=> 'subcategory', 3 => 'product_title', 4 => 'product_ref'),
 'produits/%s/%s/article-%s-%d.html');
$router->addRoute($article);

return $moduleLoader;
}

}

Ainsi on pourra créer et appeler une url de type : « www.maboutique.com/produits/processeurs/dual-core/article-intelcore2duo-PI5421.html »

A l’heure où les environnements de développement pour PHP sont majoritairement basé sur Eclipse : PHP Development Tools, Aptana et Zend Studio, Netbeans quant à lui se faisait très discret dans le domaine des IDE PHP.

Voici la nouvelle version de NetBeans en release 6.8 avec des outils de développement pour PHP 5 fort intéressants :

Tout d’abord il existe une version de l’IDE entièrement dédié au développement PHP comme c’est le cas de la version All-In-One d’Eclipse.

- Il supporte également la version 5.3 de PHP

- Débugage de PHP dans l’IDE

- Exécution et pilotage de test-unitaires mis en place avec PHPUnit

- Support du Framework Symfony (autocompletion, exécution d’actions en ligne de commande depuis une console dans l’ide, support du YAML, …)

Nous allons nous intéresser au support de Symfony dans l’IDE et voir si son usage facile le développement avec le framework PHP français !

L’interface de NetBeans 6.8 est relativement simple, ergonome et traduite dans toutes les langues pour les non-anglophones.

1. Paramétrage de NetBeans pour PHP

Le paramétrage de NetBeans se fait en 3 étapes :

- Le chemin de l’exécutable « php.exe »
- Le chemin du script de PHPUnit (facultatif)
- Le chemin de la sandbox de symfony (symfony.bat ou symfony.sh)

Vous devez spécifier le chemin de votre serveur PHP, c’est à dire l’emplacement du « php.exe » de votre installation pour utiliser les fonctions de débugage, compilation et exécution de code PHP en « Command Line Interface ». Dans mon exemple, je donne le chemin d’accès de mon installation WAMP.

En suite, il vous faudra spécifier le chemin d’accès à la sandbox de Symfony, sous Windows il s’agit du fichier « symfony.bat ».

2. Création de votre projet Symfony

Pour créer votre projet Symfony, rien de plus simple, il suffit d’aller sur « Fichier -> Nouveau Projet » et de créer un nouveau projet « Application PHP ».

Donnez ensuite, un nom à votre projet, sélectionnez la version de PHP utilisée, dans notre cas, on pourra se contenter de la version 5.2.x.
N’oublier pas de donner le répertoire contenant le code source  du framework Symfony cela fonctionne avec n’importe quelle version du framework à priori sauf peut être pour la version en développement 2.0.

Pour ce qui est de la configuration de l’environnement de production pour le déploiement, nous n’avons pas à nous en soucier. On se contentera d’un environnement serveur en local.

Enfin on pourra spécifier que l’on veut utiliser le framework Symfony et que l’on veut générer une application « frontend » (application web principale destinée aux visiteurs du site) et une application « backend » (application dédiée à l’administration et au backoffice de l’application principale).

3. Dans la pratique

Voici comment se présente notre projet Symfony sous Netbeans 6.8. Nous avons un très bon éditeur de YML / YAML avec coloration syntaxique, autocompletion et schéma hiérarchique

On pourra également utiliser l’outil de génération de code en ligne de commande de Symfony en allant sur « MySymfonyProject -> click-droit -> Run Symfony Command ».

On a le résultat de l’exécution de la ligne de commande dans le partie console de NetBeans cet outil est très pratique pour exécuter les tests-unitaires de LIME le framework de test intégré à Symfony.

On niveau du développement « pur », on constate que l’autocompletion répond bien à la plupart des besoins de développeurs : les objets des vues, contrôleurs comme $sfWebRequest, $sfWebResponse, $view peuvent être appeler sans problème avec une intelliSense et même avec une petite documentation.

Conclusion

Ce support du framework Symfony est très intéressant à la fois pour la communauté des développeurs Symfony mais aussi pour NetBeans qui pourra peut être se faire une meilleure réputation dans le développement PHP car il faut le rappeler Symfony est le framework de développement PHP le plus utilisé avec Zend Framework . Les fonctionnalités de NetBeans vis à vis de ce framework sont très basiques mais relativement utiles. On regrettera peut être une meilleure intégration du framework de test unitaire et une génération de code plus importante. Peut-être vaut-il le coup d’être utiliser à la place d’Eclipse ou Aptana dans une optique de développement Symfony ? Ou aurons-nous du mal à nous séparer de nos bons vieux plugins sur Eclipse (pour Subversion, Database Explorer, PDT, Smarty, jQuery) ? Pour ma part, NetBeans a gagné ma confiance, je lui trouve une bonne ergonomie et une grande simplicité d’utilisation. Il existe une autre solution  pour le support de Symfony mais qui est quant-à-elle payante : il s’agit de PHPEdit il faut compter environ 219€ pour une version avec le support de Symfony et presque 300 € pour le support de PHPUnit et SVN.

La sortie de cette nouvelle version s’accompagne d’une amélioration de la rubrique PhoogleMap sur le site avec des exemples téléchargeables, des sources mises à jour, une présentation approfondie, une PHP Doc en anglais, et des nouvelles ressources.

Très prochainement, je rajouterai une documentation complète en français et en anglais ainsi que de nouveaux exemples.

Aptana Studio est un IDE (Environnement de Développement orienté) Web 2.0 et basé sur les fondations d’Eclipse. Son principal avantage est qu’il n’utilise pas les plugin’s traditionnels d’Eclipse au profit de plugin’s développés par aptana qui sont beaucoup plus performants et plus astucieux.

Le logiciel est un environnement complet pour :

- PHP (sans passer le PDT d’Eclipse)

- Ruby On Rails

- Python Web

- Framework Javascript : jQuery, Prototype, Mootools, Adobe Spry, Dojo, …

- Javascript, HTML, CSS

- Application Adobe Air, Flex, …

De plus, vous pourrez installer tous vos plugins préférés sur Aptana ou bien inversement, installer les plugins d’Aptana sur votre Eclipse existant !

Aptana est totalement libre et disponible sur Windows, MacOS X, Linux. Certaines personnes pourront également le coupler à une version 64 bits d’Eclipse sous Linux.

Rendez-vous sur le site Officiel : http://www.aptana.com

Il s’agit avant tout d’un projet Symfony 1.2 qui utilise le design pattern MVC, Doctrine et Symfony.

Le projet a l’air très prometteur, il est toujours en version de test mais on peut dors-et-déjà le télécharger sur le site Officiel : http://www.sympalphp.org

Le CMS a l’air tout aussi complet qu’un Drupal, Spip ou Joomla et s’intègrera parfaitement avec les applications Symfony.

Voici 2 screencasts présents sur le site officiel pour illustrer le fonctionnement de l’application :

Nouvelle version de Zend Framework, elle corrige une quarantaine de bugs

Voici la liste issue de la changelog…

Bugs corrigés :

• [ZF-7605]: Zend_Application docs mistake
• [ZF-7550]: Bootstrap fails after checking out r17414
• [ZF-7417]: clarify confusion between ‘resource plugins’ and ‘resources’ in docs
• [ZF-7401]: Errors in QuickStart
• [ZF-7158]: No automatic creation of Zend_Application_Module_Autoloader for default module
• [ZF-7095]: Zend_Application_Resource_Modules Example is wrong
• [ZF-7091]: « scripts/load.sqlite.php » is missing « set_include_path »
• [ZF-6893]: Cannot use Zend_Application_Resource_FrontController to set baseurl for a subset of environments
• [ZF-6861]: Stripping all require_once calls makes Zend_Application unable to work
• [ZF-6803]: Zend_Application Default Module Bootstrap is Skipped
• [ZF-6679]: Items configured from Zend_Application::setOptions() via a config entry do not have their keys cast to lower case
• [ZF-6659]: Module bootstrap implementation
• [ZF-6634]: include warning with same module and namespace name
• [ZF-4730]: Add possibility to check group-membership in Zend_Auth_Adapter_Ldap
• [ZF-7358]: Zend_Cache_Backend_ZendServer_ShMem and Zend_Cache_Backend_ZendServer_Disk throws an exception in test()
• [ZF-7172]: How to instatiate the ZendServer cache backends
• [ZF-6291]: Zend_Cache::factory() denies creation of Zend_Cache_Backend_TwoLevels backend on Linux
• [ZF-5740]: Partial cleaning in Zend_Cache_Backend_TwoLevels::clean()
• [ZF-7589]: Zend_Date::setDate when parsing the date to set in an array
• [ZF-7554]: testSetLocale(Zend_DateTest) unit tests failure
• [ZF-7456]: Regression in 1.9 in ability to create Zend_Date from array
• [ZF-7454]: Timezone and Zend_Date
• [ZF-7647]: fetchAssoc() and fetchPairs() in Zend_Db_Adapter_Abstract have wrong docblock return type
• [ZF-7629]: Zend_Db_Adapter_Pdo_Mssql should pass @table_owner to sp_pkeys
• [ZF-5823]: Non-optimized SQL generated for LIMIT clause in MSSQL adapter
• [ZF-4251]: Zend_Db_Adapter_Pdo_Mssql doeas not support both LIMIT and DISTINCT in the same query
• [ZF-4099]: Zend_Db_Adapter_Pdo_Mssql – Order By in Limit Function
• [ZF-3434]: PDO_Mssql DSN includes _config['options']
• [ZF-3216]: Zend_Db_Adapter_Mysqli does not provide a proper way to catch MySQL error codes.
• [ZF-7549]: Missing prefix and type parameters in the PHPdoc for most of the addPrefixPath methods
• [ZF-7544]: Fatal Error when setting same FilterRule more than one time in script call
• [ZF-7135]: null values are treated as missing data instead of an empty value
• [ZF-7449]: Directive $element->setRegisterInArrayValidator(false) doesn’t work anymore
• [ZF-7208]: Incubator unit tests stop with fatal error ‘Class ‘Zend_Ldap_AllTests’ not found’
• [ZF-7604]: No Zend_Log_Writer_Syslog::setApplication() hence documentation
• [ZF-7614]: Incorrect function name in the #42.2 manual entry
• [ZF-7613]: There is not « factory » method in the Zend_Queue class
• [ZF-7560]: Zend_Translate_Adapter does not properly handle numeric key values
• [ZF-7648]: testNotSameMessageContainsTokenAndValue(Zend_Validate_IdenticalTest) unit tests failure
• [ZF-7643]: Empty token value in Zend_Validate_Identical::NOT_SAME
• [ZF-7631]: Zend_Validate_NotEmpty compatibility
• [ZF-7630]: Zend_Validate_Date doesn’t accept Zend_Date object
• [ZF-6457]: Zend_Validate_Date doesn’t validate a value filtered by Zend_Filter_LocalizedToNormalized
• [ZF-7597]: Reference guide minor error
• [ZF-7676]: Unit tests stop because of the « Call to undefined method Zend_XmlRpc_Server_Fault::getReturnValue() » fatal error

Il existe bien évidement celui de Zend qui est founit avec PHP, cela dit il existe également Xdebug qui est un excellent outil permettant de se configurer sur Eclipse pour faire du debug, d’améliorer les var_dump en PHP pour visualiser plus facilement les erreurs et de mettre en cache des données pour visualiser les performances de votre application.

Nous allons voir comment installer et configurer Xdebug dans votre environnement PHP.

Tout d’abord, il faut s’avoir que Xdebug est une extension à PHP (sous forme d’une DLL sous Windows, et d’un .so sous linux). Il faut récupérer l’extension sur le site de Xdebug : http://www.xdebug.org/ (vous pouvez essayer les paquets dans les dépôts sous linux c’est beaucoup plus pratique).

Il faut ensuite copier le fichier dans le répertoire des extensions :

Il faut ensuite activer l’extension dans le php.ini en rajoutant la ligne suivante :

extension=php_xdebug-2.0.4-5.2.8.dll

Xdebug est enfin installé sur le serveur php, la première chose que l’on peut remarque c’est que les var_dump sont beaucoup plus complets et lisibles que précédemment :

Les messages d’erreurs sont également plus complets :

On peut également utilisé Xdebug pour faire du profiling, c’est à dire faire un affichage de toutes les fonctions exécutées avec les temps de réponses. Pour cela il faut modifier le fichier php.ini et rajouter le code suivant dans la partie module settings :

[xdebug]
xdebug.profiler_enable=On
; On choisit le répertoire où on stocke le cache
xdebug.profiler_output_dir="c:\traces"
xdebug.profiler_append=On
xdebug.profiler_enable_trigger=On

Il faudra penser à vider le cache lorsqu’on veut profiler l’exécution d’une page en supprimer le fichier dans le répertoire.

On regarde ensuite le profilage avec un logiciel prévu à cet effet, il s’agit de WinCacheGrid sous Windows et XCacheGrid sous Linux, et on pourra avoir les résultats sous la forme suivante :

Pour une utilisation plus avancée, on peut aussi configurer Xdebug avec le PDT d’Eclipse pour avoir une vraie fonction de débogage perfectionnée ou sinon il reste aussi la solution ultime Zend Studio mais qui est relativement coûteuse.

On appelle cela une couche d’abstraction qui sert intermédiaire entre la base de données et l’application. Le but est de modéliser le schéma d’une base de données sous forme de classes et d’objet pour ne pas travailler avec le langage SQL et les drivers de base de données car il est évident qu’une application écrite de A à Z avec des mysql_connect() et mysql_query() ne sera pas très robuste et migrera difficilement vers un autre SGBD comme Postgre ou Oracle…

Zend_Framework fournit un outil nommé Zend_Db_Table pour gérer à l’aide d’un système de DAO (Database Access Object) les transactions avec les bases de données.

Nous allons voir dans un premier temps comment configurer Zend_Framework pour mettre en place ce système :

Configuration du fichier Application.ini :

;database configuration
resources.db.adapter = "pdo_mysql"
resources.db.params.host = "localhost"
resources.db.params.username = "root"
resources.db.params.password = ""
resources.db.params.dbname = "announcements"
resources.db.params.date_format = "YYYY-MM-ddTHH:mm:ss"
resources.db.isDefaultTableAdapter = true

Il faut spécifier dans le « Application.ini » les paramètres pour accéder à votre base de données, il faut y spécifier l’adresse de la base, le type (pdo_mysql, postgre, sqllite, oci8, mssql, …), l’utilisateur avec le mot de passe, le nom de la base de données et le format de date et heure.

Ecrire les classes d’accès aux données (utilisation de Zend_Db_Table) :

Il nous faut maintenant écrire les classes permettant de modéliser les tables de la base de données pour cela on va utiliser Zend_Db_Table pour générer une classe permettant d’accéder à la table « posts  » de notre application :

On créer tout d’abord un dossier « models » dans notre répertoire /application avec un dossier DbTable dedans.

Nous allons générer un fichier Post.php :

Tout d’abord, on crée une classe dérivée de Zend_Db_Table que l’on nommera avec la syntaxe suivante : Model_DbTablr_NomDeLaTable en spécifiant le nom extact dans l’attribut protégé « name » :

Ensuite il ne reste plus qu’à écrire les méthodes qui permet les transactions avec les bases de données, je recommende fortement d’utiliser une méthode pour chaque transaction plutôt que de les écrire dans le contrôleur, on est dans un design-pattern MVC !

Voici le prototypage de notre classe et l’implémentation de notre classe :

fetchRow('id = '.(int)$id);
		if (!$row)
		{
			// On lance une exception en cas d'erreur
			throw new Exception ("Erreur, l'enregistrement $id n'existe pas !");
		}
		// On retourne le résultat sous forme de tableau
		return $row->toArray();
	}

	/**
	 * Ajoute un article en base de données
	 * @param $values
	 * @return unknown_type
	 */
	public function addPost ($values)
	{
		// On enregistre les valeurs sous forme de tableau [champs] => valeur
		$result = $this->insert($values);
		if (!$result)
		{
			throw new Exception ("Erreur impossible d'enregister");
		}
	}

	/**
	 * Met à jour un article en base de donneés
	 * @param $values
	 * @return unknown_type
	 */
	public function updatePost ($id,$newValues)
	{
		$result = $this->update($newValues, 'id = '.(int)$id);
		if (!$result)
		{
			throw new Exception ("Erreur impossible de mettre à jour");
		}
	}

	/**
	 * Supprime l'article $id
	 * @param $id
	 * @return unknown_type
	 */
	public function removePost ($id)
	{
		$result = $this->delete('id = '.$id);
		if (!$result)
		{
			throw new Exception ("Erreur impossible de supprimer");
		}
	}

	/**
	 * Requête avec jointure pour récupérer les 5 premiers
	 * articles avec les données de la table auteur en jointure
	 * et qui ont leur status publié
	 * @return unknown_type
	 */
	public function findPostsWithAuthorsInformations ()
	{
		$db = $this->getAdapter();

		$select = $db->select()
					 ->from('post')
					 ->joinInner('author', 'post.author_id = author.id')
					 ->where('status = "published"')
					 ->limit(5);
		$query = $select->query();
                $result = $query->fetchAll();

		return $result;
	}
}
?>

Pour appeler cette classe dans le contrôleur rien de plus simple, on instancie un objet « $model » et pis on appelle les méthodes que l’on a implémentée :

< ?php
	class PostController extends Zend_Controller_Action
	{
		public function init ()
		{
			// On fait rien
		}

		public function testModelAction ()
		{
			$model = new Model_DbTable_Post();

			// Ajout
			$model->addPost(array('title' => 'test', 'content' => 'ceci est mon premier post', 'status' => 'publised'));

			// Requête
			$this->view->posts = $model->findPostsWithAuthorsInformations();

			// Suppression
			$model->removePost(2);

		}
	}
?>

La prochaine fois nous verrons le fonctionnement des formulaires avec Zend_Form

Doctrine ORM PHP 5 dors et déjà présent sur le framework Symfony, prépare une nouvelle version majeure du projet : Doctrine 2.0

Cette nouvelle version exclusivement compatible avec PHP 5.3 au minimum s’avère assez prometteuse et assez ambitieuse.

Petit rappel sur Doctrine : ce projet a été conçu tout comme Propel (basé sur Active Record) dans un but de créer un ORM relativement puissant et extrèmement riche en fonctionnalités : tests unitaires automatiser sur les classes relationnelles, schéma des bases en YML, génération de code automatique, système de cache avancé, plugins, gestion des contraintes d’intégrités avancée, load-balancing, profiler, outils de performances, validations des données en fonction du schéma, … Bref un véritable équivalent de Hibernate en PHP 5.

Le projet est principalement supporté par Sensio Labs (framework Symfony).

La prochaine version (Doctrine 2.0) sera basée sur PHP 5.3, elle utilisera les nouveaux drivers de PHP, et promet de véritable amélioration au niveau des performances.

Voici des benchmarks des performances de Doctrine 2.0 par rapport à sa version précédente :

PHP 5.2.8

#	Seconds	Memory
1	24	129170.648438 KB
2	23	129164.078125 KB
3	23	129176.851562 KB

PHP 5.3.0alpha4-dev

D’autre part, Doctrine deviendra beaucoup moins coûteux en code et sera moins verbeux.

Microsoft vient de publier l’ensemble des librairies ADO.NET dans un projet open-source baptisé PHP Toolkit for ADO.NET Data Services.

Il s’agit d’une version PHP qui reprend l’ensemble des librairies et fonctionnalités du sous-framework ADO.NET du .NET Framework. Il s’agit d’un système de DAO (Data Access Object) pour générer des couches d’abstractions aux base de données offrant ainsi une flexibilité entre l’application et les systèmes de base de  données.

Ce PHP Tookit for ADO.NET se présente sous la forme d’un Webservice accessible via HTTP (API REST) pour permettre aux applications PHP d’accès aux bases de donneés via des webservices.

Le principal intérêt de cet outil est avant tout pour Microsoft puisqu’il permet de familiariser les développeurs PHP avec des librairies du Framework .NET

Le projet est accessible sur Codeplex à l’adresse suivante : http://phpdataservices.codeplex.com/

La carte est disponible dans la rubrique du blog dédiée et sur Google Code.

http://www.monsite.com/employements_offers?country=43&city=4215&category=452&societe=4321

peut se renommer de la façon suivante :

http://www.monsite.com/france/marseille/developpement-web/ssii-xxx

En effet des url’s plus explicites et qui cachent les noms des paramètres GET sont à privilégier pour optimiser le référencement de vos applications Web.

Cela vous oblige à rajouter un champs particulier dans vos tables que l’on appelle le « slug » et qui est une sorte de d’identifiant publique explicite prévu pour les urls. Pour générer automatiquement ces slugs, il vous faut une expression régulière qui va modifier un terme pour le mettre dans une forme compatible avec les navigateurs. Par exemple : Provence Alpes Côte D’Azur on peut le transformer en provence-alpes-cote-dazur.

La fonction suivante vous permettra de générer facilement ces slugs :

/*  $str : terme à transformer
 *  $replace : des caractères ou termes à remplacer par quelque chose passé
 *  en paramètre dans un tableau
 *  $delimiter : délimiteur pour representer les espaces par défaut
 *  c'est un tiret "-" je conseille fortement de garder
 *  ce format qui est le meilleur dans un souci de référencement.
 */
function toAscii($str, $replace=array(), $delimiter='-') {

setlocale(LC_ALL, 'en_US.UTF8');

if( !empty($replace) ) {

$str = str_replace((array)$replace, ' ', $str);

}

$clean = iconv('UTF-8', 'ASCII//TRANSLIT', $str);

$clean = preg_replace("/[^a-zA-Z0-9\/_|+ -]/", '', $clean);

$clean = strtolower(trim($clean, '-'));

$clean = preg_replace("/[\/_|+ -]+/", $delimiter, $clean);

return $clean;

}

En effet, on peut remédier à ce problème grâce aux mathématiques : il suffit de prendre le point central entre les 2 points les plus éloignés et d’ajuster le zoom en fonction de la distance entre ces 2 derniers.

Le script suivant vous montre comment calculer le zoom et les coordonnées du cadrage le plus approprié à partir d’un ensemble de marqueurs. Cette fonctionnalité est disponible sur PhoogleMap.

public function enableAutoZoom ()
{
$latitude_array = array();
$latitude_array = array();
foreach ($this->validPoints as $key => $value)
{
$latitude_array[] = $value['lat'];
$longitude_array[] = $value['long'];
}
$minimal_latitude = min ($latitude_array);
$maximal_latitude = max ($latitude_array);
$minimal_longitude = min ($longitude_array);
$maximal_longitude = max ($longitude_array);

$central_latitude = $minimal_latitude + ($maximal_latitude - $minimal_latitude) / 2;
$central_longitude = $minimal_longitude + ($maximal_longitude - $minimal_longitude) / 2;

$miles = (3958.75 * acos(sin($minimal_latitude / 57.2958) * sin($maximal_latitude / 57.2958) + cos($minimal_latitude / 57.2958) * cos($maximal_latitude / 57.2958) * cos($maximal_longitude / 57.2958 - $minimal_longitude / 57.2958)));

switch ($miles)
{
case ($miles < 0.2):
$zoom = 2;
break;
case ($miles < 0.5):
$zoom = 3;
break;
case ($miles < 1):
$zoom = 3;
break;
case ($miles < 2):
$zoom = 4;
break;
case ($miles < 3):
$zoom = 5;
break;
case ($miles < 7):
$zoom = 6;
break;
case ($miles < 15):
$zoom = 8;
break;

case ($miles < 50):
$zoom = 9;
break;

case ($miles < 300):
$zoom = 12;
break;

case ($miles < 600):
$zoom = 14;
break;
default:
$zoom = 16;
break;
}
$this->centerMap($central_latitude, $central_longitude);
$this->zoomLevel = $zoom;
}