Validation de l'entité Drupal 8 et données dactylographiées expliquées

Validation de l'entité Drupal 8 et données dactylographiées: une plongée profonde

Cet article explore l'API de validation d'entité de Drupal 8 et sa dépendance à l'API de données typés pour la validation robuste des données, allant au-delà des limites de l'approche basée sur la forme de Drupal 7. Nous examinerons comment ce système améliore la gestion des données programmatiques et améliore la cohérence entre différentes méthodes d'accès aux données.

Concepts clés:

• Amélioration de la validation des données: Drupal 8 exploite l'API de validation de l'entité et l'API de données typés pour rationaliser la validation des données, ce qui rend la manipulation programmatique indépendante du système de formulaire.
• API de données typées: Cette API fournit un moyen standardisé d'interagir avec les données et les métadonnées. La validation est définie et exécutée sur des objets de données tapés, incorporant les définitions de données et les plugins de type de données.
• Contraintes: Celles-ci font partie intégrante du processus de validation, en spécifiant les règles de validation appliquées aux données. Ils peuvent être ajoutés aux définitions d'entité et de champ.
• Structure des données de l'entité: DRUPAL 8 UNIFIES PROPRIÉTÉS ENTITY ET FIELD FIELD FIELDS. Les champs de base et les champs configurables utilisent tous deux des implémentations FieldItemListInterface pour gérer les données.

La nécessité d'une meilleure approche:

Drupal 7 reposait fortement sur l'API du formulaire pour la validation, ce qui s'est avéré lourd pour la validation de l'entité programmatique. Le réimplémentation de la logique de validation ou des soumissions de formulaire simulant était inefficace et a étroitement couplé l'interaction des données avec le système de formulaire. L'avènement des API REST et d'autres interfaces programmatiques de Drupal 8 a nécessité une solution plus flexible. Drupal 8 a adopté le composant de validation Symfony, en s'appuyant sur celui-ci pour s'intégrer aux données typées et au système d'entités basé sur les plugins. Cela garantit une validation cohérente sur toutes les méthodes d'interaction.

Cet article et sa suite se plongeront dans l'application pratique et l'extension de l'API de validation d'entité Drupal 8. Nous explorerons l'API de données typés sous-jacentes et fournirons des exemples de code (disponibles dans un module de démonstration dans ce dépositaire git ).

Comprendre l'API de données typés:

L'API de données typés offre une interface cohérente pour l'interaction des données. Son importance réside dans la définition et l'invocation de la validation sur les objets de données typés. Les composants clés comprennent:

• Définition des données: Définit la structure des données, les méthodes d'interaction, les paramètres et les contraintes de validation.
• Plugins de type de données: Fournir des mécanismes pour obtenir et définir des valeurs en fonction du type de données. Ils utilisent les instances de définition des données fournies par le gestionnaire de plugin.

Exemple:

<code class="language-php">$definition = DataDefinition::create('string')
    ->addConstraint('Length', array('max' => 20));

$string_typed_data = \Drupal::typedDataManager()->create($definition, 'my string');</code>

Cela crée une définition de données de chaîne avec une contrainte de longueur maximale, puis utilise le TypedDataManager pour créer une instance de plugin StringData. La méthode validate() sur cette instance déclenche la validation par rapport aux contraintes définies, renvoyant un ConstraintViolationList.

Données et entités de contenu dactylographiées:

Drupal 8 intègre les propriétés d'entité et les champs API de champ. Bien que certains champs soient des champs de base (essentiellement les anciennes propriétés d'entité), d'autres sont configurables. Chaque champ utilise une implémentation FieldItemListInterface pour gérer les données, contenant généralement des plugins FieldItem, chacun étendant un plugin de type de données et utilisant une implémentation DataDefinitionInterface (souvent FieldItemDataDefinition).

Ajout de contraintes:

Les contraintes sont des plugins contenant des détails de validation, des messages d'erreur et des options de validateur. La classe Validator effectue la validation réelle.

Contraintes au niveau de l'entité: ajoutées via des annotations dans la classe d'entité. Exemple:

<code class="language-php">constraints = {
  "CommentName" = {}
}</code>

pour modifier les contraintes d'entité, utilisez hook_entity_type_alter():

<code class="language-php">function demo_entity_type_alter(array &$entity_types) {
  $node = $entity_types['node'];
  $node->addConstraint('ConstraintPluginName', ['array', 'of', 'options']);
}</code>

Contraintes au niveau du champ: Les méthodes dépendent de la personnalité ou du noyau que le type d'entité est personnalisé, et si le champ est basé ou configurable. Pour les types d'entités personnalisés, ajoutez des contraintes dans baseFieldDefinitions(). Pour les types d'entités existants, utilisez hook_entity_base_field_info_alter() pour les champs de base et hook_entity_bundle_field_info_alter() pour les champs configurables. Exemple pour un champ de base:

<code class="language-php">function demo_entity_base_field_info_alter(&$fields, EntityTypeInterface $entity_type) {
  if ($entity_type->id() === 'node') {
    $title = $fields['title'];
    $title->addPropertyConstraints('value', ['Length' => ['max' => 5]]);
  }
}</code>

Conclusion et étapes suivantes:

Cet article fournit une compréhension fondamentale de la validation de l'entité de Drupal 8 et des API de données typées. La partie suivante se plongera dans le processus de validation lui-même, gérera les violations et la création de contraintes et de validateurs personnalisés.

(La section FAQ fournie est omise ici en raison de contraintes de longueur, mais elle pourrait être intégrée en tant que section distincte.)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!