Permalink
Browse files

translation in french of models files

  • Loading branch information...
1 parent 4335d69 commit b56868edc875b69daf8d6d1bf9b02588eae854e8 cake17 committed with markstory Aug 31, 2012
View
BIN en/_static/.DS_Store
Binary file not shown.
View
BIN en/tutorials-and-examples/.DS_Store
Binary file not shown.
View
364 fr/models/behaviors.rst
@@ -1,64 +1,69 @@
Behaviors
#########
-Model behaviors are a way to organize some of the functionality
-defined in CakePHP models. They allow us to separate and reuse logic that
-creates a type of behavior, and they do this without requiring inheritance. For
-example creating tree structures. By providing a simple yet powerful way to
-enhance models, behaviors allow us to attach functionality to models by defining
-a simple class variable. That's how behaviors allow models to get rid of all the
-extra weight that might not be part of the business contract they are modeling,
-or that is also needed in different models and can then be extrapolated.
-
-As an example, consider a model that gives us access to a database table which
-stores structural information about a tree. Removing, adding, and migrating
-nodes in the tree is not as simple as deleting, inserting, and editing rows in
-the table. Many records may need to be updated as things move around. Rather
-than creating those tree-manipulation methods on a per model basis (for every
-model that needs that functionality), we could simply tell our model to use the
-:php:class:`TreeBehavior`, or in more formal terms, we tell our model to behave
-as a Tree. This is known as attaching a behavior to a model. With just one line
-of code, our CakePHP model takes on a whole new set of methods that allow it to
-interact with the underlying structure.
-
-CakePHP already includes behaviors for tree structures, translated content,
-access control list interaction, not to mention the community-contributed
-behaviors already available in the CakePHP Bakery (`http://bakery.cakephp.org
-<http://bakery.cakephp.org>`_). In this section, we'll cover the basic usage
-pattern for adding behaviors to models, how to use CakePHP's built-in behaviors,
-and how to create our own.
-
-In essence, Behaviors are
-`Mixins <http://en.wikipedia.org/wiki/Mixin>`_ with callbacks.
-
-Using Behaviors
-===============
-
-Behaviors are attached to models through the ``$actsAs`` model class
-variable::
+Les comportements (behaviors) de Modèle sont une manière d'organiser certaines
+des fonctionnalités définies dans les modèles CakePHP. Ils nous permettent de
+séparer la logique qui ne doit pas être directement reliée à un modèle, mais
+qui nécessite d'être là. En offrant une simple, mais puissante, manière
+d'étendre les modèles, les comportements nous permettent d'attacher des
+fonctionnalités aux modèles en définissant une simple variable de classe.
+C'est comme çà que les comportements permettent de débarrasser les modèles de
+tout le "sur-poids" qui ne devrait pas faire partie du contrat métier qu'ils
+modèlent ou de ce qui est aussi nécessité par différents modèles et qui peut
+alors être extrapolé.
+
+Par exemple, considérez un modèle qui nous donne accès à une table qui stocke
+des informations sur la structure d'un arbre hiérarchique. Supprimer, ajouter
+ou déplacer les nœuds dans l'arbre n'est pas aussi simple que d'effacer,
+d'insérer ou d'éditer les lignes d'une table. De nombreux enregistrements
+peuvent nécessiter une mise à jour suite au déplacement des éléments. Plutôt
+que de créer ces méthodes de manipulation d'arbre une fois par modèle de base
+(pour chaque modèle nécessitant cette fonctionnalité), nous pourrions
+simplement dire à notre modèle d'utiliser le Comportement Tree (TreeBehavior)
+ou, en des termes plus formels, nous dirions à notre modèle de se comporter
+comme un Arbre. On appelle cela attacher un comportement à un modèle. Avec
+une seule ligne de code, notre modèle CakePHP disposera d'un nouvel ensemble
+complet de méthodes lui permettant d'interagir avec la structure sous-jacente.
+
+CakePHP contient déjà des comportements pour les structures en arbre, les
+contenus traduits, les interactions par liste de contrôle d'accès, sans
+oublier les comportements des contributeurs de la communauté déjà disponibles
+dans la Boulangerie (Bakery) CakePHP
+(`http://bakery.cakephp.org <http://bakery.cakephp.org>`_). Dans cette
+section nous couvrirons le schéma d'usage classique pour ajouter des
+comportements aux modèles, l'utilisation des comportements intégrés à
+CakePHP et la manière de créer nos propres comportements.
+
+Au final, les Behaviors sont
+`Mixins <http://en.wikipedia.org/wiki/Mixin>`_ avec les callbacks.
+
+Utiliser les Behaviors
+======================
+
+Les Behaviors sont attachés aux modèles grâce à la variable ``$actsAs``
+des classes modèle::
<?php
class Category extends AppModel {
public $name = 'Category';
public $actsAs = array('Tree');
}
-This example shows how a Category model could be managed in a tree
-structure using the TreeBehavior. Once a behavior has been
-specified, use the methods added by the behavior as if they always
-existed as part of the original model::
+Cette exemple montre comme un modèle Catégory pourrait être gérer dans
+une structure en arbre en utilisant le comportement Tree. Une fois
+qu'un comportement a été spécifié, utilisez les méthodes qu'il ajoute
+comme si elles avaient toujours existé et fait partie du modèle original::
<?php
- // Set ID
+ // Définir ID
$this->Category->id = 42;
- // Use behavior method, children():
+ // Utiliser la méthode children() du behavior:
$kids = $this->Category->children();
-Some behaviors may require or allow settings to be defined when the
-behavior is attached to the model. Here, we tell our TreeBehavior
-the names of the "left" and "right" fields in the underlying
-database table::
+Quelques behaviors peuvent nécessiter ou permettre des réglages quand
+ils sont attachés au modèle. Ici, nous indiquons à notre behavior
+Tree les noms des champs "left" et "right" de la table sous-jacente::
<?php
class Category extends AppModel {
@@ -69,9 +74,9 @@ database table::
));
}
-We can also attach several behaviors to a model. There's no reason
-why, for example, our Category model should only behave as a tree,
-it may also need internationalization support::
+Nous pouvons aussi attacher plusieurs behaviors à un modèle. Il n'y
+aucune raison pour que, par exemple, notre modèle Category se comporte
+seulement comme un arbre, il pourrait aussi supporter l'internationalisation::
<?php
class Category extends AppModel {
@@ -85,108 +90,111 @@ it may also need internationalization support::
);
}
-So far we have been adding behaviors to models using a model class
-variable. That means that our behaviors will be attached to our
-models throughout the model's lifetime. However, we may need to
-"detach" behaviors from our models at runtime. Let's say that on
-our previous Category model, which is acting as a Tree and a
-Translate model, we need for some reason to force it to stop acting
-as a Translate model::
+Jusqu'à présent, nous avons ajouter les comportements aux modèles en utilisant
+une variable de classe. Cela signifie que nos comportements seront attachés
+à nos modèles de tout au long de leur durée vie. Pourtant, nous pourrions
+avoir besoin de "détacher" les comportements des modèles à l'exécution.
+Considérons que dans notre précédent modèle Catégorie, lequel agit comme un
+modèle Tree et Translate, nous ayons besoin pour quelque raison de le forcer
+à ne plus agir comme un modèle Translate::
<?php
- // Detach a behavior from our model:
+ // Détache un behavior de notre modèle :
$this->Category->Behaviors->unload('Translate');
-That will make our Category model stop behaving as a Translate
-model from thereon. We may need, instead, to just disable the
-Translate behavior from acting upon our normal model operations:
-our finds, our saves, etc. In fact, we are looking to disable the
-behavior from acting upon our CakePHP model callbacks. Instead of
-detaching the behavior, we then tell our model to stop informing of
-these callbacks to the Translate behavior::
+Cela fera que notre modèle Categorie arrêtera dorénavant de se comporter
+comme un modèle Translate. Nous pourrions avoir besoin, sinon, de désactiver
+simplement le comportement Translate pour qu'il n'agisse pas sur les
+opérations normales de notre modèle : nos finds, nos saves, etc. En fait,
+nous cherchons à désactiver le comportement qui agit sur nos callbacks de
+modèle CakePHP. Au lieu de détacher le comportement, nous allons dire à notre
+modèle d'arrêter d'informer ses callbacks du comportement Translate::
<?php
- // Stop letting the behavior handle our model callbacks
+ // Empêcher le behavior de manipuler nos callbacks de modèle
$this->Category->Behaviors->disable('Translate');
-We may also need to find out if our behavior is handling those
-model callbacks, and if not we then restore its ability to react to
-them::
+Nous pourrions également avoir besoin de chercher si notre comportement
+manipule ces callbacks de modèle et si ce n'est pas le cas, alors de
+restaurer sa capacité à réagir avec eux::
<?php
- // If our behavior is not handling model callbacks
+ // Si notre comportement ne manipule pas nos callbacks de modèle
if (!$this->Category->Behaviors->enabled('Translate')) {
- // Tell it to start doing so
+ // Disons lui de le faire maintenant !
$this->Category->Behaviors->enable('Translate');
}
-Just as we could completely detach a behavior from a model at
-runtime, we can also attach new behaviors. Say that our familiar
-Category model needs to start behaving as a Christmas model, but
-only on Christmas day::
+De la même manière que nous pouvons détacher complètement un behavior
+d'un modèle à l'exécution, nous pouvons aussi attacher de nouveaux
+comportements. Disons que notre modèle familier Category nécessite de
+se comporter comme un modèle de Noël, mais seulement le jour de Noël::
<?php
- // If today is Dec 25
+ // Si nous sommes le 25 déc
if (date('m/d') == '12/25') {
- // Our model needs to behave as a Christmas model
+ // Notre modèle nécessite de se comporter comme un modèle de Noël
$this->Category->Behaviors->load('Christmas');
}
-We can also use the load method to override behavior settings::
+Nous pouvons aussi utiliser la méthode attach pour réécrire les réglages
+du comportement::
<?php
- // We will change one setting from our already attached behavior
+ // Nous changerons un réglage de notre comportement déjà attaché
$this->Category->Behaviors->load('Tree', array('left' => 'new_left_node'));
-There's also a method to obtain the list of behaviors a model has
-attached. If we pass the name of a behavior to the method, it will
-tell us if that behavior is attached to the model, otherwise it
-will give us the list of attached behaviors::
+Il y a aussi une méthode pour obtenir la liste des comportements qui sont
+attachés à un modèle. Si nous passons le nom d'un comportement à une méthode,
+elle nous dira si ce comportement est attaché au modèle, sinon elle nous
+donnera la liste des comportements attachés::
<?php
- // If the Translate behavior is not attached
+ // Si le comportement Translate n'est pas attaché
if (!$this->Category->Behaviors->attached('Translate')) {
- // Get the list of all behaviors the model has attached
+ // Obtenir la liste de tous les comportements qui sont attachés au modèle
$behaviors = $this->Category->Behaviors->attached();
}
-Creating Behaviors
-==================
+Créer des Behaviors
+===================
-Behaviors that are attached to Models get their callbacks called
-automatically. The callbacks are similar to those found in Models:
-``beforeFind``, ``afterFind``, ``beforeSave``, ``afterSave``, ``beforeDelete``,
-``afterDelete`` and ``onError`` - see
+Les behaviors qui sont attachés aux Modèles voient leurs callbacks appelés
+automatiquement. Ces callbacks sont similaires à ceux qu'on trouve dans les
+Modèles : ``beforeFind``, ``afterFind``, ``beforeSave``, ``afterSave``,
+``beforeDelete``, ``afterDelete`` et ``onError``. Voir
:doc:`/models/callback-methods`.
-Your behaviors should be placed in ``app/Model/Behavior``. They are named in CamelCase and
-postfixed by ``Behavior``, ex. NameBehavior.php.
-It's often helpful to use a core behavior as a template when creating
-your own. Find them in ``lib/Cake/Model/Behavior/``.
+Vos behaviors devront être placés dans ``app/Model/Behavior``. Ils sont
+nommés en CamelCase et suffixé 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/``.
-Every callback and behavior method takes a reference to the model it is being called
-from as the first parameter.
+Chaque callback prend comme premier paramètre, une référence du modèle par
+lequel il est appelé.
-Besides implementing the callbacks, you can add settings per behavior and/or
-model behavior attachment. Information about specifying settings can be found in
-the chapters about core behaviors and their configuration.
+En plus de l'implémentation des callbacks, vous pouvez ajouter des réglages
+par comportement et/ou par liaison d'un comportement au modèle. Des
+informations à propos des réglages spécifiques peuvent être trouvées dans
+les chapitres concernant les comportements du cœur et leur configuration.
-A quick example that illustrates how behavior settings can be
-passed from the model to the behavior::
+Voici un exemple rapide qui illustre comment les réglages peuvent êtres passés
+du modèle au comportement::
<?php
class Post extends AppModel {
public $name = 'Post'
public $actsAs = array(
'YourBehavior' => array(
- 'option1_key' => 'option1_value'
+ 'option1_key' => 'option1_valeur'
)
);
}
-Since behaviors are shared across all the model instances that use them, it's a
-good practice to store the settings per alias/model name that is using the
-behavior. When created behaviors will have their ``setup()`` method called::
+Puisque les behaviors sont partagés à travers toutes les instances de modèle
+qui l'utilisent, une bonne pratique pour stocker les paramètres par nom
+d'alias/modèle qui utilise le behavior. La création des behaviors entraînera
+l'appel de leur méthode ``setup()``::
<?php
public function setup(Model $Model, $settings = array()) {
@@ -201,108 +209,113 @@ behavior. When created behaviors will have their ``setup()`` method called::
$this->settings[$Model->alias], (array)$settings);
}
-Creating behavior methods
-=========================
+Créer les méthodes du behavior
+==============================
-Behavior methods are automatically available on any model acting as
-the behavior. For example if you had::
+Les méthodes du Behavior sont automatiquement disponibles sur tout modèle
+qui 'act as' le behavior. Par exemple si vous avez::
<?php
class Duck extends AppModel {
public $name = 'Duck';
public $actsAs = array('Flying');
}
-You would be able to call ``FlyingBehavior`` methods as if they were
-methods on your Duck model. When creating behavior methods you
-automatically get passed a reference of the calling model as the
-first parameter. All other supplied parameters are shifted one
-place to the right. For example::
+Vous seriez capable d'appeler les méthodes de ``FlyingBehavior`` comme si
+elles étaient des méthodes du modèle Duck. Quand on créer des méthodes d'un
+behavior, vous obtenez automatiquement une référence du modèle appelé en
+premier paramètre. Tous les autres paramètres fournis sont shifté one
+place to the right. Par exemple::
<?php
$this->Duck->fly('toronto', 'montreal');
-Although this method takes two parameters, the method signature
-should look like::
+Bien que cette méthode prenne deux paramètres, la méthode signature
+ressemblerait à cela::
<?php
public function fly(Model $Model, $from, $to) {
- // Do some flying.
+ // Faire quelque chose à la volée.
}
-Keep in mind that methods called in a ``$this->doIt()`` fashion
-from inside a behavior method will not get the $model parameter
-automatically appended.
+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é.
-Mapped methods
---------------
+Méthodes mappées
+----------------
-In addition to providing 'mixin' methods, behaviors can also provide pattern
-matching methods. Behaviors can also define mapped methods. Mapped methods use
-pattern matching for method invocation. This allows you to create methods
-similar to ``Model::findAllByXXX`` methods on your behaviors. Mapped methods need
-to be declared in your behaviors ``$mapMethods`` array. The method signature for
-a mapped method is slightly different than a normal behavior mixin method::
+En plus de fournir des méthodes 'mixin', les behaviors peuvent aussi fournir
+des méthodes d'appariemment de formes (pattern matching). Les Behaviors peuvent
+aussi définir des méthodes mappées. Les méthodes mappées utilisent les
+pattern matching for method invocation. Cela vous permet de créer des méthodes
+du type ``Model::findAllByXXX`` sur vos behaviors. Les méthodes mappées ont
+besoin d'être déclarées dans votre tableau ``$mapMethods`` de behaviors. La
+signature de la méthode pour une méthode mappée est légèrement différente de
+celle d'une méthode mixin normal d'un behavior::
<?php
class MyBehavior extends ModelBehavior {
- public $mapMethods = array('/do(\w+)/' => 'doSomething');
+ public $mapMethods = array('/do(\w+)/' => 'faireQuelqueChose');
public function doSomething($model, $method, $arg1, $arg2) {
debug(func_get_args());
//do something
}
}
-The above will map every ``doXXX()`` method call to the behavior. As you can see, the model is
-still the first parameter, but the called method name will be the 2nd parameter. This allows
-you to munge the method name for additional information, much like ``Model::findAllByXX``. If the above
-behavior was attached to a model the following would happen::
+Ce qui est au-dessus mappera chaque méthode ``doXXX()`` appélé vers le
+behavior. Comme vous pouvez le voir, le modèle est toujours le premier
+paramètre, mais le nom de la méthode appelée sera le deuxième paramètre.
+Cela vous permet de munge le nom de la méthode pour des informations
+supplémentaires, un peu comme ``Model::findAllByXX``. Si le behavior
+du dessus est attaché à un modèle, ce qui suit arrivera::
<?php
$model->doReleaseTheHounds('homer', 'lenny');
- // would output
+ // sortira
'ReleaseTheHounds', 'homer', 'lenny'
-Behavior callbacks
-==================
+Callbacks du Behavior
+=====================
-Model Behaviors can define a number of callbacks that are triggered
-before/after the model callbacks of the same name. Behavior
-callbacks allow your behaviors to capture events in attached models
-and augment the parameters or splice in additional behavior.
+Les Behaviors d'un Modèle peuvent définir un nombre de callbacks qui sont
+déclenchés before/after les callbacks du modèle du même nom. Les callbacks
+du Behavior vous permettent de capturer des évènements dans les modèles
+attachés et d'augmenter les paramètres ou accoler dans un beahvior
+supplémentaire.
-The available callbacks are:
+Les callbacks disponibles sont:
-- ``beforeValidate`` is fired before a model's beforeValidate
-- ``beforeFind`` is fired before a model's beforeFind
-- ``afterFind`` is fired before a model's afterFind
-- ``beforeSave`` is fired before a model's beforeSave
-- ``afterSave`` is fired before a model's afterSave
-- ``beforeDelete`` is fired after a model's beforeDelete
-- ``afterDelete`` is fired before a model's afterDelete
+- ``beforeValidate`` est lancé avant beforeValidate du modèle
+- ``beforeFind`` est lancé avant beforeFind du modèle
+- ``afterFind`` est lancé avant afterFind du modèle
+- ``beforeSave`` est lancé avant beforeSave du modèle
+- ``afterSave`` est lancé avant afterSave du modèle
+- ``beforeDelete`` est lancé après beforeDelete du modèle
+- ``afterDelete`` est lancé avant afterDelete du modèle
-Creating a behavior callback
-----------------------------
+Créer un callback du behavior
+-----------------------------
.. php:class:: ModelBehavior
-Model behavior callbacks are defined as simple methods in your
-behavior class. Much like regular behavior methods, they receive a
-``$Model`` parameter as the first argument. This parameter is the
-model that the behavior method was invoked on.
+Les callbacks d'un behavior d'un modèle sont définis comme de simples méthodes
+dans votre classe de behavior. Un peu comme les méthodes classiques du
+behavior, ils reçoivent un paramètre ``$Model`` en premier argument. Ce
+paramètre est le modèle pour lequel la méthode du behavior a été invoquée.
.. php:method:: setup(Model $Model, array $settings = array())
- Called when a behavior is attached to a model. The settings come from the
- attached model's ``$actsAs`` property.
+ Appelé quand un behavior est attaché à un modèle. Les paramètres viennent
+ de la propriété ``$actsAs`` du modèle attaché.
.. php:method:: cleanup(Model $Model)
- Called when a behavior is detached from a model. The base method removes
- model settings based on ``$model->alias``. You can override this method and
- provide custom cleanup functionality.
+ Appelé quand un behavior est détaché d'un modèle. La méthode de base retire
+ les paramètres du modèle basées sur ``$model->alias``. Vous pouvez écraser
+ cette méthode et fournir une fonctionnalité personnalisée nettoyée.
.. php:method:: beforeFind(Model $Model, array $query)
@@ -312,40 +325,39 @@ model that the behavior method was invoked on.
.. php:method:: afterFind(Model $Model, mixed $results, boolean $primary)
- You can use the afterFind to augment the results of a find. The
- return value will be passed on as the results to either the next
- behavior in the chain or the model's afterFind.
+ Vous pouvez utiliser le afterFind pour augmenter les résultats d'un find.
+ La valeur retournée sera passée en résultats soit au behavior suivant dans
+ la chaîne, soit au afterFind du modèle.
.. php:method:: beforeDelete(Model $Model, boolean $cascade = true)
- You can return false from a behavior's beforeDelete to abort the
- delete. Return true to allow it continue.
+ Vous pouvez retourner false d'un beforeDelete d'un behavior pour annuler
+ la suppression. Retourne true pour autoriser la suite.
.. php:method:: afterDelete(Model $Model)
- You can use afterDelete to perform clean up operations related to
- your behavior.
+ Vous pouvez utiliser afterDelete pour effectuer des opérations de nettoyage
+ liées à votre behavior.
.. php:method:: beforeSave(Model $Model)
- You can return false from a behavior's beforeSave to abort the
- save. Return true to allow it continue.
+ Vous pouvez retourner false d'un beforeSave d'un behavior pour annuler
+ la sauvegarde. Retourner true pour permettre de continuer.
.. php:method:: afterSave(Model $Model, boolean $created)
- You can use afterSave to perform clean up operations related to
- your behavior. $created will be true when a record is created, and
- false when a record is updated.
+ Vous pouvez utiliser afterSave pour effectuer des opérations de nettoyage
+ liées au behavior. $created sera à true quand un enregistrement sera crée,
+ et à false quand un enregistrement sera mis à jour.
.. php:method:: beforeValidate(Model $Model)
- You can use beforeValidate to modify a model's validate array or
- handle any other pre-validation logic. Returning false from a
- beforeValidate callback will abort the validation and cause it to
- fail.
+ Vous pouvez utiliser beforeValidate pour modifier un tableau de validation
+ de modèle ou gérer tout autrre logique de pré-validation. Retourner false
+ d'un callback beforeValidate annulera la validation et entraînera son echec.
.. meta::
- :title lang=en: Behaviors
- :keywords lang=en: tree manipulation,manipulation methods,model behaviors,access control list,model class,tree structures,php class,business contract,class category,database table,bakery,inheritance,functionality,interaction,logic,cakephp,models,essence
+ :title lang=fr: Behaviors (Comportements)
+ :keywords lang=fr: tree manipulation,manipulation methods,model behaviors,access control list,model class,tree structures,php class,business contract,class category,database table,bakery,inheritance,functionality,interaction,logic,cakephp,models,essence
View
149 fr/models/callback-methods.rst
@@ -1,52 +1,55 @@
-Callback Methods
-################
+Méthodes Callback
+#################
-If you want to sneak in some logic just before or after a CakePHP
-model operation, use model callbacks. These functions can be
-defined in model classes (including your AppModel) class. Be sure
-to note the expected return values for each of these special
-functions.
+Si vous voulez glisser un bout de logique applicative juste avant ou
+après une opération d’un modèle CakePHP, utilisez les callbacks de modèle.
+Ces fonctions peuvent être définies dans les classes de modèle (cela
+comprend également votre classe AppModel). Notez bien les valeurs de
+retour attendues pour chacune de ces méthodes spéciales.
beforeFind
==========
``beforeFind(mixed $queryData)``
-Called before any find-related operation. The ``$queryData`` passed
-to this callback contains information about the current query:
-conditions, fields, etc.
+Appelée avant toute opération liée à la recherche. Les ``$donneesRequete``
+passées à cette méthode de callback contiennent des informations sur
+la requête courante : conditions, champs, etc.
-If you do not wish the find operation to begin (possibly based on a
-decision relating to the ``$queryData`` options), return *false*.
-Otherwise, return the possibly modified ``$queryData``, or anything
-you want to get passed to find and its counterparts.
+Si vous ne souhaitez pas que l'opération de recherche commence (par
+rapport à une décision liée aux options de ``$donneesRequete``), retournez
+*false*. Autrement, retournez la variable ``$donneesRequete`` éventuellement
+modifiée, ou tout ce que vous souhaitez voir passé à la méthode find()
+ou ses équivalents.
-You might use this callback to restrict find operations based on a
-user’s role, or make caching decisions based on the current load.
+Vous pouvez utiliser cette méthode de callback pour restreindre les
+opérations de recherche en se basant sur le rôle de l'utilisateur, ou
+prendre des décisions sur la politique de mise en cache en fonction de
+la charge actuelle.
afterFind
=========
``afterFind(array $results, bool $primary)``
-Use this callback to modify results that have been returned from a
-find operation, or to perform any other post-find logic. The
-$results parameter passed to this callback contains the returned
-results from the model's find operation, i.e. something like::
+Utilisez cette méthode de callback pour modifier les résultats qui ont
+été retournés par une opération de recherche, ou pour effectuer toute
+logique post-recherche. Le paramètre $results passé à cette méthode contient
+les résultats retournés par l'opération find() du modèle, càd quelque
+chose comme::
<?php
$results = array(
0 => array(
- 'ModelName' => array(
- 'field1' => 'value1',
- 'field2' => 'value2',
+ 'NomModel' => array(
+ 'champ1' => 'valeur1',
+ 'champ2' => 'valeur2',
),
),
);
-The return value for this callback should be the (possibly
-modified) results for the find operation that triggered this
-callback.
+La valeur de retour de ce callback doit être le résultat de l'opération
+de recherche (potentiellement modifié) qui a déclenché ce callback.
The ``$primary`` parameter indicates whether or not the current
model was the model that the query originated on or whether or not
@@ -57,18 +60,18 @@ this::
<?php
$results = array(
- 'field_1' => 'value1',
- 'field_2' => 'value2'
+ 'champ1' => 'valeur1',
+ 'champ2' => 'valeur2'
);
.. warning::
- Code expecting ``$primary`` to be true will probably get a "Cannot
- use string offset as an array" fatal error from PHP if a recursive
- find is used.
+ Un code nécessitant que ``$primaire`` soit vrai auront probablement
+ l'erreur fatale "Cannot use string offset as an array" de la part de
+ PHP si une recherche récursive est utilisée.
-Below is an example of how afterfind can be used for date
-formatting::
+Ci-dessous un exemple de la manière dont afterfind peut être utilisé
+pour formater des dates::
<?php
public function afterFind($results) {
@@ -89,30 +92,32 @@ beforeValidate
``beforeValidate()``
-Use this callback to modify model data before it is validated, or
-to modify validation rules if required. This function must also
-return *true*, otherwise the current save() execution will abort.
+Utilisez ce rappel pour modifier les données du modèle avant qu'elles ne
+soient validées ou pour modifier les règles de validation si nécessaire.
+Cette fonction doit aussi retourner *vrai*, sinon l'exécution du save()
+courant sera annulée.
beforeSave
==========
``beforeSave()``
-Place any pre-save logic in this function. This function executes
-immediately after model data has been successfully validated, but
-just before the data is saved. This function should also return
-true if you want the save operation to continue.
+Placez toute logique de pré-enregistrement dans cette fonction. Cette fonction
+s'exécute immediatement après que les données du modèle ont été validées avec
+succès, mais juste avant que les données ne soient sauvegardées. Cette fonction
+devrait toujours retourner vrai si voulez que l'opération d'enregistrement
+se poursuive.
-This callback is especially handy for any data-massaging logic that
-needs to happen before your data is stored. If your storage engine
-needs dates in a specific format, access it at $this->data and
-modify it.
+Ce callback est particulièrement pratique, pour toute logique de manipulation
+des données qui nécessite de se produire avant que vos données ne soient
+stockées. Si votre moteur de stockage nécessite un format spécifique pour les
+dates, accédez-y par $this->data et modifiez-les.
-Below is an example of how beforeSave can be used for date
-conversion. The code in the example is used for an application with
-a begindate formatted like YYYY-MM-DD in the database and is
-displayed like DD-MM-YYYY in the application. Of course this can be
-changed very easily. Use the code below in the appropriate model.
+Ci-dessous un exemple montrant comment beforeSave peut-être utilisé pour la
+conversion de date. Le code de l'exemple est utilisé pour une application qui
+a une date de début, au format YYYY-MM-DD dans la base de données et au format
+DD-MM-YYYY dans l'affichage de l'application. Bien sûr, ceci peut être très
+facilement modifié. Utilisez le code ci-dessous dans le modèle approprié.
::
@@ -131,47 +136,47 @@ changed very easily. Use the code below in the appropriate model.
.. tip::
- Be sure that beforeSave() returns true, or your save is going to
- fail.
+ Assurez-vous que beforeSave() retourne vrai ou bien votre sauvegarde
+ échouera.
afterSave
=========
``afterSave(boolean $created)``
-If you have logic you need to be executed just after every save
-operation, place it in this callback method.
+Si vous avez besoin d'exécuter de la logique juste après chaque opération de
+sauvegarde, placez-la dans cette méthode de rappel.
-The value of ``$created`` will be true if a new record was created
-(rather than an update).
+La valeur de ``$created`` sera vrai si un nouvel objet a été créé (plutôt qu'un
+objet mis à jour).
beforeDelete
============
``beforeDelete(boolean $cascade)``
-Place any pre-deletion logic in this function. This function should
-return true if you want the deletion to continue, and false if you
-want to abort.
+Placez dans cette fonction, toute logique de pré-suppression. Cette fonction
+doit retourner vrai si vous voulez que la suppression continue et faux si
+vous voulez l'annuler.
-The value of ``$cascade`` will be ``true`` if records that depend
-on this record will also be deleted.
+La valeur de ``$cascade`` sera ``true``, pour que les enregistrements qui
+dépendent de cet enregistrement soient aussi supprimés.
.. tip::
- Be sure that beforeDelete() returns true, or your delete is going
- to fail.
+ Assurez vous que beforeDelete() retourne true, ou votre suppression ne va
+ pas marcher.
::
<?php
- // using app/Model/ProductCategory.php
- // In the following example, do not let a product category be deleted if it still contains products.
- // A call of $this->Product->delete($id) from ProductsController.php has set $this->id .
- // Assuming 'ProductCategory hasMany Product', we can access $this->Product in the model.
+ // using app/Model/ProduitCategory.php
+ // Dans l'exemple suivant, ne laissez pas une catégorie être supprimée si elle contient des produits.
+ // Un appel de $this->Produit->delete($id) de ProduitsController.php a défini $this->id .
+ // En admettant que 'ProduitCategory hasMany Produit', nous pouvons accéder à $this->Produit dans le modèle.
public function beforeDelete() {
$count = $this->Product->find("count", array(
- "conditions" => array("product_category_id" => $this->id)
+ "conditions" => array("produit_category_id" => $this->id)
));
if ($count == 0) {
return true;
@@ -185,17 +190,17 @@ afterDelete
``afterDelete()``
-Place any logic that you want to be executed after every deletion
-in this callback method.
+Placez dans cette méthode de rappel, toute logique que vous souhaitez exécuter
+après chaque suppression.
onError
=======
``onError()``
-Called if any problems occur.
+Appelée si quelque problème se produit.
.. meta::
- :title lang=en: Callback Methods
- :keywords lang=en: querydata,query conditions,model classes,callback methods,special functions,return values,counterparts,array,logic,decisions
+ :title lang=fr: Méthodes Callback
+ :keywords lang=fr: donnée requêtée,conditions requêtes,classes model modèle,méthodes de callback,fonctions spéciales,valeurs retournées,homologues,tableau,logique,décisions
View
883 fr/models/data-validation.rst
@@ -1,167 +1,166 @@
-Data Validation
-###############
-
-Data validation is an important part of any application, as it
-helps to make sure that the data in a Model conforms to the
-business rules of the application. For example, you might want to
-make sure that passwords are at least eight characters long, or
-ensure that usernames are unique. Defining validation rules makes
-form handling much, much easier.
-
-There are many different aspects to the validation process. What
-we’ll cover in this section is the model side of things.
-Essentially: what happens when you call the save() method of your
-model. For more information about how to handle the displaying of
-validation errors, check out
+Validation des Donnnées
+#######################
+
+La validation des données est une partie importante de toute application,
+puisqu'elle permet de s'assurer que les données d'un modèle respectent les
+règles métiers de l'application. Par exemple, vous aimeriez vérifier que les
+mots de passe sont longs d'au moins huit caractères ou bien vous assurer que
+les noms d'utilisateurs sont uniques. La définition des règles de validation
+facilite grandement la gestion des formulaires.
+
+Il y a de nombreux aspects différents dans le processus de validation. Ce
+que nous aborderons dans cette section c'est le côté modèle des choses. En
+résumé : ce qui se produit lorsque vous appelez la méthode save() de votre
+modèle. Pour obtenir plus d'informations sur la manière d'afficher les erreurs
+de validation, regardez la section traitant de l'assistant
:doc:`/core-libraries/helpers/form`.
-The first step to data validation is creating the validation rules
-in the Model. To do that, use the Model::validate array in the
-Model definition, for example::
+La première étape pour la validation de données est de créer les règles dans
+le Modèle. Pour ce faire, utilisez le tableau Model::validate dans la
+définition du modèle, par exemple::
<?php
- class User extends AppModel {
- public $name = 'User';
+ class Utilisateur extends AppModel {
+ public $name = 'Utilisateur';
public $validate = array();
}
-In the example above, the ``$validate`` array is added to the User
-Model, but the array contains no validation rules. Assuming that
-the users table has login, password, email and born fields, the
-example below shows some simple validation rules that apply to
-those fields::
+Dans l'exemple ci-dessus, le tableau ``$validate`` est ajouté au modèle
+Utilisateur, mais ce tableau ne contient pas de règles de validation.
+En supposant que la table "utilisateurs" ait les champs "login",
+"mot_de_passe", "email" et "date_de_naissance", l'exemple ci-dessous
+montre quelques règles simples de validation qui s'appliquent à ces champs :
<?php
- class User extends AppModel {
- public $name = 'User';
+ class Utilisateur extends AppModel {
+ public $name = 'Utilisateur';
public $validate = array(
'login' => 'alphaNumeric',
'email' => 'email',
- 'born' => 'date'
+ 'date_de_naissance' => 'date'
);
}
-This last example shows how validation rules can be added to model
-fields. For the login field, only letters and numbers will be
-accepted, the email should be valid, and born should be a valid
-date. Defining validation rules enables CakePHP’s automagic showing
-of error messages in forms if the data submitted does not follow
-the defined rules.
-CakePHP has many validation rules and using them can be quite easy.
-Some of the built-in rules allow you to verify the formatting of
-emails, URLs, and credit card numbers – but we’ll cover these in
-detail later on.
+Ce dernier exemple montre comment des règles de validation peuvent être
+ajoutées aux champs d'un modèle. Pour le champ 'login', seules les lettres
+et les chiffres sont autorisés, l'email doit être valide et la date de
+naissance doit être une date valide. La définition de règles de validation
+active l'affichage "automagique" de messages d'erreurs dans les formulaires
+par CakePHP, si les données saisies ne respectent pas les règles définies.
+
+CakePHP a de nombreuses règles et leur utilisation peut être très simple.
+Certaines de ces règles intégrées vous permettent de vérifier le format des
+adresses emails, des URLs, des numéros de carte de crédit, etc. - mais nous
+couvrirons cela en détail plus loin.
-Here is a more complex validation example that takes advantage of
-some of these built-in validation rules::
+Voici un autre exemple de validation plus complexe qui tire avantage de
+quelques-unes de ces règles pré-définies::
<?php
- class User extends AppModel {
+ class Utilisateur extends AppModel {
public $name = 'User';
public $validate = array(
'login' => array(
'alphaNumeric' => array(
'rule' => 'alphaNumeric',
'required' => true,
- 'message' => 'Alphabets and numbers only'
+ 'message' => 'Chiffres et lettres uniquement !'
),
'between' => array(
'rule' => array('between', 5, 15),
- 'message' => 'Between 5 to 15 characters'
+ 'message' => 'Entre 5 et 15 caractères'
)
),
- 'password' => array(
+ 'mot_de_passe' => array(
'rule' => array('minLength', '8'),
- 'message' => 'Minimum 8 characters long'
+ 'message' => '8 caractères minimum'
),
'email' => 'email',
- 'born' => array(
+ 'date_de_naissance' => array(
'rule' => 'date',
- 'message' => 'Enter a valid date',
+ 'message' => 'Entrez une date valide',
'allowEmpty' => true
)
);
}
-Two validation rules are defined for login: it should contain
-letters and numbers only, and its length should be between 5 and
-15. The password field should be a minimum of 8 characters long.
-The email should be a valid email address, and born should be a
-valid date. Also, notice how you can define specific error messages
-that CakePHP will use when these validation rules fail.
+Deux règles de validation sont définies pour le login : il doit contenir
+des lettres et des chiffres uniquement et sa longueur doit être comprise
+entre 5 et 15. Le mot de passe doit avoir au minimum 8 caractères. L'email
+doit avoir un format correct et la date de naissance être une date valide.
+Vous pouvez voir dans cet exemple comment personnaliser les messages que
+CakePHP affichera en cas de non respect de ces règles.
-As the example above shows, a single field can have multiple
-validation rules. And if the built-in rules do not match your
-criteria, you can always add your own validation rules as
-required.
+Comme le montre l'exemple ci-dessus, un seul champ peut avoir plusieurs règles
+de validation. Si les règles pré-définies ne correspondent pas à vos critères,
+vous pouvez toujours ajouter vos propres règles de validation, selon vos
+besoins.
-Now that you’ve seen the big picture on how validation works, let’s
-look at how these rules are defined in the model. There are three
-different ways that you can define validation rules: simple arrays,
-single rule per field, and multiple rules per field.
+Maintenant que nous avons vu, en gros, comment la validation fonctionne, voyons
+comme ces règles sont définies dans le modèle. Il y a trois manières
+différentes pour définir les règles de validation : tableaux simples, une règle
+par champ et plusieurs règles par champ.
+Règles simples
+==============
-Simple Rules
-============
-
-As the name suggests, this is the simplest way to define a
-validation rule. The general syntax for defining rules this way
-is::
+Comme le suggère le nom, c'est la manière la plus simple de définir une
+règle de validation. La syntaxe générale pour définir des règles de cette
+manière est::
<?php
- public $validate = array('fieldName' => 'ruleName');
+ public $validate = array('nomChamp' => 'nomRegle');
-Where, 'fieldName' is the name of the field the rule is defined
-for, and ‘ruleName’ is a pre-defined rule name, such as
-'alphaNumeric', 'email' or 'isUnique'.
+Où 'nomChamp' est le nom du champ pour lequel la règle est définie, et
+'nomRegle' est un nom prédéfini, comme 'alphaNumeric', 'email' ou 'isUnique'.
-For example, to ensure that the user is giving a well formatted
-email address, you could use this rule::
+Par exemple, pour s'assurer que l'utilisateur fourni une adresse email
+correcte, vous pouvez utiliser cette règle::
<?php
- public $validate = array('user_email' => 'email');
+ public $validate = array('email_utilisateur' => 'email');
-One Rule Per Field
-==================
+Une règle par champ
+===================
-This definition technique allows for better control of how the
-validation rules work. But before we discuss that, let’s see the
-general usage pattern adding a rule for a single field::
+Cette technique de définition permet un meilleur contrôle sur le fonctionnement
+des règles de validation. Mais avant d'aborder ce point, regardons le schéma
+d'utilisation général pour ajouter une règle à un seul champ::
<?php
public $validate = array(
- 'fieldName1' => array(
- 'rule' => 'ruleName', // or: array('ruleName', 'param1', 'param2' ...)
+ 'champ1' => array(
+ 'rule' => 'nomRegle', // ou bien : array('nomRegle', 'parametre1', 'parametre2' ...)
'required' => true,
'allowEmpty' => false,
- 'on' => 'create', // or: 'update'
- 'message' => 'Your Error Message'
+ 'on' => 'create', // ou bien: 'update'
+ 'message' => 'Votre message d\'erreur'
)
);
-The 'rule' key is required. If you only set 'required' => true, the
-form validation will not function correctly. This is because
-'required' is not actually a rule.
+La clé 'rule' est obligatoire. Si vous définissez uniquement
+'required' => true, la validation du formulaire ne fonctionnera pas
+correctement. C'est à cause du fait que 'required' n'est pas à proprement
+parlé une règle.
-As you can see here, each field (only one field shown above) is
-associated with an array that contains five keys: ‘rule’,
-‘required’, ‘allowEmpty, ‘on’ and ‘message’. Let’s have a closer
-look at these keys.
+Comme vous pouvez le voir ici, chaque champ (un seul est présenté ci-dessus)
+est associé à un tableau contenant cinq clés : ‘rule‘, ‘required‘,
+‘allowEmpty, ‘on‘ et ‘message‘. Toutes les clés sont optionnelles sauf
+'rule'. Regardons en détail ces clés.
-rule
-----
+La clé 'rule'
+-------------
-The 'rule' key defines the validation method and takes either a
-single value or an array. The specified 'rule' may be the name of a
-method in your model, a method of the core Validation class, or a
-regular expression. For more information on the rules available by
-default, see
-:ref:`core-validation-rules`.
+La clé 'rule' définit la méthode de validation et attend soit une valeur
+simple, soit un tableau. La règle spécifiée peut-être le nom d'une méthode
+dans votre modèle, une méthode de la classe globale Validation ou une
+expression régulière. Pour une liste complète des règles pré-définies,
+allez voir :ref:`core-validation-rules`.
-If the rule does not require any parameters, 'rule' can be a single
-value e.g.::
+Si la règle ne nécessite pas de paramètre, 'rule' peut-être une simple
+valeur, comme::
<?php
public $validate = array(
@@ -170,27 +169,28 @@ value e.g.::
)
);
-If the rule requires some parameters (like the max, min or range),
-'rule' should be an array::
+Si la règle nécessite quelques paramètres (tels que un maximum, un
+minimum ou une plage de valeurs), 'rule' doit être un tableau::
<?php
public $validate = array(
- 'password' => array(
+ 'mot_de_passe' => array(
'rule' => array('minLength', 8)
)
);
-Remember, the 'rule' key is required for array-based rule
-definitions.
+Souvenez-vous, la clé 'rule' est obligatoire pour les définitions de
+règles sous forme de tableau.
-required
---------
+La clé 'required'
+-----------------
-This key accepts either a boolean, or ``create`` or ``update``. Setting this
-key to ``true`` will make the field always required. While setting it to
-``create`` or ``update`` will make the field required only for update or create
-operations. If 'required' is evaluated to true, the field must be present in the
-data array. For example, if the validation rule has been defined as follows::
+Cette clé doit être définie par une valeur booléenne, ou ``create`` ou
+``update``. Si 'required' est ``true`` alors le champ doit être présent
+dans le tableau de données. Tandis que mettre le champ à ``create`` ou
+``update`` rendra le champ nécessaire seulement lors des opérations de
+création ou de mise à jour. Par exemple, si la règle de validation a
+été définie comme suit::
<?php
public $validate = array(
@@ -200,213 +200,213 @@ data array. For example, if the validation rule has been defined as follows::
)
);
-The data sent to the model’s save() method must contain data for
-the login field. If it doesn’t, validation will fail. The default
-value for this key is boolean false.
+Les données envoyées à la méthode save() du modèle doivent contenir des
+données pour le champ 'login'. Dans le cas contraire, la validation
+échouera. La valeur par défaut de cette clé est le booléen 'false'.
-``required => true`` does not mean the same as the validation rule
-``notEmpty()``. ``required => true`` indicates that the array *key*
-must be present - it does not mean it must have a value. Therefore
-validation will fail if the field is not present in the dataset,
-but may (depending on the rule) succeed if the value submitted is
-empty ('').
+``required => true`` ne signifie pas la même chose que la règle de validation
+``notEmpty()``. ``required => true`` indique que la *clé* du tableau doit être
+présente - cela ne veut pas dire qu'elle doit avoir une valeur. Par
+conséquent, la validation échouera si le champ n'est pas présent dans le jeu
+de données, mais pourra réussir (en fonction de la règle) si la valeur soumise
+est vide ('').
.. versionchanged:: 2.1
- Support for ``create`` and ``update`` were added.
+ Support pour ``create`` et ``update`` a été ajouté.
-allowEmpty
-----------
+La Clé 'allowEmpty'
+-------------------
-If set to ``false``, the field value must be **nonempty**, where
-"nonempty" is defined as ``!empty($value) || is_numeric($value)``.
-The numeric check is so that CakePHP does the right thing when
-``$value`` is zero.
+Si définie à ``false``, la valeur du champ doit être **non vide**, ceci
+étant déterminé par ``!empty($value) || is_numeric($value)``. La vérification
+numérique est là pour que CakePHP fasse ce qu'il faut quand ``$valeur`` vaut
+zéro.
-The difference between ``required`` and ``allowEmpty`` can be
-confusing. ``'required' => true`` means that you cannot save the
-model without the *key* for this field being present in
-``$this->data`` (the check is performed with ``isset``); whereas,
-``'allowEmpty' => false`` makes sure that the current field *value*
-is nonempty, as described above.
+La différence entre ``required`` et ``allowEmpty`` peut être confuse.
+``'required' => true`` signifie que vous ne pouvez pas sauvegarder le modèle,
+si la *clé* pour ce champ n'est pas présente dans ``$this->data`` (la
+vérification est réalisé avec isset) ; tandis que ``'allowEmpty' => false``
+s'assure que la *valeur* du champ courant est "non vide", comme décrit
+ci-dessus.
-on
---
+La clé 'on'
+-----------
-The 'on' key can be set to either one of the following values:
-'update' or 'create'. This provides a mechanism that allows a
-certain rule to be applied either during the creation of a new
-record, or during update of a record.
+La clé 'on' peut prendre l'une des valeurs suivantes : 'update' ou 'create'.
+Ceci fournit un mécanisme qui permet à une règle donnée d'être appliquée
+pendant la création ou la mise à jour d'un enregistrement.
-If a rule has defined 'on' => 'create', the rule will only be
-enforced during the creation of a new record. Likewise, if it is
-defined as 'on' => 'update', it will only be enforced during the
-updating of a record.
+Si une règle est définie à 'on' => 'create', elle sera seulement appliquée
+lors de la création d'un nouvel enregistrement. Autrement, si elle est
+définie à 'on' => 'update', elle s'appliquera uniquement lors de la mise
+à jour de l'enregistrement.
-The default value for 'on' is null. When 'on' is null, the rule
-will be enforced during both creation and update.
+La valeur par défaut pour 'on' est 'null'. Quand 'on' est nul, la règle
+s'applique à la fois pendant la création et la mise à jour.
-message
--------
+La clé 'message'
+----------------
-The message key allows you to define a custom validation error
-message for the rule::
+La clé ‘message’ vous permet de définir un message d'erreur de validation
+personnalisé pour la règle::
<?php
public $validate = array(
- 'password' => array(
+ 'mot_de_passe' => array(
'rule' => array('minLength', 8),
- 'message' => 'Password must be at least 8 characters long'
+ 'message' => 'Le mot de passe doit comporter au moins 8 caractères'
)
);
-Multiple Rules per Field
-========================
+Plusieurs règles par champs
+===========================
-The technique outlined above gives us much more flexibility than
-simple rules assignment, but there’s an extra step we can take in
-order to gain more fine-grained control of data validation. The
-next technique we’ll outline allows us to assign multiple
-validation rules per model field.
+La technique que nous venons de voir nous donne plus de flexibilité que
+l'assignation simple de règles, mais il y a une étape supplémentaire que
+nous pouvons mettre en œuvre, pour avoir un contrôle encore plus fin sur la
+validation des données. La prochaine technique que nous allons voir nous
+permet d'affecter plusieurs règles de validation par champ de modèle.
-If you would like to assign multiple validation rules to a single
-field, this is basically how it should look::
+Si vous souhaitiez affecter plusieurs règles de validation à un seul champ,
+voici basiquement comment il faudrait faire::
<?php
public $validate = array(
- 'fieldName' => array(
- 'ruleName' => array(
- 'rule' => 'ruleName',
- // extra keys like on, required, etc. go here...
+ 'nomChamp' => array(
+ 'nomRegle' => array(
+ 'rule' => 'nomRegle',
+ // clés supplémentaires comme 'on', 'required', etc. à mettre ici
),
- 'ruleName2' => array(
- 'rule' => 'ruleName2',
- // extra keys like on, required, etc. go here...
+ 'nomRegle2' => array(
+ 'rule' => 'nomRegle2',
+ // clés supplémentaires comme 'on', 'required', etc. à mettre ici
)
)
);
-As you can see, this is quite similar to what we did in the
-previous section. There, for each field we had only one array of
-validation parameters. In this case, each ‘fieldName’ consists of
-an array of rule indices. Each 'ruleName' contains a separate array
-of validation parameters.
+Comme vous pouvez le voir, cela ressemble beaucoup à ce que nous avons vu
+dans la section précédente. Ici pour chaque champ, nous avons uniquement un
+tableau de paramètres de validation. Dans ce cas, chaque ‘nomChamp‘ est un
+tableau de règles indexé. Chaque 'nomRegle' contient un tableau indépendant
+de paramètres de validation.
-This is better explained with a practical example::
+Ce sera plus explicite avec un exemple pratique::
<?php
public $validate = array(
'login' => array(
- 'loginRule-1' => array(
+ 'regleLogin-1' => array(
'rule' => 'alphaNumeric',
- 'message' => 'Only alphabets and numbers allowed',
+ 'message' => 'Lettres et chiffres uniquement',
'last' => true
),
- 'loginRule-2' => array(
+ 'regleLogin-2' => array(
'rule' => array('minLength', 8),
- 'message' => 'Minimum length of 8 characters'
+ 'message' => 'Taille minimum de 8 caractères'
)
)
);
-The above example defines two rules for the login field:
-loginRule-1 and loginRule-2. As you can see, each rule is
-identified with an arbitrary name.
-
-By default CakePHP tries to validate a field using all the
-validation rules declared for it and returns the error message for
-the last failing rule. But if the key ``last`` is set to ``true``
-for a rule and it fails, then the error message for that rule is
-returned and further rules are not validated. So if you prefer to
-show the error message for the first failing rule then set
-``'last' => true`` for each rule.
+L'exemple ci-dessus définit deux règles pour le champ 'login': 'regleLogin-1'
+et 'regleLogin-2'. Comme vous pouvez le voir, chaque règle est identifiée avec
+un nom arbitraire.
-When using multiple rules per field the 'required' and 'allowEmpty'
-keys need to be used only once in the first rule.
+Par défaut, CakePHP essaye de valider un champ en utilisant toutes les règles
+de validation déclarées pour lui et renvoie le message d'erreur pour la
+dernière règle qui n'est pas passée. Mais si la clé ``last`` est définie à
+``true`` pour une règle et qu'elle ne passe pas, le message d'erreur pour
+cette règle est retourné et les règles suivantes ne sont pas validées. Donc
+si vous préférez voir le message d'erreur de la première règle qui ne passe
+pas au lieu de la dernière, définissez ``'last' => true`` pour chaque règle.
+Quand vous utilisez des règles multiples par champ, les clés
+'required' and 'allowEmpty' ont besoin d'être utilisées seulement une fois
+dans la première règle.
-Custom Validation Rules
-=======================
+Règles personnalisées de validation des données
+===============================================
-If you haven’t found what you need thus far, you can always create
-your own validation rules. There are two ways you can do this: by
-defining custom regular expressions, or by creating custom
-validation methods.
+Si ce qui précède ne vous convient pas, vous pouvez toujours créer vos propres
+règles de validation. Il y a deux moyens de réaliser cela : en définissant
+des expressions régulières ou en créant des méthodes de validation
+personnalisées.
-Custom Regular Expression Validation
-------------------------------------
+Validation avec Expression Régulière personnalisée
+--------------------------------------------------
-If the validation technique you need to use can be completed by
-using regular expression matching, you can define a custom
-expression as a field validation rule::
+Si la technique de validation dont vous avez besoin peut être complétée par
+l'utilisation d'une expression régulière, vous pouvez définir une expression
+personnalisée comme une règle de validation de champ::
<?php
public $validate = array(
'login' => array(
'rule' => '/^[a-z0-9]{3,}$/i',
- 'message' => 'Only letters and integers, min 3 characters'
+ 'message' => 'Seulement des lettres et des entiers, minimum 3 caractères'
)
);
-The example above checks if the login contains only letters and
-integers, with a minimum of three characters.
+L'exemple ci-dessus vérifie que le login contient seulement des lettres et des
+entiers et qu'il a au minimum trois caractères.
-The regular expression in the ``rule`` must be delimited by
-slashes. The optional trailing 'i' after the last slash means the
-reg-exp is case *i*\ nsensitive.
+L'expression régulière dans ``rule`` doit être délimitée par des slashes (/).
+Le 'i' final optionnel après le dernier slash signifie que l'expression
+régulière est *i*\ nsensible à la casse.
-Adding your own Validation Methods
-----------------------------------
+Ajouter vos propres méthodes de validation
+------------------------------------------
-Sometimes checking data with regular expression patterns is not
-enough. For example, if you want to ensure that a promotional code
-can only be used 25 times, you need to add your own validation
-function, as shown below::
+Parfois, la vérification des données par un motif d'expression régulière ne
+suffit pas. Par exemple, si vous voulez vous assurer qu'un coupon de réduction
+(code promo) n'est pas utilisé plus de 25 fois, vous devez ajouter votre
+propre méthode de validation, comme indiqué ci-dessous::
<?php
- class User extends AppModel {
- public $name = 'User';
+ class Utilisateur extends AppModel {
+ public $name = 'Utilisateur';
public $validate = array(
- 'promotion_code' => array(
- 'rule' => array('limitDuplicates', 25),
- 'message' => 'This code has been used too many times.'
+ 'code_promo' => array(
+ 'rule' => array('limiteUtilisations', 25),
+ 'message' => 'Ce code promo a dépassé son nombre maximal d\'utilisation.'
)
);
- public function limitDuplicates($check, $limit) {
- // $check will have value: array('promomotion_code' => 'some-value')
- // $limit will have value: 25
- $existing_promo_count = $this->find('count', array(
+ public function limiteUtilisations($check, $limit) {
+ // $check aura comme valeur : array('code_promo' => 'une valeur')
+ // $limit aura comme valeur : 25
+ $compteur_code_actuel = $this->find( 'count', array(
'conditions' => $check,
'recursive' => -1
));
- return $existing_promo_count < $limit;
+ return $compteur_code_actuel < $limit;
}
}
-The current field to be validated is passed into the function as
-first parameter as an associated array with field name as key and
-posted data as value.
+Le champ en cours de validation est passé à la fonction comme premier
+paramètre, sous la forme d'un tableau associatif avec le nom du champ
+comme clé et les données postées comme valeur.
-If you want to pass extra parameters to your validation function,
-add elements onto the ‘rule’ array, and handle them as extra params
-(after the main ``$check`` param) in your function.
+Si vous voulez passer des paramètres supplémentaires à votre fonction de
+validation, ajoutez des éléments dans le tableau ’rule’ et manipulez-les
+comme des paramètres supplémentaires (après le paramètre principal ``$check``)
+dans votre fonction.
-Your validation function can be in the model (as in the example
-above), or in a behavior that the model implements. This includes
-mapped methods.
+Votre fonction de validation peut être dans le modèle (comme dans l'exemple)
+ou dans un comportement (behavior) que votre modèle implémente. Ceci inclus
+les méthodes mappées.
-Model/behavior methods are checked first, before looking for a
-method on the ``Validation`` class. This means that you can
-override existing validation methods (such as ``alphaNumeric()``)
-at an application level (by adding the method to ``AppModel``), or
-at model level.
+Les méthodes des modèles/behaviors sont vérifiées en premier, avant de
+chercher pour une méthode dans la class ``Validation``. Cela veut dire que vous
+pouvez écraser les méthodes de validation existantes (telle que
+``alphaNumeric()``) au niveau de l'application (en ajoutant la méthode dans
+``AppModel``) ou au niveau du modèle.
-When writing a validation rule which can be used by multiple
-fields, take care to extract the field value from the $check array.
-The $check array is passed with the form field name as its key and
-the field value as its value. The full record being validated is
-stored in $this->data member variable::
+Quand vous écrivez une règle de validation qui peut être utilisée par
+plusieurs champs, prenez soin d'extraire la valeur du champ du tableau
+$check. Le tableau $check est passé avec le nom du champ comme clé et la
+valeur du champ comme valeur. Le champ complet qui doit être validé est
+stocké dans une variable de $this->data::
<?php
class Post extends AppModel {
@@ -415,69 +415,72 @@ stored in $this->data member variable::
public $validate = array(
'slug' => array(
'rule' => 'alphaNumericDashUnderscore',
- 'message' => 'Slug can only be letters, numbers, dash and underscore'
+ 'message' => 'Le slug ne peut contenir que des lettres, des nombres, des tirets ou des underscores.'
)
);
public function alphaNumericDashUnderscore($check) {
- // $data array is passed using the form field name as the key
- // have to extract the value to make the function generic
- $value = array_values($check);
- $value = $value[0];
+ // le tableau $check est passé en utilisant le nom du champ de formulaire comme clé
+ // nous devons extraire la valeur pour rendre la fonction générique
+ $valeur = array_values($check);
+ $valeur = $valeur[0];
- return preg_match('|^[0-9a-zA-Z_-]*$|', $value);
+ return preg_match('|^[0-9a-zA-Z_-]*$|', $valeur);
}
}
.. _core-validation-rules:
-Core Validation Rules
-=====================
+Règles de validation incluses
+=============================
.. php:class:: Validation
-The Validation class in CakePHP contains many validation rules that
-can make model data validation much easier. This class contains
-many oft-used validation techniques you won’t need to write on your
-own. Below, you'll find a complete list of all the rules, along
-with usage examples.
+La classe de validation de CakePHP contient un certain nombre de règles
+prédéfinies, qui rendent la validation des données plus simple dans vos
+modèles. Cette classe contient de nombreuses règles souvent utilisées que
+vous n'aurez pas à ré-écrire vous même. Ci-dessous vous trouverez une liste
+complète de toutes les règles, illustrées par des exemples d'utilisation.
+
.. php:staticmethod:: alphaNumeric(mixed $check)
- The data for the field must only contain letters and numbers.::
+ Les données pour ce champ ne doivent contenir que chiffres et lettres::
<?php
public $validate = array(
'login' => array(
'rule' => 'alphaNumeric',
- 'message' => 'Usernames must only contain letters and numbers.'
+ 'message' => 'Les données pour ce champ ne doivent contenir que lettres et chiffres.'
)
);
+
.. php:staticmethod:: between(string $check, integer $min, integer $max)
- The length of the data for the field must fall within the specified
- numeric range. Both minimum and maximum values must be supplied.
- Uses = not.::
+ La longueur des données du champ doit être comprise dans la plage
+ numérique spécifiée. Les valeurs minimum et maximum doivent être toutes
+ les deux fournies. Cette méthode utilise <= et non <::
<?php
public $validate = array(
- 'password' => array(
+ 'mot_de_passe' => array(
'rule' => array('between', 5, 15),
- 'message' => 'Passwords must be between 5 and 15 characters long.'
+ 'message' => 'Le mot de passe doit avoir une longueur comprise entre 5 et 15 caractères.'
)
);
- The length of data is "the number of bytes in the string
- representation of the data". Be careful that it may be larger than
- the number of characters when handling non-ASCII characters.
+ La longueur des données est "le nombre d'octets dans la représentation
+ des données sous forme de chaîne". Faites attention, car elle peut être
+ plus grande que le nombre de caractères quand vous manipulez des caractères
+ non-ASCII.
.. php:staticmethod:: blank(mixed $check)
- This rule is used to make sure that the field is left blank or only
- white space characters are present in its value. White space
- characters include space, tab, carriage return, and newline.::
+ Cette règle est utilisé pour vérifier que le champ est laissé vide ou que
+ seulement des caractères blancs y sont présent. Les caractères blancs
+ incluent l'espace, la tabulation, le retour chariot et nouvelle ligne.::
<?php
public $validate = array(
@@ -490,25 +493,27 @@ with usage examples.
.. php:staticmethod:: boolean(string $check)
- The data for the field must be a boolean value. Valid values are
- true or false, integers 0 or 1 or strings '0' or '1'.::
+ Les données pour ce champ doivent être une valeur booléenne. Les valeurs
+ possibles sont : true ou false, les entiers 0 ou 1, les chaînes '0' ou
+ '1'.::
<?php
public $validate = array(
- 'myCheckbox' => array(
+ 'maCaseACocher' => array(
'rule' => array('boolean'),
- 'message' => 'Incorrect value for myCheckbox'
+ 'message' => 'Valeur incorrecte pour maCaseACocher'
)
);
.. php:staticmethod:: cc(mixed $check, mixed $type = 'fast', boolean $deep = false, string $regex = null)
- This rule is used to check whether the data is a valid credit card
- number. It takes three parameters: ‘type’, ‘deep’ and ‘regex’.
+ Cette règle est utilisée pour vérifier si une donnée est un numéro de
+ carte de crédit valide. Elle prend trois paramètres : ‘type’, ‘deep’ et
+ ‘regex’.
- The ‘type’ key can be assigned to the values of ‘fast’, ‘all’ or
- any of the following:
+ Le paramètre ‘type‘ peut être assigné aux valeurs ‘fast’, ‘all’ ou à
+ l'une des suivantes :
- amex
- bankcard
@@ -524,273 +529,276 @@ with usage examples.
- visa
- voyager
- If ‘type’ is set to ‘fast’, it validates the data against the major
- credit cards’ numbering formats. Setting ‘type’ to ‘all’ will check
- with all the credit card types. You can also set ‘type’ to an array
- of the types you wish to match.
+ Si ‘type’ est défini à ‘fast’, cela valide les données de la majorité des
+ formats numériques de cartes de crédits. Définir ‘type’ à ‘all’ vérifiera
+ tous les types de cartes de crédits. Vous pouvez aussi définir 'type’
+ comme un tableau des types que vous voulez détecter.
- The ‘deep’ key should be set to a boolean value. If it is set to
- true, the validation will check the Luhn algorithm of the credit
- card
- (`http://en.wikipedia.org/wiki/Luhn\_algorithm <http://en.wikipedia.org/wiki/Luhn_algorithm>`_).
- It defaults to false.
+ Le paramètre ‘deep’ devrait être défini comme une valeur booléenne. S'il
+ est défini à true, la validation vérifiera l'algorithme Luhn de la carte
+ de crédit
+ (`http://en.wikipedia.org/wiki/Luhn\_algorithm <http://en.wikipedia.org/wiki/Luhn_algorithm>`_).
+ Par défaut, elle est à false.
- The ‘regex’ key allows you to supply your own regular expression
- that will be used to validate the credit card number::
+ Le paramètre ‘regex’ vous permet de passer votre propre expression
+ régulière, laquelle sera utilisée pour valider le numéro de la carte de
+ crédit::
<?php
public $validate = array(
- 'ccnumber' => array(
+ 'numero_cc' => array(
'rule' => array('cc', array('visa', 'maestro'), false, null),
- 'message' => 'The credit card number you supplied was invalid.'
+ 'message' => 'Le numéro de carte de crédit que vous avez saisi était invalide.'
)
);
.. php:staticmethod:: comparison(mixed $check1, string $operator = null, integer $check2 = null)
- Comparison is used to compare numeric values. It supports “is
- greater”, “is less”, “greater or equal”, “less or equal”, “equal
- to”, and “not equal”. Some examples are shown below::
+ Comparison est utilisé pour comparer des valeurs numériques. Il supporte
+ “est supérieur”, “est inférieur”, “supérieur ou égal”, “inférieur ou
+ égal”, “égal à” et “non égal”. Quelques exemples sont indiqués
+ ci-dessous::
<?php
public $validate = array(
'age' => array(
'rule' => array('comparison', '>=', 18),
- 'message' => 'Must be at least 18 years old to qualify.'
+ 'message' => 'Vous devez avoir 18 ans au moins pour vous inscrire.'
)
);
public $validate = array(
'age' => array(
'rule' => array('comparison', 'greater or equal', 18),
- 'message' => 'Must be at least 18 years old to qualify.'
+ 'message' => 'Vous devez avoir 18 ans au moins pour vous inscrire.'
)
);
.. php:staticmethod:: custom(mixed $check, string $regex = null)
- Used when a custom regular expression is needed::
+ Utilisé quand une règle personnalisée est nécessaire::
<?php
public $validate = array(
'infinite' => array(
'rule' => array('custom', '\u221E'),
- 'message' => 'Please enter an infinite number.'
+ 'message' => 'Merci de rentrer un nombre infini.'
)
);
.. php:staticmethod:: date(string $check, mixed $format = 'ymd', string $regex = null)
- This rule ensures that data is submitted in valid date formats. A
- single parameter (which can be an array) can be passed that will be
- used to check the format of the supplied date. The value of the
- parameter can be one of the following:
-
- - ‘dmy’ e.g. 27-12-2006 or 27-12-06 (separators can be a space,
- period, dash, forward slash)
- - ‘mdy’ e.g. 12-27-2006 or 12-27-06 (separators can be a space,
- period, dash, forward slash)
- - ‘ymd’ e.g. 2006-12-27 or 06-12-27 (separators can be a space,
- period, dash, forward slash)
- - ‘dMy’ e.g. 27 December 2006 or 27 Dec 2006
- - ‘Mdy’ e.g. December 27, 2006 or Dec 27, 2006 (comma is optional)
- - ‘My’ e.g. (December 2006 or Dec 2006)
- - ‘my’ e.g. 12/2006 or 12/06 (separators can be a space, period,
- dash, forward slash)
-
- If no keys are supplied, the default key that will be used is
- ymd::
+ Cette règle s'assure que les données soumises sont des formats de date
+ valides. Un seul paramètre (qui peut être un tableau) doit être passé
+ et sera utilisé pour vérifier le format de la date soumise. La valeur
+ de ce paramètre peut être l'une des suivantes :
+
+ - ‘dmy’, par exemple : 27-12-2006 ou 27-12-06 (les séparateurs peuvent
+ être l'espace, le point, le tiret, le slash)
+ - ‘mdy’, par exemple : 12-27-2006 ou 12-27-06 (les séparateurs peuvent
+ être l'espace, le point, le tiret, le slash)
+ - ‘ymd’, par exemple : 2006-12-27 ou 06-12-27 (les séparateurs peuvent
+ être l'espace, le point, le tiret, le slash)
+ - ‘dMy’, par exemple : 27 Décembre 2006 ou 27 Déc 2006
+ - ‘Mdy’, par exemple : Décembre 27, 2006 ou Déc 27, 2006 (la virgule
+ est optionnelle)
+ - ‘My’, par exemple : (Décembre 2006 ou Déc 2006)
+ - ‘my’, par exemple : 12/2006 ou 12/06 (les séparateurs peuvent être
+ l'espace, le point, le tiret, le slash)
+
+ Si aucune clé n'est soumise, la clé par défaut 'ymd' sera utilisée::
<?php
public $validate = array(
- 'born' => array(
+ 'date_de_naissance' => array(
'rule' => array('date', 'ymd'),
- 'message' => 'Enter a valid date in YY-MM-DD format.',
+ 'message' => 'Entrez une date valide au format AA-MM-JJ.',
'allowEmpty' => true
)
);
- While many data stores require a certain date format, you might
- consider doing the heavy lifting by accepting a wide-array of date
- formats and trying to convert them, rather than forcing users to
- supply a given format. The more work you can do for your users, the
- better.
-
+ Etant donné que de nombreux moteurs de stockage réclament un certain
+ format de date, vous devriez envisager de faire le plus gros du travail
+ en acceptant un large choix de formats et en essayant de les convertir,
+ plutôt que de forcer les gens à les soumettre dans un format donné. Le
+ plus de travail vous ferez pour les utilisateurs, le mieux ce sera.
+
.. php:staticmethod:: datetime(array $check, mixed $dateFormat = 'ymd', string $regex = null)
- This rule ensures that the data is a valid datetime format. A
- parameter (which can be an array) can be passed to specify the format
- of the date. The value of the parameter can be one or more of the
- following:
-
- - ‘dmy’ e.g. 27-12-2006 or 27-12-06 (separators can be a space,
- period, dash, forward slash)
- - ‘mdy’ e.g. 12-27-2006 or 12-27-06 (separators can be a space,
- period, dash, forward slash)
- - ‘ymd’ e.g. 2006-12-27 or 06-12-27 (separators can be a space,
- period, dash, forward slash)
- - ‘dMy’ e.g. 27 December 2006 or 27 Dec 2006
- - ‘Mdy’ e.g. December 27, 2006 or Dec 27, 2006 (comma is optional)
- - ‘My’ e.g. (December 2006 or Dec 2006)
- - ‘my’ e.g. 12/2006 or 12/06 (separators can be a space, period,
- dash, forward slash)
-
- If no keys are supplied, the default key that will be used is
+ Cette règle s'assure que les données sont dans format datetime valide.
+ Un paramètre (qui peut être un tableau) peut être passé pour spécifier le
+ format de la date. La valeur du paramètre peut être une ou plusieurs des
+ valeurs suivantes:
+
+ - ‘dmy’, par exemple : 27-12-2006 or 27-12-06 (les séparateurs peuvent
+ être l'espace, le point, le tiret, le slash)
+ - ‘mdy’, par exemple : 12-27-2006 or 12-27-06 (les séparateurs peuvent
+ être l'espace, le point, le tiret, le slash)
+ - ‘ymd’, par exemple : 2006-12-27 or 06-12-27 (les séparateurs peuvent
+ être l'espace, le point, le tiret, le slash)
+ - ‘dMy’, par exemple : 27 December 2006 or 27 Dec 2006
+ - ‘Mdy’, par exemple : December 27, 2006 or Dec 27, 2006 (le point est
+ optionnel)
+ - ‘My’, par exemple : (December 2006 or Dec 2006)
+ - ‘my’, par exemple : 12/2006 or 12/06 (les séparateurs peuvent
+ être l'espace, le point, le tiret, le slash)
+
+ Si aucune clé n'est fournie, la clé par défaut qui sera utilisée est
‘ymd’::
<?php
public $validate = array(
'birthday' => array(
'rule' => array('datetime', 'dmy'),
- 'message' => 'Please enter a valid date and time.'
+ 'message' => 'Merci de rentrer une date et un time valide.'
)
);
- Also a second parameter can be passed to specify a custom regular
- expression. If this parameter is used, this will be the only
- validation that will occur.
-
- Note that unlike date(), datetime() will validate a date and a time.
+ Un second paramètre peut aussi être passé pour spécifier une expression
+ réguière personnalisée. Si un paramètre est utilisé, ce sera la seule
+ validation qui apparaitra.
+
+ Notez que au contraire de date(), datetime() validera une date et un time.
.. php:staticmethod:: decimal(integer $check, integer $places = null, string $regex = null)
- This rule ensures that the data is a valid decimal number. A
- parameter can be passed to specify the number of digits required
- after the decimal point. If no parameter is passed, the data will
- be validated as a scientific float, which will cause validation to
- fail if no digits are found after the decimal point::
+ Cette règle s'assure que la donnée est un nombre décimal valide. Un
+ paramètre peut être passé pour spécifier le nombre de décimales requises
+ après le point. Si aucun paramètre n'est passé, la donnée sera validée
+ comme un nombre scientifique à virgule flottante, entraînant une erreur
+ si aucune décimale n'est trouvée après le point::
<?php
public $validate = array(
- 'price' => array(
+ 'prix' => array(
'rule' => array('decimal', 2)
)
);
.. php:staticmethod:: email(string $check, boolean $deep = false, string $regex = null)
- This checks whether the data is a valid email address. Passing a
- boolean true as the second parameter for this rule will also
- attempt to verify that the host for the address is valid::
+ Celle-ci vérifie que la donnée soit une adresse email valide. En passant
+ un booléen true comme second paramètre de cette règle, elle tentera de
+ vérifier aussi, que l'hôte de l'adresse soit valide::
<?php
public $validate = array('email' => array('rule' => 'email'));
public $validate = array(
'email' => array(
'rule' => array('email', true),
- 'message' => 'Please supply a valid email address.'
+ 'message' => 'Merci de soumettre une adresse email valide.'
)
);
.. php:staticmethod:: equalTo(mixed $check, mixed $compareTo)
- This rule will ensure that the value is equal to, and of the same
- type as the given value.
+ Cette règle s'assurera que la valeur est égal à la valeur passée et
+ qu'elle est du même type.
::
<?php
public $validate = array(
- 'food' => array(
- 'rule' => array('equalTo', 'cake'),
- 'message' => 'This value must be the string cake'
+ 'nourriture' => array(
+ 'rule' => array('equalTo', 'gâteau'),
+ 'message' => 'Cette valeur devrait être la chaîne gâteau'
)
);
.. php:staticmethod:: extension(mixed $check, array $extensions = array('gif', 'jpeg', 'png', 'jpg'))
- This rule checks for valid file extensions like .jpg or .png. Allow
- multiple extensions by passing them in array form.
+ Cette règle vérifie les extensions valides de fichier, comme .jpg ou .png.
+ Permet la vérification d'extensions multiples, en les passant sous forme
+ de tableau.
::
<?php
public $validate = array(
'image' => array(
'rule' => array('extension', array('gif', 'jpeg', 'png', 'jpg')),
- 'message' => 'Please supply a valid image.'
+ 'message' => 'Merci de soumettre une image valide.'
)
);
.. php:staticmethod:: inList(string $check, array $list)
- This rule will ensure that the value is in a given set. It needs an
- array of values. The field is valid if the field's value matches
- one of the values in the given array.
+ Cette règle s'assurera que la valeur est dans un ensemble donné. Elle
+ nécessite un tableau des valeurs. Le champ est valide si sa valeur
+ vérifie l'une des valeurs du tableau donné.
- Example::
+ Exemple::
<?php
public $validate = array(
- 'function' => array(
- 'allowedChoice' => array(
+ 'fonction' => array(
+ 'choixAutorise' => array(
'rule' => array('inList', array('Foo', 'Bar')),
- 'message' => 'Enter either Foo or Bar.'
+ 'message' => 'Entrez soit Foo, soit Bar.'
)
)
);
.. php:staticmethod:: ip(string $check, string $type = 'both')
- This rule will ensure that a valid IPv4 or IPv6 address has been
- submitted. Accepts as option 'both' (default), 'IPv4' or 'IPv6'.
+ Cette règle s'assurera qu'une adresse IPv4 ou IPv6 valide ait été soumise.
+ Accepte 'both' en option (par défaut), 'IPv4' ou 'IPv6'.
::
<?php
public $validate = array(
- 'clientip' => array(
- 'rule' => array('ip', 'IPv4'), // or 'IPv6' or 'both' (default)
- 'message' => 'Please supply a valid IP address.'
+ 'ip_client' => array(
+ 'rule' => array('ip', 'IPv4'), // or 'IPv6' ou 'both' (default)
+ 'message' => 'Merci de soumettre une adresse IP valide.'
)
);
.. php:staticmethod:: isUnique()
- The data for the field must be unique, it cannot be used by any
- other rows.
+ La donnée pour le champ doit être unique, elle ne peut être utilisée par
+ aucune autre ligne.
::
<?php
public $validate = array(
'login' => array(
'rule' => 'isUnique',
- 'message' => 'This username has already been taken.'
+ 'message' => 'Ce nom d\'utilisateur a déjà été choisi.'
)
);
.. php:staticmethod:: luhn(string|array $check, boolean $deep = false)
- The Luhn algorithm: A checksum formula to validate a variety of
- identification numbers. See http://en.wikipedia.org/wiki/Luhn_algorithm for
- more information.
+ L'algorithme Luhn: A checksum formula to validate a variety of
+ identification numbers. Regardez
+ http://en.wikipedia.org/wiki/Luhn_algorithm pour plus d'informations.
.. php:staticmethod:: maxLength(string $check, integer $max)
- This rule ensures that the data stays within a maximum length
- requirement.
+ Cette règle s'assure que la donnée respecte la longueur maximale requise.
::
<?php
public $validate = array(
'login' => array(
'rule' => array('maxLength', 15),
- 'message' => 'Usernames must be no larger than 15 characters long.'
+ 'message' => 'Les noms d\'utilisateur ne doivent pas dépasser 15 caractères.'
)
);
@@ -814,32 +822,31 @@ with usage examples.
)
);
- The length here is "the number of bytes in the string
- representation of the data". Be careful that it may be larger than
- the number of characters when handling non-ASCII characters.
+ La longueur ici est "le nombre d'octets dans la représentation des données
+ sous forme de chaîne". Faites attention car elle pourrait être plus grande
+ que le nombre de caractères en manipulant des caractères non-ASCII.
.. php:staticmethod:: money(string $check, string $symbolPosition = 'left')
- This rule will ensure that the value is in a valid monetary
- amount.
+ Cette règle s'assurera que la valeur est une somme monétaire valide.
- Second parameter defines where symbol is located (left/right).
+ Le second paramètre définit où le symbole est situé (gauche/droite).
::
<?php
public $validate = array(
- 'salary' => array(
+ 'salaire' => array(
'rule' => array('money', 'left'),
- 'message' => 'Please supply a valid monetary amount.'
+ 'message' => 'Merci de soumettre une somme monétaire valide.'
)
);
.. php:staticmethod:: multiple(mixed $check, mixed $options = array())
- Use this for validating a multiple select input. It supports
- parameters "in", "max" and "min".
+ Utilisez cette règle pour valider un champ select multiple. Elle
+ accepte les paramètres "in", "max" et "min".
::
@@ -851,91 +858,93 @@ with usage examples.
'min' => 1,
'max' => 3
)),
- 'message' => 'Please select one, two or three options'
+ 'message' => 'Merci de choisir une, deux ou trois options'
)
);
.. php:staticmethod:: notEmpty(mixed $check)
- The basic rule to ensure that a field is not empty.::
+ La règle de base pour s'assurer qu'un champ n'est pas vide.::
<?php
public $validate = array(
- 'title' => array(
+ 'titre' => array(
'rule' => 'notEmpty',
- 'message' => 'This field cannot be left blank'
+ 'message' => 'Ce champ ne peut pas rester vide'
)
);
- Do not use this for a multiple select input as it will cause an
- error. Instead, use "multiple".
+ Ne l'utilisez pas pour un champ select multiple, sinon cela causera
+ une erreur. A la place, utilisez "multiple".
.. php:staticmethod:: numeric(string $check)
- Checks if the data passed is a valid number.::
+ Vérifie si la donnée passée est un nombre valide.::
<?php
public $validate = array(
'cars' => array(
'rule' => 'numeric',
- 'message' => 'Please supply the number of cars.'
+ 'message' => 'Merci de soumettre le nombre de voitures.'
)
);
.. php:staticmethod:: phone(mixed $check, string $regex = null, string $country = 'all')
- Phone validates US phone numbers. If you want to validate non-US
- phone numbers, you can provide a regular expression as the second
- parameter to cover additional number formats.
+ Phone valide les numéros de téléphone US. Si vous voulez valider des
+ numéros de téléphones non-US, vous pouvez fournir une expression
+ régulière comme second paramètre pour couvrir des formats de numéros
+ additionnels.
::
<?php
public $validate = array(
- 'phone' => array(
+ 'telephone' => array(
'rule' => array('phone', null, 'us')
)
);
.. php:staticmethod:: postal(mixed $check, string $regex = null, string $country = 'us')
- Postal is used to validate ZIP codes from the U.S. (us), Canada
- (ca), U.K (uk), Italy (it), Germany (de) and Belgium (be). For
- other ZIP code formats, you may provide a regular expression as the
- second parameter.
+ Postal est utilisé pour valider des codes postaux des U.S.A. (us), du
+ Canada (ca), du Royaume-Uni (uk), de l'Italie (it), d'Allemagne (de) et
+ de Belgique (be). Pour les autres formats de codes postaux, vous devez
+ fournir une expression régulière comme second paramètre.
::
<?php
public $validate = array(
- 'zipcode' => array(
+ 'code_postal' => array(
'rule' => array('postal', null, 'us')
)
);
.. php:staticmethod:: range(string $check, integer $lower = null, integer $upper = null)
- This rule ensures that the value is in a given range. If no range
- is supplied, the rule will check to ensure the value is a legal
- finite on the current platform.
+ Cette règle s'assure que la valeur est dans une fourchette donnée. Si
+ aucune fourchette n'est soumise, la règle s'assurera que la valeur est
+ un nombre limite valide pour la plateforme courante.
::
<?php
public $validate = array(
- 'number' => array(
+ 'nombre' => array(
'rule' => array('range', -1, 11),
- 'message' => 'Please enter a number between 0 and 10'
+ 'message' => 'Merci d\'entrer un nombre entre 0 et 10'
)
);
- The above example will accept any value which is larger than 0
- (e.g., 0.01) and less than 10 (e.g., 9.99).
+ L'exemple ci-dessus acceptera toutes les valeurs qui sont plus grandes que
+ 0 (par ex, 0.01) et plus petite que 10 (par ex, 9.99). Note : Les deux
+ extrémités données (-1 et 11) ne sont pas incluses !!!
.. note::
@@ -944,9 +953,9 @@ with usage examples.
.. php:staticmethod:: ssn(mixed $check, string $regex = null, string $country = null)
- Ssn validates social security numbers from the U.S. (us), Denmark
- (dk), and the Netherlands (nl). For other social security number
- formats, you may provide a regular expression.
+ Ssn valide les numéros de sécurité sociale des U.S.A. (us), du Danemark
+ (dk) et des Pays-Bas (nl). Pour les autres formats de numéros de sécurité
+ sociale, vous devez fournir une expression régulière.
::
@@ -960,42 +969,42 @@ with usage examples.
.. php:staticmethod:: time(string $check)
- Time validation, determines if the string passed is a valid time. Validates
- time as 24hr (HH:MM) or am/pm ([H]H:MM[a|p]m) Does not allow/validate
- seconds.
+ La validation du Time, détermine si une chaîne de caractères est un time
+ valide. Valide le time en 24hr (HH:MM) ou am/pm ([H]H:MM[a|p]m).
+ N'autorise/ne valide pas les secondes.
.. php:staticmethod:: url(string $check, boolean $strict = false)
- This rule checks for valid URL formats. Supports http(s), ftp(s),
- file, news, and gopher protocols::
+ Cette règle vérifie les formats valides d'URL. Elle supporte les
+ protocoles http(s), ftp(s), file, news et gopher::
<?php
public $validate = array(
- 'website' => array(
+ 'siteweb' => array(
'rule' => 'url'
)
);
- To ensure that a protocol is in the url, strict mode can be enabled
- like so::
+ Pour s'assurer qu'un protocole est présent dans l'url, le mode strict
+ mode peut être activé comme ceci::
<?php
public $validate = array(
- 'website' => array(
+ 'siteweb' => array(
'rule' => array('url', true)
)
);
.. php:staticmethod:: userDefined(mixed $check, object $object, string $method, array $args = null)
- Runs an user-defined validation.
+ Lance une validation de définition d'utilisateur.
.. php:staticmethod:: uuid(string $check)
- Checks that a value is a valid uuid: http://tools.ietf.org/html/rfc4122
+ Vérifie que la valeur est une valeur uuid valide: http://tools.ietf.org/html/rfc4122
.. toctree::
@@ -1004,5 +1013,5 @@ with usage examples.
.. meta::
- :title lang=en: Data Validation
- :keywords lang=en: validation rules,validation data,validation errors,data validation,credit card numbers,core libraries,password email,model fields,login field,model definition,php class,many different aspects,eight characters,letters and numbers,business rules,validation process,date validation,error messages,array,formatting
+ :title lang=fr: Validation des Donnnées
+ :keywords lang=fr: règles de validation,données de validation,erreurs de validation,données validation,numéros de carte de crédit,librairies du coeur,mot de passe email,champs du modèle,champ login,définition du modèle,classe php,plusieurs aspects différents,huit caractères,lettres et nombres,règles business,processus de validation,validation de date,messages d'erreurs,tableau,format
View
2 fr/models/data-validation/validating-data-from-the-controller.rst
@@ -82,4 +82,4 @@ validation du save pour éviter un deuxième contrôle::
.. meta::
:title lang=fr: Validation des données depuis un controlleur
- :keywords lang=fr: règles de mot de passe,validations,sous-ensemble,tableau,logs,logic,email,prénom nom,modèles,options,données du modèle
+ :keywords lang=fr: règles de mot de passe,validations,sous-ensemble,tableau,logs,logique,email,prénom nom,modèles,options,données du modèle
View
89 fr/models/datasources.rst
@@ -1,13 +1,13 @@
DataSources
###########
-DataSources are the link between models and the source of data that
-models represent. In many cases, the data is retrieved from a
-relational database such as MySQL, PostgreSQL or MSSQL. CakePHP is
-distributed with several database-specific datasources (see the
-class files in ``lib/Cake/Model/Datasource/Database``), a summary
-of which is listed here for your convenience:
-
+Les Sources de données (DataSources) sont les liens entre les modèles et la
+source de données qu'ils représentent. Dans de nombreux cas, les données
+sont récupérées depuis une base de données relationnelle telle MySQL,
+PostgreSQL ou MSSQL. CakePHP est distribué avec de nombreuses sources de
+données spécifiques d'une base de données (voir les fichiers de classe
+dans ``lib/Cake/Model/Datasource/Database``), un résumé de ceux-ci est listé
+ici pour votre confort :
- MySql
- Postgres
@@ -17,60 +17,63 @@ of which is listed here for your convenience:
.. note::
- You can find additional community contributed datasources in the
- `CakePHP DataSources repository at github <https://github.com/cakephp/datasources/tree/2.0>`_.
+ Vous pouvez trouver des sources de données de contribution de la communauté
+ supplémentaites dans le
+ `Dépôt de Sources de Données CakePHP sur github <https://github.com/cakephp/datasources/tree/2.0>`_.
-When specifying a database connection configuration in
-``app/Config/database.php``, CakePHP transparently uses the corresponding
-database datasource for all model operations. So, even though you might not have
-known about datasources, you've been using them all along.
+Quand vous spécifiez une configuration de connexion à une base de données
+dans ``app/Config/database.php``, CakePHP utilise de manière transparente la
+source de données correspondant à la base de données pour toutes les
+opérations de modèle. Donc, même si vous pensiez ne rien connaître aux
+sources de données, vous les utilisez tout le temps.
-All of the above sources derive from a base ``DboSource`` class, which
-aggregates some logic that is common to most relational databases. If you decide
-to write a RDBMS datasource, working from one of these (e.g. Mysql, or Sqlite is
-your best bet.)
+Toutes les sources ci-dessus dérivent d'une classe de base ``DboSource``,
+qui agrège de la logique commune à la plupart des bases de données
+relationnelles. Si vous décidez d'écrire une source de donnée RDBMS,
+travailler à partir de l'une d'entre elles (par ex Mysql ou
+Sqlite) est plus sûr.
-Most people, however, are interested in writing datasources for external sources