Autoriser l'utilisateur à modifier uniquement certaines pages

16

Je voudrais autoriser certains utilisateurs à modifier une seule page et ses sous-pages. Comment serait-ce possible? J'ai essayé l'ancien Rôle Scoper, mais il semble avoir beaucoup de problèmes et de bugs.

naf
la source
2
J'ai supprimé votre demande de recommandation de plugin car cela rendait la question hors sujet. Oui, cela devrait être possible avec un plugin mais quand je vois des tentatives de faire des choses qui nécessitent ce type de piratage des fonctionnalités de base, je ne peux pas m'empêcher de penser que vous adoptez la mauvaise approche. Pouvez-vous expliquer le projet plus en détail?
s_ha_dum

Réponses:

14

La première chose à faire pour implémenter une telle tâche est de pouvoir reconnaître quelle page un utilisateur peut éditer.

Il existe différentes façons de procéder. Il pourrait s'agir d'une méta utilisateur, d'une certaine valeur de configuration ... Pour cette réponse, je suppose qu'une fonction existe:

function wpse_user_can_edit( $user_id, $page_id ) {

   $page = get_post( $page_id );

   // let's find the topmost page in the hierarchy
   while( $page && (int) $page->parent ) {
     $page = get_post( $page->parent );
   }

   if ( ! $page ) {
     return false;
   }

   // now $page is the top page in the hierarchy
   // how to know if an user can edit it, it's up to you...

}

Maintenant que nous avons un moyen de déterminer si un utilisateur peut modifier une page, il nous suffit de dire à WordPress d'utiliser cette fonction pour vérifier la capacité de l'utilisateur à modifier une page.

Cela peut être fait via un 'map_meta_cap'filtre.

Quelque chose comme:

add_filter( 'map_meta_cap', function ( $caps, $cap, $user_id, $args ) {

    $to_filter = [ 'edit_post', 'delete_post', 'edit_page', 'delete_page' ];

    // If the capability being filtered isn't of our interest, just return current value
    if ( ! in_array( $cap, $to_filter, true ) ) {
        return $caps;
    }

    // First item in $args array should be page ID
    if ( ! $args || empty( $args[0] ) || ! wpse_user_can_edit( $user_id, $args[0] ) ) {
        // User is not allowed, let's tell that to WP
        return [ 'do_not_allow' ];
    }
    // Otherwise just return current value
    return $caps;

}, 10, 4 );

À ce stade, nous n'avons besoin que d'un moyen de connecter un utilisateur à une ou plusieurs pages.

Il peut y avoir différentes solutions selon le cas d'utilisation.

Une solution flexible pourrait être d'ajouter une liste déroulante de pages "racine" (voir wp_dropdown_pages) à l'écran de modification de l'administrateur utilisateur et d'enregistrer les pages sélectionnées en tant que méta utilisateur.

Nous pourrions tirer parti 'edit_user_profile'de l'ajout du champ déroulant des pages et 'edit_user_profile_update'de stocker la valeur sélectionnée en tant que méta utilisateur.

Je suis sûr que dans ce site Web, il y a suffisamment de conseils sur la façon de le faire en détail.

Lorsque les pages sont stockées en tant que méta utilisateur, la wpse_user_can_edit()fonction ci-dessus peut être terminée en vérifiant si l'ID de page fait partie de la valeur méta utilisateur.

Supprimant la possibilité de modifier la page, WordPress fera le reste: supprimera tout lien de modification du backend et du frontend, empêchera l'accès direct ... et ainsi de suite.

gmazzap
la source
3
C'est bien mieux que ma réponse. Pourquoi limiter les liens d'édition lorsque vous pouvez simplement modifier les capacités de l'utilisateur et laisser WordPress s'occuper du reste?
ricotheque
vous devez utiliser "a" avant le mot "utilisateur" et non "an" car un long "u" sonne comme "yu" qui commence par une consonne.
Philip
7

Il faut une petite quantité de code pour implémenter cette fonctionnalité, même si vous utilisez une classe PHP pour éviter les variables globales. Je ne voulais pas non plus masquer les pages interdites pour l'utilisateur dans le tableau de bord. Et s'ils ajoutaient du contenu déjà sur le site?

$user_edit_limit = new NS_User_Edit_Limit(
    15,       // User ID we want to limit
    [2, 17]   // Array of parent page IDs user is allowed to edit
                 (also accepts sub-page IDs)
);

class NS_User_Edit_Limit {

    /**
     * Store the ID of the user we want to control, and the
     * posts we will let the user edit.
     */
    private $user_id = 0;
    private $allowed = array();

    public function __construct( $user_id, $allowed ) {

        // Save the ID of the user we want to limit.
        $this->user_id = $user_id;

        // Expand the list of allowed pages to include sub pages
        $all_pages = new WP_Query( array(
            'post_type' => 'page',
            'posts_per_page' => -1,
        ) );            
        foreach ( $allowed as $page ) {
            $this->allowed[] = $page;
            $sub_pages = get_page_children( $page, $all_pages );
            foreach ( $sub_pages as $sub_page ) {
                $this->allowed[] = $sub_page->ID;
            }
        }

        // For the prohibited user...
        // Remove the edit link from the front-end as needed
        add_filter( 'get_edit_post_link', array( $this, 'remove_edit_link' ), 10, 3 );
        add_action( 'admin_bar_menu', array( $this, 'remove_wp_admin_edit_link' ), 10, 1 );
        // Remove the edit link from wp-admin as needed
        add_action( 'page_row_actions', array( $this, 'remove_page_list_edit_link' ), 10, 2 );
    }

    /**
     * Helper functions that check if the current user is the one
     * we want to limit, and check if a specific post is in our
     * list of posts that we allow the user to edit.
     */
    private function is_user_limited() {
        $current_user = wp_get_current_user();
        return ( $current_user->ID == $this->user_id );
    }
    private function is_page_allowed( $post_id ) {
        return in_array( $post_id, $this->allowed );
    }

    /**
     * Removes the edit link from the front-end as needed.
     */
    public function remove_edit_link( $link, $post_id, $test ) {
        /**
         * If...
         * - The limited user is logged in
         * - The page the edit link is being created for is not in the allowed list
         * ...return an empty $link. This also causes edit_post_link() to show nothing.
         *
         * Otherwise, return link as normal.
         */
        if ( $this->is_user_limited() && !$this->is_page_allowed( $post_id ) ) {
            return '';
        }
        return $link;
    }

    /**
     * Removes the edit link from WP Admin Bar
     */
    public function remove_wp_admin_edit_link( $wp_admin_bar ) {
        /**
         *  If:
         *  - We're on a single page
         *  - The limited user is logged in
         *  - The page is not in the allowed list
         *  ...Remove the edit link from the WP Admin Bar
         */
        if ( 
            is_page() &&
            $this->is_user_limited() &&
            !$this->is_page_allowed( get_post()->ID )
        ) {
            $wp_admin_bar->remove_node( 'edit' );
        }
    }

    /**
     * Removes the edit link from WP Admin's edit.php
     */
    public function remove_page_list_edit_link( $actions, $post ) {
        /**
         * If:
         * -The limited user is logged in
         * -The page is not in the allowed list
         * ...Remove the "Edit", "Quick Edit", and "Trash" quick links.
         */
        if ( 
            $this->is_user_limited() &&
            !$this->is_page_allowed( $post->ID )
        ) {
            unset( $actions['edit'] );
            unset( $actions['inline hide-if-no-js']);
            unset( $actions['trash'] );
        }
        return $actions;
    }
}

Le code ci-dessus empêche les éléments suivants de fonctionner ou d'apparaître selon les besoins:

  1. get_edit_post_link
  2. Edit Page lien sur la barre d'administration WP qui apparaît pour les pages
  3. Edit, Quick EditEt des Trashliens rapides qui apparaissent sous les pages de/wp-admin/edit.php?post_type=page

Cela a fonctionné sur mon installation WordPress 4.7 locale. En supposant que les pages du site ne changent pas souvent, il serait préférable de coder en dur les ID de la page et de ses sous-pages, et de supprimer l' WP_Queryintérieur de la __constructméthode. Cela permettra d'économiser beaucoup sur les appels de base de données.

ricotheque
la source
+1 pour la réponse plus complète que @ Ben's mais la bonne façon de gérer les liens est de manipuler les capacités,
Mark Kaplun
Ouais, quand j'ai vu la réponse de gmazzap, j'ai fini par penser "Maintenant, pourquoi n'y ai-je pas pensé?"
ricotheque
5

Si vous vouliez vous éloigner des plugins, vous pourriez une variation du code ci-dessous dans un fichier functions.php ou un plugin personnalisé.

Il y a 2 parties séparées dans ce code, vous n'auriez besoin d'en utiliser qu'une seule, mais laquelle dépend de la complexité des exigences.

La partie 1 spécifie un seul utilisateur et les restreint à un poste spécifique.

La partie 2 vous permet de créer une carte des utilisateurs et des ID de publication et autorise plusieurs publications

Le code ci-dessous est uniquement pour une page, mais si vous voulez changer cela en un article ou un type de message personnalisé, vous devrez changer la chaîne en $screen->id == 'page'quelque chose d'autre.

Vous pouvez trouver une référence aux ID d'écran autour de wp-admin ici

function my_pre_get_posts( $query ){

    $screen = get_current_screen();
    $current_user = wp_get_current_user();

    /**
     * Specify a single user and restrict to a single page
     */
    $restricted_user_id = 10; //User ID of the restricted user
    $allowed_post_id = 1234; //Post ID of the allowed post

    $current_post_id = isset( $_GET['post'] ) ? (int)$_GET['post'] : false ;

    //Only affecting a specific user
    if( $current_user->ID !== $restricted_user_id ){
        return;
    }

    //Only Affecting EDIT page.
    if( ! $current_post_id ){
        return;
    }

    if( $screen->id == 'page' && $current_post_id !== $allowed_post_id ){
        wp_redirect( admin_url( ) );
        exit;
    }

    /**
     * Specify a map of user_id => $allowed_posts
     */
    $restrictions_map = [
        10 => [ 123 ], //Allow user ID to edit Page ID 123
        11 => [ 152, 186 ] //Allow user ID to edit Page ID 123 and 186
    ];

    if( array_key_exists( $current_user->ID, $restrictions_map ) ){

        $allowed_posts = $restrictions_map[$current_user->ID];

        if( $screen->id == 'page' && ! in_array( $current_user->ID, $allowed_posts ) ){
            wp_redirect( admin_url( ) );
            exit;
        }

    }

}
add_action( 'pre_get_posts', 'my_pre_get_posts' );
Ben Casey
la source
1
+1 car cela peut fonctionner pour faire la fonctionnalité de base, mais cela laisse toujours les liens pour modifier les pages en cours de sortie, même pour les utilisateurs qui ne peuvent pas les modifier, ce qui fait une mauvaise interface utilisateur
Mark Kaplun
-4

Je l'ai utilisé User Role Editorplusieurs fois et c'est assez bon. Cela pourrait peut-être aussi vous aider. Voici le lien Editeur de rôle utilisateur

user2319361
la source
Semble être un plugin solide, mais je ne trouve pas un moyen de restreindre un utilisateur pour modifier des pages spécifiques.
naf
Rendre les utilisateurs que vous souhaitez limiter de cette façon les utilisateurs de niveau auteur Ajoutez la capacité "edit_pages" au niveau utilisateur auteur (en utilisant l'éditeur de rôle utilisateur) Définissez l'auteur d'une page à l'utilisateur que vous souhaitez accorder le privilège de la modifier. Un utilisateur de niveau auteur ayant la capacité de edit_pages peut voir la liste des pages dans le tableau de bord, mais n'a pas la possibilité de modifier, sauf pour les pages dont il est l'auteur.
user2319361
4
Merci, cela fonctionne dans une certaine mesure. À un moment donné, je devrais peut-être avoir plusieurs utilisateurs restreints pour modifier une page spécifique, il devrait donc y avoir un moyen de définir plusieurs auteurs sur une page.
naf
Pour restreindre les utilisateurs à des pages spécifiques, vous devrez acheter le Versoin Pro. Je cherche la même chose et je l'ai découvert. wordpress.stackexchange.com/questions/191658/…
Ricardo Andres
1
Bien que ce plugin spécifique soit une chose solide en ce moment, il est probablement plus facile d'écrire du code pour le faire que de parcourir toutes les options du plugin. (si cela vous permet même de faire ce que le PO vous demande)
Mark Kaplun