Form
-
class Cake\View\Helper\FormHelper(View $view, array $config = [])
Le FormHelper prend en charge la plupart des opérations lourdes de la création
de formulaire. Le FormHelper se concentre sur la possibilité de créer des
formulaires rapidement, d’une manière qui permettra de rationaliser la
validation, la re-population et la mise en page (layout). Le FormHelper est
aussi flexible - Il va faire à peu près tout pour vous en utilisant les
conventions, ou vous pouvez utiliser des méthodes spécifiques pour ne prendre
uniquement que ce dont vous avez besoin.
Création de Formulaire
-
Cake\View\Helper\FormHelper::create(mixed $context = null, array $options = [])
$context - Le contexte pour lequel le formulaire est créé. Cela peut être
une Entity de l’ORM, un retour (ResultSet) de l’ORM, un tableau de meta-données
ou false/null (dans le cas où vous créez un formulaire qui ne serait lié à
aucun Model).
$options - Un tableau d’options et / ou d’attributs HTML.
La première méthode que vous aurez besoin d’utiliser pour tirer pleinement
profit du FormHelper est create(). Cette méthode affichera une balise
d’ouverture de formulaire.
Tous les paramètres sont optionnels. Si create() est appelée sans paramètre,
CakePHP supposera que vous voulez créer un formulaire en rapport avec le
controller courant, via l’URL actuelle. Par défaut, la méthode de soumission par
des formulaires est POST. Si vous appelez create() dans une vue pour
UsersController::add(), vous verrez la sortie suivante dans la vue:
<form method="post" action="/users/add">
L’argument $context est utilisé comme “context” du formulaire. Il y a
plusieurs contextes de formulaires intégrés et vous pouvez ajouter les vôtres,
ce que nous allons voir dans la prochaine section. Ceux intégrés correspondent
aux valeurs suivantes de $context:
Une instance Entity ou un iterateur qui mappe vers
EntityContext;
ce contexte permet au FormHelper de fonctionner avec les retours de l’ORM.
Un tableau contenant la clé schema, qui mappe vers
ArrayContext
ce qui vous permet de créer des structures simples de données pour construire
des formulaires.
null et false mappe vers
NullContext;
cette classe de contexte satisfait simplement l’interface requise par FormHelper.
Ce contexte est utile si vous voulez construire un formulaire court qui ne nécessite
pas de persistance via l’ORM.
Toutes les classes de contexte ont aussi un accès aux données requêtées,
facilitant la construction des formulaires.
Une fois qu’un formulaire a été créé avec un contexte, tous les inputs que vous
créez vont utiliser le contexte actif. Dans le cas d’un formulaire basé sur
l’ORM, FormHelper peut accéder aux données associées, aux erreurs de validation
et aux metadata du schema rendant la construction de formulaires simples. Vous
pouvez fermer le contexte actif en utilisant la méthode end(), ou en
appelant create() à nouveau. Pour créer un formulaire pour une entity,
faîtes ce qui suit:
// Si vous êtes sur /articles/add
// $article devra être une entity Article vide .
echo $this->Form->create($article);
Affichera:
<form method="post" action="/articles/add">
Celui-ci va POSTer les données de formulaire à l’action add() de
ArticlesController. Cependant, vous pouvez utiliser la même logique pour
créer un formulaire d’édition. Le FormHelper utilise l’objet Entity pour
détecter automatiquement s’il faut créer un formulaire d’ajout (add) ou un
d’édition (edit). Si l’entity fournie n’est pas “nouvelle”, le form va être créé
comme un formulaire d’édition.
Par exemple, si nous naviguons vers http://example.org/articles/edit/5,
nous pourrions faire ce qui suit:
// src/Controller/ArticlesController.php:
public function edit($id = null)
{
if (empty($id)) {
throw new NotFoundException;
}
$article = $this->Articles->get($id);
// Logique d'enregistrement
$this->set('article', $article);
}
// View/Articles/edit.ctp:
// Si $article->isNew() est false, nous aurons un formulaire d'édition
<?= $this->Form->create($article) ?>
Affichera:
<form method="post" action="/articles/edit/5">
<input type="hidden" name="_method" value="PUT" />
Note
Puisque c’est un formulaire d’édition, un champ input caché est généré
pour surcharger la méthode HTTP par défaut.
Utiliser des Validateurs Personnalisés
Les models vont souvent avoir des ensembles de validation multiples et vous
voudrez que FormHelper marque les champs nécessaires basés sur les règles de
validation spécifiques que l’action de votre controller est en train
d’appliquer. Par exemple, votre table Users a des règles de validation
spécifiques qui s’appliquent uniquement quand un compte est enregistré:
echo $this->Form->create($user, [
'context' => ['validator' => 'register']
]);
L’exemple précédent va utiliser les règles de validation définies dans le
validateur register, définies par UsersTable::validationRegister(),
pour le $user et toutes les associations liées. Si vous créez un
formulaire pour les entities associées, vous pouvez définir les règles de
validation pour chaque association en utilisant un tableau:
echo $this->Form->create($user, [
'context' => [
'validator' => [
'Users' => 'register',
'Comments' => 'default'
]
]
]);
Ce qui est au-dessus va utiliser register pour l’utilisateur, et default
pour les commentaires de l’utilisateur.
Créer des Classes de Contexte
Alors que les classes de contexte intégrées essaient de couvrir les cas
habituels que vous pouvez rencontrer, vous pouvez avoir besoin de construire
une nouvelle classe de contexte si vous utilisez un ORM différent. Dans ces
situations, vous devrez intégrer Cake\View\Form\ContextInterface . Une
fois que vous avez intégré cette interface, vous pouvez connecter votre nouveau
contexte dans le FormHelper. Il est souvent mieux de faire ceci dans un
event listener View.beforeRender, ou dans une classe de vue de
l’application:
$this->Form->addContextProvider('myprovider', function($request, $data) {
if ($data['entity'] instanceof MyOrmClass) {
return new MyProvider($request, $data);
}
});
Les fonctions de fabrique de contexte sont l’endroit où vous pouvez ajouter la
logique pour vérifier les options du formulaire pour le type d’entity approprié.
Si une donnée d’entrée correspondante est trouvée, vous pouvez retourner un
objet. Si n’y a pas de correspondance, retourne null.
Création d’éléments de Formulaire
-
Cake\View\Helper\FormHelper::control(string $fieldName, array $options = [])
$fieldName - Nom du champ (attribut name) de l’élément dans le
formulaire (exemple : 'Modelname.fieldname').
$options - Un tableau d’option qui peut inclure à la fois des Options pour la méthode control()
et des options d’autres méthodes (que la méthode control() utilise en interne
pour générer les différents éléments HTML) ainsi que attribut HTML valide.
La méthode control() vous laisse générer des inputs de formulaire. Ces inputs
incluent une div enveloppante, un label, un widget d’input, et une erreur de
validation si besoin. En utilisant les metadonnées dans le contexte du
formulaire, cette méthode va choisir un type d’input approprié pour chaque
champ. En interne, control() utilise les autres méthodes de FormHelper.
Astuce
Veuillez notez que, même si les éléments générés par la méthode control()
sont appelés des « inputs » sur cette page, techniquement parlant, la méthode
control() peut générer n’importe quel type de balise input ainsi
que tous les autres types d’éléments HTML de formulaire (select,
button, textarea)
Par défaut, la méthode control() utilisera les templates de widget suivant:
'inputContainer' => '<div class="input {{type}}{{required}}">{{content}}</div>'
'input' => '<input type="{{type}}" name="{{name}}"{{attrs}}/>'
En cas d’erreurs de validation, elle utilisera également:
'inputContainerError' => '<div class="input {{type}}{{required}} error">{{content}}{{error}}</div>'
Le type d’élément créé, dans le cas où aucune autre option n’est fournie pour
générer le type d’élément est induit par l’introspection du Model et dépendra
du datatype de la colonne en question:
- Column Type
Champ de formulaire résultant
- string, uuid (char, varchar, etc.)
text
- boolean, tinyint(1)
checkbox
- decimal
number
- float
number
- integer
number
- text
textarea
- text, avec le nom de password, passwd, ou psword
password
- text, avec le nom de email
email
- text, avec le nom de tel, telephone, ou phone
tel
- date
day, month, et year selects
- datetime, timestamp
day, month, year, hour, minute, et meridian selects
- time
hour, minute, et meridian selects
- binary
file
Le paramètre $options vous permet de choisir un type d’input spécifique si
vous avez besoin:
echo $this->Form->control('published', ['type' => 'checkbox']);
Astuce
Veuillez notez que, par défaut, générer un élément via la méthode control()
générera systématiquement un div autour de l’élément généré.
Cependant, générer le même élément mais avec la méthode spécifique du FormHelper
(par exemple $this->Form->checkbox('published');) ne générera pas, dans la
majorité des cas, un div autour de l’élément. En fonction de votre cas d’usage,
utilisez l’une ou l’autre méthode.
Un nom de classe required sera ajouté à la div enveloppante si les règles de
validation pour le champ du model indiquent qu’il est requis et ne peut pas être
vide. Vous pouvez désactiver les required automatiques en utilisant l’option
required:
echo $this->Form->control('title', ['required' => false]);
Pour empêcher la validation faite par le navigateur pour l’ensemble du
formulaire, vous pouvez définir l’option 'formnovalidate' => true pour le
bouton input que vous générez en utilisant
submit() ou définir
'novalidate' => true dans les options pour
create().
Par exemple, supposons que votre model User intègre les champs pour un
username (varchar), password (varchar), approved (datetime) and
quote (text). Vous pouvez utiliser la méthode control() du FormHelper pour
créer les bons inputs pour tous ces champs de formulaire:
echo $this->Form->create($user);
// Va générer un input type="text"
echo $this->Form->control('username');
// Va générer un input type="password"
echo $this->Form->control('password');
// En partant du principe que 'approved' est un "datetime" ou un "timestamp"
// va générer des champs Jour, mois, année, heure, minute
echo $this->Form->control('approved');
// Va générer un textarea
echo $this->Form->control('quote');
echo $this->Form->button('Ajouter');
echo $this->Form->end();
Un exemple plus complet montrant quelques options pour le champ de date:
echo $this->Form->control('birth_dt', [
'label' => 'Date de naissance',
'minYear' => date('Y') - 70,
'maxYear' => date('Y') - 18,
]);
Outre les Options pour la méthode control() pour control() vu ci-dessus,
vous pouvez spécifier n’importe quelle option des méthodes spécifiques pour le
type d’input et n’importe quel attribut HTML (par exemple onfocus).
Si vous voulez un select utilisant une relation belongsTo ou hasOne,
vous pouvez ajouter ceci dans votre controller Users (en supposant que
l’User belongsTo Group):
$this->set('groups', $this->Users->Groups->find('list'));
Ensuite, ajouter les lignes suivantes à votre template de vue de formulaire:
echo $this->Form->control('group_id', ['options' => $groups]);
Pour créer un select pour l’association belongsToMany Groups, vous pouvez
ajouter ce qui suit dans votre UsersController:
$this->set('groups', $this->Users->Groups->find('list'));
Ensuite, ajouter les lignes suivantes à votre template de vue:
echo $this->Form->control('groups._ids', ['options' => $groups]);
Si votre nom de model est composé de deux mots ou plus (ex. « UserGroup »),
quand vous passez les données en utilisant set() vous devrez nommer vos
données dans un format CamelCase (les Majuscules séparent les mots) et au pluriel comme ceci:
$this->set('userGroups', $this->UserGroups->find('list'));
Note
N’utilisez pas FormHelper::control() pour générer
les boutons submit. Utilisez plutôt
submit().
Conventions de Nommage des Champs
Lors de la création de widgets, vous devez nommer vos champs d’après leur
attribut correspondant dans l’entity du formulaire. Par exemple, si vous
créez un formulaire pour un $article, vous créez des champs nommés d’après
les propriétés. Par exemple
title, body et published.
Vous pouvez créer des inputs pour les models associés, ou pour les models
arbitraires en le passant dans association.fieldname en premier paramètre:
echo $this->Form->control('association.fieldname');
Tout point dans vos noms de champs sera converti dans des données de requête
imbriquées. Par exemple, si vous créez un champ avec un nom
0.comments.body vous aurez un nom d’attribut qui sera
0[comments][body]. Cette convention facilite la sauvegarde des données
avec l’ORM. Plus de détails pour tous les types d’associations se trouvent
dans la section Créer des Inputs pour les Données Associées.
Lors de la création d’inputs de type datetime, FormHelper va ajouter un
suffixe au champ. Vous pouvez remarquer des champs supplémentaires nommés
year, month, day, hour, minute, ou meridian qui
ont été ajoutés. Ces champs seront automatiquement convertis en objets
DateTime quand les entities sont triées.
Options pour la méthode control()
FormHelper::control() supporte un nombre important d’options via son
paramètre $options. En plus de ses propres options, control()
accepte des options pour les champs input générés (et les autres type d’éléments
comme les checkbox ou les textarea), comme les attributs HTML. Ce qui
suit va couvrir les options spécifiques de FormHelper::control().
$options['type'] - Une chaîne qui précise le type de widget à générer.
En plus des types de champs vus dans Création d’éléments de Formulaire, vous
pouvez aussi créer input de type file, password et tous les types
supportés par HTML5. En spécifiant vous-même le type de l’élément à générer,
vous écraserez le type automatique deviné par l’introspection du Model. Le défaut
est null:
echo $this->Form->control('field', ['type' => 'file']);
echo $this->Form->control('email', ['type' => 'email']);
Affichera:
<div class="input file">
<label for="field">Field</label>
<input type="file" name="field" value="" id="field" />
</div>
<div class="input email">
<label for="email">Email</label>
<input type="email" name="email" value="" id="email" />
</div>
$options['label'] Soit une chaîne qui sera utilisé comme valeur pour
l’élément HTML <label> ou bien un tableau d’options pour le label.
Le défaut est null.
Par exemple:
echo $this->Form->control('name', [
'label' => 'The User Alias'
]);
Affiche :
<div class="input">
<label for="name">The User Alias</label>
<input name="name" type="text" value="" id="name" />
</div>
Vous pouvez définir cette clé à false pour désactiver l’affichage de
l’élément <label>
Par exemple:
echo $this->Form->control('name', ['label' => false]);
Affiche :
<div class="input">
<input name="name" type="text" value="" id="name" />
</div>
Si vous passez un tableau, vous pourrez fournir des options supplémentaires pour
l’element label. Si vous le faîtes, vous pouvez utiliser une clé text
dans le tableau pour personnaliser le texte du label::
Par exemple:
echo $this->Form->control('name', [
'label' => [
'class' => 'thingy',
'text' => 'The User Alias'
]
]);
Affiche :
<div class="input">
<label for="name" class="thingy">The User Alias</label>
<input name="name" type="text" value="" id="name" />
</div>
$options['options'] - Vous pouvez passez à cette option un tableau contenant
les choix pour les éléments comme les radio et les select. Reportez vous
à Créer des Boutons Radio et Créer des Select pour plus de détails.
Les défaut est null.
$options['error'] Utiliser cette clé vous permettra de transformer
les messages de model par défaut et de les utiliser, par exemple, pour
définir des messages i18n. Pour désactiver le rendu des messages d’erreurs
définissez la clé error à false:
echo $this->Form->control('name', ['error' => false]);
Pour surcharger les messages d’erreurs du model utilisez un tableau
avec les clés respectant les messages d’erreurs de validation originaux:
$this->Form->control('name', [
'error' => ['Not long enough' => __('This is not long enough')]
]);
Comme vu précédemment, vous pouvez définir le message d’erreur pour chaque
règle de validation dans vos models. De plus, vous pouvez fournir des
messages i18n pour vos formulaires.
$options['nestedInput'] - Utilisez avec les inputs checkbox et radio.
Cette option permet de contrôler si les éléments input doivent être générés
dans ou à l’extérieur de l’élément label. Quand control() génère une
checkbox ou un bouton radio, vous pouvez définir l’option à false pour
forcer la génération de l’élément input en dehors du label.
Cependant, vous pouvez également la définir à true pour n’importe quel type
d’élément pour forcer la génération de l’élément input dans le label.
Si vous changez l’option pour les boutons radio, vous aurez également besoin de
modifier le template par défaut “radioWrapper”.
En fonction du type d’élément à générer, la valeur par défaut sera true
ou false.
$options['templates'] - Les templates à utiliser pour cet input.
N’importe quel template spécifié via cette option surchargera les templates
déjà chargés. Cette option accepte soit un nom de fichier (sans extension)
provenant de /config qui contient les templates à charger ou bien un
tableau définissant les templates à utiliser.
$options['labelOptions'] - Définissez l’option à false pour désactiver
les label autour des nestedWidgets ou bien définissez un tableau
d’attributs à appliquer à l’élément label.
Créer les Labels
-
Cake\View\Helper\FormHelper::label(string $fieldName, string $text, array $options)
$fieldName - Le name du champ sous la forme 'Modelname.fieldname'.
$text - Chaîne optionnelle pour définir le texte du label.
$options - Optionel. Chaîne ou tableau qui peut contenir n’importe laquelle
des options générales ainsi que n’importe quel
attribut HTML valide.
Crée un élément label. $fieldName est utilisé pour générer l’attribut for.
Si $text n’est pas défini, $fieldName sera utilisé pour définir le texte
du label:
echo $this->Form->label('User.name');
echo $this->Form->label('User.name', 'Your username');
Affichera :
<label for="user-name">Name</label>
<label for="user-name">Your username</label>
Avec le troisième paramètre $options, vous pouvez définir un
id ou une classe:
echo $this->Form->label('User.name', null, ['id' => 'user-label']);
echo $this->Form->label('User.name', 'Your username', ['class' => 'highlight']);
Affichera:
<label for="user-name" id="user-label">Name</label>
<label for="user-name" class="highlight">Your username</label>
Afficher et vérifier les erreurs
FormHelper expose quelques méthodes qui vous permette de facilement vérifier
si vos champs contiennent des erreurs ou pour afficher des messages d’erreur
personnalisés.
Afficher les Erreurs
-
Cake\View\Helper\FormHelper::error(string $fieldName, mixed $text, array $options)
$fieldName - Le name du champ sous la forme 'Modelname.fieldname'.
$text - Optionnel. Une chaîne ou un tableau fournissant le(s) message(s)
d’erreur. Si c’est un tableau, cela devra être un tableau de paire clé / valeur
où la clé est le nom du champ en erreur et la valeur le message associé.
Défaut à null.
$options - Tableau optionnel qui ne peut contenir qu’une clé escape
qui attend un booléen et qui permet de définir si le contenu HTML du message
d’erreur doit être échappé ou non. Défaut à true.
Affiche un message d’erreur de validation, spécifiée par $text, pour
le champ donné, dans le cas où une erreur de validation a eu lieu. Si $text
n’est pas fourni alors le message de validation par défaut pour le type de champ
sera utilisé.
Cette méthode utilise les templates de widgets suivant:
'error' => '<div class="error-message">{{content}}</div>'
'errorList' => '<ul>{{content}}</ul>'
'errorItem' => '<li>{{text}}</li>'
Les templates 'errorList' et 'errorItem' sont utilisés pour formater
plusieurs messages d’erreur pour un seul champ.
Exemple:
// Dans TicketsTable vous avez une règle de validation 'notEmpty' :
public function validationDefault(Validator $validator)
{
$validator
->requirePresence('ticket', 'create')
->notEmpty('ticket');
}
// Dans Templates/Tickets/add.ctp vous avez :
echo $this->Form->text('ticket');
if ($this->Form->isFieldError('ticket')) {
echo $this->Form->error('ticket', 'Message d\'erreur 100% personnalisé !');
}
Si vous soumettez le formulaire sans fournir de valeur pour le champ Ticket,
votre formulaire affichera :
<input name="ticket" class="form-error" required="required" value="" type="text">
<div class="error-message">Message d'erreur 100% personnalisé !</div>
Note
En utilisant control(), les erreurs
sont rendues par défaut, donc vous n’aurez pas besoin d’utiliser isFieldError()
ou d’appeler error() manuellement.
Vérifier la Présence d’Erreurs
-
Cake\View\Helper\FormHelper::isFieldError(string $fieldName)
Retourne true si le champ $fieldName fourni a une erreur de validation en
cours. Sinon, retournera false:
if ($this->Form->isFieldError('gender')) {
echo $this->Form->error('gender');
}
Note
En utilisant control(), les
erreurs sont retournées par défaut.
Création des boutons et des éléments submit
Créer des éléments Submit
-
Cake\View\Helper\FormHelper::submit(string $caption, array $options)
$caption - Chaîne optionnelle qui permet de fournir le texte à afficher
ou le chemin vers une image pour le bouton. Défaut à 'Submit'.
$options - Optionel. Chaîne ou tableau qui peut contenir n’importe laquelle
des options générales ainsi que n’importe quel
attribut HTML valide.
Crée un input submit avec le texte $caption. Si la $caption
fournie est l’URL d’une image (sous-entendu que la valeur fournie contient “://”
ou que son extension soit “.jpg, .jpe, .jpeg, .gif”), un bouton submit de
l’image sera généré (si l’image existe). Si le premier caractère est “/” alors
le chemin de l’image sera relatif à webroot, sinon, il sera relatif à webroot/img.
Par défaut, les templates de widgets utilisés sont:
'inputSubmit' => '<input type="{{type}}"{{attrs}}/>'
'submitContainer' => '<div class="submit">{{content}}</div>'
Options pour les Submit
'type' - Définissez cette option à 'reset' pour générer un bouton
« reset » (de remise à zéro) pour le formulaire. Défaut à 'submit'.
'templateVars' - Utilisez ce tableau pour fournir des templates de
variables supplémentaire pour l’élément et / ou ses conteneurs.
Tout autre paramètre sera considéré comme un attribut à l’élément HTML input.
Le code suivant:
echo $this->Form->submit('Click me');
Affichera:
<div class="submit"><input value="Click me" type="submit"></div>
Vous pouvez aussi passer une URL relative ou absolue vers une image
au paramètre caption au lieu d’un caption text:
echo $this->Form->submit('ok.png');
Affichera:
<div class="submit"><input type="image" src="/img/ok.png"></div>
Les inputs submit sont utiles quand vous avez seulement besoin de textes
basiques ou d’images. Si vous avez besoin d’un contenu de bouton plus
complexe, vous devrez plutôt utiliser button().
Créer des Boutons Indépendants et des liens POST
Créer des Boutons POST
-
Cake\View\Helper\FormHelper::postButton(string $title, mixed $url, array $options = [])
$title - Chaîne obligatoire qui sera utilisé comme texte du bouton. Notez
que, par défaut, cette valeur ne sera pas échappée.
$url - URL cible du formulaire, sous forme de chaîne ou de tableau.
$options - Optionel. Chaîne ou tableau qui peut contenir n’importe laquelle
des options générales, les options spécifiques
(ci-dessous) ainsi que n’importe quel attribut HTML valide.
Crée une balise <button> avec un <form> l’entourant qui soumet une requête
POST. De plus, par défaut, cela générera des inputs hidden pour le
SecurityComponent.
Options for POST Button
'data' - Tableau clé / valeur à passer aux inputs hidden.
'method' - La méthode de la requête à utiliser. Par exemple si vous voulez
que la requête émise simule une requête HTTP/1.1 DELETE, passez delete.
La valeur par défaut est post.
'form' - Tableau dans lequel vous pouvez passer n’importe quelle valeur
supportée par FormHelper::create().
De plus, la méthode postButton() acceptera n’importe quelle option également
valide pour la méthode button().
Par exemple
// Dans Templates/Tickets/index.ctp
<?= $this->Form->postButton('Supprimer', ['controller' => 'Tickets', 'action' => 'delete', 5]) ?>
Affichera un HTML similaire à:
<form method="post" accept-charset="utf-8" action="/Rtools/tickets/delete/5">
<div style="display:none;">
<input name="_method" value="POST" type="hidden">
</div>
<button type="submit">Supprimer</button>
<div style="display:none;">
<input name="_Token[fields]" value="186cfbfc6f519622e19d1e688633c4028229081f%3A" type="hidden">
<input name="_Token[unlocked]" value="" type="hidden">
<input name="_Token[debug]" value="%5B%22%5C%2FRtools%5C%2Ftickets%5C%2Fdelete%5C%2F1%22%2C%5B%5D%2C%5B%5D%5D" type="hidden">
</div>
</form>
Cette méthode crée un élément <form>. Donc n’utilisez pas cette méthode dans
un formulaire ouvert. Utilisez plutôt
Cake\View\Helper\FormHelper::submit() ou
Cake\View\Helper\FormHelper::button()
pour créer des boutons à l’intérieur de formulaires ouvert.
Créer des liens POST
-
Cake\View\Helper\FormHelper::postLink(string $title, mixed $url = null, array $options = [])
$title - Chaîne obligatoire qui sera utilisé comme texte du bouton. Notez
que, par défaut, cette valeur ne sera pas échappée.
$url - URL cible du formulaire, sous forme de chaîne ou de tableau.
$options - Optionel. Chaîne ou tableau qui peut contenir n’importe laquelle
des options générales, les options spécifiques
(ci-dessous) ainsi que n’importe quel attribut HTML valide.
Crée un lien HTML, mais accède à l’Url en utilisant la méthode POST (par défaut).
Requiert que JavaScript soit autorisé dans votre navigateur.
Options pour les liens POST
'data' - Tableau clé / valeur à passer aux inputs hidden.
'method' - La méthode de la requête à utiliser. Par exemple si vous voulez
que la requête émise simule une requête HTTP/1.1 DELETE, passez delete.
La valeur par défaut est post.
'confirm' - Le message de confirmation à afficher lors du clic sur le lien.
Défaut à null.
'block' - Définissez cette option à true pour ajouter le lien au
« view block » 'postLink' ou pour fournir un nom de bloc personnalisé.
Défaut à null.
De plus, la méthode postLink acceptera n’importe quelle option également
valide pour la méthode link().
Cette méthode crée un élément <form>. Si vous souhaitez utiliser cette
méthode à l’intérieur d’un formulaire existant, vous devez utiliser l’option
block pour que le nouveau formulaire soit défini en un view block
qui peut être affiché en dehors du formulaire principal.
Si vous souhaitez plutôt créer un bouton pour soumettre votre formulaire, alors vous
devriez plutôt utiliser Cake\View\Helper\FormHelper::button()
ou Cake\View\Helper\FormHelper::submit().
Note
Attention à ne pas mettre un postLink à l’intérieur d’un formulaire
ouvert. À la place, utilisez l’option block pour mettre en mémoire
tampon le formulaire dans des Utiliser les Blocks de Vues
Travailler avec SecurityComponent
Cake\Controller\Component\SecurityComponent offre plusieurs
fonctionnalités qui rendent vos formulaires plus sûrs et
plus sécurisés. En incluant simplement le SecurityComponent dans votre
controller, vous bénéficierez automatiquement des fonctionnalités de prévention
contre la falsification de formulaires.
Tel que mentionné précédemment, lorsque vous utilisez le SecurityComponent,
vous devez toujours fermer vos formulaires en utilisant
end(). Cela assurera que les
inputs spéciales _Token soient générées.
-
Cake\View\Helper\FormHelper::unlockField($name)
Déverrouille un champ en l’exemptant du hashage de SecurityComponent.
Cela autorise également à manipuler le champ via JavaScript.
Le paramètre $name doit correspondre au nom de la propriété de l’entity
pour l’input:
$this->Form->unlockField('id');
-
Cake\View\Helper\FormHelper::secure(array $fields = [], array $secureAttributes = [])
$fields - Optionnel. Un tableau contenant la liste des champs à utiliser
lors de la génération du hash. S’il n’est pas fourni, alors $this->fields
sera utilisé.
$secureAttributes - Optionnel. Un tableau d’attributs HTML à passer aux
élément input de type hidden qui seront générés.
Génère un input de type hidden avec un hash de sécurité basé sur les
champs du formulaire ou une chaîne si la sécurisation des formulaire n’est pas
utilisée.
Si l’option $secureAttributes est définie, ces attributs HTML seront utilisés
avec ceux générés par le SecurityComponent. Cela vous permet de définir des attributs
HTML spécifique en fonction de vos besoins.
