Behaviors (Comportements)¶

Utiliser les Behaviors¶

Les Behaviors sont attachés aux models grâce à la variable $actsAs des classes model:

class Category extends AppModel {
    public $actsAs = array('Tree');
}

Cette exemple montre comme un model Category pourrait être gérer dans une structure en arbre en utilisant le behavior Tree. Une fois qu’un behavior a été spécifié, utilisez les méthodes qu’il ajoute comme si elles avaient toujours existé et fait partie du model original:

// Définir ID
$this->Category->id = 42;

// Utiliser la méthode children() du behavior:
$kids = $this->Category->children();

Quelques behaviors peuvent nécessiter ou permettre des réglages quand ils sont attachés au model. Ici, nous indiquons à notre behavior Tree les noms des champs « left » et « right » de la table sous-jacente:

class Category extends AppModel {
    public $actsAs = array('Tree' => array(
        'left'  => 'left_node',
        'right' => 'right_node'
    ));
}

Nous pouvons aussi attacher plusieurs behaviors à un model. Il n’y aucune raison pour que, par exemple, notre model Category se comporte seulement comme un arbre, il pourrait aussi supporter l’internationalisation:

class Category extends AppModel {
    public $actsAs = array(
        'Tree' => array(
          'left'  => 'left_node',
          'right' => 'right_node'
        ),
        'Translate'
    );
}

Jusqu’à présent, nous avons ajouter les behaviors aux models en utilisant une variable de classe. Cela signifie que nos behaviors seront attachés à nos models tout au long de leur durée vie. Pourtant, nous pourrions avoir besoin de « détacher » les behaviors des models à l’exécution. Considérons que dans notre précédent model Category, lequel agit comme un model Tree et Translate, nous ayons besoin pour quelque raison de le forcer à ne plus agir comme un model Translate:

// Détache un behavior de notre model :
$this->Category->Behaviors->unload('Translate');

Cela fera que notre model Category arrêtera dorénavant de se comporter comme un model Translate. Nous pourrions avoir besoin, sinon, de désactiver simplement le behavior Translate pour qu’il n’agisse pas sur les opérations normales de notre model : nos finds, nos saves, etc. En fait, nous cherchons à désactiver le behavior qui agit sur nos callbacks de model CakePHP. Au lieu de détacher le behavior, nous allons dire à notre model d’arrêter d’informer ses callbacks du behavior Translate:

// Empêcher le behavior de manipuler nos callbacks de model
$this->Category->Behaviors->disable('Translate');

Nous pourrions également avoir besoin de chercher si notre behavior manipule ces callbacks de model et si ce n’est pas le cas, alors de restaurer sa capacité à réagir avec eux:

// Si notre behavior ne manipule pas nos callbacks de model
if (!$this->Category->Behaviors->enabled('Translate')) {
    // Disons lui de le faire maintenant !
    $this->Category->Behaviors->enable('Translate');
}

De la même manière que nous pouvons détacher complètement un behavior d’un model à l’exécution, nous pouvons aussi attacher de nouveaux behaviors. Disons que notre model familier Category nécessite de se comporter comme un model Christmas, mais seulement le jour de Noël:

// Si nous sommes le 25 déc
if (date('m/d') === '12/25') {
    // Notre model nécessite de se comporter comme un model Christmas
    $this->Category->Behaviors->load('Christmas');
}

Nous pouvons aussi utiliser la méthode attach pour surcharger les réglages du behavior:

// Nous changerons un réglage de notre behavior déjà attaché
$this->Category->Behaviors->load('Tree', array('left' => 'new_left_node'));

Et en utilisant des alias, nous pouvons personnaliser l’alias avec lequel il sera chargé, lui permettant aussi d’être chargé plusieurs fois avec différentes configurations:

// Le behavior sera disponible en tant que 'MyTree'
$this->Category->Behaviors->load('MyTree', array('className' => 'Tree'));

Il y a aussi une méthode pour obtenir la liste des behaviors qui sont attachés à un model. Si nous passons le nom d’un behavior à une méthode, elle nous dira si ce behavior est attaché au model, sinon elle nous donnera la liste des behaviors attachés:

// Si le behavior Translate n'est pas attaché
if (!$this->Category->Behaviors->attached('Translate')) {
    // Obtenir la liste de tous les behaviors qui sont attachés au model
    $behaviors = $this->Category->Behaviors->attached();
}

Créer des Behaviors¶

Les behaviors qui sont attachés aux Models voient leurs callbacks appelés automatiquement. Ces callbacks sont similaires à ceux qu’on trouve dans les Models : beforeFind, afterFind, beforeValidate, afterValidate, beforeSave, afterSave, beforeDelete, afterDelete et onError. Regardez Méthodes Callback.

Vos behaviors devront être placés dans app/Model/Behavior. Ils sont nommés en CamelCase et suffixés par Behavior, par ex. NomBehavior.php. Il est utile d’utiliser un behavior du coeur comme template quand on crée son propre behavior. Vous les trouverez dans lib/Cake/Model/Behavior/.

Chaque callback et behavior prend comme premier paramètre, une référence du model par lequel il est appelé.

En plus de l’implémentation des callbacks, vous pouvez ajouter des réglages par behavior et/ou par liaison d’un behavior au model. Des informations à propos des réglages spécifiques peuvent être trouvées dans les chapitres concernant les behaviors du cœur et leur configuration.

Voici un exemple rapide qui illustre comment les réglages peuvent êtres passés du model au behavior:

class Post extends AppModel {
    public $actsAs = array(
        'YourBehavior' => array(
            'option1_key' => 'option1_valeur'
        )
    );
}

Puisque les behaviors sont partagés à travers toutes les instances de model qui l’utilisent, une bonne pratique pour stocker les paramètres par nom d’alias/model qui utilise le behavior. La création des behaviors entraînera l’appel de leur méthode setup():

public function setup(Model $Model, $settings = array()) {
    if (!isset($this->settings[$Model->alias])) {
        $this->settings[$Model->alias] = array(
            'option1_key' => 'option1_default_value',
            'option2_key' => 'option2_default_value',
            'option3_key' => 'option3_default_value',
        );
    }
    $this->settings[$Model->alias] = array_merge(
        $this->settings[$Model->alias], (array)$settings);
}

Créer les méthodes du behavior¶

Les méthodes du Behavior sont automatiquement disponibles sur tout model qui “act as” le behavior. Par exemple si vous avez:

class Duck extends AppModel {
    public $actsAs = array('Flying');
}

Vous seriez capable d’appeler les méthodes de FlyingBehavior comme si elles étaient des méthodes du model Duck. Quand vous créez des méthodes d’un behavior, vous obtenez automatiquement une référence du model appelé en premier paramètre. Tous les autres paramètres fournis sont décalés d’une place vers la droite. Par exemple:

$this->Duck->fly('toronto', 'montreal');

Bien que cette méthode prenne deux paramètres, la méthode signature ressemblerait à cela:

public function fly(Model $Model, $from, $to) {
    // Faire quelque chose à la volée.
}

Gardez à l’esprit que les méthodes appelées dans un fashion $this->doIt() à partir de l’intérieur d’une méthode d’un behavior n’obtiendra pas le paramètre $model automatiquement annexé.

class MyBehavior extends ModelBehavior {
    public $mapMethods = array('/do(\w+)/' => 'doSomething');

    public function doSomething($model, $method, $arg1, $arg2) {
        debug(func_get_args());
        //faire quelque chose
    }
}

$model->doReleaseTheHounds('karl', 'lenny');

// sortira
'ReleaseTheHounds', 'karl', 'lenny'

Callbacks du Behavior¶

Les Behaviors d’un Model peuvent définir un nombre de callbacks qui sont déclenchés avant les callbacks du model du même nom. Les callbacks du Behavior vous permettent de capturer des évènements dans les models attachés et d’augmenter les paramètres ou de les accoler dans un behavior supplémentaire.

Tous les callbacks des behaviors sont lancés avant les callbacks du model:

• beforeFind

• afterFind

• beforeValidate

• afterValidate

• beforeSave

• afterSave

• beforeDelete

• afterDelete