Thunderbird 9 est aussi de sortie sur Ubuntu !

Installer Thunderbird sur Ubuntu

Comment installer la dernière version stable de Thunderbird sur Ubuntu

Chez Mozilla, ils ne font pas les choses à moitié en cette fin d’annèe 2011 !

Après la sortie de Firefox 9, c’est au tour de Thunderbird 9 de pointer le bout de son nez … Joli cadeau de noël que d’avoir les 2 dernières versions stables de vos logiciels open source préférés, tous 2 en version 9.

Comme je viens de l’expliquer pour l’installation de Firefox 9 sur votre système Ubuntu, vous pouvez également disposer de cette toute dernière version de Thunderbird dès maintenant en tapant la série de commandes suivantes dans un terminal :

1
2
3
sudo add-apt-repository ppa:mozillateam/thunderbird-stable 
sudo apt-get update
sudo apt-get install thunderbird

Comme pour Firefox, rien de plus simple ! Thunderbird 9 va s’installer et vous disposerez d’un des meilleurs logiciels de messagerie du marché !

Firefox 9 est de sortie sur Ubuntu !

Installer la dernière version stable de Firefox (9, 10, 11)

Installer une version stable de Firefox (9, 10, 11)

1 jour à peine après la sortie de la toute dernière version stable de Firefox (Firefox 9) et à en croire les requêtes qui mènent à ce blog, nombreux sont les gens qui cherchent à savoir comment installer Firefox 9 sur leur système d’exploitation Ubuntu.

Et bien, comme je l’avais expliqué dans un précédent article sur Comment installer / désinstaller les futures versions de Firefox sur Ubuntu (versions bêta), je vous explique ici la marche à suivre pour avoir la toute dernière version stable (v9.0.1) pour Ubuntu :

1
2
3
sudo add-apt-repository ppa:mozillateam/firefox-stable
sudo apt-get update
sudo apt-get install firefox

Vous pouvez également installer les packs de langue française comme cela :

1
sudo apt-get install language-pack-fr language-pack-fr-base

Pour rappel, si cette version de Firefox ne vous plaît pas, vous pouvez toujours revenir à votre ancienne version de Firefox en tapant la commande :

1
sudo ppa-purge ppa:mozillateam/firefox-stable

Tout en ayant pris soin au préalable d’installer le paquet « ppa-purge » (j’explique sur le précédent article où le trouver)

Firefox 9 rocks !

Mettre en forme les messages d’erreur Php avec Xdebug sous Ubuntu

Logo php

Aujourd’hui, un petit billet qui ressemble plus à un mémo qu’à autre chose …

Depuis quelques temps déjà, j’ai pris la bonne habitude d’activer le module xdebug pour php5 lorsque je développe sur ma machine de dev.

Pour les novices, Xdebug c’est quoi ? C’est un outil de deboggage et de profiling pour Php. En clair, ce programme va vous aider à déboguer vos erreurs Php.

Généralement une erreur Php, lorsqu’elle est affichée à l’écran ne dit pas beaucoup plus que l’endroit où le script a généré une erreur.

Xdebug lui va en plus vous rajouter la pile d’appel Php qui a généré l’erreur. C’est à dire que vous aurez tout le contexte d’exécution de votre programme, en remontant jusqu’à la première fonction exécutée.

Très pratique donc lorsque l’on utilise des frameworks récents qui utilisent le modèle MVC comme Symfony ou Zend Framework puisque tous les appels à vos fonctionnalités sont faits depuis un controlleur principal.

Voici comment installer Xdebug sous Ubuntu :

sudo apt-get install php5-xdebug

A ce stade la, logiquement, vous devriez déjà avoir une installation fonctionnelle…

Cependant, si vous voulez avoir une mise en forme améliorée, il y a une petite astuce à connaître !

Par défaut, il ne me semble pas que la mise en forme HTML soit activée sous Ubuntu ce qui fait que vous allez avoir votre pile d’appel Php rendu brut de forme … et bien vous pouvez afficher cela dans un joli tableau HTML encore plus lisible.

Pour cela, pas besoin d’aller trifouiller dans les réglages d’Xdebug comme je l’ai fait avant de me rendre compte qu’il suffisait simplement de mettre la directive « html_errors » à On dans votre php.ini !

Soit dans le fichier « /etc/php5/apache2/php.ini »:

html_errors = On

That’s all !

Tutoriel override prestashop partie 3 : surcharge de la classe Link pour modifier l’URL rewriting

Prestashop 1.4Nous souhaitons à présent accéder à notre page Manufacturer listant tous les produits de la marque.

Si vous avez suivi ce tutoriel jusqu’ici, vous saurez que cette page a forcément une nouvelle URL puisque l’URL de base redirige vers une page de type CMS.

Nous allons décider que pour y accèder, nous passerons un paramètre à notre URL afin d’indiquer au controller qu’il faut bien afficher le listing de produits. Nous lui passerons le paramètre « param » avec la valeur « products« .

Si vous reprenez le code du ManufacturerController, à la ligne 19, vous verrez que nous testons si nous recevons bien ce paramètre, et si oui, nous effectuons le traitement classique :

if(in_array(Tools::getValue("param"), array("products")))
			{
				$nbProducts = $this->manufacturer->getProducts($this->manufacturer->id, NULL, NULL, NULL, $this->orderBy, $this->orderWay, true);
				$this->pagination($nbProducts);
				self::$smarty->assign(array(
					'nb_products' => $nbProducts,
					'products' => $this->manufacturer->getProducts($this->manufacturer->id, (int)self::$cookie->id_lang, (int)$this->p, (int)$this->n, $this->orderBy, $this->orderWay),
					'manufacturer' => $this->manufacturer,
					'path' => ($this->manufacturer->active ? Tools::safeOutput($this->manufacturer->name) : ''),
				));
			}

Très bien, sauf que nous devons maintenant avoir une méthode qui va générer cette nouvelle URL et l’afficher sur le lien « Voir tous les produits » présent dans la page.

Pour cela, faisons tout d’abord en sorte que le fichier « .htaccess » prenne en compte notre règle. Rajoutez ou remplacez ceci dans votre fichier « .htaccess » :

RewriteRule ^(products/)?([0-9]+)_([a-zA-Z0-9-]*)(.*)$ manufacturer.php?id_manufacturer=$2&param=$1$4 [QSA,L,E]

Attention, cela n’est utile que si vous utilisez la fonctionnalité d’URL rewriting ou URL simplifiées de Prestashop.

Puis, nous devons maintenant redéfinir la méthode de génération d’URL pours les manufacturers.

Dans prestashop, tout se passe dans la classe Link qui gère les URLs de tous les composants. Nous allons l’overrider. Rendez vous donc dans « override/classes » pour y créer le fichier « Link.php » suivant :

<?php
class Link extends LinkCore
{
	public function getManufacturerProductsLink($id_manufacturer, $alias = NULL, $id_lang = NULL)
	{
		return $this->getManufacturerWithParamLink($id_manufacturer, 'products', $alias, $id_lang);
	}	
 
	public function getManufacturerWithParamLink($id_manufacturer, $param = 'products', $alias = NULL, $id_lang = NULL)
	{
		if (is_object($id_manufacturer))
			return ($this->allow == 1) ? (_PS_BASE_URL_.__PS_BASE_URI__.$param.'/'.$this->getLangLink((int)($id_lang)).(int)($id_manufacturer->id).'_'.$id_manufacturer->link_rewrite) :
			(_PS_BASE_URL_.__PS_BASE_URI__.'manufacturer.php?id_manufacturer='.(int)($id_manufacturer->id).'&param='.$param);
		if ($alias)
			return ($this->allow == 1) ? (_PS_BASE_URL_.__PS_BASE_URI__.$param.'/'.$this->getLangLink((int)($id_lang)).(int)($id_manufacturer).'_'.$alias) :
			(_PS_BASE_URL_.__PS_BASE_URI__.'manufacturer.php?id_manufacturer='.(int)($id_manufacturer).'&param='.$param);
		return _PS_BASE_URL_.__PS_BASE_URI__.'manufacturer.php?id_manufacturer='.(int)($id_manufacturer).'&param='.$param;
	}
}

La méthode « getManufacturerLink() » de la classe de base est donc remplacée par « getManufacturerWithParamLink() » qui prend en argument un « $param » qui aura la valeur par défaut « products« . Ainsi nous pourrons si nous le voulons plus tard, lui passer d’autres paramètres (comme « photos » pour afficher un diaporama photos de la marque par exemple).

Nous avons également écrit une méthode « getManufacturerProductsLink() » qui nous servira à écrire plus simplement la fonction lors de l’appel dans notre template Smarty.

Et c’est enfin terminé, nous avons maintenant accès à notre page Manufacturer par une URL du type : »manufacturer.php?id_manufacturer=2&param=products » pour les URL non réécrites et : « products/2_ma-marque » pour les URL réécrites.

CONCLUSION

Cet article clôt une série de 3 articles traitant de la surcharge de classes et de controllers dans Prestashop 1.4. Pour mettre en oeuvre une fonctionnalité concrête de liaison de pages CMS aux pages Marques, nous avons eu à surcharger différentes classes et controllers et également changer les règles d’URL rewriting.

Nous retiendrons surtout que depuis que l’override classe est possible dans notre logiciel e-commerce préféré, les possibilités de customisation de vos pages sont quasiment illimités ! A vous d’inventer et de coder des fonctionnalités qui ne seraient pas encore disponibles !

Tutoriel override Prestashop partie 2 : surcharge du controller ManufactureController

Prestashop 1.4Comme décrit en préambule, nous souhaitons qu’une page Manufacturer redirige sur la première page CMS qui lui est rattachée.

Il faudra donc également prévoir d’accéder à la page Manufacturer « classique » par une nouvelle URL. (nous verrons cela plus tard dans la partie traitant de l’URL rewriting de Prestashop).

Voyons alors le code du ManufacturerController (sans la partie gérant l’url):

<?php
class ManufacturerController extends ManufacturerControllerCore
{
	public $php_self = 'manufacturer.php';
 
	protected $manufacturer;
	protected $cms;
 
	public function process()
	{
		global $link;
		if (Validate::isLoadedObject($this->manufacturer) AND $this->manufacturer->active)
		{
			$first_page = CMS::getFirstCMSPage((int)(self::$cookie->id_lang), (int)($this->manufacturer->id) );
 
			self::$smarty->assign(array(
				'first_cms_page' => $first_page
			));
 
			if(in_array(Tools::getValue("param"), array("products")))
			{
				$nbProducts = $this->manufacturer->getProducts($this->manufacturer->id, NULL, NULL, NULL, $this->orderBy, $this->orderWay, true);
				$this->pagination($nbProducts);
				self::$smarty->assign(array(
					'nb_products' => $nbProducts,
					'products' => $this->manufacturer->getProducts($this->manufacturer->id, (int)self::$cookie->id_lang, (int)$this->p, (int)$this->n, $this->orderBy, $this->orderWay),
					'manufacturer' => $this->manufacturer,
					'path' => ($this->manufacturer->active ? Tools::safeOutput($this->manufacturer->name) : ''),
				));
			}
			else {
				self::$smarty->assign(array(
					'manufacturer' => $this->manufacturer,
				));
				$this->cms = new CMS($first_page[0]["id_cms"], self::$cookie->id_lang);
				Tools::redirect($link->getCMSLink($this->cms),"");
			}
		}
		elseif (!Tools::getValue('id_manufacturer'))
		{
			if (Configuration::get('PS_DISPLAY_SUPPLIERS'))
			{
				$result = Manufacturer::getManufacturers(true, (int)self::$cookie->id_lang, true);
				$nbProducts = count($result);
				$this->pagination($nbProducts);
 
				$manufacturers = Manufacturer::getManufacturers(true, (int)self::$cookie->id_lang, true, $this->p, $this->n);
				foreach ($manufacturers AS &$row) {
					$man = new Manufacturer($row['id_manufacturer']);
					$row['title'] = $man->title[(int)self::$cookie->id_lang];
					$row['image'] = (!file_exists(_PS_MANU_IMG_DIR_.'/'.$row['id_manufacturer'].'-medium.jpg')) ? Language::getIsoById((int)self::$cookie->id_lang).'-default' : $row['id_manufacturer'];
				}
 
				self::$smarty->assign(array(
					'pages_nb' => ceil($nbProducts / (int)$this->n),
					'nbManufacturers' => $nbProducts,
					'mediumSize' => Image::getSize('medium'),
					'manufacturers' => $manufacturers,
					'add_prod_display' => Configuration::get('PS_ATTRIBUTE_CATEGORY_DISPLAY'),
				));
			}
			else
				self::$smarty->assign('nbManufacturers', 0);
		}
	}		
 
}

Nous récupérons la première page CMS rattachée à la marque en cours :

$first_page = CMS::getFirstCMSPage((int)(self::$cookie->id_lang), (int)($this->manufacturer->id) );
 
			self::$smarty->assign(array(
				'first_cms_page' => $first_page
			));

Pour pouvoir par la suite rediriger sur cette page CMS. Vous noterez que nous avons déclaré une propriété protégée ($this->cms) de la classe afin de stocker l’objet « cms » récupéré au même titre que l’objet « manufacturer »

$this->cms = new CMS($first_page[0]["id_cms"], self::$cookie->id_lang);
				Tools::redirect($link->getCMSLink($this->cms),"");

Et voilà, lorsque nous arrivons sur une page Marque, le controller nous redirige bien sur la première page CMS qui lui est rattachée :

Tools::redirect($link->getCMSLink($this->cms),"");

Voyons à présent comment rediriger vers la page Manufacturer « classique » avec un listing de produits de la marque.

Tutoriel override Prestashop partie 3 : Surcharge de la classe Link pour modifier l’URL rewriting des manufacturers

Tutoriel override Prestashop partie 1: Surcharge de classe et controller CMS

Prestashop 1.4Pour commencer nous allons nous rendre dans le back office de prestashop afin de créer des pages CMS.

L’astuce ici consiste à utiliser les sous catégories de pages CMS comme des références à des marques de votre catalogue. (ATTENTION, cela détourne la fonctionnalité première des catégories de CMS de prestashop).

Etant donné que la catégorie 1 existe déjà et ne peut pas être supprimée (c’est la catégorie d’accueil), il faudra bien faire attention de ne pas créer de marque avec l’identifiant 1 (ou du moins penser à désactiver cette marque).

Je vais donc créer en premier lieu une sous catégorie 2, portant le nom « Ma marque » puis je vais lui rattacher 3 pages CMS que je vais également créer. Une fois cela fait, je vais pouvoir commencer mes overrides.

Nous allons tout d’abord surcharger la classe CMSCore afin de lui ajouter une méthode (getFirstCMSPage()), qui nous permettra de savoir quelle est la première page CMS rattachée à notre marque. Nous nous en servirons dans le CMSController afin de rediriger vers la page CMS récupérée. Voici le code :

<?php
class CMS extends CMSCore
{
 
	public static function getFirstCMSPage($id_lang = NULL, $id_cms_category = NULL, $active = true)
	{
		return Db::getInstance()->ExecuteS('
		SELECT *
		FROM `'._DB_PREFIX_.'cms` c
		JOIN `'._DB_PREFIX_.'cms_lang` l ON (c.id_cms = l.id_cms)'.
		(isset($id_cms_category) ? 'WHERE `id_cms_category` = '.(int)($id_cms_category) : '').
		($active ? ' AND c.`active` = 1 ' : '').'
		AND l.id_lang = '.(int)($id_lang).'
		ORDER BY `position`
		LIMIT 0, 1');
	}
 
}

Comme indiqué dans mon premier tuto sur l’override de classes prestashop, pour surcharger cette classe CMS, vous devrez enregistrer ce fichier sous le nom « CMS.php » dans le répertoire « override/classes« .
Maintenant, allons surcharger le CMSController afin de pouvoir afficher des infos sur la marque en entête de page et afficher également le listing des pages CMS rattachées à ce Manufacturer.

<?php
class CmsController extends CmsControllerCore
{
	public $php_self = 'cms.php';
 
	public $assignCase;
	public $manufacturer;
	public $cms;
	public $cms_category;
 
	public function preProcess()
	{
		if ($id_cms = (int)Tools::getValue('id_cms')) {
		    $this->cms = new CMS($id_cms, self::$cookie->id_lang);
		    $this->manufacturer = new Manufacturer($this->cms->id_cms_category, self::$cookie->id_lang);
		}
		$this->canonicalRedirection();
 
		parent::preProcess();
 
		/* assignCase (1 = CMS page, 2 = CMS category) */
		if (Validate::isLoadedObject($this->cms) AND ($this->cms->active OR (Tools::getValue('adtoken') == Tools::encrypt('PreviewCMS'.$this->cms->id) AND file_exists(dirname(__FILE__).'/../'.Tools::getValue('ad').'/ajax.php'))))
			$this->assignCase = 1;
		else
			Tools::display404Error('404.php');
	}
 
	public function process()
	{
		global $link;
		$pipe = Configuration::get('PS_NAVIGATION_PIPE');
		if (empty($pipe))
			$pipe = '>';
		FrontControllerCore::process();
		$parent_cat = new CMSCategory(1, (int)(self::$cookie->id_lang));
		self::$smarty->assign('id_current_lang', self::$cookie->id_lang);
		self::$smarty->assign('home_title', $parent_cat->name);
 
		if ($this->assignCase == 1)
		{
			$path = '<a title="'.htmlentities($this->manufacturer->name, ENT_NOQUOTES, 'UTF-8').
				'" href="%27%20.%20%20%09%09%09%09Tools::safeOutput%28$link-%3EgetManufacturerLink%28%28int%29$this-%3Emanufacturer-%3Eid_manufacturer%29%29.%0A%09%09%09%09%27">' . $this->manufacturer->name . '</a>'. $pipe. '';
			self::$smarty->assign(array(
				'cms' => $this->cms,
				'content_only' => (int)(Tools::getValue('content_only')),
				'path' => $path . Tools::getFullPath(1, $this->cms->meta_title, 'CMS'),
				'cms_pages' => CMS::getCMSPages((int)(self::$cookie->id_lang), (int)($this->cms->id_cms_category) )
			));
		}
		if (Validate::isLoadedObject($this->manufacturer) AND $this->manufacturer->active)
		{
			self::$smarty->assign(array(
				'manufacturer' => $this->manufacturer));
		}
	}
 
	public function displayContent()
	{
		FrontControllerCore::displayContent();
		self::$smarty->display(_PS_THEME_DIR_.'manufacturer-cms.tpl');
	}
}

Maintenant, décrivons ce que nous venons de faire : comme expliqué en introduction, nous avons besoin d’un Manufacturer pour pouvoir afficher les infos en entete de page et mettre un lien vers ses produits. C’est ce que nous faisons à la ligne 10 en initialisant un objet Manufacturer avec l’identifiant de category de notre page CMS en cours :

$this->manufacturer = new Manufacturer($this->cms->id_cms_category, self::$cookie->id_lang);

Puis, nous avons besoin des autres pages CMS rattachées à notre marque pour pouvoir les afficher dans notre menu, c’est ce que fait cette ligne :

'cms_pages' => CMS::getCMSPages((int)(self::$cookie->id_lang), (int)($this->cms->id_cms_category) )

Vous remarquerez au passage que nous avons complètement enlevé les lignes de code faisant référence aux sous catégories de CMS (assignCase == 2).

Je passe rapidement sur l’initialisation du fil d’ariane (ou chemin de fer) que l’on aurait certainement pu gérer autrement. Nous afficherons juste le nom de la marque entre la page Accueil et le nom de la page CMS en cours.

$pipe = Configuration::get('PS_NAVIGATION_PIPE');
		if (empty($pipe))
			$pipe = '>';
$path = '<a title="'.htmlentities($this->manufacturer->name, ENT_NOQUOTES, 'UTF-8').
				'" href="%27%20.%20%20%09%09%09%09Tools::safeOutput%28$link-%3EgetManufacturerLink%28%28int%29$this-%3Emanufacturer-%3Eid_manufacturer%29%29.%0A%09%09%09%09%27">' . $this->manufacturer->name . '</a>'. $pipe. '';
'path' => $path . Tools::getFullPath(1, $this->cms->meta_title, 'CMS'),

Attention également à bien appeler la méthode « process()« , non pas du parent mais du FrontController (pour éviter d’appeler 2 fois les mêmes choses vu que votre Controller hérite de CMSControllerCore):

FrontControllerCore::process();

Idem dans la méthode « displayContent()« , pensez bien à appeler la méthode de FrontControllerCore.

Voici le code du fichier manufacturer-cms.tpl pour ceux que cela intéresse :

{include file="$tpl_dir./breadcrumb.tpl"}
{include file="$tpl_dir./manufacturer-header.tpl"}	
{if isset($cms) && !isset($category)}
<div class="rte{if $content_only} content_only{/if}">
<div id="left">{$cms->content}</div>
&nbsp;
<div id="right">{if isset($cms_pages) & !empty($cms_pages)} 
<ul class="bullet">
<ul class="bullet">{foreach from=$cms_pages item=cmspages} id} class='actif'{/if}></ul>
</ul>
<a href="{$link->getCMSLink($cmspages.id_cms, $cmspages.link_rewrite)|escape:'htmlall':'UTF-8'}#anchor">{if $cmspages.meta_keywords}{$cmspages.meta_keywords|escape:'htmlall':'UTF-8'}{else}{$cmspages.meta_title|escape:'htmlall':'UTF-8'}{/if}</a>{/foreach}
 
{/if}
 
</div>
</div>
{else} {l s='This page does not exist.'} {/if}

Et également le code de manufacturer-header.tpl utilisé dans manufacturer-cms.tpl et manufacturer.tpl

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
<div id="imgprod"><img src="{$img_manu_dir}{$manufacturer->id}.jpg"></div>
<div id="infoprod">
	<h1>{$manufacturer->name}</h1>
	<h2>{$manufacturer->title}</h2>
	<div id="adresse">
	<p>{l s='Address :'}</p>
	<address>
	{$manufacturer->address1}
	{$manufacturer->address2}
	{$manufacturer->postcode}
	{$manufacturer->city}
	</address>
	</div>
	<div id="infocontact">
    <ul>
    	<li>	
		<p>{l s='Phone :'}</p>
		{$manufacturer->phone}
		</li>
	</ul>
	</div>
</div>
<hr class="clearhr" />
<a name="anchor"></a>
<ul id="sousnav"> 
{if isset($first_cms_page)}
	{foreach from=$first_cms_page item=cmspage}
   	<li><a href="{$link->getCMSLink($cmspage.id_cms, $cmspage.link_rewrite)|escape:'htmlall':'UTF-8'}#anchor"{if $smarty.server.SCRIPT_NAME == "/cms.php"} class="actif"{/if}>{l s='Presentation'}</a></li>
    {/foreach}
{else}
    <li><a{if $smarty.server.SCRIPT_NAME == "/cms.php"} class="actif"{/if}>{l s='Presentation'}</a></li>
{/if}
 
	<li><a href="{$link->getManufacturerProductsLink($manufacturer)}#anchor"{if ($smarty.server.SCRIPT_NAME == "/manufacturer.php" && $smarty.get.param == "products") || $smarty.server.SCRIPT_NAME == "/product.php"} class="actif"{/if}>{l s='Our products'}</a></li>
</ul>

Et voilà pour notre surcharge de CMSController, nos pages CMS sont prêtes à être affichées, nous pouvons maintenant travailler sur les pages Manufacturer et le controller Manufacturer :

Tutoriel override prestashop partie 2 : surcharge du controller ManufacturerController

Surcharge de classes et controllers dans prestashop : un exemple complet

Prestashop 1.4Aujourd’hui, je mets en ligne une nouvelle série d’articles sur la solution e-commerce open-source Prestashop, dans laquelle je vais vous reparler de l’override de classes et de controllers dans prestashop 1.4 en vous présentant un exemple complet, mettant en oeuvre les 2 types d’override (classe et controller) et également une gestion de l’URL rewriting.

Pour cela , j’ai écrit un « long » tutoriel présentant une fonctionnalité à implémenter dans Prestashop (que je vous présente ci-dessous) et que j’ai séparé en 3 articles bien distincts.

Mais avant de rentrer plus en détail dans la technique, je vous propose de décrire simplement la fonctionnalité que je souhaite mettre en place sur mon Prestashop 1.4.

 

Lier les pages CMS aux Marques / Fabricants

Les marques ou fabricants dans Prestashop sont des entités administrables par le Back Office avec un nom, un logo, et une petite description associée. Cependant, cela n’est pas suffisant lorsque l’on a besoin de rajouter du contenu lié à ces marques, comme des pages de présentation etc … afin de travailler son contenu éditorial et par la même occasion son SEO.

D’autre part, Prestashop dispose d’une fonctionnalité CMS qui permet d’éditer des pages de contenu (administrables par le Back Office prestashop) et de les relier à des catégories CMS. Vous pourrez écrire autant de contenu éditorial que vous voudrez dans ces pages. Le seul problème de mon point de vue est qu’elles sont un peu « isolées » car il vous faudra les relier à la main depuis les pages de votre site pour y donner accès.

Nous disposons donc de 2 fonctionnalités intéressantes mais qui n’ont aucun lien / rapport entre elles.

Je vous propose de lier les pages CMS à nos marques pour avoir des pages Manufacturer comportant plus de contenu. (par exemple pour présenter l’historique de la marque, le métier, etc …)

Nous allons pour cela overrider leurs classes et controllers afin de les faire fonctionner ensemble.

Nous allons également faire en sorte qu’une page Marque (Manufacturer) affiche par défaut la première page CMS qui lui est rattachée au lieu du classique listing de produits. Sur chaque page CMS, nous afficherons les autres pages CMS du Manufacturer par le biais d’un menu dans la page et nous aurons également accès au listing produits par un lien (dans un onglet de la page).

Voici un schéma présentant la fonctionnalité :

Prestashop override Manufacturer

Voici maintenant un schéma de ce que la page Manufacturer (onglet produits) affichera :

Prestashop override manufacturer products

Voici comment nous allons procéder :

  1. Surcharge de la classe CMS et du controller CMSContollerCore
  2. Surcharge du controller ManufacturerControllerCore
  3. Surcharge de la classe Link pour changer l’URL rewriting des pages Marque


Comment réparer l’autocompletion sous Zend Studio 7 et 8 sur Ubuntu

Zend Studio 8

Zend Studio 8

Alors si comme moi vous codez en Php sous l’IDE Zend Studio 7 ou 8 sur votre système Ubuntu, vous devez certainement trouver ce logiciel indispensable.

En effet, pour en avoir testé quelques uns, je trouve que cet IDE est vraiment le plus abouti pour développer en Php :

 

  • refactoring
  • autocompletion
  • intégration de fonctionnalités Zend Framework
  • autocompletion de JQuery
  • intégration avec VMWare Workstation
  • fonctionnalités de débuggage grâ à Zend Server
  • etc …

Cependant, sur certaines versions de cet IDE sur Ubuntu, l’autocompletion des méthodes, noms de classes, namespaces, etc … ne fonctione plus. Chose dérangeante vous me direz puisque c’est ce qu’on attend comme fonctionalité de base d’un IDE de ce calibre.

Alors voici comment faire pour refaire fonctionner cette autocompletion.

  1. Tout d’abord, éteignez votre Zend Studio
  2. Allez dans le répertoire de votre workspacepuis descendez dans l’arborescence jusqu’à trouver le fichier de préférences :
    cd /votre_workspace_dir/.metadata/.plugins/org.eclipse.core.runtime/.settings/
  3. Puis supprimer le fichier « org.eclipse.dltk.ui.prefs » :
    rm org.eclipse.dltk.ui.prefs
  4. Redémarrez votre Zend Studio et vous devriez de nouveau avoir l’auto complétion qui fonctionne !


Comment refaire fonctionner Gmail Manager avec Firefox 7 sur Ubuntu

Gmail, la solution de mail par Google

Gmail, la solution de mail par Google

Depuis quelques temps maintenant, et ce n’est pas la première fois, mon extension Gmail Manager de Firefox ne veut plus se connecter à mes comptes Gmail.

Comptant sur la communauté Ubuntu pour m’aider à résoudre ce problème, j’ai fait quelques recherches sur notre moteur préféré et j’ai trouvé une astuce qui va vous permettre de refaire fonctionner cette extension correctement. Je vous livre ici la marche à suivre :

Rendez vous dans votre répertoire home. Un simple « cd » suffira à vous déplacer au bon endroit.

michel@ubuntu:~$ cd

Firefox stocke ses données utilisateurs (extension etc…) dans un répertoire caché nommé « .mozilla ». Une fois dedans, comme il se peut que vous ayez plusieurs produits mozilla installés, allez dans le répertoire « firefox » puis dans le répertoire de votre profil par défaut (une série de chiffre suivie de default). Le paramétrage de l’extension se trouve dans le répertoire « extensions » puis « {582195F5-92E7-40a0-A127-DB71295901D7} » puis « components ».
Donc si je résume, voici la commande à taper :

michel@ubuntu:~$ cd .mozilla/firefox/default.une_serie_de_chiffre_et_lettre/extensions/{582195F5-92E7-40a0-A127-DB71295901D7}/components/

Ici vous trouverez un fichier nommé « gmServiceGmail.js ». Je vous conseille d’en faire une sauvegarde :

michel@ubuntu:~/.mozilla/firefox/default.une_serie_de_chiffre_et_lettre/extensions/{582195F5-92E7-40a0-A127-DB71295901D7}/components$ cp gmServiceGmail.js gmServiceGmail.bak.js

Puis vous pouvez éditer le fichier avec votre éditeur préféré (vi, emacs, gedit etc …)

michel@ubuntu:~/.mozilla/firefox/default.une_serie_de_chiffre_et_lettre/extensions/{582195F5-92E7-40a0-A127-DB71295901D7}/components$ gedit gmServiceGmail.js

Chez moi les modifications à effectuer se situent aux lignes 218 et 224.
Tout d’abord, à la ligne 218, (vous pouvez la mettre en commentaire // devant la ligne), remplacez :

this._loginURL = "https://www.google.com/a/" + this.domain + "/LoginAction2";

par :

this._loginURL = "https://accounts.google.com/a/"+ar[1]+"/LoginAction2?service=mail";

et enfin à la ligne 224, remplacez :

this._loginURL = "https://www.google.com/accounts/ServiceLoginAuth";

par :

this._loginURL = "https://accounts.google.com/accounts/ServiceLoginAuth?service=mail";

Et voilà, sauvegardez votre fichier, redémarrez firefox et vous devriez de nouveau voir votre extension Gmail Manager se connecter aux serveurs Google !

Prestashop 1.4 : Marre des Hooks ? Essayez un plugin !

Logo PrestashopAujourd’hui, je vous propose une petite traduction / adaptation d’un article de ecartservice.net qui m’a bien servi.

Si comme moi, vous développez des modules et des themes pour Prestashop, vous vous êtes certainement arraché quelques cheveux lorsque vous avez du vous servir du système de hooks.

Autant cela peut s’avérer très pratique lorsque vous devez coder une fonctionnalité simple (rajouter un évènement après une commande par exemple), autant cela peut devenir très complexe lorsque vous avez une fonctionnalité qui doit s’attacher sur plusieurs hooks ou à des endroits non prévus dans le core de Prestashop.

La version 1.4 de Prestashop a quand même apporté une grande évolution avec son système d’override de classes mais si vous développez des modules, vous ne pourrez pas échapper à l’utilisation de Hooks.

Aujourd’hui, je vous propose de vous affranchir de ceux-ci pour utiliser ce que nous appelerons un Plugin. Son but est de pouvoir afficher n’importe quel affichage de module, page CMS ou variable de config Prestashop, à n’importe quel endroit dans votre theme, et ce sans avoir à vous accrocher à des hooks.

Pour cela, créons une classe Plugin dans le fichier Plugin.php que nous mettrons dans le dossier /overrides/classes/ :

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
<?php
class Plugin
{
  public static $initialized = false;
  protected static $smarty;
  protected static $cookie;
  protected static $link;
  protected static $cart;
  function init()
  {
    global $smarty, $cookie, $link, $cart;
    if (self::$initialized)
      return;
    self::$initialized = true;
    self::$cookie = $cookie;
    self::$cart = $cart;
    self::$smarty = $smarty;
    self::$link = $link;
    if (!Configuration::get('PS_FORCE_SMARTY_2'))
    {
      self::$smarty->registerPlugin('function', 'plugin', array('Plugin', 'mc_smartyplugin'));
      self::$smarty->registerPlugin('function', 'cmspage', array('Plugin', 'mc_smartycmspage'));
      self::$smarty->registerPlugin('function', 'psconfig', array('Plugin', 'mc_smartypsconfig'));
    } else {
      self::$smarty->register_function('plugin', array('Plugin', 'mc_smartyplugin'));
      self::$smarty->register_function('cmspage', array('Plugin', 'mc_smartycmspage'));
      self::$smarty->register_function('psconfig', array('Plugin', 'mc_smartypsconfig'));
    }
  }
  public static function moduleoutput($module, $hook, $hookArgs = array())
  {
    $output = '';
    if (!isset($hookArgs['cookie']) OR !$hookArgs['cookie'])
      $hookArgs['cookie'] = self::$cookie;
    if (!isset($hookArgs['cart']) OR !$hookArgs['cart'])
      $hookArgs['cart'] = self::$cart;
    $hookArgs['altern'] = 1;
    $instance = Module::getInstanceByName($module);
    if (is_callable(array($instance, 'hook'.$hook)))
      $output = call_user_func(array($instance,'hook'.$hook), $hookArgs);
    echo $output;
  }
  public static function cmspage($id_cms = 1)
  {
    $output = '';
    $cms = new CMS($id_cms, intval(self::$cookie->id_lang));
    if (Validate::isLoadedObject($cms))
      $output = $cms->content;
    return $output;
  }
  static function mc_smartyplugin($params, &$smarty)
  {
    return Plugin::moduleoutput($params['module'], $params['hook'], isset($params['args']) ? $params['args'] : array());
  }
  static function mc_smartycmspage($params, &$smarty)
  {
    return Plugin::cmspage($params['id']);
  }
  static function mc_smartypsconfig($params, &$smarty)
  {
    return Configuration::get($params['item']);
  }
}

Maintenant, faisons en sorte que Prestashop prenne en compte notre nouvelle classe dès l’initialisation du programme (fonction init du FrontController). Pour cela, nous allons surcharger le controller principal afin d’initialiser notre classe Plugin.

Créez le fichier FrontController.php dans /overrides/classes/ avec le contenu suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
class FrontController extends FrontControllerCore
{
  protected static $plugin;
  function __construct()
  {
    parent::__construct();
    self::$plugin = new Plugin();
  }
  function init()
  {
    parent::init();
    self::$plugin->init();
  }
}

Voilà notre classe Plugin est utilisable à présent.

Pour la mettre en oeuvre, rien de plus simple, vous pouvez utiliser les 3 syntaxes suivantes :

  1. {plugin module='nomdevotremodule' hook='home'}

    ce qui affichera la « sortie » de votre module se nommant « nomdevotremodule« 

  2. {cmspage id='2'}

    ce qui affichera le contenu de la page CMS ayant l’identifiant 2. Très pratique par exemple pour rajouter du contenu dans une page comme la page contact.php qui n’a rien de prévu à cet effet de base dans Prestashop

  3. et enfin :
    {psconfig item='PS_SHOP_PHONE'}

    qui vous permettra d’insérer où vous voulez le contenu des variables de configuration de Prestashop comme ici le numéro de téléphone de votre magasin

Note importante: attention, même si ce code a bien été testé, si vous l’utilisez, je ne garantis pas le bon fonctionnement de votre boutique Prestashop