Share
Questo è un tutorial in quattro parti che copre l'argomento WordPress utenti, ruoli e capacità. La serie riguarderà l'architettura e il design dei ruoli utente in WordPress; evidenziare le funzioni più importanti per interagire con gli utenti e gestire ruoli e capacità; e nell'ultimo tutorial, costruiremo un esempio di vita reale che dimostra l'utilità di questa API.
Questo tutorial sarà incentrato sulla creazione di una soluzione pratica utilizzando il sistema di ruoli e capacità di WordPress. Se hai perso gli ultimi due tutorial, ti consiglio caldamente di controllarli. La prima parte "Ruoli e funzionalità di WordPress: le basi" spiega il design di questo sistema; mentre la seconda parte "Ruoli e funzionalità di WordPress: Funzioni di nota" si concentra sulle funzioni e sulle classi che WordPress offre per interagire con il sistema.
La soluzione proposta in questo tutorial è la stessa che sto utilizzando per uno dei miei plugin WordPress premium. L'ho scelto dopo aver provato approcci diversi. È semplice, breve e incapsulato in una classe. Puoi facilmente adattarlo per il tuo plugin. Il codice è disponibile su GitHub; e non è concesso in licenza. Inoltre, non ha garanzie e sei libero di usarlo e concederlo in licenza come desideri.
Stiamo costruendo un plugin per WordPress che ha un pannello di amministrazione client speciale. Questo pannello di amministrazione dovrebbe essere accessibile solo a un numero limitato di utenti. Questi utenti possono essere selezionati dall'amministratore del blog. Può abilitare diversi ruoli, utenti o tutti loro per accedere al pannello di amministrazione o alle funzionalità del client.
Oltre a questo, è necessario disporre di un accesso limitato alla libreria multimediale per gli utenti con un accesso al pannello client. WordPress ha una capacità speciale per accedere e caricare file nella libreria multimediale: "caricare filesTuttavia, questo fornisce all'utente (o ruolo) pieno accesso al Catalogo multimediale. Questa non è una buona cosa, specialmente che le foto (oi file) non possono essere gerarchizzati in diverse categorie dove è possibile limitare l'accesso per ognuno.
Dobbiamo limitare l'accesso alla libreria multimediale solo ai file che l'utente ha caricato. Non dovrebbe avere accesso ai caricamenti di altri utenti. Questa limitazione dovrebbe essere applicata solo agli utenti che non hanno il "caricare files"Capacità. Altri utenti e ruoli non sono interessati a questa limitazione poiché hanno già un accesso completo alla Libreria multimediale.
Il nostro blog avrà queste quattro categorie di utenti:
I primi due gruppi di utenti sono quelli che non avranno accesso al pannello del client del plugin. Ho evidenziato il fatto che ci sono utenti che hanno accesso alla libreria multimediale e un set che non ha accesso. È essenziale che la nostra soluzione non influenzi le prime due categorie e lasci intatte le loro capacità.
Con questo in mente, la nostra classe dovrebbe fare due cose:
Prima di creare la nostra classe, diamo un'idea più approfondita del plugin. Il plugin ha una struttura piuttosto semplice. È composto da due menu diversi: uno per l'amministratore e funge da pannello amministrativo, accessibile solo agli utenti con capacità di "manage_optionsMsgstr "Il secondo menu è per i client e dà accesso al pannello client. Questo pannello richiede un"wptuts_client_page" capacità.
Questa funzionalità non esiste in WordPress; dobbiamo aggiungere e assegnarlo agli utenti o ai ruoli specificati. Ma prima diamo un'occhiata al plugin.
Accentsconagua
/ * Nome plugin: URI plugin plugin per WordPress Plugin: https://github.com/omarabid/WordPress-Roles-Plugin Descrizione: Un plugin per ruoli di WordPress Autore: Abid Omar Autore URI: http://omarabid.com Versione: 1.0 * / // Aggiungi un menu utente Admin al Dashboard di WordPress add_action ('admin_menu', 'wptuts_admin_menu'); function wptuts_admin_menu () add_menu_page ('Admin Access', 'Admin Access', 'manage_options', 'wptuts-admin', 'wptuts_admin_page'); function wptuts_admin_page () echo 'Pagina amministratore'; // Aggiungi un menu utente client al Dashboard di WordPress add_action ('admin_menu', 'wptuts_client_menu'); function wptuts_client_menu () add_menu_page ('Accesso client', 'Accesso client', 'wptuts_client', 'wptuts-client', 'wptuts_client_page'); function wptuts_client_page () echo 'Pagina client'; Abbiamo due "admin_menu"agganci di azione che aggiungono il menu di amministrazione sia per l'amministratore che per il client.Possiamo accorciarlo a un solo hook che aggiunge entrambi, ma preferisco separarli."add_menu_page"la funzione si aggancia ad un'altra funzione che visualizzerà il contenuto della pagina.
Successivamente, dobbiamo inizializzare la nostra classe Roles. Il codice di classe è inserito in un altro file; e il processo di inizializzazione è fatto durante il "dentro"hook che garantisce il completamento del caricamento di WordPress.
La funzione di costruzione accetta tre parametri:
$ tutto Booleano (facoltativo) Se si desidera consentire al client l'accesso a tutti gli utenti del blog, è possibile impostarlo su true e ignorare i parametri rimanenti.$ ruoli Array (facoltativo) Un array con ID di ruoli che avranno accesso al pannello del client.$ gli utenti Array (facoltativo) Un array con i nomi utente degli utenti che avranno accesso al pannello del client. // Carica e inizializza la classe dei ruoli add_action ('init', 'wptuts_start_plugin'); function wptuts_start_plugin () require_once ('roles_class.php'); $ tutto = falso; $ roles = array ('subscriber'); $ users = array (3); nuovi wpttuts_roles ($ all, $ ruoli, $ utenti); La classe ha solo 3 proprietà: $ tutto, $ ruoli e $ gli utenti. Queste sono le stesse variabili che si passano alla funzione di costruzione. Il valore delle variabili non è cambiato nel nostro esempio; ma in un caso pratico reale, potresti voler unire con un'altra fonte. Per questo, hai il set_entities funzione. Puoi adattarlo alle tue esigenze.
/ ** * @var boolean * / private $ all; / ** * @var array * / private $ ruoli; / ** * @var array * / private $ users; / ** * Imposta le entità di autorizzazione * * @param booleano $ tutto * @param array $ ruoli * @param array $ utenti * / funzione privata set_entities ($ tutto, $ ruoli, $ utenti) $ this-> all = $ tutti; $ this-> roles = $ ruoli; $ this-> users = $ users;
In un primo passaggio, la funzione di costruzione inizializza il $ tutto, $ ruoli e $ gli utenti variabili usando il set_entitites () funzione. Successivamente, chiama una funzione privata per l'impostazione delle funzionalità e un'altra per la restrizione della libreria multimediale. Questi sono esattamente i passi che abbiamo definito nel nostro scenario.
/ ** * Crea una nuova istanza della classe Ruoli * * @param booleano $ all * @param array $ ruoli * @param array $ users * / function __construct ($ all = false, $ roles = array (), $ users = array ()) // Imposta le entità consentite $ this-> set_entities ($ all, $ ruoli, $ users); // Imposta l'autorizzazione di accesso utente $ this-> set_permissions (); // Filtro libreria multimediale $ this-> media_filter ();
Le funzioni statiche non richiedono l'inizializzazione della classe. Sono simili alle funzioni indipendenti, ma semplicemente collegate alla classe specificata. Ho deciso di mantenere alcune funzioni statiche perché possono essere utilizzate indipendentemente; e potresti trovarli utili in un altro contesto.
Queste funzioni sono filter_roles () e filter_users (); che sono associati con altre due funzioni role_has_caps () e user_has_caps (). Le funzioni svolgono la parte di un filtro. Filtrano i ruoli (o gli utenti) in base alle funzionalità che hanno e non hanno.
Entrambe le funzioni accettano due argomenti:
$ includono schieramento Una serie di funzionalità che il ruolo ha.$ escludere schieramento Una serie di funzionalità che il ruolo non ha./ ** * Filtra tutti i ruoli del blog in base alle funzionalità * * @static * @param array $ include Array di funzionalità da includere * @param array $ escludi Array di funzionalità da escludere * @return array * / static function filter_roles ($ include, $ exclude) $ filtered_roles = array (); globale $ wp_roles; $ ruoli = $ wp_roles-> get_names (); foreach ($ role as $ role_id => $ role_name) $ role = get_role ($ role_id); if (self :: role_has_caps ($ role, $ include) &&! self :: role_has_caps ($ role, $ exclude)) $ filtered_roles [] = $ role_id; return $ filtered_roles; / ** * Filtra tutti gli utenti del blog in base alle funzionalità * * @static * @param array $ include Array di funzionalità da includere * @param array $ escludi Array di funzionalità da escludere * @return array * / static function filter_users ( $ include, $ exclude) $ filtered_users = array (); $ users = get_users (); foreach ($ users as $ user) $ user = new WP_User ($ user-> ID); if (self :: user_has_caps ($ user, $ include) &&! self :: user_has_caps ($ user, $ exclude)) $ filtered_users [] = $ user-> ID; restituisce $ filtered_users;
Le funzioni eseguono il ciclo di tutti i ruoli e gli utenti nel database. Per ogni ruolo (o utente), controlla se ha le capacità richieste e non ha le capacità da escludere. Questo controllo è fatto con il role_has_caps () e user_has_caps () funzioni.
Queste due funzioni (role_has_caps () e user_has_caps ()) accetta due argomenti:
Se il ruolo (o utente) ha le capacità specificate in $ caps array, la funzione restituisce true. Nell'altro caso, la funzione restituisce false. La funzione scorre sostanzialmente in ogni funzionalità e verifica che il ruolo (o l'utente) abbia la capacità specificata.
/ ** * Restituisce vero se un ruolo ha le capacità nell'array passato * * @static * @param $ role * @param $ caps * @return bool * / static function role_has_caps ($ role, $ caps) foreach ($ caps come $ cap) if (! $ role-> has_cap ($ cap)) return false; return true; / ** * Restituisce true se un utente ha le capacità nell'array passato * * @static * @param $ user * @param $ caps * @return bool * / static function user_has_caps ($ user, $ caps) foreach ( $ caps come $ cap) if (! $ user-> ha_cap ($ cap)) return false; return true;
Questo è il primo passo per imporre la legge del nostro plugin. Ho distribuito la funzionalità su 3 funzioni: una per l'impostazione delle autorizzazioni per tutti gli utenti, una per l'impostazione delle autorizzazioni per i ruoli e un'altra per l'impostazione delle autorizzazioni per gli utenti specificati. La funzione principale decide semplicemente quali funzioni chiamare.
/ ** * Imposta i permessi di accesso Menu e Pages * / private set_permissions () $ this-> set_all_permissions (); if (! $ this-> all) $ this-> set_roles_permissions (); $ This-> set_users_permissions ();
Il set_all_permissions () la funzione esegue il loop di tutti gli utenti nel blog e aggiunge (o rimuove) il "wptuts_client"capacità in base al valore del $ tutto variabile. Otteniamo l'elenco completo degli utenti che utilizzano il get_users () funzione; e inizializzare un nuovo WP_User oggetto per ottenere l'accesso al add_cap () e remove_cap () funzioni.
/ ** * Imposta le autorizzazioni per TUTTI gli utenti * / funzione privata set_all_permissions () $ users = get_users (); foreach ($ users as $ user) $ user = new WP_User ($ user-> ID); se ($ this-> all) $ user-> add_cap ('wptuts_client'); else $ user-> remove_cap ('wptuts_client'); Il set_roles_permissions () funzione scorre in tutti i ruoli nel blog e rimuove il "wptuts_clientcapacità. Dopo di ciò, scorre attraverso i ruoli in $ ruoli array e aggiunge il "wptuts_client"capacità: il primo passo è stato quello di assicurare che puliamo la capacità da ruoli che potrebbero averli precedentemente.
/ ** * Imposta le autorizzazioni per Ruoli * / funzione privata set_roles_permissions () global $ wp_roles; $ ruoli = $ wp_roles-> get_names (); foreach ($ role as $ role_id => $ role_name) $ role = get_role ($ role_id); $ Di ruolo> remove_cap ( 'wptuts_client'); if (! empty ($ this-> roles)) foreach ($ this-> ruoli come $ role_id) $ role = get_role ($ role_id); $ Di ruolo> add_cap ( 'wptuts_client');
Il set_users_permissions () la funzione fa la stessa cosa dell'ultima funzione. L'unica differenza è che si rivolge agli utenti anziché ai ruoli.
/ ** * Imposta le autorizzazioni per Utenti specifici * / funzione privata set_users_permissions () $ users = get_users (); foreach ($ users as $ user) $ user = new WP_User ($ user-> ID); $ User-> remove_cap ( 'wptuts_client'); if (! empty ($ this-> users)) foreach ($ this-> users as $ user_id) $ user = new WP_User ($ user_id); $ User-> add_cap ( 'wptuts_client');
Ora abbiamo impostato i permessi giusti per le entità giuste. (Essere un utente o un ruolo) Dobbiamo anche limitare l'accesso alla libreria multimediale per la quarta categoria che abbiamo distinto nello scenario.
Questa categoria di ruoli (o utenti) ha il "wptuts_client"capacità, ma non ha il"caricare files"capacità, ed è qui che entrano in gioco le nostre funzioni di filtro che ci aiuteranno a filtrare e restituire questa categoria di ruoli (o utenti).
Per questa categoria, aggiungeremo due funzionalità "caricare files" e "remove_upload_files". Il "caricare files"darà pieno accesso alla libreria multimediale e l'altra funzionalità verrà utilizzata per filtrare i messaggi della libreria multimediale e verrà utilizzata anche per rimuovere"caricare files"capacità una volta"wptuts_client"Anche la capacità viene rimossa.
/ ** * Restrict Media Access * / private function media_filter () // Applica il filtro multimediale per i client correnti $ roles = self :: filter_roles (array ('wptuts_client'), array ('upload_files')); $ users = self :: filter_users (array ('wptuts_client'), array ('upload_files')); $ this-> roles_add_cap ($ ruoli, 'upload_files'); $ this-> roles_add_cap ($ roles, 'remove_upload_files'); $ this-> users_add_cap ($ users, 'upload_files'); $ this-> users_add_cap ($ users, 'remove_upload_files'); // Limita l'accesso alla libreria multimediale add_filter ('parse_query', array (& $ this, 'restrict_media_library')); // Per scopi di pulizia $ clean_roles = self :: filter_roles (array ('remove_upload_files'), array ('wptuts_client')); $ clean_users = self :: filter_users (array ('remove_upload_files'), array ('wptuts_client')); $ this-> roles_remove_cap ($ clean_roles, 'upload_files'); $ this-> roles_remove_cap ($ clean_roles, 'remove_upload_files'); $ this-> users_remove_cap ($ clean_users, 'upload_files'); $ this-> users_remove_cap ($ clean_users, 'remove_upload_files'); Dopo aver impostato le funzionalità per questa categoria, colleghiamo "parse_queryfiltro Questo filtro ci consente di modificare i post restituiti da WP_Query. Nel nostro caso, imposteremo il "autore"Variabile di query. Ciò restituisce solo i post creati dall'autore specificato.
/ ** * Limita accesso alla libreria multimediale * * @param $ wp_query * / public function restrict_media_library ($ wp_query) if (strpos ($ _ SERVER ['REQUEST_URI'], '/wp-admin/upload.php')) if (current_user_can ('remove_upload_files')) global $ current_user; $ wp_query-> set ('author', $ current_user-> ID); else if (strpos ($ _ SERVER ['REQUEST_URI'], '/wp-admin/media-upload.php')) if (current_user_can ('remove_upload_files')) global $ current_user; $ wp_query-> set ('author', $ current_user-> ID); if (! class_exists ('wpttuts_roles')) class wpttuts_roles / ** * Determina se tutti gli utenti avranno le autorizzazioni richieste * * @var boolean * / private $ all; / ** * Una matrice con i ruoli che hanno le autorizzazioni richieste * * @var array * / private $ ruoli; / ** * Una matrice con i nomi utente che hanno le autorizzazioni richieste * * @var array * / private $ users; / ** * Crea una nuova istanza della classe Ruoli * * @param booleano $ all * @param array $ ruoli * @param array $ users * / function __construct ($ all = false, $ roles = array (), $ users = array ()) // Imposta le entità consentite $ this-> set_entities ($ all, $ ruoli, $ users); // Imposta l'autorizzazione di accesso utente $ this-> set_permissions (); // Filtro libreria multimediale $ this-> media_filter (); / ** * Imposta le entità di autorizzazione * * @param booleano $ all * @param array $ ruoli * @param array $ utenti * / funzione privata set_entities ($ tutto, $ ruoli, $ utenti) $ this-> all = $ tutto; $ this-> roles = $ ruoli; $ this-> users = $ users; / ** * Imposta le autorizzazioni di accesso a Menu e Pagine * / private set_permissions () $ this-> set_all_permissions (); if (! $ this-> all) $ this-> set_roles_permissions (); $ This-> set_users_permissions (); / ** * Imposta le autorizzazioni per TUTTI gli utenti * / funzione privata set_all_permissions () $ users = get_users (); foreach ($ users as $ user) $ user = new WP_User ($ user-> ID); se ($ this-> all) $ user-> add_cap ('wptuts_client'); else $ user-> remove_cap ('wptuts_client'); / ** * Imposta le autorizzazioni per Ruoli * / funzione privata set_roles_permissions () global $ wp_roles; $ ruoli = $ wp_roles-> get_names (); foreach ($ role as $ role_id => $ role_name) $ role = get_role ($ role_id); $ Di ruolo> remove_cap ( 'wptuts_client'); if (! empty ($ this-> roles)) foreach ($ this-> ruoli come $ role_id) $ role = get_role ($ role_id); $ Di ruolo> add_cap ( 'wptuts_client'); / ** * Imposta le autorizzazioni per Utenti specifici * / funzione privata set_users_permissions () $ users = get_users (); foreach ($ users as $ user) $ user = new WP_User ($ user-> ID); $ User-> remove_cap ( 'wptuts_client'); if (! empty ($ this-> users)) foreach ($ this-> users as $ user_id) $ user = new WP_User ($ user_id); $ User-> add_cap ( 'wptuts_client'); / ** * Restrict Media Access * / private function media_filter () // Applica il filtro multimediale per i client AdPress currenct $ roles = self :: filter_roles (array ('wptuts_client'), array ('upload_files'))) ; $ users = self :: filter_users (array ('wptuts_client'), array ('upload_files')); $ this-> roles_add_cap ($ ruoli, 'upload_files'); $ this-> roles_add_cap ($ roles, 'remove_upload_files'); $ this-> users_add_cap ($ users, 'upload_files'); $ this-> users_add_cap ($ users, 'remove_upload_files'); // Limita l'accesso alla libreria multimediale add_filter ('parse_query', array (& $ this, 'restrict_media_library')); // Per scopi di pulizia $ clean_roles = self :: filter_roles (array ('remove_upload_files'), array ('wptuts_client')); $ clean_users = self :: filter_users (array ('remove_upload_files'), array ('wptuts_client')); $ this-> roles_remove_cap ($ clean_roles, 'upload_files'); $ this-> roles_remove_cap ($ clean_roles, 'remove_upload_files'); $ this-> users_remove_cap ($ clean_users, 'upload_files'); $ this-> users_remove_cap ($ clean_users, 'remove_upload_files'); / ** * Aggiungi una funzionalità a una matrice di ruoli * * @param $ ruoli * @param $ cap * / funzione privata roles_add_cap ($ ruoli, $ cap) foreach ($ ruoli come $ ruolo) $ role = get_role ($ ruolo); $ Di ruolo> add_cap ($ cap); / ** * Aggiungi una funzionalità a una matrice di utenti * * @param $ utenti * @param $ cap * / funzione privata users_add_cap ($ users, $ cap) foreach ($ users as $ user $ user = nuovo WP_User ($ utente); $ User-> add_cap ($ cap); / ** * Rimuovi una funzionalità da una serie di ruoli * * @param $ ruoli * @param $ cap * / funzione privata roles_remove_cap ($ ruoli, $ cap) foreach ($ ruoli come $ ruolo) $ ruolo = get_role ($ ruolo); $ Di ruolo> remove_cap ($ cap); / ** * Rimuovi una funzionalità da una matrice di utenti * * @param $ utenti * @param $ cap * / private function users_remove_cap ($ users, $ cap) foreach ($ users as $ user $ user = nuovo WP_User ($ utente); $ User-> remove_cap ($ cap); / ** * Filtra tutti i ruoli del blog in base alle funzionalità * * @static * @param array $ include Array di funzionalità da includere * @param array $ escludi Array di funzionalità da escludere * @return array * / static function filter_roles ($ include, $ exclude) $ filtered_roles = array (); globale $ wp_roles; $ ruoli = $ wp_roles-> get_names (); foreach ($ role as $ role_id => $ role_name) $ role = get_role ($ role_id); if (self :: role_has_caps ($ role, $ include) &&! self :: role_has_caps ($ role, $ exclude)) $ filtered_roles [] = $ role_id; return $ filtered_roles; / ** * Restituisce true se un ruolo ha le capacità nell'array passato * * @static * @param $ role * @param $ caps * @return bool * / static function role_has_caps ($ role, $ caps) foreach ( $ caps come $ cap) if (! $ role-> has_cap ($ cap)) return false; return true; / ** * Filtra tutti gli utenti del blog in base alle funzionalità * * @static * @param array $ include Array di funzionalità da includere * @param array $ escludi Array di funzionalità da escludere * @return array * / static function filter_users ( $ include, $ exclude) $ filtered_users = array (); $ users = get_users (); foreach ($ users as $ user) $ user = new WP_User ($ user-> ID); if (self :: user_has_caps ($ user, $ include) &&! self :: user_has_caps ($ user, $ exclude)) $ filtered_users [] = $ user-> ID; restituisce $ filtered_users; / ** * Restituisce true se un utente ha le capacità nell'array passato * * @static * @param $ user * @param $ caps * @return bool * / static function user_has_caps ($ user, $ caps) foreach ( $ caps come $ cap) if (! $ user-> ha_cap ($ cap)) return false; return true; / ** * Limita accesso alla libreria multimediale * * @param $ wp_query * / public function restrict_media_library ($ wp_query) if (strpos ($ _ SERVER ['REQUEST_URI'], /wp-admin/upload.php ')) if (current_user_can ('remove_upload_files')) global $ current_user; $ wp_query-> set ('author', $ current_user-> ID); else if (strpos ($ _ SERVER ['REQUEST_URI'], '/wp-admin/media-upload.php')) if (current_user_can ('remove_upload_files')) global $ current_user; $ wp_query-> set ('author', $ current_user-> ID); In questo tutorial, ho cercato di utilizzare il materiale che abbiamo appreso dai due post precedenti per creare una soluzione personalizzata per ruoli e funzionalità. La soluzione è stata incapsulata in una classe che può essere personalizzata per le proprie esigenze o plugin. Puoi trovare il codice su Github.
Se hai domande, suggerimenti o miglioramenti sentiti libero di postarlo nei commenti.
