Spanish (Español) translation by Eva Collados Pascual (you can also view the original English article)
Este es un tutorial de una serie formada por cuatro partes que cubre el tema de los usuarios, los roles y las capacidades de WordPress. La serie cubrirá la arquitectura y el diseño de los roles de usuario en WordPress; resaltará las funciones más importantes para interactuar con los usuarios y administrar roles y capacidades; y en el último tutorial, crearemos un ejemplo de la vida real que demuestra la utilidad de esta API.
Introducción
Este tutorial se centrará en la creación de una solución práctica utilizando el sistema de roles y capacidades de WordPress. Si te has perdido los dos últimos tutoriales, te sugiero encarecidamente que los revises. La primera parte "Roles y capacidades de WordPress: Lo básico" explica el diseño de este sistema; mientras que la segunda parte "Roles y capacidades de WordPress: Funciones de nota" se centra en las funciones y clases que WordPress ofrece para interactuar con el sistema.
La solución propuesta en este tutorial es la misma que estoy usando para uno de mis plugins prémium de WordPress. Lo he elegido después de probar diferentes enfoques. Es simple, breve y está encapsulado en una clase. Puedes adaptarlo fácilmente a tu propio plugin. El código está disponible en GitHub; y no tiene licencia. También viene sin garantías, y eres libre de usarlo y licenciarlo como desees.
Paso 1 El escenario
Estamos construyendo un plugin de WordPress que tiene un panel de administración especial para el cliente. Este panel de administración solo debe ser accesible para un conjunto limitado de usuarios. Estos usuarios pueden ser seleccionados por el administrador del blog. Puedes habilitar diferentes roles, usuarios o todos ellos para acceder al panel de administración o características del cliente.
Aparte de eso, necesitamos tener un acceso restringido a la Biblioteca de medios para los usuarios con acceso al Panel de cliente. WordPress tiene una capacidad especial para acceder y cargar archivos a la Biblioteca de medios: "upload_files". Sin embargo, esto proporciona al usuario (o rol) acceso completo a la Biblioteca de medios. Esto no es algo bueno, especialmente porque las fotos (o archivos) no se pueden jerarquizar en diferentes categorías de manera que puedas restringir el acceso a cada una de ellas.
Necesitamos restringir el acceso a la Biblioteca de medios solo a los archivos que el usuario haya cargado. Este no debería tener acceso a los archivos cargados por otros usuarios. Esta restricción solo debe aplicarse a los usuarios que no tengan la capacidad "upload_files". A otros usuarios y roles no les afectará esta restricción, ya que ya tienen acceso completo a la Biblioteca de medios.
Nuestro blog tendrá estas cuatro categorías de usuarios:
Los dos primeros conjuntos de usuarios son los que no tendrán acceso al panel de cliente del plugin. He destacado el hecho de que hay usuarios que tienen acceso a la Biblioteca de medios, y un conjunto que no lo hace. Es esencial que nuestra solución no afecte a las dos primeras categorías y deje sus capacidades intactas.
Con eso en mente, nuestra clase debe hacer dos cosas:
- Establecer los permisos adecuados para el tercer y cuarto conjunto de usuarios
- Habilitar un acceso restringido a la biblioteca de medios a la cuarta categoría. Debe asegurarse de que después de deshabilitar el plugin o cambiar los derechos de los usuarios, esta categoría de usuarios recupere sus permisos originales.
Paso 2 La interfaz del plugin
Antes de crear nuestra clase, tengamos una idea más profunda sobre el plugin. El plugin tiene una estructura bastante simple. Se compone de dos menús diferentes: Uno para el administrador y sirve como panel administrativo, accesible solo para usuarios con una capacidad "manage_options". El segundo menú es para clientes y da acceso al Panel de cliente. Este panel requiere una capacidad "wptuts_client_page".
Esta capacidad no existe en WordPress; necesitamos añadirla y asignarla a los usuarios o roles especificados. Pero antes de eso, echemos un vistazo al plugin.
1 |
/*
|
2 |
Plugin Name: WordPress Roles Plugin
|
3 |
Plugin URI: https://github.com/omarabid/WordPress-Roles-Plugin
|
4 |
Description: A WordPress Roles Plugin
|
5 |
Author: Abid Omar
|
6 |
Author URI: https://omarabid.com
|
7 |
Version: 1.0
|
8 |
*/
|
9 |
|
10 |
// Add an Admin user menu to the WordPress Dashboard
|
11 |
add_action('admin_menu', 'wptuts_admin_menu'); |
12 |
function wptuts_admin_menu() { |
13 |
add_menu_page('Admin Access', 'Admin Access', 'manage_options', 'wptuts-admin', 'wptuts_admin_page'); |
14 |
}
|
15 |
|
16 |
function wptuts_admin_page() { |
17 |
echo 'Admin Page'; |
18 |
}
|
19 |
|
20 |
// Add a client user menu to the WordPress Dashboard
|
21 |
add_action('admin_menu', 'wptuts_client_menu'); |
22 |
function wptuts_client_menu() { |
23 |
add_menu_page('Client Access', 'Client Access', 'wptuts_client', 'wptuts-client', 'wptuts_client_page'); |
24 |
}
|
25 |
|
26 |
function wptuts_client_page() { |
27 |
echo 'Client Page'; |
28 |
}
|
Tenemos dos ganchos de acción "admin_menu" que agregan el menú Administrador tanto para el administrador como para el cliente. Podemos acortarlo a un solo gancho que añada ambos; pero prefiero separarlos. Cada función "add_menu_page" se engancha a otra función que mostrará el contenido de la página.
A continuación, necesitamos inicializar nuestra clase Roles. El código de clase se coloca en otro archivo; y el proceso de inicialización se realiza durante el gancho "init" que se asegura de que WordPress se haya terminado de cargar.
La función constructora acepta tres parámetros:
-
$allBooleano (opcional) Si deseas dar acceso de cliente a todos los usuarios del blog, puedes establecerlo en true e ignorar los parámetros restantes. -
$rolesMatriz (opcional) Una matriz con los identificadores de los roles que tendrán acceso al panel cliente. -
$usersMatriz (opcional) Una matriz con los nombres de usuario de los usuarios que tendrán acceso al panel del cliente.
1 |
// Loads and initialize the roles class
|
2 |
add_action('init', 'wptuts_start_plugin'); |
3 |
function wptuts_start_plugin() { |
4 |
require_once('roles_class.php'); |
5 |
$all = false; |
6 |
$roles = array('subscriber'); |
7 |
$users = array(3); |
8 |
new wpttuts_roles($all, $roles, $users); |
9 |
}
|
Paso 3 La clase roles
Las propiedades
La clase solo tiene 3 propiedades: $all, $roles y $users. Estas son las mismas variables que se pasan a la función constructora. El valor de las variables no se cambia en nuestro ejemplo; pero en un caso práctico real, es posible que desees fusionarlas con otra fuente. Para ello, tienes la función set_entities. Puedes acomodarlo según tus propias necesidades.
1 |
/**
|
2 |
* @var boolean
|
3 |
*/
|
4 |
private $all; |
5 |
|
6 |
/**
|
7 |
* @var array
|
8 |
*/
|
9 |
private $roles; |
10 |
|
11 |
/**
|
12 |
* @var array
|
13 |
*/
|
14 |
private $users; |
15 |
|
16 |
/**
|
17 |
* Set the permission entities
|
18 |
*
|
19 |
* @param boolean $all
|
20 |
* @param array $roles
|
21 |
* @param array $users
|
22 |
*/
|
23 |
private function set_entities($all, $roles, $users) { |
24 |
$this->all = $all; |
25 |
$this->roles = $roles; |
26 |
$this->users = $users; |
27 |
}
|
La función constructora
En un primer paso, la función constructora inicializa las variables $all, $roles y $users mediante la función set_entitites(). A continuación, llama a una función privada para establecer las capacidades y otra para la restricción de la Biblioteca de medios. Estos son exactamente los pasos que hemos definido en nuestro escenario.
1 |
/**
|
2 |
* Creates a new instance of the Roles Class
|
3 |
*
|
4 |
* @param boolean $all
|
5 |
* @param array $roles
|
6 |
* @param array $users
|
7 |
*/
|
8 |
function __construct($all = false, $roles = array(), $users = array()) { |
9 |
// Set the allowed entities
|
10 |
$this->set_entities($all, $roles, $users); |
11 |
|
12 |
// Set the user access permission
|
13 |
$this->set_permissions(); |
14 |
|
15 |
// Media Library Filter
|
16 |
$this->media_filter(); |
17 |
}
|
Funciones estáticas
Las funciones estáticas no requieren inicialización de clase. Son similares a las funciones independientes, simplemente se vinculan a la clase especificada. He decidido mantener algunas funciones estáticas porque así se pueden utilizar de forma independiente; y es posible que las encuentre útiles en otro contexto.
Estas funciones son filter_roles() y filter_users(); que están asociadas con otras dos funciones role_has_caps() y user_has_caps(). Las funciones desempeñan el papel de un filtro. Filtran roles (o usuarios) en función de las capacidades que tengan y no tengan.
Ambas funciones aceptan dos argumentos:
-
$includeMatriz Una matriz de las capacidades que tiene el rol. -
$excludeMatriz Una matriz de capacidades que el rol no tiene.
1 |
/**
|
2 |
* Filter all roles of the blog based on capabilities
|
3 |
*
|
4 |
* @static
|
5 |
* @param array $include Array of capabilities to include
|
6 |
* @param array $exclude Array of capabilities to exclude
|
7 |
* @return array
|
8 |
*/
|
9 |
static function filter_roles($include, $exclude) { |
10 |
$filtered_roles = array(); |
11 |
global $wp_roles; |
12 |
$roles = $wp_roles->get_names(); |
13 |
foreach ($roles as $role_id => $role_name) { |
14 |
$role = get_role($role_id); |
15 |
if (self::role_has_caps($role, $include) && !self::role_has_caps($role, $exclude)) { |
16 |
$filtered_roles[] = $role_id; |
17 |
}
|
18 |
}
|
19 |
return $filtered_roles; |
20 |
}
|
21 |
|
22 |
/**
|
23 |
* Filter all users of the blog based on capabilities
|
24 |
*
|
25 |
* @static
|
26 |
* @param array $include Array of capabilities to include
|
27 |
* @param array $exclude Array of capabilities to exclude
|
28 |
* @return array
|
29 |
*/
|
30 |
static function filter_users($include, $exclude) { |
31 |
$filtered_users = array(); |
32 |
$users = get_users(); |
33 |
foreach ($users as $user) { |
34 |
$user = new WP_User($user->ID); |
35 |
if (self::user_has_caps($user, $include) && !self::user_has_caps($user, $exclude)) { |
36 |
$filtered_users[] = $user->ID; |
37 |
}
|
38 |
}
|
39 |
return $filtered_users; |
40 |
}
|
Las funciones recorren todos los roles y usuarios de la base de datos. Para cada rol (o usuario), comprueba si tiene las capacidades necesarias y si no tiene capacidades que excluir. Esta comprobación se realiza con las funciones role_has_caps() y user_has_caps().
Estas dos funciones (role_has_caps() y user_has_caps()) aceptan dos argumentos:
- $role (o $user) Cadena El identificador del rol o el ID de usuario.
- $caps Matriz Una serie de capacidades a comprobar.
Si el rol (o usuario) tiene las capacidades especificadas en la matriz $caps, la función devuelve true. En otro caso, la función devuelve false. La función básicamente recorre cada capacidad y comprueba si el rol (o usuario) tiene la capacidad especificada.
1 |
/**
|
2 |
* Returns true if a role has the capabilities in the passed array
|
3 |
*
|
4 |
* @static
|
5 |
* @param $role
|
6 |
* @param $caps
|
7 |
* @return bool
|
8 |
*/
|
9 |
static function role_has_caps($role, $caps) { |
10 |
foreach ($caps as $cap) { |
11 |
if (!$role->has_cap($cap)) { |
12 |
return false; |
13 |
}
|
14 |
}
|
15 |
return true; |
16 |
}
|
17 |
|
18 |
/**
|
19 |
* Returns true if a user has the capabilities in the passed array
|
20 |
*
|
21 |
* @static
|
22 |
* @param $user
|
23 |
* @param $caps
|
24 |
* @return bool
|
25 |
*/
|
26 |
static function user_has_caps($user, $caps) { |
27 |
foreach ($caps as $cap) { |
28 |
if (!$user->has_cap($cap)) { |
29 |
return false; |
30 |
}
|
31 |
}
|
32 |
return true; |
33 |
}
|
Adición de permisos
Este es el primer paso para imponer la ley de nuestro plugin. He distribuido la funcionalidad en 3 funciones: una para establecer permisos para todos los usuarios, otra para establecer permisos en los roles y otra para establecer permisos para los usuarios especificados. La función principal simplemente decide qué funciones llamar.
1 |
/**
|
2 |
* Set the Menu and Pages access permissions
|
3 |
*/
|
4 |
private function set_permissions() { |
5 |
$this->set_all_permissions(); |
6 |
if (!$this->all) { |
7 |
$this->set_roles_permissions(); |
8 |
$this->set_users_permissions(); |
9 |
}
|
10 |
}
|
La función set_all_permissions() recorre todos los usuarios del blog y añade (o elimina) la capacidad "wptuts_client" en función del valor de la variable $all. Obtenemos la lista completa de usuarios que utilizan la función get_users(); e inicializa un nuevo objeto WP_User para obtener acceso a las funciones add_cap() y remove_cap().
1 |
/**
|
2 |
* Set the permissions for ALL users
|
3 |
*/
|
4 |
private function set_all_permissions() { |
5 |
$users = get_users(); |
6 |
foreach ($users as $user) { |
7 |
$user = new WP_User($user->ID); |
8 |
if ($this->all) { |
9 |
$user->add_cap('wptuts_client'); |
10 |
}
|
11 |
else { |
12 |
$user->remove_cap('wptuts_client'); |
13 |
}
|
14 |
}
|
15 |
}
|
La función set_roles_permissions() recorre todos los roles del blog y elimina la capacidad "wptuts_client". Después de eso, recorre los roles de la matriz $roles y añade la capacidad "wptuts_client". El primer paso fue asegurarnos de limpiar la capacidad de los roles que pudieron haberla tenido anteriormente.
1 |
/**
|
2 |
* Set the permissions for Roles
|
3 |
*/
|
4 |
private function set_roles_permissions() { |
5 |
global $wp_roles; |
6 |
$roles = $wp_roles->get_names(); |
7 |
foreach ($roles as $role_id => $role_name) { |
8 |
$role = get_role($role_id); |
9 |
$role->remove_cap('wptuts_client'); |
10 |
}
|
11 |
if (!empty($this->roles)) { |
12 |
foreach ($this->roles as $role_id) { |
13 |
$role = get_role($role_id); |
14 |
$role->add_cap('wptuts_client'); |
15 |
}
|
16 |
}
|
17 |
}
|
La función set_users_permissions() hace lo mismo que la última función. La única diferencia es que se dirige a los usuarios en lugar de a los roles.
1 |
/**
|
2 |
* Set the permissions for specific Users
|
3 |
*/
|
4 |
private function set_users_permissions() { |
5 |
$users = get_users(); |
6 |
foreach ($users as $user) { |
7 |
$user = new WP_User($user->ID); |
8 |
$user->remove_cap('wptuts_client'); |
9 |
}
|
10 |
if (!empty($this->users)) { |
11 |
foreach ($this->users as $user_id) { |
12 |
$user = new WP_User($user_id); |
13 |
$user->add_cap('wptuts_client'); |
14 |
}
|
15 |
}
|
16 |
}
|
Filtro de Biblioteca de medios
Ahora hemos establecido los permisos adecuados para las entidades adecuadas. (Sea usuario o rol) También tenemos que restringir el acceso a la Biblioteca de medios para la cuarta categoría que distinguimos en el escenario.
Esta categoría de roles (o usuarios) tiene la capacidad "wptuts_client", pero no tiene la capacidad "upload_files". Y ahí es donde entran en juego nuestras funciones de filtro. Nos ayudarán a filtrar y devolver esta categoría de roles (o usuarios).
Para esta categoría, añadiremos dos capacidades "upload_files" y "remove_upload_files". "upload_files" dará acceso completo a la Biblioteca de medios; y la otra capacidad se usará para filtrar las entradas de la Biblioteca de medios, y también se usará para quitar la capacidad de "upload_files" una vez que también se haya eliminado la capacidad "wptuts_client".
1 |
/**
|
2 |
* Restrict Media Access
|
3 |
*/
|
4 |
private function media_filter() { |
5 |
// Apply the media filter for current Clients
|
6 |
$roles = self::filter_roles(array('wptuts_client'), array('upload_files')); |
7 |
$users = self::filter_users(array('wptuts_client'), array('upload_files')); |
8 |
$this->roles_add_cap($roles, 'upload_files'); |
9 |
$this->roles_add_cap($roles, 'remove_upload_files'); |
10 |
$this->users_add_cap($users, 'upload_files'); |
11 |
$this->users_add_cap($users, 'remove_upload_files'); |
12 |
|
13 |
// Restrict Media Library access
|
14 |
add_filter('parse_query', array(&$this, 'restrict_media_library')); |
15 |
|
16 |
// For cleaning purposes
|
17 |
$clean_roles = self::filter_roles(array('remove_upload_files'), array('wptuts_client')); |
18 |
$clean_users = self::filter_users(array('remove_upload_files'), array('wptuts_client')); |
19 |
$this->roles_remove_cap($clean_roles, 'upload_files'); |
20 |
$this->roles_remove_cap($clean_roles, 'remove_upload_files'); |
21 |
$this->users_remove_cap($clean_users, 'upload_files'); |
22 |
$this->users_remove_cap($clean_users, 'remove_upload_files'); |
23 |
}
|
Después de establecer las capacidades en esta categoría, enganchamos al filtro "parse_query". Este filtro nos permite cambiar las entradas devueltas por WP_Query. En nuestro caso, vamos a establecer la variable de la consulta "autor". Esto da como resultado la devolución de solo las entradas creadas por el autor especificado.
1 |
/**
|
2 |
* Restrict Media Library access
|
3 |
*
|
4 |
* @param $wp_query
|
5 |
*/
|
6 |
public function restrict_media_library($wp_query) { |
7 |
if (strpos($_SERVER['REQUEST_URI'], '/wp-admin/upload.php')) { |
8 |
if (current_user_can('remove_upload_files')) { |
9 |
global $current_user; |
10 |
$wp_query->set('author', $current_user->ID); |
11 |
}
|
12 |
}
|
13 |
else if (strpos($_SERVER['REQUEST_URI'], '/wp-admin/media-upload.php')) { |
14 |
if (current_user_can('remove_upload_files')) { |
15 |
global $current_user; |
16 |
$wp_query->set('author', $current_user->ID); |
17 |
}
|
18 |
}
|
19 |
}
|
El código completo
1 |
if (!class_exists('wpttuts_roles')) { |
2 |
class wpttuts_roles { |
3 |
/**
|
4 |
* Determines if all users will have the required permissions
|
5 |
*
|
6 |
* @var boolean
|
7 |
*/
|
8 |
private $all; |
9 |
|
10 |
/**
|
11 |
* An array with the roles which have the required permissions
|
12 |
*
|
13 |
* @var array
|
14 |
*/
|
15 |
private $roles; |
16 |
|
17 |
/**
|
18 |
* An array with the user names which have the required permissions
|
19 |
*
|
20 |
* @var array
|
21 |
*/
|
22 |
private $users; |
23 |
|
24 |
/**
|
25 |
* Creates a new instance of the Roles Class
|
26 |
*
|
27 |
* @param boolean $all
|
28 |
* @param array $roles
|
29 |
* @param array $users
|
30 |
*/
|
31 |
function __construct($all = false, $roles = array(), $users = array()) { |
32 |
// Set the allowed entities
|
33 |
$this->set_entities($all, $roles, $users); |
34 |
|
35 |
// Set the user access permission
|
36 |
$this->set_permissions(); |
37 |
|
38 |
// Media Library Filter
|
39 |
$this->media_filter(); |
40 |
}
|
41 |
|
42 |
/**
|
43 |
* Set the permission entities
|
44 |
*
|
45 |
* @param boolean $all
|
46 |
* @param array $roles
|
47 |
* @param array $users
|
48 |
*/
|
49 |
private function set_entities($all, $roles, $users) { |
50 |
$this->all = $all; |
51 |
$this->roles = $roles; |
52 |
$this->users = $users; |
53 |
}
|
54 |
|
55 |
/**
|
56 |
* Set the Menu and Pages access permissions
|
57 |
*/
|
58 |
private function set_permissions() { |
59 |
$this->set_all_permissions(); |
60 |
if (!$this->all) { |
61 |
$this->set_roles_permissions(); |
62 |
$this->set_users_permissions(); |
63 |
}
|
64 |
}
|
65 |
|
66 |
/**
|
67 |
* Set the permissions for ALL users
|
68 |
*/
|
69 |
private function set_all_permissions() { |
70 |
$users = get_users(); |
71 |
foreach ($users as $user) { |
72 |
$user = new WP_User($user->ID); |
73 |
if ($this->all) { |
74 |
$user->add_cap('wptuts_client'); |
75 |
}
|
76 |
else { |
77 |
$user->remove_cap('wptuts_client'); |
78 |
}
|
79 |
}
|
80 |
}
|
81 |
|
82 |
/**
|
83 |
* Set the permissions for Roles
|
84 |
*/
|
85 |
private function set_roles_permissions() { |
86 |
global $wp_roles; |
87 |
$roles = $wp_roles->get_names(); |
88 |
foreach ($roles as $role_id => $role_name) { |
89 |
$role = get_role($role_id); |
90 |
$role->remove_cap('wptuts_client'); |
91 |
}
|
92 |
if (!empty($this->roles)) { |
93 |
foreach ($this->roles as $role_id) { |
94 |
$role = get_role($role_id); |
95 |
$role->add_cap('wptuts_client'); |
96 |
}
|
97 |
}
|
98 |
}
|
99 |
|
100 |
/**
|
101 |
* Set the permissions for specific Users
|
102 |
*/
|
103 |
private function set_users_permissions() { |
104 |
$users = get_users(); |
105 |
foreach ($users as $user) { |
106 |
$user = new WP_User($user->ID); |
107 |
$user->remove_cap('wptuts_client'); |
108 |
}
|
109 |
if (!empty($this->users)) { |
110 |
foreach ($this->users as $user_id) { |
111 |
$user = new WP_User($user_id); |
112 |
$user->add_cap('wptuts_client'); |
113 |
}
|
114 |
}
|
115 |
}
|
116 |
|
117 |
/**
|
118 |
* Restrict Media Access
|
119 |
*/
|
120 |
private function media_filter() { |
121 |
// Apply the media filter for currenct AdPress Clients
|
122 |
$roles = self::filter_roles(array('wptuts_client'), array('upload_files')); |
123 |
$users = self::filter_users(array('wptuts_client'), array('upload_files')); |
124 |
$this->roles_add_cap($roles, 'upload_files'); |
125 |
$this->roles_add_cap($roles, 'remove_upload_files'); |
126 |
$this->users_add_cap($users, 'upload_files'); |
127 |
$this->users_add_cap($users, 'remove_upload_files'); |
128 |
|
129 |
// Restrict Media Library access
|
130 |
add_filter('parse_query', array(&$this, 'restrict_media_library')); |
131 |
|
132 |
// For cleaning purposes
|
133 |
$clean_roles = self::filter_roles(array('remove_upload_files'), array('wptuts_client')); |
134 |
$clean_users = self::filter_users(array('remove_upload_files'), array('wptuts_client')); |
135 |
$this->roles_remove_cap($clean_roles, 'upload_files'); |
136 |
$this->roles_remove_cap($clean_roles, 'remove_upload_files'); |
137 |
$this->users_remove_cap($clean_users, 'upload_files'); |
138 |
$this->users_remove_cap($clean_users, 'remove_upload_files'); |
139 |
}
|
140 |
|
141 |
/**
|
142 |
* Add a capability to an Array of roles
|
143 |
*
|
144 |
* @param $roles
|
145 |
* @param $cap
|
146 |
*/
|
147 |
private function roles_add_cap($roles, $cap) { |
148 |
foreach ($roles as $role) { |
149 |
$role = get_role($role); |
150 |
$role->add_cap($cap); |
151 |
}
|
152 |
}
|
153 |
|
154 |
/**
|
155 |
* Add a capability to an Array of users
|
156 |
*
|
157 |
* @param $users
|
158 |
* @param $cap
|
159 |
*/
|
160 |
private function users_add_cap($users, $cap) { |
161 |
foreach ($users as $user) { |
162 |
$user = new WP_User($user); |
163 |
$user->add_cap($cap); |
164 |
}
|
165 |
}
|
166 |
|
167 |
/**
|
168 |
* Remove a capability from an Array of roles
|
169 |
*
|
170 |
* @param $roles
|
171 |
* @param $cap
|
172 |
*/
|
173 |
private function roles_remove_cap($roles, $cap) { |
174 |
foreach ($roles as $role) { |
175 |
$role = get_role($role); |
176 |
$role->remove_cap($cap); |
177 |
}
|
178 |
}
|
179 |
|
180 |
/**
|
181 |
* Remove a capability from an Array of users
|
182 |
*
|
183 |
* @param $users
|
184 |
* @param $cap
|
185 |
*/
|
186 |
private function users_remove_cap($users, $cap) { |
187 |
foreach ($users as $user) { |
188 |
$user = new WP_User($user); |
189 |
$user->remove_cap($cap); |
190 |
}
|
191 |
}
|
192 |
|
193 |
/**
|
194 |
* Filter all roles of the blog based on capabilities
|
195 |
*
|
196 |
* @static
|
197 |
* @param array $include Array of capabilities to include
|
198 |
* @param array $exclude Array of capabilities to exclude
|
199 |
* @return array
|
200 |
*/
|
201 |
static function filter_roles($include, $exclude) { |
202 |
$filtered_roles = array(); |
203 |
global $wp_roles; |
204 |
$roles = $wp_roles->get_names(); |
205 |
foreach ($roles as $role_id => $role_name) { |
206 |
$role = get_role($role_id); |
207 |
if (self::role_has_caps($role, $include) && !self::role_has_caps($role, $exclude)) { |
208 |
$filtered_roles[] = $role_id; |
209 |
}
|
210 |
}
|
211 |
return $filtered_roles; |
212 |
}
|
213 |
|
214 |
/**
|
215 |
* Returns true if a role has the capabilities in the passed array
|
216 |
*
|
217 |
* @static
|
218 |
* @param $role
|
219 |
* @param $caps
|
220 |
* @return bool
|
221 |
*/
|
222 |
static function role_has_caps($role, $caps) { |
223 |
foreach ($caps as $cap) { |
224 |
if (!$role->has_cap($cap)) { |
225 |
return false; |
226 |
}
|
227 |
}
|
228 |
return true; |
229 |
}
|
230 |
|
231 |
/**
|
232 |
* Filter all users of the blog based on capabilities
|
233 |
*
|
234 |
* @static
|
235 |
* @param array $include Array of capabilities to include
|
236 |
* @param array $exclude Array of capabilities to exclude
|
237 |
* @return array
|
238 |
*/
|
239 |
static function filter_users($include, $exclude) { |
240 |
$filtered_users = array(); |
241 |
$users = get_users(); |
242 |
foreach ($users as $user) { |
243 |
$user = new WP_User($user->ID); |
244 |
if (self::user_has_caps($user, $include) && !self::user_has_caps($user, $exclude)) { |
245 |
$filtered_users[] = $user->ID; |
246 |
}
|
247 |
}
|
248 |
return $filtered_users; |
249 |
}
|
250 |
|
251 |
/**
|
252 |
* Returns true if a user has the capabilities in the passed array
|
253 |
*
|
254 |
* @static
|
255 |
* @param $user
|
256 |
* @param $caps
|
257 |
* @return bool
|
258 |
*/
|
259 |
static function user_has_caps($user, $caps) { |
260 |
foreach ($caps as $cap) { |
261 |
if (!$user->has_cap($cap)) { |
262 |
return false; |
263 |
}
|
264 |
}
|
265 |
return true; |
266 |
}
|
267 |
|
268 |
/**
|
269 |
* Restrict Media Library access
|
270 |
*
|
271 |
* @param $wp_query
|
272 |
*/
|
273 |
public function restrict_media_library($wp_query) { |
274 |
if (strpos($_SERVER['REQUEST_URI'], '/wp-admin/upload.php')) { |
275 |
if (current_user_can('remove_upload_files')) { |
276 |
global $current_user; |
277 |
$wp_query->set('author', $current_user->ID); |
278 |
}
|
279 |
}
|
280 |
else if (strpos($_SERVER['REQUEST_URI'], '/wp-admin/media-upload.php')) { |
281 |
if (current_user_can('remove_upload_files')) { |
282 |
global $current_user; |
283 |
$wp_query->set('author', $current_user->ID); |
284 |
}
|
285 |
}
|
286 |
}
|
287 |
|
288 |
}
|
289 |
}
|
Conclusión
En este tutorial, traté de usar el material que aprendimos en los dos tutoriales anteriores para crear una solución personalizada para los roles y las capacidades. La solución se encapsula en una clase que se puede personalizar para tus propias necesidades o plugins. Puedes encontrar el código en Github.
Si tienes alguna pregunta, sugerencia o sugerencia de mejora, no dudes en publicarlo en los comentarios.
