Bonjour,

Pour utiliser google analytics dans Symfony il existe un plugin, mais j'aimerais rendre ce système disponible pour n'importe quel sorte de tag. C'est à dire de définir les tag qui sont toujours présent de ceux qui sont à appeler dans certains modules et actions.

Faire un component de tag avec un appel ou non dans des fichiers yaml ? faire un module complet ? un helper ?

Une idée ?

Et pour pimenter un peu il faut que ce soit disponible pour plusieurs langages, un compte par langue ou pas forcement de compte.
Il faudrait pouvoir entrer les ID de tous les comptes et activer en fonction de la langue choisie.

Bien sur il y a du GA mais aussi d'autres d'où l'impossibilité d'utiliser sfGoogleAnalyticsPlugin qui doit bien sur passer sur tous les modules / action pour bien tracker.

J'imagine que certains se sont déjà frottés à ce type de soucis pour du tracking ?

Il faudrait découper le problème en section :
1) une factory capable de charger et d'afficher des objets de type "tag".
2) une classe abstraite "tag" qui contiendrais le prototype des fonctions appelables par la factory
3) par type de tag, un héritage de la classe "tag" qui connaitrais les spécificités de chaque tag, et qui serait capable de charger une configuration spécifique.

Il faudrait découper le problème en section :
1) une factory capable de charger et d'afficher des objets de type "tag".
2) une classe abstraite "tag" qui contiendrais le prototype des fonctions appelables par la factory
3) par type de tag, un héritage de la classe "tag" qui connaitrais les spécificités de chaque tag, et qui serait capable de charger une configuration spécifique.

Qu'est ce que tu appel une factory ? ce serait une class au niveau des lib ?

Et ensuite faire une class abstraite mais ou ?

En fait c'est dans l'architecture que je me perds à savoir ou commencer.

Essaye de te détacher du code pour penser à ce que tu as besoin, de manière à visualiser les traitements nécessaires, puis ensuite, tu te demandes comment on les appelles, où on mets les fichiers.

En fait, ce que je te propose, c'est de faire une classe qui serait une interface unique pour les développeurs voulant utiliser ton système.
Cette classe serait capable de comprendre le type de tag que tu lui demande, et d'instancier la classe qui sais le gérer.

Les classes permettant de gérer les tags seraient toutes filles d'une classe abstraite qui contiendrais le prototype des méthodes qu'appellent la factory.

Ainsi, dans ton code, tu appelles toujours la même classe, en disant que tu veux tel ou tel tag, et tout se fait en souterrain
Et chaque classe manipulant un tag sais quoi gérer (langue, environnement, ...)

Ok voilà comment je compte faire suivant tes indications :

Une class mère Tag.class.php : le constructeur définira l'instance du type de tag à charger pour cette class.
Une class abstraite TagPrototype.class.php : elle permet de créer les différents éléments javascript.
Une class pour chaque type de tag Tag{nom}.class.php instanciée par Tag.class.php qui instancie la class TagPrototype.class.php pour créer son tag.

Avec ça c'est ok pour toute l'appli, le système est ouvert, facilement compréhensible pour une personne hors du code.

Si c'est bien comme ça que je dois m'organiser ?

Pas tout à fait.

Ce soir, je vais essayer de prendre le temps de te faire un petit schéma, qui sera plus clair que tout texte.

Merci c'est bien sympa j'avoue que c'est une partie assez importante pour y passer quelque temps, j'attends de tes novuelles

N'hésite pas à me relancer si je t'oublie

Ok en fait de ce que je comprends soit je créer un plugin soit je créer une factory dans les lib (autoload) mais alors si je fais une nouvelle factory que dois-je étendre comme class symfony ?

Lien vers l'image

Avec ce schéma, je tente de décrire ce que je pense.
1/ Pour gérer tout tes tags, qui vont avoir un chouia de traitement commun, je te conseille de faire une classe JavascriptTagBase qui sera une classe abstraite, et qui ne contiendra que les méthodes qui peuvent être partagées par tous les tags (affichage, par exemple)
2/ Pour chaque tag que tu veux gérer, tu crées une classe pour le gérer. Dans mon exemple, j'ai une classe pour gérer les tags GoogleAnalytics et une autre pour les tags AdLedge.
3/ La classe JavascriptTagFactory est LA seule classe que tu utiliseras dans ton code. Le but étant de dire, "je veux la classe permettant de gérer les tags Google Analytics", et que la factory sache où aller chercher la classe, voir charger une configuration liée, ... en un mot, faire le lien entre la classe GoogleAnalyticsTag, qui ne doit gérer QUE le tag, et les spécificitiés de ton projet (la configuration présente dans le projet, les paramètres passés par l'utilisateur, ...)

J'espère que ce découpage est plus clair.

En terme de fichier, dans /lib, je pense qu'il faut un dossier JavascriptTag qui contient la classe "JavascriptTagFactory" et "JavascriptTagBase", puis un sous-dossiers "Tag" qui contient tes classes finales.

C'est marrant j'ai exactement fait ça avec les même noms sauf pour JavascriptTagBase

En fait le truc c'est que je compte faire comme le plugin sfGoogleAnalyticsPlugin et de faire une extension du filtre (extend sfFilter) ensuite j'instancie le tag dont j'ai besoin mais j'ai l'impression que je refais un peu la même chose. Si tu as du code déjà fais je suis preneur car j'avance un peu à l'aveuglette pour le moment.

Non, je n'ai aucun code, c'est juste un jet de conception que je te donne.

Non, je n'ai aucun code, c'est juste un jet de conception que je te donne.

Ok merci voilà donc ce que j'ai fais dis moi si tu vois pour l'instant une manière de l'améliorer.

Class JavascriptTagFactory :

<?php 
/**
 * Manage e-commerce Javascript Tags.
 * 
 * @package     JavascriptTag
 * @author      //
 */
class JavascriptTagFactory extends sfFilter
{

	public 
		$aFinalTag   = array(),
		$aTags       = array('Criteo');
	
	/**
	 * Constructor
	 * 
	 * @param parent class $filterChain
	 */
	public function execute($filterChain) 
	{ 		
		$filterChain->execute();

		foreach($this->aTags as $tag) {
			$tag = $this->addTag(ucfirst($tag));
		}

		$response = $this->getContext()->getResponse();
		$response->setContent(str_ireplace('</body>',$this->getTags().'</body>',$response->getContent())); 
	}

	/**
	 * Instance of all tags class needed, push to array
	 * 
	 * @param string $tag
	 */
	public function addTag($tag)
	{
		if(class_exists($tag)) {
			array_push($this->aFinalTag, new $tag());
		}
	}
	
	/**
	 * Get all tags from the array
	 * 
	 * @param string $display
	 * @return string $display
	 */
	public function getTags($display = '') 
	{
		foreach($this->aFinalTag as $oTag)  {
			$display .= $oTag->getTag();
		}
			
		return $display;
	}
}
?>

class JavascriptTagPrototype :

<?php 
/**
 * Prototypes for javascript tags
 * 
 * @package     JavascriptTag
 * @author      //
 */
abstract class JavascriptTagPrototype
{
	const JS_START    = '<script type="text/javascript">';
	const JS_STOP     = '</script>';
	const CDATA_START = "//<![CDATA[";
	const CDATA_STOP  = '//]]>';

	/**
	 * Add div with class and content
	 * 
	 * @param string $class
	 * @param string $param
	 * @return string 
	 */
	public function addDivWithClass($class,$param) {
		return '<div class=\"'.$class.'\">'.$param.'</div>';
	}
}
?>

class Criteo :

<?php 
/**
 * Criteo (http://widget.criteo.com)
 * 
 * @package JavascriptTag
 * @author  //
 *
 */
class Criteo extends JavascriptTagPrototype
{
	const ID = 'TEST';
	
	public 
		$tag,
		$module;
	
	/**
	 * Constructor
	 */	
	function __construct()
	{
		sfContext::getInstance()->getConfiguration()->loadHelpers(array('Helper','Tag','Javascript'));
		
		$this->module = sfContext::getInstance()->getModuleName();
		
		// Comment
		$criteo[] = "<!-- ".$this." -->";
		
		// Load Criteo javascript file
		$criteo[]  .= '<script type="text/javascript" src="http://ld2.criteo.com/criteo_ld.js"></script>';
		
		// Start Tag 
		$criteo[] .= parent::JS_START;
		$criteo[] .= parent::CDATA_START;
		
		$criteo[] .= 'document.write(\'<div id=\"'.self::ID.'\" style=\"display:none\">\')'; 
		$criteo[] .= $this->addDivWithClass('ctoWidgetServer','http://widget.criteo.com/pvx');
		$criteo[] .= $this->addDivWithClass('ctoDataType',$this->getCtoDataType());
		$criteo[] .= $this->addDivWithClass('ctoParams',$this->getCtoParams());
		$criteo[] .= "document.write('<\/div>')";
		
		// End Tag
		$criteo[] .= parent::CDATA_STOP;
		$criteo[] .= parent::JS_STOP;
		
		// Set the tag
		$this->setTag(join("\n", $criteo));
	}
	
	/**
	 * Return class name
	 */
	public function __toString() {
		return "CRITEO";
	}
	
	/**
	 * Setter for the tag
	 * 
	 * @param $string $tag
	 */
	public function setTag($tag) {
		$this->tag = $tag;
	}
	
	/**
	 * Getter for the tag
	 * 
	 * @return string $tag
	 */
	public function getTag() {
		return $this->tag;
	}
	
	/**
	 * (non-PHPdoc)
	 * @see lib/JavascripTag/JavascriptTagPrototype#addDivWithClass($class, $param)
	 */
	public function addDivWithClass($class,$param)
	{
		return "document.write('".parent::addDivWithClass($class,$param)."');";
	}
	
	/**
	 * Return ctoDataType for the module
	 * 
	 * @return string $ctoDataType
	 */
	public function getCtoDataType() 
	{
		switch($this->module)
		{
			case 'order':
				$ctoDataType = 'transaction';
			break;
			
			default:
				$ctoDataType = 'sendEvent';
			break;
		}
		
		return $ctoDataType;
	}
	
	/**
	 * Return ctoParams for the module
	 * 
	 * @return string $ctoParms
	 */
	public function getCtoParams() 
	{
		switch($this->module)
		{
			case 'order':
				$ctoParams = 'transaction';
			break;
			
			case 'sells':
				$ctoParams = 'wi=7708871&pt1=0&pt2=1&s=1&si=1';
			break;
				
			default:
				$ctoParams = 'wi=7708871&pt1=0&pt2=1&si=1';
			break;
		}
		
		return $ctoParams;
	}
}
?>

En gros avec une première class de tag.

Maintenant mon soucis c'est de trouver comment récuperer des informations des actions / template sans avoir à passer par des fichier YAML ?