Permitindo que o usuário edite apenas determinadas páginas

Eu gostaria de permitir que determinado usuário edite apenas uma página e suas subpáginas. Como isso seria possível? Eu tentei o antigo Role Scoper, mas parece ter muitos problemas e bugs.

A primeira coisa a fazer para implementar essa tarefa é ser capaz de reconhecer qual página um usuário pode editar.

Existem diferentes maneiras de fazer isso. Poderia ser uma meta do usuário, algum valor de configuração ... Por uma questão de resposta, assumirei que existe uma função nesse estilo:

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...

}

Agora que temos uma maneira de determinar se um usuário pode editar uma página, precisamos dizer ao WordPress para usar essa função para verificar a capacidade do usuário de editar uma página.

Isso pode ser feito via 'map_meta_cap'filtro.

Algo como:

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 );

Neste ponto, precisamos apenas de uma maneira de conectar um usuário a uma ou mais páginas.

Pode haver soluções diferentes, dependendo do caso de uso.

Uma solução flexível poderia ser adicionar uma lista suspensa de páginas "raiz" (consulte wp_dropdown_pages) à tela de edição do administrador do usuário e salvar as páginas selecionadas como meta do usuário.

Poderíamos aproveitar 'edit_user_profile'para adicionar o campo suspenso de páginas e 'edit_user_profile_update'armazenar o valor selecionado como meta do usuário.

Estou certo de que neste site há orientações suficientes sobre como fazer isso em detalhes.

Quando as páginas são armazenadas como meta do usuário, a wpse_user_can_edit()função acima pode ser concluída verificando se o ID da página faz parte do valor da meta do usuário.

Removendo a capacidade de editar a página, o WordPress fará o resto: removerá qualquer link de edição do back-end e do front-end, impedirá o acesso direto ... e assim por diante.

É preciso uma pequena quantidade de código para implementar esse recurso, mesmo se você usar uma classe PHP para evitar variáveis ​​globais. Também não queria ocultar as páginas proibidas para o usuário no painel. E se eles adicionassem conteúdo que já estava no 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;
    }
}

O que o código acima faz é impedir que o seguinte funcione ou apareça conforme necessário:

1. get_edit_post_link
2. Edit Page link na barra de administração do WP que aparece nas páginas
3. Edit, Quick EditE Trashlinks rápidos que aparecem debaixo das Páginas na/wp-admin/edit.php?post_type=page

Isso funcionou na minha instalação local do WordPress 4.7. Supondo que as páginas do site não sejam alteradas com frequência, talvez seja melhor codificar os IDs da página e de suas subpáginas e remover o WP_Queryinterior do __constructmétodo. Isso economizará muito em chamadas ao banco de dados.

Se você quiser se manter afastado dos plug-ins, poderá fazer uma variação do código abaixo em um arquivo functions.php ou em um plug-in personalizado.

Existem duas partes separadas nesse código. Você só precisa usar 1 delas, mas qual delas depende da complexidade dos requisitos.

A Parte 1 está especificando um único usuário e restringindo-o a uma postagem específica.

A parte 2 permite criar um mapa de usuários e IDs de postagem e permite várias postagens

O código abaixo é apenas para uma página, mas se você quiser alterar isso para uma postagem ou um tipo de postagem personalizado, será necessário alterar a sequência $screen->id == 'page'para outra coisa.

Você pode encontrar uma referência aos IDs da tela em torno de wp-admin aqui

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' );

Eu usei User Role Editoralgumas vezes e é muito bom. Talvez isso possa ajudá-lo também. Aqui está o link Editor de Função de Usuário