Pour rappel, Drupal propose un système de droits appelés permissions en anglais. Pour réaliser des actions, un utilisateur doit posséder les droits correspondant à cette action. Par exemple, il existe un droit "modifier des articles". Si l'utilisateur n'a pas ce droit, il ne voit pas le bouton "Modifier" au-dessus des articles et s'il tape directement l'adresse dans la barre, il est redirigé vers la page 403.

Dans Drupal, on n'affecte pas les droits à des personnes mais à des rôles. Par défaut, il existe 3 types de rôles : Administrateur, Utilisateur authentifié, et Utilisateur anonyme. Chaque rôle va disposer d'un ensemble de droit qu'il est possible de modifier. Par exemple, on peut permettre la modification des articles par les Utilisateurs authentifiés mais pas leur suppression.  Une fois les droits des rôles définis, on peut donner un ou plusieurs rôles aux utilisateurs. Drupal va permettre une gestion très fine des  droits, car il est possible de créer des rôles et des droits.

Dans ce tuto Drupal, nous allons voir comment un module peut, lors de son installation :

• créer un rôle et les droits correspondants.
• appliquer ce rôle à des utilisateurs.

créer un rôle et les droits correspondants.

Un rôle est une entité. Il est donc possible le créer avec un fichier yaml qui est rajouté dans le répertoire config/install. Il est aussi possible d'utiliser Drupal console pour exporter le droit que l'on a créé à travers l'interface graphique dans le fichier config/install du module. Enfin, il est possible de créer les droits en ligne de code dans le hook_install

Création du fichier yaml

Le fichier doit porter le noom user.role.id_role.yml. Par exemple un rôle dont l'identifiant est agent aura un fichier user.role.agent.yml. Il devra contenir les clés suivantes :

• id : qui est le nom machine
• label : qui est le nom affiché dans l'interface graphique
• langcode: qui indique la langue de ce droit
• weight: qui indique l'ordre d'affichage dans l'interface graphique
• is_admin: qui donne tous les droits si elle a pour valeur true
• permissions: qui liste dans un tableau les droits rattachés à ce rôle. Il faut connaitre les noms machines des permissions. Pour cela, il est possible d'inspecter les droits avec l'outil du navigateur dans la page admin de gestion des droits. Chaque ligne possède un attribut "data-drupal-selector" dont la valeur est "edit-permissions-" + droit avec des tirets à la place des espaces. Par exemple le droit "create article content" est inscrit "edit-permissions-create-article-content"
• dependancies qui permet les éléments qui doivent être activés pour que le droit soit installé.

Par exemple le fichier suivant permet de créer le rôle agent qui a le droit de créer et modifier des contenus appelé immeuble.

langcode: fr
status: true
id: agent
label: "agent immobilier"
weight: 3
is_admin: null
dependencies:
  enforced:
    module:
      - tp5
permissions:
  - 'create immeuble content'
  - 'edit immeuble content'

On voit aussi que ce droit est rattaché au module tp5 à l'aide de la clé :

dependencies: 
  enforced: 
    module: 
      tp5

 En cas de désinstallation du module, le droit sera supprimé

Utilisation de drupal console

Si vous n'avez pas drupal console, vous pouvez lire l'article "installer drupal console"

L'outil en ligne de commande Drupal console permet de générer des fichier yaml d'un entité (comme un rôle) dans le répertoire config/install d'un module. Pour cela, il faut commencer par créer le rôle et lui affecter des droits dans l'interface graphique. Ensuite, il suffit de lancer la commande :

drupal config:export:entity

Il faut alors dans l'ordre

• indiquer le nom du module dans lequel on souhaite générer le fichier yaml
• saisir "user_role" pour indiquer que c'est un rôle que l'on veut exporter
• saisir le nom du rôle
• préciser si on veut que le rôle soit optionnel lors de l'installation du module si oui le répertoire devient config/optional à la place de config install
• indiquer si on veut garder l'identifiant du rôle. Il faut répondre non, sauf si on veut éditer ce rôle lors d'un autre export. Par contre, lors de l'import, si une autre entité porte cet identifiant, elle sera remplacé par le rôle.
• indiquer si l'on veut garder l'identifiant du site. Il faut répondre non car sinon, on ne pourra pas installer le module sur un autre site.
• indiquer si l'on veut rajouter les dépendances nécessaire dans le fichier nommodule.info.yml. Il faut répondre oui, pour obliger l'utilisateur  à installer les éléments nécessaires au module avant d'installer notre module.

Créer le rôle en ligne de commande dans le hook_install

Dans le fichier nom_module.install situé à la racine de votre module vous devez créer une entité du type user_role en appelant la méthode create de la classe Role. Ensuite il faut rajouter les permissions avec la méthode grantPermission() de la même classe. Enfin, il faut sauvegarder le rôle avec la méthode save().

Par exemple dans le module premiermo on veut créer un rôle client qui a le droit de créer des article et de modifier ses propres article . Pour cela on crée le fichier premiermo_install et on rajoute la fonction suivante :

function premiermo_install() {
  $role = \Drupal\user\Entity\Role::create([
    'id' => 'client',
    'label' => 'Client',
    'weight'=>4,
    'is_admin'=>null,
    ]);
  $role->grantPermission('create article content');
  $role->grantPermission('edit own article content');
  $role->save();

}

Les clés du tableau create sont les mêmes que celles du fichier yaml.

Attention, si vous voulez supprimer ce rôle à la désinstallation, il est nécessaire de rajouter un hook_unsinstall dans le fichier nommodule_install (oui c'est bizarre de gérer la désinstallation dans le fichier nommodule_install)

Pour supprimer le rôle client lors de la désinstallation du module premiermo, on rajoute dans le fichier premiermo_install la méthode suivante :

function tp5_uninstall() {
  $node_storage = \Drupal::entityManager()->getStorage('user_role')->load('client');
  if (!is_null($node_storage)) $node_storage->delete();
}

Le test pour vérifier si la variable $node_storage n'est pas nulle, sert au cas où l'utilisateur a supprimé le rôle. 

appliquer ce rôle à des utilisateurs.

Pour appliquer des rôles aux utilisateurs, on va charger les utilisateurs et leur appliquer le rôle avec la méthode ->addRole('id_role')

$users = \Drupal::entityTypeManager()
    ->getStorage('user')
    ->loadByProperties([
      'status' => '1'
    ]);

  foreach($users as $user) {
    $user->addRole('client');
    $user->save();
  }