WordPress, les rôles et droits utilisateurs

WordPress, les rôles et droits utilisateurs

Tech web
Cloche d'abonnement aux notifications | |
  • Recevoir les notifications

Vous développez une solution WordPress ? Vous souhaitez personnaliser l’aspect multi-utilisateur, avec des rôles, des permissions et tutti quanti ? Vous êtes au bon endroit.

  1. Les bases
    1. Créer un rôle
    2. Supprimer un rôle
    3. Ajouter des capabilities (droits utilisateurs) à un rôle
  2. Pour aller plus loin
    1. Créer des capabilities (droits utilisateurs) pour un custom post
    2. Limiter une action à un certain type de rôle
    3. Cacher des éléments du panneau d'administration pour certains rôles
    4. Définir une capability (droit utilisateur) pour une page d'options ACF
  3. Sources

 

Les bases

Le système WordPress fonctionne de la manière suivante. Un utilisateur est pourvu d’un rôle, celui-ci va définir les droits qu’il dispose. Ces permissions sont appelés : capabilities.

De base, WordPress propose quelques rôles par défaut, comme le fameux Administrateur, qui a les droits totaux sur l’ensemble du backend, l’Auteur qui lui peut rédiger des posts, etc.

Si vous développez un site WordPress vitrine, en utilisant les posts par défaut, ces rôles peuvent largement suffire. Cependant, si votre projet nécessite un système multi-user plus complexe avec différents custom posts, savoir créer des rôles et leur octroyer des capabilities vous sera fort précieux.

Dans WordPress, les utilisateurs ne peuvent avoir qu’un seul rôle chacun. Je vous conseille vivement de respecter cette règle. Néanmoins, si vous désirez vraiment bypasser ce concept, il existe différents plugins déjà tout prêts. Vous pouvez également développer une petite surcouche maison.

 

Créer un rôle

Tout d’abord, à la racine de notre thème nous allons créer un fichier qui contiendra les nouveaux rôles. Appelons-le user_roles.php.

Pour que ce fichier soit déclenché, nous devons l’inclure dans le fameux fichier functions.php. Ajoutons-y la ligne suivante :

include ('user_roles.php');

Pour l’exercice, nous allons créer un rôle que nous allons nommer Membre. Dans le fichier user_roles.php, commençons par ajouter le code suivant :

$result = add_role( 'membre', __(
    'Membre' ),
    array(
     )
);

Laissons le array vide pour l’instant. C’est dans celui-ci que nous allons ajouter les droits utilisateurs.

Quand nous sommes en phase de développement, il est d’usage, avant de créer un rôle, de commencer par le supprimer. Cette pratique permet d’éviter d’éventuelles erreurs. Pour cela, nous devons ajouter le code suivant, juste avant le code précédent $result = …

if( get_role('membre') ){
      remove_role( 'membre' );
}

Lorsque votre projet passera en production, vous pourrez enlever ces lignes afin de gagner en performance.

 

Supprimer un rôle

Afin d’éviter de se retrouver avec une multitude de rôles qui ne sont finalement pas forcément utiles, vous pouvez supprimer un rôle créé par défaut par WordPress.

Pour cela, dans le fichier créé précédemment, à savoir user_roles.php, nous allons ajouter la ligne suivante :

if( get_role('author') ){
      remove_role( 'author' );
}

Comme vous l’aurez compris, ce bout de code va supprimer le rôle auteur (author en anglais). Si vous désirez écarter d’autres rôles, il vous suffit de dupliquer ce code et de remplacer author par le nom d’un autre rôle.

Attention à bien utiliser les noms des rôles anglais, sans quoi cela ne va pas fonctionner. La liste des rôles est consultable ici.

À leur installation, certains plugins ajoutent des rôles. Si ceux-ci ne sont pas les bienvenus, consultez la documentation du plugin pour repérer le nom du/des rôle/s et supprimez-le/les avec la méthode que nous venons de découvrir. Par exemple, le plugin de SEO Yoast, crée deux rôles, à savoir wpseo_editor et wpseo_manager. Pour les supprimer nous ajouterons à notre fichier user_roles.php :

if ( get_role('wpseo_manager') ) {
      remove_role( 'wpseo_manager' );
}
if ( get_role('wpseo_editor') ) {
      remove_role( 'wpseo_editor' );
}

 

Ajouter des capabilities (droits utilisateurs) à un rôle

Il existe des capabilities de base créées par WordPress. Par exemple, upload_files pour téléverser un fichier, activate_plugins pour avoir le droit d’activer les plugins, etc. La liste de ces droits utilisateurs créés par défaut est disponible ici.

Imaginons que nous désirons décerner le droit de téléverser un fichier ainsi que celui d’activer des plugins à notre rôle membre. Pour cela, il suffit d’ouvrir notre fichier user_roles.php et d’ajouter dans le array de la fonction de création du rôle membre les capabilities en spécifiant celles-ci à true.

$result = add_role( 'membre', __(
    'Membre' ),
    array(
      'upload_files'           => true,
      'activate_plugins'       => true,
    )
);

Si une capability n’est pas affectée, celle-ci se comporte comme un false (donc non octroyée).

 

Pour aller plus loin

Les chapitres suivants sont dédiés aux personnes ayant l’habitude de travailler avec WordPress.

 

Créer des capabilities (droits utilisateurs) pour un custom post

Passons aux choses sérieuses, imaginons que nous avons créé un custom post nommé document. Nous allons maintenant lui créer différentes capabilities et les attribuer à notre rôle membre.

Pour ce faire, rendez-vous dans le fichier gérant le custom post, et dans l’array gérant les arguments ($args = array(…. ) ajoutons une ligne capabilities ouvrant un nouvel array dans lequel nous allons nommer les droits utilisateurs.

…
'capabilities' => array(
   'edit_post'                   => 'edit_document',
   'read_post'                   => 'read_document',
   'delete_post'                 => 'delete_document',
   'edit_posts'                  => 'edit_documents',
   'edit_others_posts'           => 'edit_others_documents',
   'read_others_posts'           => 'read_others_documents',
   'publish_posts'               => 'publish_documents',
   'publish_pages'               => 'publish_pages_documents',
   'read_private_posts'          => 'read_private_documents',
   'create_posts'                => 'create_private_documents',
   'edit_published_posts'        => 'edit_published_documents',
   'delete_published_posts'      => 'delete_published_documents',
   'delete_others_posts'         => 'delete_others_documents',
   'edit_private_posts'          => 'edit_private_documents',
   'delete_private_posts'        => 'delete_private_documents',
),
…

Pour pouvoir éditer un document, l’utilisateur devra dorénavant avoir un rôle qui contient la permission edit_document.

Ajoutons ces droits liés au custom post document à notre rôle membre. Pour cela, rendons-nous dans le fichier user_roles.php et insérons les capabilities dans l’array dédié.

$result = add_role( 'membre', __(
    'Membre' ),
    array(
       'upload_files'                 => true,
       'activate_plugins'             => true,
       'edit_document'                => true,
       'read_document'                => true,
       'delete_document'              => true,
       'edit_documents'               => true,
       'edit_others_documents'        => false,
       'read_others_documents'        => true,
       'publish_documents'            => true,
       'publish_pages_documents'      => true,
       'read_private_documents'       => true,
       'create_private_documents'     => true,
       'edit_published_documents'     => true,
       'delete_published_documents'   => true,
       'delete_others_documents'      => false,
       'edit_private_documents'       => true,
       'delete_private_documents'     => true,
     )
);

Nous les avons tous passé à true sauf edit_others_documents ainsi que delete_others_documents, car nous ne souhaitons pas qu’un membre puisse modifier et/ou supprimer les documents des autres membres.

Pour octroyer ces nouvelles capabilities à un rôle par défaut, nous allons tout d’abord utiliser get_role() pour sélectionner le rôle, puis add_cap() dans une boucle foreach() pour y distribuer les permissions utilisateurs. La boucle foreach n'est évidemment pas obligatoire, puisque nous pourrions passer les capabilities une à une en dupliquant add_cap(), mais cela encombrerait le code.

Par exemple, si nous désirions que l’administrateur du site puisse bénéficier un contrôle total sur les documents, dans le fichier user_roles.php, nous ajouterions le code suivant :

$role_administrateur = get_role( 'administrator' );
$capabilities_admin = array(
    'edit_document',
    'read_document',
    'delete_document',
    'edit_documents',
    'edit_others_documents',
    'read_others_documents',
    'publish_documents',
    'publish_pages_documents',
    'read_private_documents',
    'create_private_documents',
    'edit_published_documents',
    'delete_published_documents',
    'delete_others_documents',
    'edit_private_documents',
    'delete_private_documents',
);
 
foreach( $capabilities_admin as $capabilitie_admin ) {
        $role_administrateur->add_cap( $capabilitie_admin );
}

 

Limiter une action à un certain type de rôle

Il peut arriver que l’on doive contrôler si un utilisateur a bien un certain rôle, afin qu’il puisse accéder à une fonctionnalité, à une page, etc.

$user = wp_get_current_user();
$allowed_roles = array('administrator','membre');
if( ! array_intersect($allowed_roles, $user->roles ) ) {
   wp_redirect( home_url() );
   exit;
 }

Dans le code ci-dessus, nous redirigeons tous les utilisateurs qui n’ont pas le rôle administrator ou membre sur la page d’accueil. Ce code est à placer dans une fonction, qui elle sera ajoutée à un hook à l’aide de la fonction add_action().

Exemple :

add_action(‘nom_du_hook’, ‘nom_de_la_fonction’);

function nom_de_la_fonction(){
   …
   //Code à mettre ici
   …
};

La liste des hooks WordPress peut être consultée ici.

 

Cacher des éléments du panneau d’administration pour certains rôles

Imaginons, que nous souhaitons dissimuler un élément du dashboard aux utilisateurs qui ne font pas parties du rôle membre. Pour cela, dans functions.php, nous allons nous accrocher au hook admin_head pour y placer notre fonction. Celle-ci va tout simplement ajouter du CSS dans le panneau d’administration WordPress. Nous allons utiliser la règle CSS display :none sur l’élément à cacher (ici #menu-media).

Le hook admin_head est idéal pour ajouter du CSS au sein du panneau d’administration WordPress.

//CSS Custom pour le dashboard pour les membres
add_action('admin_head', 'projet_css_dashboard_pour_membres');
function projet_css_dashboard_pour_membres() {
    $user = wp_get_current_user();
    $allowed_roles = array('membre');
    if( array_intersect($allowed_roles, $user->roles ) ):
         echo '<style>
            #menu-media {
                  display:none;
            }
            </style>';
    endif;
}

Attention, cette technique cache visuellement certains éléments du dashboard, cependant ceux-ci sont toujours techniquement accessibles. Pour faire les choses proprement, vous allez devoir, en plus de cette méthode, utiliser également celle rencontrée dans le chapitre Limiter une action à un certain type de rôle.

 

Définir une capability (droit utilisateur) pour une page d’options ACF

Vous utilisez le plugin ACF (permet d’ajouter des champs aux posts, pages, users…) et vous désirez bloquer l’accès d’une page d’options à tous les utilisateurs sauf ceux qui appartiennent à un rôle spécifique ? Voyons ensemble comment confectionner cela.

Rendons-nous dans le fichier functions.php et créons une page d’options que nous allons appeler Options des documents.

// ACF Page d’options

if( function_exists('acf_add_options_page') ) {
    acf_add_options_page();
}

add_action('acf/init', 'register_acf_options_pages');

function register_acf_options_pages() {

    // Contrôle est-ce que la function existe
    if( !function_exists('acf_add_options_page') )
        return;

    // enregistrement de la page d’options des documents
    $option_page_documents = acf_add_options_page(array(
        'page_title'    => __('Options des documents'),
        'menu_title'    => __('Options des documents'),
        'menu_slug'     => 'options-documents',
        'redirect'      => false
    ));
}

Il nous suffit maintenant d’ajouter le paramètre capability dans notre array() de acf_add_options_page et de lui spécifier un nom (edit_options_documents par exemple)

…
    'menu_slug'     => 'options-documents',
    'capability'    => 'edit_options_documents',
    'redirect'      => false
…

Maintenant qu’une permission a été créée, vous pouvez la distribuer à différents rôles normalement, comme vu dans le chapitre Ajouter des capabilitites (droits utilisateurs) à un rôle.

 

Sources

 

Catégories :
Tech web

Tags :
PHP Wordpress

Vous avez aimé cet article ? Suivez-nous sur Facebook pour ne rien manquer !