Clear Cache

Little tip when you need to load your own yaml file

eNk` — Sun, 09 May 2010 16:25:00 +0200

So this is just a little tip when you need to load your own yaml file.
To load a yaml file you can use sfYamlConfigHandler::parseYaml() ( or sfYaml::load() ). And just after you can also use sfYamlConfigHandler::replaceConstants() to replace constant(s) from Symfony such as %SF_LIB_DIR% (or any other value defined in a yaml config file) in the values you've just loaded from your custom yaml file.

A little exemple:

# config/my_config.yml
dirs:
  lib:    %SF_LIB_DIR%/my_lib
  custom: %SUPER_PATH%/is/here

sfConfig::set('super_path', '/the/super/path');

$configuration = sfYamlConfigHandler::parseYaml(sfConfig::get('sf_config_dir').'/my_config.yml');
$configuration = sfYamlConfigHandler::replaceConstants($configuration);

var_dump($configuration);
/*
array(1) {
  ["dirs"]=>
  array(2) {
    ["lib"]=>
    string(53) "/Users/cedric/Dev/workspace/my_sf_project/lib/my_lib"
    ["custom"]=>
    string(23) "/the/super/path/is/here"
  }
}
*/

Custom sfValidatorFile and sfValidatedFile

eNk` — Mon, 05 Apr 2010 10:56:00 +0200

In this post I will show a way to customize the file upload with the forms framework. The forms framework provide the sfWidgetFormInputFile class to display a file input tag and the sfValidatorFile class which is the default class used to validate a file input field. As all validator classes sfValidatorFile check if the field value is ok according to the validation options, but instead of returning a "basic" value such as an integer or a string, this validator will return an instance of sfValidatedFile as a clean value.

In this exemple I will use an Image class and cutomize the ImageForm class.

Image:
  columns:
    title: { type: string(255) }
    file:  { type: string(255) }

The Image form class configured with a sfWidgetFormInputFile and a sfValidadorFile:

class ImageForm extends BaseImageForm
{
    public function configure()
    {
        $this->setWidget('file', new sfWidgetFormInputFile());
	
        $this->setValidator('file', new sfValidadorFile(array(
            'path' => '/my/super/folder';
            // ... other options ...
        ))));
    }
}

By using the previous configuration, when we will save the form the image file will automaticaly be saved in /my/super/folder. But let's say we need to save the image in several size, how to do it ? To do this the sfValidadorFile validator provide a 'validated_file_class' option to define your own sfValidtedFile class. So you can easly create a ImageValidatedFile class which extends from sfValidatedFile and override the sfValidatedFile::save() function to save the image as the way you want.

But let's go a little bit futher, it would be cool if we could pass the several size format to the ImageValidatedFile class from the form configuration function, so something like:

class ImageForm extends BaseImageForm
{
    public function configure()
    {
    	$this->setWidget('file', new sfWidgetFormInputFile());
	
        $this->setValidator('file', new sfValidatorFile(array(
            'path' => '/my/super/folder',
            'resize_formats' => array(
                'big' => array('width' => 800, 'height' => 600),
                'thumb' => array('width' => 120, 'height' => 80) ))
        ));
    }
}

As you can see in the following sfValidatorFile::doClean() function, the sfValidatorFile validator don't pass any options to the validated file class except the path option.

protected function doClean($value)
{
  // ...

  $class = $this->getOption('validated_file_class');
	
  return new $class($value['name'], $mimeType, $value['tmp_name'], $value['size'], $this->getOption('path'));
}

So to pass some options to the validated file class we can create a custom ImageValidatorFile class which will use the ImageValidatedFile class by default. So the idea is to configure the ImageForm like this:

class ImageForm extends BaseImageForm
{
    public function configure()
    {
    	$this->setWidget('file', new sfWidgetFormInputFile());
	
        $this->setValidator('file', new ImageValidatorFile(array(
            'path' => '/my/super/folder',
            // custom options I will define in ImageValidatorFile:
            'preserve_ratio' => true,
            'resize_formats' => array(
                'big' => array('width' => 800, 'height' => 600),
                'thumb' => array('width' => 120, 'height' => 80) ))
        ));
    }
}

In the ImageValidatorFile class we just need to override the configure() and doClean() functions to set the validator options and pass the custom options to the validated file class:

class ImageValidatorFile extends sfValidatorFile
{
    protected function configure($options = array(), $messages = array())
    {
        parent::configure($options, $messages);
    	$this->setOption('validated_file_class', 'ImageValidatedFile');
        $this->setOption('required', false);

        $this->addOption('preserve_ratio', true);
        $this->addOption('resize_formats', array()));
    }

    protected function doClean($value)
    {
        $validatedFile = parent::doClean($value);
        $validatedFile->setResizeFormats($this->getOption('resize_formats'));
        $validatedFile->setPreserveRation($this->getOption('preserve_ratio'));
        
        return $validatedFile;
    }
}

And in the ImageValidatedFile we just need to override the save() function:

class ImageValidatedFile extends sfValidatedFile
{
    private $resizeFormats = array();

    private $preserveRatio = true;

    public function setResizeFileFormats($value)
    {
        $this->resizeFormats = $value;
    }

    public function setPreserveRation($value)
    {
        $this->preserveRatio = (boolean) $value;
    }
	
    public function save($file = null, $fileMode = 0666, $create = true, $dirMode = 0777)
    {
        if(is_null($file))
        {
            $fileName = substr($this->originalName, 0, strpos($this->originalName, '.'));
        	
            $file = preg_replace('/\W+/', '-', $fileName);
            $file = strtolower(trim($file, '-'));
            $file .= $this->getExtension('.jpg');
        }

        if($create)
        {
            // create the folder where to save the files with $dirMode permissions.
        }

        if(!is_array($this->resizeFileFormats))
        {
            $this->resizeFileFormats = array();
        }

        // here I use sfImageTransformPlugin to resize the image
        $img = new sfImage($this->tempName, $this->type);
         
        foreach($this->resizeFormats as $formatName => $dimensions)
        {
            $img->resize($dimensions['width'], $this->preserveRatio ? null : $dimensions['height']);
            $img->saveAs($this->path.'/'.$formatName.'/'.$file, $this->type);
        }
        
        return $file; // return the file's name
    }
}

Customize Doctrine model builder options

eNk` — Thu, 21 Jan 2010 14:51:00 +0100

This is just a little tip to customize the builder options for the generated model classes (lib/model/). Basically if we define a MyClass class in the schema.yml we will have this:
- MyClass > BaseMyClass > sfDoctrineRecord > Doctrine_Record > ...
- MyClassTable > Doctrine_Table > ...

So the idea is to get somthing like:
- MyClass > BaseMyClass > MyDoctrineRecord > sfDoctrineRecord > Doctrine_Record > ...
- MyClassTable > MyDoctrineTable > Doctrine_Table > ...
This can be useful if we need to add common elements to all record or table objects in a project.

When you run a build model the task load the sfDoctrinePlugin default configuration. You can find this default configuration in sfDoctrinePluginConfiguration::getModelBuilderOptions(). This is the code from getModelBuilderOptions() (here I'm using sf1.3):

public function getModelBuilderOptions()
  {
    $options = array(
      'generateBaseClasses'  => true,
      'generateTableClasses' => true,
      'packagesPrefix'       => 'Plugin',
      'suffix'               => '.class.php',
      'baseClassesDirectory' => 'base',
      'baseClassName'        => 'sfDoctrineRecord',
    );

    // for BC
    $options = array_merge($options, sfConfig::get('doctrine_model_builder_options', array()));

    // filter options through the dispatcher
    $options = $this->dispatcher->filter(new sfEvent($this, 'doctrine.filter_model_builder_options'), $options)->getReturnValue();

    return $options;
  }

As you can see $options contain the default configuration, this config is merged with sfConfig::get('doctrine_model_builder_options', array()), so we can easily customize this configuration by setting doctrine_model_builder_options in the ProjectConfiguration class like this:

class ProjectConfiguration extends sfProjectConfiguration
{
    public function setup()
    {
        // ...

        $this->setupCorePluginsCustomConfig();
    }

    public function setupCorePluginsCustomConfig()
    {
        // custom builder options for doctrine
        sfConfig::set('doctrine_model_builder_options',
                      array('baseTableClassName' => 'MyDoctrineTable',
                            'baseClassName' => 'MyDoctrineRecord'));
    }
}

MyDoctrineTable and MyDoctrineRecord simply extends Doctrine_Table and sfDoctrineRecord.

class MyDoctrineTable extends Doctrine_Table
{
    // ...
}

class MyDoctrineRecord extends sfDoctrineRecord
{
    // ...
}

Now if we build model base model files (for record objects in lib/model/base) will be generated with 'extends MyDoctrineRecord'. For table objects, if the files don't exist they will be created with 'extends MyDoctrineTable' else you will have to update it manually.

You can have a look to the Doctrine_Import_Builder class attributes to see all options.

How to create a custom Doctrine behavior

eNk` — Thu, 26 Nov 2009 15:19:00 +0100

So all is in the tittle ^^, in this post I will speak about a way to create your own Doctrine behavior. I really want to share this because it's the first time I create a behavior and I didn't really find any post about it with some complete exemple with code.

Before starting:
Why behavior could be very useful ? I think this well explained in the Doctrine documentation here ^^.

Why I wrote this post ? The Doctrine documentation contains very good explainations about the way of using temaples but I think it's blur about the way you can link a template and a generator in order to generate some classes on the fly.

Let's go:
Here, the aim is to create a "Commentable" behavior to allow us to say that a class can have some comments and also create the corresponding comment class. In the exemple I suppose I need to add some comments on a Post class and a comment have the following fields: content, element_id, user_id and created_at. I would like to write my schema.yml like this: (and also be able to define the name of my user class to create a foreign key on the user_id field):

#config/doctrine/schema.yml
Post:
  actAs:
    Timestampable: ~
    Commentable:
      userColumn: MyUserClass
  columns:
    content: { type: string }

MyUserClass:
  actAs:
    Timestampable: ~
  columns:
    name: { type: string }

Let's start to create our behavior, first of all we need to create a template class to define fields and relations that a class on which we apply the template will have. In our exemple this template will be used on the Post class. So let's create the Commentable template to define that the Post class has many comments. To do this template simply create a new class (for exemple in my_project/lib/template/) and extend the Doctrine_Template class. We will have to use two functions:

setTableDefinition(): define the table fields
setUp(): define the relations and load generators.

// lib/template/Commentable.class.php
class Commentable extends Doctrine_Template
{
    public function setTableDefinition() { }

    public function setUp()
    {
        $this->hasMany($this->getTable()->getComponentName().'Comment as Comments', // here $this->getTable()->getComponentName() will return 'Post'
                       array('local' => 'id',
                             'foreign' => 'element_id'));
    }
}

Ok so we have a temple to say that a commentable class has many comments, and now we need a comment class (it will be PostComment in the exemple), and we will also generate files for this class. So to do that we can create a generator. The generator class will define fields and relations for the comment class (PostComment) and generate the files if needed. Let's create a CommentGenerator class (in my_project/lib/generator/) which extend the Doctrine_Record_Generator class.

// lib/generator/CommentGenerator.class.php
class CommentGenerator extends Doctrine_Record_Generator
{
    public function initOptions()
    {
        $builderOptions = array('suffix' => '.class.php',
                                'baseClassesDirectory' => 'base',
                                'generateBaseClasses' => true,
                                'generateTableClasses' => true,
                                'baseClassName' => 'sfDoctrineRecord');

        $this->setOption('builderOptions', $builderOptions);
        $this->setOption('className', '%CLASS%Comment');
        $this->setOption('generateFiles', true);
        $this->setOption('generatePath', sfConfig::get('sf_lib_dir').DIRECTORY_SEPARATOR.'model'.DIRECTORY_SEPARATOR.'doctrine');
    }

    public function getRelationLocalKey()
    {
        return 'element_id';
    }

    public function buildRelation()
    {
        $this->buildForeignRelation('Comments');
        $this->buildLocalRelation('Element');
    }

    public function setTableDefinition()
    {
        $this->hasColumn('id', 'integer', null, array('primary' => true, 'autoincrement' => true));
        $this->hasColumn('content', 'text', null, array('type' => 'text'));
        $this->hasColumn($this->getRelationLocalKey(), 'integer');
        $this->hasColumn('user_id', 'integer');
        $this->hasColumn('created_at', 'date');
    }

    public function setUp()
    {
        $this->hasOne($this->getOption('userClass'),
                      array('local' => 'user_id',
                            'foreign' => 'id',
                            'onDelete' => 'cascade'));
    }
}

Now we will add a listener to automaticly handle the created_at field on an insertion. Of course we could use the Timesptampable behavior in the table definition of CommentGenerator, but for the exemple I prefer create a new listener. So for this listener, we just need to create a CommentListener which extend from Doctrine_Record_Listener and overrride some function such as preInsert() in our case.

// lib/listener/CommentListener.class.php
class CommentListener extends Doctrine_Record_Listener
{
    public function preInsert(Doctrine_Event $event)
    {
        $event->getInvoker()->created_at = date('Y-m-d', time());
    }
}

Add then we can add the listener to our generator class in setTableDefinition(). Here I also add a constructor to get the options from the template .

// lib/generator/CommentGenerator.class.php
class CommentGenerator extends Doctrine_Record_Generator
{
    public function __construct($options)
    {
        $this->addOptions($options);
    }

    public function initOptions()
    {
        $builderOptions = array('suffix' => '.class.php',
                                'baseClassesDirectory' => 'base',
                                'generateBaseClasses' => true,
                                'generateTableClasses' => true,
                                'baseClassName' => 'sfDoctrineRecord');

        $this->setOption('builderOptions', $builderOptions);
        $this->setOption('className', '%CLASS%Comment');
        $this->setOption('generateFiles', true);
        $this->setOption('generatePath', sfConfig::get('sf_lib_dir').DIRECTORY_SEPARATOR.'model'.DIRECTORY_SEPARATOR.'doctrine');
    }

    public function getRelationLocalKey()
    {
        return 'element_id';
    }

    public function buildRelation()
    {
        $this->buildForeignRelation('Comments');
        $this->buildLocalRelation('Element');
    }

    public function setTableDefinition()
    {
        $this->hasColumn('id', 'integer', null, array('primary' => true, 'autoincrement' => true));
        $this->hasColumn('content', 'text', null, array('type' => 'text'));
        $this->hasColumn($this->getRelationLocalKey(), 'integer');
        $this->hasColumn('user_id', 'integer');
        $this->hasColumn('created', 'date');

        $this->addListener(new CommentListener());
    }

    public function setUp()
    {
        $this->hasOne($this->getOption('userClass'),
                      array('local' => 'user_id',
                            'foreign' => 'id',
                            'onDelete' => 'cascade'));
    }

    // I override this function and set the generate_once option to true.
    // The file seems to be generated each time the behavior is set up, so if you don't generate the file you don't need this, the class will be loaded in memory and nothing is write physically.
    public function generateClassFromTable(Doctrine_Table $table) 
    {
        $definition = array();
        $definition['columns'] = $table->getColumns();
        $definition['tableName'] = $table->getTableName();
        $definition['actAs'] = $table->getTemplates();
        $definition['generate_once'] = true;

        return $this->generateClass($definition);
    }

    public function addOptions(array $options)
    {
        $this->_options = Doctrine_Lib::arrayDeepMerge($this->_options, $options);
    }
}

So now in the Commentable template we just need to load the CommentGenerator as a template's plugin (the Doctrine_Template class also provide the loadGenerator() method).

// lib/template/Commentable.class.php
class Commentable extends Doctrine_Template
{
    public function __construct(array $options = array())
    {
        parent::__construct($options);

        if($this->getOption('userClass', null) == null)
        {
            throw new sfException('You need to specify the userClass option for Commentable.');
        }

        $this->_plugin = new CommentGenerator($this->getOptions());
    }

    public function setTableDefinition() { }

    public function setUp()
    {
        $this->hasMany($this->getTable()->getComponentName().'Comment as Comments',
                       array('local' => 'id',
                             'foreign' => 'element_id'));

        $this->_plugin->initialize($this->getTable());
    }
}

Now just run a build-model and a build-sql and then look at the generated files and sql.
If you choose to generate files for PostComment you can also build forms and filters, and symfony you sould create the corresponding form and form filter classes.

Advanced filters with numbers for Doctrine. (fr and en)

Mathieu — Fri, 13 Nov 2009 13:07:00 +0100

Dernièrement j'ai du filtrer les nombres de façon supérieur ou inférieure sur un champ "prix", je me suis alors rendu compte que les filtres de Symfony avec Doctrine ne permettait pas cela, j'ai donc commençait à chercher une solution en me plongeant dans le code de Symfony, sans vraiment chercher sur internet je l'avoue, mais ça fait parfois du bien de voir comment marche l'outil que l'on utilise tous les jours ;) .

Lately I had to filter some numbers on a price field. The aim was to filter by bigger or smaller than the price value. I realized default Doctrine filters doesn't allow to do that, so I started to search a solution by looking at the Symfony code. I admint I don't really look on the internet to find a solution, but sometimes it's good to look inside the tool we use everyday ;).

J'ai donc découvert une façon simple qui est de faire une méthode spéciale pour le champ concerné, qui consiste donc pour un champ "price" de crée la fonction addPriceColumnQuery($query, $field, $value) et qui devra retourner la requête ($query), ainsi de suite... mais ici je ne vous parlerai pas de cette manière de faire, après quelque recherche avec votre ami Google vous trouverez des articles pour ça (enfin si il y a une demande un article peut être possible...)
Le problème pour ceci est qu'il faudrait répéter l'opération pour tous les champs auxquels on voudrait appliquer cette modification, donc nous allons nous pencher sur une autre solution.

I discovered an easy way to do it by creating a specific method for a given field. For exemple for the price field we can create an addPriceColumnQuery($query, $field, $value) which add some selection criteria to the $query and return it. But I won't speak about this manner of doing. You can find some tips about this by searching on Google. (But perhaps I could write a post about it if someone need it.)
If we created a method for a field we need to do the same thing for each field on which we need to apply the change. So let's see another issue.

L'idée serait de renseigner dans notre champ l'opérateur voulu suivi de sa valeur, avec la possibilité d'utiliser les opérateurs suivant: "<", ">", "<=", ">=" et dans le cas où l'on ne saisie pas d'opérateur on utilise "=". On pourrai donc par exemple saisir: >200.

The idea would be to create something to allow us to write in the field the operator with the value. We could use the following operators: "<", ">", "<=", ">=" , and in the case of no operator we will use "=". So for exemple we could fill the field value with: >200.

Donc en fouillant d'avantage on remarque que les champs sont "typés" (voir BaseXXXFormFilter::getFields()) par exemple le champ prix est typé "Number" et que pour filtrer ce champ on fait appel à la fonction addNumberQuery dans sfFormFilterDoctrine.
Donc l'idée est de créer alors un nouveau type: "NumberOperator", de créer la fonction addNumberOperatorQuery qui sera appelé par Symfony lors du filtrage.

''So if we look at BaseXXXFormFilter we can see a getFields() method. This method describe the type for each field of the filter class. For exemple my price field has a "Number" type and so to filter this field symfony will automaticly call the addNumberQuery() method from the sfFormFilterDoctrine class.
So here the idea is to create a new type "NumberOperator" with an addNumberOperatorQuery() mehod and use this to filter the price field.''

Pour ceci on écrit notre fonction dans la classe BaseFormFilterDoctrine et on remercie Doctrine d'avoir pensé à cette classe ;)

To do this we add addNumberOperatorQuery() in BaseFormFilterDoctrine and we say thanks to Doctrine to generate this class ;)

/**
 * Project filter form base class.
 */
abstract class BaseFormFilterDoctrine extends sfFormFilterDoctrine
{
  const TYPE_NUMBER_OPERATOR = 'NumberOperator';

  public function setup()
  {
  }

  public function addNumberOperatorQuery(Doctrine_Query $query, $field, $values)
  {
    $fieldName = $this->getFieldName($field);
    $fields = $this->getFields();
    $type = $fields[$field];

    if (is_array($values) && isset($values['is_empty']) && $values['is_empty'])
    {
      $query->addWhere('r.' . $fieldName . ' IS NULL');
    }
    else if (is_array($values) && isset($values['text']) && '' != $values['text'])
    {
      if(preg_match('/^(=|<=|>=|<|>)(.+)/', trim($values["text"]), $matches))
      {
        $query->addWhere('r.' . $fieldName . ' '.$matches[1].' ?', trim($matches[2]));
      }
      else
      {
        // Call the default function
        if(!method_exists($this, $method = sprintf('add%sQuery', $type)))
        {
          throw new LogicException(sprintf('Unable to filter for the "%s" type.', $type));
        }
        $query = $this->$method($query, $field, $values);
      }
    }
    return $query;
  }
}

Ensuite dans notre classe de filtre il faut modifier le type de notre champ et changer le validateur, un nouveau le cas échéant pour pouvoir aller avec notre nouvelle fonction crée auparavant.

Then in our filter class we need to change the field's type and also change the validator, a new one in this case just to check that the field value is something like operator+value.

/**
 * Product filter form.
 */
class ProductFormFilter extends BaseContactFormFilter
{
  public function configure()
  {
    //...
    // we use the new validator
    $this->validatorSchema['price'] = new sfValidatorSchemaFilter('text', new myValidatorNumberOperator(array('required' => false)));
    //...
  }

  public function getFields()
  {
    $fields = parent::getFields();

    $fields['price'] = BaseFormFilterDoctrine::TYPE_NUMBER_OPERATOR; // change the field type
    return $fields;
  }
}

Et notre nouveau validateur:
And so the new validator:

class myValidatorNumberOperator extends sfValidatorNumber
{
  protected function configure($options = array(), $messages = array())
  {
    $this->setMessage('invalid', '"%value%" is not a number "operator" (accepted symbols: "", "=", "<=", ">=", "<", ">").');
  }

  protected function doClean($value)
  {
    $compareSymbol = '';
    if(preg_match('/^(=|<=|>=|<|>)(.+)/', trim($value), $matches))
    {
      $compareSymbol = $matches[1];
      $numberValue   = $matches[2];
    }
    else
    {
      $numberValue = $value;
    }

    try {
      $cleanNumber = parent::doClean($numberValue);
    }
    catch (sfValidatorError $e) {
      throw new sfValidatorError($this, 'invalid', array('value' => $value));
    }

    return $compareSymbol.$cleanNumber;
  }
}

Ensuite pour pouvoir filtrer un prix il suffit de renseigner dans notre filtre pour un prix supérieur ou égal à 200 par exemple : ">=200".

Now to filter the price filed you can use values such as: ">=200".

Et en faisant cet article j'ai eu une autre idée faire un filtre qui filtrerai également une valeur suivant deux critères, explications rechercher par exemple un prix supérieur à 100 et inférieur à 300 : "100<x<300" à vos claviers ;)

Traduced by eNk`

Add new tasks in your Symfony project

eNk` — Fri, 16 Oct 2009 11:10:00 +0200

So for my very first post in english I will talk about how to add a new task in symfony. Task are very useful to handle a lot of data and can be launched manually or placed in a cron job.

I started to create task on a new project, in the past I used to create a batch folder in my symfony project. In this folder I created a symfony.inc.php to load symfony and others php files which use the symfony.inc.php to handle data. So this way of creating task work, but symfony provide the sfBaseTask class so why don't use it ? This class allow you to add task to your symfony project in addition to those provided by the framework.

Let's see how does it work through a little exemple. The follwing exemple is quite stupid, but it's just to show the way you can create a task. So the aim of this task is to display a sentence given as an arguments for each user from your data base.
Basically you will have to create a class which extend from sfBaseTask and use the configure() method to set the name, the name space, the options and the arguments of your task. Then you will have to implement an execute() function to handle your data.

// myProject/lib/task/SayHelloTask.class.php

class SayHelloTask extends sfBaseTask
{
    const ALL_USERS = -1;

    public function configure()
    {
        // task's name, description and aliases
        $this->name = "say-hello";
        $this->namespace = "mytasks";
        $this->briefDescription = "A little description of this task.";
        $this->detailedDescription = "Detailed description, blablablabla blabla blabla bla.";
        $this->aliases = array('mytasks-say-hello', 'sh');

        // options
        $this->addOptions(array(new sfCommandOption('env', null, sfCommandOption::PARAMETER_REQUIRED, 'The environement', 'prod')));

        // arguments
        $this->addArguments(array(new sfCommandArgument('message', sfCommandArgument::OPTIONAL, 'your message', 'Hello %s :)'),
                                  new sfCommandArgument('number', sfCommandArgument::OPTIONAL, 'how many users ?', self::ALL_USERS)));
    }

    public function execute($arguments = array(), $options = array())
    {
        // data base manager to open a connection
        $sfDatabaseManager = new sfDatabaseManager($this->configuration);

        if(substr_count($arguments['message'], '%s') === 1)
        {
            // get users from data base
            $users = UserTable::getAll();

            $end = 0;
			$nbUsers = count($users);
			if($arguments['number'] === self::ALL_USERS)
			{
				$end = $nbUsers;
			}
			else
			{
                $nb = (int) $arguments['number'];
                $end = ($nb <= $nbUsers) ? $nb : $nbUsers;
			}

			$i = 0;
			while($i<$end)
			{
                $this->log(sprintf($arguments['message'], $users[$i]->getFullName()));
                $i++;
		    }
		}
		else
		{
			$this->logBlock("Only one '%s' in the message.", 'ERROR');
		}
    }
}

To run this task you just have to execute this command line :

$ php symfony mytasks:say-hello

OR

$ php symfony mytasks:say-hello "Hi %s :p"

OR

$ php symfony sh "Hi %s :p"

Clear Cache

eNk` — Mon, 03 Aug 2009 16:42:00 +0200

Bon il fallait bien le faire, donc le voici. Le mini billet sur notre commande préférée LE "symfony cc".
cache:clear de son nom complet et "cc" pour les intimes et gros flemmard que nous sommes =]. Qui a déjà écris "cache:clear" en entier ? Dénoncez vos collègues, et pour la peine ils devront payer une tournée au prochain sfPot.

Donc évidement cette commande sert à vider le cache d'un projet Symfony et offre la possibilité de vider la totalité ou juste une partie du cache.
Options de la commande cache:clear :

--app: précise le nom de l'application pour laquelle le cache doit être vidé.
--type: type du cache à vider, possibilités : template, config, i18n, routing.
--env: précise l'environnement pour lequel le cache doit être vidé.

Exemple :

// Vide tout le cache
$ php symfony cache:clear

// Vide le cache HTML de l'application frontend.
$ php symfony cache:clear --app=frontend --type=template

// Vide le cache de configuration de l'application frontend pour l'environnement prod.
$ php symfony cache:clear --app=frontend --type=config --env=prod

Bon cc !

Les Criteria c'est trop nul :p

eNk` — Thu, 09 Jul 2009 13:35:00 +0200

Derrière ce titre un peu "trollesque" se cache en fait un petit billet dans lequel nous allons voir comment faire des requêtes avec Propel 1.3 en utilisant directement PDO, donc sans passer par la case Criteria/Criterion, et hydrater les objets correspondant.

Prenons un exemple avec le schéma suivant, dans lequel nous avons des utilisateurs pouvant écrire des posts et faire parti de groupes.

propel:
  user:
    _attributes: { phpName: User }
    id:          ~
    login:       { type: varchar, size: 255, required: true, index: unique }
    email:       { type: varchar, size: 255 }
    created_at:  ~
    updated_at:  ~

  post:
    _attributes: { phpName: Post }
    id:          ~
    content:     { type: longvarchar }
    user_id:     { type: integer, foreignTable: user, foreignReference: id, onDelete: cascade }
    created_at:  ~
    updated_at:  ~

  group:
    _attributes: { phpName: Group }
    id:          ~
    name:        { type: varchar, size: 255 }
    created_at:  ~
    updated_at:  ~

  user_group:
    _attributes: { phpName: UserGroup }
    group_id:    { type: integer, required: true, primaryKey: true, foreignTable: group, foreignReference: id, onDelete: cascade }
    user_id:     { type: integer, required: true, primaryKey: true, foreignTable: user, foreignReference: id, onDelete: cascade }
    created_at:  ~
    updated_at:  ~

Commençons par voir un exemple très simple avec une requête sur une seule table. Nous allons donc créer une méthode getAll() dans UserPeer pour récupérer tous les utilisateurs. Pour réaliser cela c'est très simple il suffit de récupérer la connexion, préparer un statment avec notre requête SQL, l'exécuter et hydrater les objets à l'aide de le méthode populateObjects() de la classe BaseUserPeer. Au passage toutes les classes BaseXXXPeer générées par Propel possèdent une méthode populateObjects(PDOStament $stmt) permettant d'hydrater des objets de la classe XXX.

/**
 * Get all users.
 *
 * @return array - An array of User objects
 */
public static function getAll()
{
    $result = null;
    
	// query
    $sql = "SELECT * FROM user ORDER BY user.CREATED_AT DESC";
    
	// get the connexion
    $con = Propel::getConnection();
	
	// prepare a statment and execute the query
    $pdoStmt = $con->prepare($sql);
    $pdoStmt->execute();
	
	// hydrate objects from the resultset
    $result = UserPeer::populateObjects($pdoStmt);
    
    return $result;
}

Voyons maintenant un exemple de requête avec une jointure entre les tables user et post afin de sélectionner un utilisateur avec tous ses posts. Nous allons donc créer une méthode getUserByIdWithPost() dans laquelle, comme pour getAll(), nous allons créer un statment, l'exécuter puis hydrater le résultat. Cependant il serait pratique d'hydrater les objets User et Post en même temps et de les lier. Donc au lieu d'utiliser la méthode populateObjects() nous allons créer une méthode populateObjectsWithPost(). Cette méthode va évidement faire le même traitement que populateObjects() et va en plus hydrater les objets Post puis les relier à l'objet User.
Pour hydrater un objet avec Propel il suffit d'utiliser les méthodes suivantes des objets BaseXXXPeer:

getPrimaryKeyHashFromRow(): donne la clé primaire d'un objet sous forme d'une chaine de caractères unique.
getInstanceFromPool(): retourne un objet (ou null) présent dans le pool d'instance en fonction de sa clé (généré par getPrimaryKeyHashFromRow() ).
addInstanceToPool(): ajoute un objet au pool d'instance.

ainsi que la méthode hydrate() des objets BaseXXX qui permet d'hydrater un objet.

/**
 * Get a user with all post.
 * 
 * @param int $userId - The user id.
 * @return User
 */
public static function getUserByIdWithPost($userId)
{
    $user = null;
    
	// query
    $sql = "SELECT * FROM user LEFT JOIN post ON user.ID = post.USER_ID WHERE user.ID = :user_id";
    
	// get the connexion
    $con = Propel::getConnection();
	
	// prepare a statment and execute the query
    $pdoStmt = $con->prepare($sql);
	$pdoStmt->bindValue('user_id', $userId, PDO::PARAM_INT);
    $pdoStmt->execute();
	
	// hydrate objects from the resultset
    $result = UserPeer::populateObjectsWithPost($pdoStmt);
    
	if(isset($result[0])) { $user = $result[0]; }
	
    return $user;
}

/**
 * Hydrate some User objects with their related Post.
 * 
 * @param PDOStatement $pdoStmt - A statment PDO.
 * @return array
 */
public static function populateObjectsWithPost(PDOStatement $pdoStmt)
{
    $results = array();
    
    // set the class once to avoid overhead in the loop
    $cls = UserPeer::getOMClass();
    $cls = substr('.'.$cls, strrpos('.'.$cls, '.') + 1);
    // populate the object(s)
    while ($row = $pdoStmt->fetch(PDO::FETCH_NUM))
    {
        $key = UserPeer::getPrimaryKeyHashFromRow($row, 0);
        if (null !== ($obj = UserPeer::getInstanceFromPool($key)))
        {
            $nextColToStart = UserPeer::NUM_COLUMNS - UserPeer::NUM_LAZY_LOAD_COLUMNS;
        }
        else
        {
            $obj = new $cls();
            $nextColToStart = $obj->hydrate($row);
            UserPeer::addInstanceToPool($obj, $key);
        } // if key exists

        // hydrate a post object and associate it to the user
        if(isset($row[$nextColToStart]))
        {
            $postKey = PostPeer::getPrimaryKeyHashFromRow($row, $nextColToStart);
            if(null === ($post = PostPeer::getInstanceFromPool($postKey)))
            {
                $post = new Post();
                $post->hydrate($row, $nextColToStart);
                PostPeer::addInstanceToPool($post, $postKey);
            }
            $obj->addPost($post);
        }

        // add the user only if not already added.
        if(in_array($obj, $results) === false) { $results[] = $obj; }
    }
		
    $pdoStmt->closeCursor();

    return $results;
}

Voici maintenant un exemple avec une requête pour récupérer un utilisateur avec tous ses groupes, donc avec une relation n:m entre user et group. Rien de nouveau au niveau de la préparation et exécution du statment. Et au niveau de l'hydratation des objets il faut relier les objets Group à l'objet UserGroup correspondant qui va lui même être rattaché à un objet User.

/**
 * Get a user with all related groups
 * 
 * @param int $userId - The user id.
 * @return User
 */
public static function getUserByIdWithGroups($userId)
{
    $user = null;
    
	// query
    $sql = "SELECT user.*, group.*, user_group.*";
	$sql .= " FROM user LEFT JOIN user_group ON user.ID = user_group.USER_ID";
	$sql .= " LEFT JOIN group ON user_group.GROUP_ID = group.ID";
    $sql .= " WHERE user.ID = :user_id";
    
	// get the connexion
    $con = Propel::getConnection();
	
	// prepare a statment and execute the query
    $pdoStmt = $con->prepare($sql);
	$pdoStmt->bindValue('user_id', $userId, PDO::PARAM_INT);
    $pdoStmt->execute();
	
	// hydrate objects from the resultset
    $result = UserPeer::populateObjectsWithGroups($pdoStmt);
    
	if(isset($result[0])) { $user = $result[0]; }
	
    return $user;
}


/**
 * Hydrate some User objects with their related Group.
 * 
 * @param PDOStatement $pdoStmt - A statment PDO.
 * @return array
 */
public static function populateObjectsWithUserGroups(PDOStatement $pdoStmt)
{
    $results = array();
    
    // set the class once to avoid overhead in the loop
    $cls = UserPeer::getOMClass();
    $cls = substr('.'.$cls, strrpos('.'.$cls, '.') + 1);
    // populate the object(s)
    while ($row = $pdoStmt->fetch(PDO::FETCH_NUM))
    {
        $key = UserPeer::getPrimaryKeyHashFromRow($row, 0);
        if (null !== ($obj = UserPeer::getInstanceFromPool($key)))
        {
            $nextColToStart = UserPeer::NUM_COLUMNS - UserPeer::NUM_LAZY_LOAD_COLUMNS;
        }
        else
        {
            $obj = new $cls();
            $nextColToStart = $obj->hydrate($row);
            UserPeer::addInstanceToPool($obj, $key);
        } // if key exists

		// hydrate a group object
        if(isset($row[$nextColToStart]))
        {
            $groupKey = GroupPeer::getPrimaryKeyHashFromRow($row, $nextColToStart);
            if(null === ($group = GroupPeer::getInstanceFromPool($groupKey)))
            {
                $group = new Group();
                $group->hydrate($row, $nextColToStart);
                GroupPeer::addInstanceToPool($group, $groupKey);
            }
        }

        $nextColToStart += GroupPeer::NUM_COLUMNS - GroupPeer::NUM_LAZY_LOAD_COLUMNS;
		
        // hydrate a userGroup object
        if(isset($row[$nextColToStart]))
        {
            $userGroupKey = UserGroupPeer::getPrimaryKeyHashFromRow($row, $nextColToStart);
            if(null === ($userGroup = UserGroupPeer::getInstanceFromPool($userGroupKey)))
            {
                $userGroup = new UserGroup();
                $userGroup->hydrate($row, $nextColToStart);
                UserGroupPeer::addInstanceToPool($userGroup, $userGroupKey);
            }
        }

        if(isset($userGroup, $group))
        {
            $userGroup->setGroup($group);
            $obj->addUserGroup($userGroup);
        }
       
        // add the user only if not already added.
        if(in_array($obj, $results) === false) { $results[] = $obj; }
    }
		
    $pdoStmt->closeCursor();

    return $results;
}

Nous avons créé dans cette exemple les méthodes populateObjectsWithUserGroups() et populateObjectsWithPost() pour hydrater le résultat des requêtes. On remarque que le mécanisme d'hydratation des objets est le même pour toutes les classes générées par Propel, on peut donc factoriser du code afin de ne pas écrire des méthodes populateObjectsXXXXX() à ralonge.
Note: dans la méthode hydrateObject() qui va permettre d'hydrater des objets Propel, j'appelle une méthode getPeerClass() sur la classe $class (dans notre exemple la variable $class peut être égale à User, Post, Group ou encore UserGroup). getPeerClass() est une méthode public static qui retourne le nom de la classe peer associée (par défaut on va retourner la constante PEER des classes BaseXXX).

// getPeerClass method exemple
public static function getPeerClass()
{
    return parent::PEER;
}

// class with useful methods.
class PropelTools
{
    /**
     * Hydrate a $class object from a result row of a result set and link this objet to his parent.
     * 
     * @param array $row
     * @param int $startCol
     * @param string $class
     * @param BaseObject $parentObject [optionnal]
     * @param string $addMethod [optionnal]
     * @return Object
     */
    public static function hydrateObject($row, $startCol, $class, $parentObject = null, $addMethod = null)
    {
        $myObject = null;

        // get peer class name
        $peerClass = call_user_func(array($class, 'getPeerClass'));
    
	if(isset($row[$startCol]) && $peerClass !== false)
        {
            $myObjectKey = call_user_func(array($peerClass, 'getPrimaryKeyHashFromRow'), $row, $startCol);
            if( null === ($myObject = call_user_func(array($peerClass, 'getInstanceFromPool'), $myObjectKey)) )
            {
                $myObject = new $class();
                $myObject->hydrate($row, $startCol);
                call_user_func(array($classPeer, 'addInstanceToPool'), $myObject, $myObjectKey);
            }
		
            if(isset($parentObject, $addMethod)) 
            {
                if(is_callable(array($parentObject, $addMethod), true)) { $parentObject->$addMethod($myObject);  }
                else { throw new sfException(sprintf("Can't call method %s() on parent object.", $addMethod)); }
            }
        }

        return $myObject;
    }
}

Et voici ce que donnerai la méthode populateObjectsWithUserGroups() en utilisant la méthode hydrateObject().

public static function populateObjectsWithUserGroups(PDOStatement $pdoStmt)
{
    $results = array();
    
    // set the class once to avoid overhead in the loop
    $cls = UserPeer::getOMClass();
    $cls = substr('.'.$cls, strrpos('.'.$cls, '.') + 1);
    // populate the object(s)
    while ($row = $pdoStmt->fetch(PDO::FETCH_NUM))
    {
        $key = UserPeer::getPrimaryKeyHashFromRow($row, 0);
        if (null !== ($obj = UserPeer::getInstanceFromPool($key)))
        {
            $nextColToStart = UserPeer::NUM_COLUMNS - UserPeer::NUM_LAZY_LOAD_COLUMNS;
        }
        else
        {
            $obj = new $cls();
            $nextColToStart = $obj->hydrate($row);
            UserPeer::addInstanceToPool($obj, $key);
        } // if key exists
        
        // hydrate a userGroup and group object
        $group = PropelTools::hydrateObject($row, $nextColToStart, 'Group', $userGroup, 'setGroup');
        $nextColToStart += GroupPeer::NUM_COLUMNS - GroupPeer::NUM_LAZY_LOAD_COLUMNS;
        $userGroup = PropelTools::hydrateObject($row, $startCol, 'UserGroup', $obj, 'addUserGroup');
				
        // add the user only if not already added.
        if(in_array($obj, $results) === false) { $results[] = $obj; }
    }
		
    $pdoStmt->closeCursor();

    return $results;
}

Liens utiles:

La doc de PDO ici
La doc de Propel 1.3 ici

Extension du Doctrine Routing Object

Mathieu — Mon, 18 May 2009 10:12:00 +0200

Pour mon premier billet je vais vous parler du routing de symfony, pour être plus précis du routing des objets doctrine.

Le problème auquel je me suis confronté était le suivant : La classe sfDoctrineRoute recherche à chaque fois, s'il existe une méthode pour récupérer le paramètre de l'objet demandé dans la règle de routage, même si le paramètre est renseigné manuellement.

Exemple du problème :
Nous avons des articles composés de plusieurs pages.
On a auparavant créé une méthode getRank(), qui retourne la première page de l'article, celle-ci est dédiée pour le routing

Le fichier de routing

article_show:
  url:     /article/:id/page/:rank.html
  class:   sfDoctrineRoute
  options: { model: Article, type: object }
  param:   { module: article, action: show }
  requirements:
    id:      \d+
    rank:    \d+
    sf_method: [get]

Lien généré ($article est une instance de Article) :

url_for('article_show', $article)
Résultat attendu : /article/1/page/1.html
Résultat obtenu  : /article/1/page/1.html

url_for('article_show', array('sf_subject' => $article, 'rank' => 2))
Résultat attendu : /article/1/page/2.html
Résultat obtenu  : /article/1/page/1.html

On remarque donc que la règle de routing n'a que faire de notre paramètre rank, il sera toujours alimenté par la méthode getRank() de l'objet Article.

Pour réglé ce problème auquel je n'ai pas trouvé de solution sur la Mailing List, j'ai donc décidé d'étendre la classe sfDoctrineRoute, pour que lorsque l'on fourni un paramètre manuellement celui-ci ne soit pas écrasé, par celui récupéré par la méthode de l'objet.

/**
 * myDoctrineRoute
 */
class myDoctrineRoute extends sfDoctrineRoute
{
  protected function convertObjectToArray($object)
  {
    if (is_array($object))
    {
      if (!isset($object['sf_subject']))
      {
        return $object;
      }

      $parameters = $object;
      $object = $parameters['sf_subject'];
      unset($parameters['sf_subject']);
    }
    else
    {
      $parameters = array();
    }

    if(isset($this->options['erase']) && $this->options['erase'] === false)
    {
      $response = array_merge($parameters, $this->doConvertObjectToArray($object));
    }
    else
    {
      // We check the parameters value and unset them if they are null
      // We define an array of null values and we check if exist one to do the foreach, to unset the null values
      $nullValues = array(null, 'null');
      $findNull   = true;
      $iFindNull  = 0;
      while($iFindNull < count($nullValues) && $findNull === false)
      {
        $findNull = in_array($nullValues[$iFindNull], $parameters);
        $iFindNull++;
      }

      if($findNull)
      {
        foreach($parameters as $parameterKey => $parameterValue)
        {
          if(in_array($parameterValue, $nullValues))
          {
            unset($parameters[$parameterKey]);
          }
        }
      }
      $response = array_merge($this->myDoConvertObjectToArray($object, $parameters), $parameters);
    }

    return $response;
  }

  protected function myDoConvertObjectToArray($object, $defaultParameters = array())
  {
    if (isset($this->options['convert']) || method_exists($object, 'toParams'))
    {
      return parent::doConvertObjectToArray($object);
    }

    $className = $this->options['model'];

    $parameters = array();

    foreach ($this->getRealVariables() as $variable)
    {
      if(!in_array($variable, array_keys($defaultParameters)))
      {
        try {
          $parameters[$variable] = $object->$variable;
        } catch (Exception $e) {
          try {
            $method = 'get'.sfInflector::camelize($variable);
            $parameters[$variable] = $object->$method;
          } catch (Exception $e) {}
        }
      }
    }
    return $parameters;
  }
}

Après cela il faut donc changé notre de règle de routing, avec en bonus un paramètre pour définir le comportement de votre règle, si celle-ci doit écrasé les paramètres renseignés manuellement ou non, à l'aide de l'option erase qui par défaut est à true:

article_show:
  url:     /article/:id/page/:rank.html
  class:   myDoctrineRoute
  options: { model: Story, type: object, erase: true }
  param:   { module: story, action: index }
  requirements:
    id:      \d+
    rank:    \d+
    sf_method: [get]

N'hésitez pas maintenant à me faire part de vos impressions, car je pense qu'il existe déjà une solution et j'ai d'ailleurs trouvé cela étrange de ne pas la trouver.

SQLSTATE[HY000]: General error: 1005

Stéphane.p — Fri, 15 May 2009 10:50:00 +0200

SQLSTATE[HY000]: General error: 1005 Can't create table './ma_table/#sql-6d79_2523.frm' (errno: 150). Failing Query: ALTER TABLE table2 ADD FOREIGN KEY (table1) 
REFERENCES table1(id) ON DELETE SET NULL

Voilà une erreur qui m'est apparue plusieurs fois, assez embêtante lorsqu'on ne connait pas la solution.

Il s'agit bien d'une erreur MYSQL et pour la résoudre nous devrons donc passer par le/les schema.yml.
Exemple:

config/
doctrine/
schema.yml

Table1:
  columns:
    name:    { type: string(255), notblank: true }

Table2:
  columns:
    table_one_id: { type: integer(11) }
  relations:
    Table1: { local: table_one_id, foreign: id, onDelete: SET NULL }

Dans ce cas nous aurons l'erreur précédemment citée. La syntaxe est correcte, donc le problème ne devrait pas être.
Cependant, table_one_id étant un integer(11), et table1.id (généré automatiquement) étant un bigint(20), c'est ceci qui provoque cette erreur mysql.

Pour ma part, tous les integer étant des foreigns sont renseignés comme ceci:

table_one_id: { type: integer }

Vous aurez ce genre de problème lorsque vous téléchargerez des plugins symfony, je l'ai eu il me semble sur 'swDoctrineAssetsLibraryPlugin'.

Custom validator sous symfony 1.2

eNk` — Thu, 07 May 2009 09:25:00 +0200

Dans ce billet nous allons voir comment créer un sfValidator custom utilisable avec le framework de formulaire.

Dans cet exemple nous allons créer un validateur permettant de vérifier si un pseudo est déjà existant dans la base de données. Ce validateur pourra par exemple être utilisé sur un formulaire d'inscription afin de forcer les utilisateurs à choisir un pseudo qui n'existe pas encore.

Commençons par créer une classe PseudoValidator qui hérite de sfValidatorBase, dans laquelle nous allons redéfinir les méthodes configure() et doClean(). La méthode configure() va permettre de définir les options et les messages de notre validateur. La méthode doClean() va quand à elle être utilisée pour valider la valeur du champ.Vous pouvez par exemple créer cette classe dans le répertoire _my_project_/lib/validator.

class PseudoValidator extends sfValidatorBase
{
    public function configure($options = array(), $messages = array()) 
    {
        // @todo ajout d'options et de messages
    }

    public function doClean($value)
    {
        // @todo validation de la valeur du champs $value
    }
}

Ajoutons maintenant le code nécessaire dans nos deux méthodes afin de valider le champ et de définir le message qui sera affiché en cas d'échec de la validation.
Dans un premier temps nous allons définir un message "invalid" dans la méthode configure(). Ensuite dans la méthode doClean() nous allons utiliser une méthode permettant de vérifier si le pseudo existe ou non en base. Dans le cas où le pseudo existe, la valeur du champ n'est donc pas valide, et nous allons lancer une exception de type sfValidatorError avec le message "invalid". Si le pseudo n'existe pas en base il n'y a rien de spécial faire, la méthode doClean() retourne la valeur.

class PseudoValidator extends sfValidatorBase
{
    public function configure($options = array(), $messages = array()) 
    {
        $this->setMessage('invalid', 'Le pseudo "%pseudo%" est déjà utilisé.');
    }

    public function doClean($value)
    {
        // Dans une classe de votre modèle, créez une méthode permettant de savoir si le pseudo $value existe en base.
        // Pour l'exemple je suppose que checkPseudo() retourne un booléen.
        $exist = YourClass::checkPseudo($value);

        if($exist) 
        {
            throw new sfValidatorError($this, 'invalid', array('pseudo' => $value));
        }
        
        return $value;
    }
}

Pour aller un peu plus loin dans l'exemple nous allons ajouter deux options à notre validateur, "trim" et "min_length", cette dernière sera une option obligatoire.

class PseudoValidator extends sfValidatorBase
{
    public function configure($options = array(), $messages = array()) 
    {
    	$this->addOption('trim');
    	$this->addRequiredOption('min_length');
    	
    	$this->addMessage('min_length_msg', 'Au moins %min% caractères.'); // message par défaut
        $this->setMessage('invalid', 'Le pseudo "%pseudo%" est déjà utilisé.');
    }

    public function doClean($value)
    {
    	if($this->hasOption('trim') && $this->getOption('trim'))
    	{
    		$value = trim($value);
    	}
    	
    	if($this->hasOption('min_length') && $this->getOption('min_length') > strlen($value))
        {
            throw new sfValidatorError($this, 'min_length_msg', array('min' => $this->getOption('min_length')));	
        }
    	
        $exist = YourClass::checkPseudo($value);

        if($exist) 
        {
            throw new sfValidatorError($this, 'invalid', array('pseudo' => $value));
        }
        
        return $value;
    }
}

Pour utiliser notre validateur, rien de plus simple, un petit symfony cc pour réinitialiser l'autoloading et il suffit d'associer le validateur au champ.

$myFormObject->setValidator('my_field', new PseudoValidator(array('min_length' => 4, 'trim' => true), array('min_length_msg' => "Le pseudo doit contenir au moins %min% caractères.")));

Formulaires symfony: Traitement sur la valeur d'un champ à la sauvegarde

eNk` — Tue, 28 Apr 2009 21:43:00 +0200

Voici une petite astuce permettant d'effectuer un traitement sur la valeur d'un champ lors de la sauvegarde d'un formulaire Doctrine ou Propel.

Imaginons par exemple une classe User avec deux attributs login et password de type string, password que nous allons sauvegarder en MD5 dans notre table user.

Pour enregistrer un utilisateur en base nous allons évidemment utiliser la classe de formulaire correspondant à notre classe User. Il serait donc pratique que lorsque l'on appelle la méthode save() de notre objet UserForm le mot de passe saisi par l'utilisateur dans le champ password soit automatiquement converti en MD5.

Pour commencer regardons la hiérarchie de classe de formulaires générée par symfony:
Propel: UserForm < BaseUserForm < BaseFormPropel < sfFormPropel
Doctrine: UserForm < BaseUserForm < BaseFormDoctrine < sfFormDoctrine

Ce sont les classes sfFormDoctrine et sfFormPropel qui vont nous intéresser car elles possèdent une méthode processValues() qui est appelée au moment de la mise à jour de l'objet User correspondant au formulaire. Elle a pour but de nettoyer les valeurs avant la mise à jour de l'objet. C'est donc grâce à cette méthode que nous allons pouvoir faire un traitement sur les valeurs saisis des champs et dans notre cas mettre le password en MD5. En effet pour chacun des champs du formulaire processValues() va appeler, si elle existe, une méthode updateXXXColumn() où XXX est le nom PHP d'un champ du formulaire, afin d'effectuer un traitement particulier sur la valeur de ce champ.

Donc pour convertir le texte saisi dans le champ password en MD5 au moment de la sauvegarde du formulaire, il suffit de définir une méthode updatePasswordColumn() dans la classe UserForm.

public function updatePasswordColumn($value)
{
	if(!empty($value)) { $value = md5($value); }

	return $value;
}

NOTE: la méthode processValues() retourne un tableau contenant les valeurs nettoyées pour chaque champ, si une méthode updateXXXColumn() retourne false alors processValues() va supprimer le champ XXX du tableau qu'elle retourne.