Vérifiez si l'utilisateur a accès à une certaine page

Comment puis-je déterminer si un utilisateur est autorisé à accéder à une certaine page?

Si vous souhaitez vérifier si l'utilisateur actuellement connecté a accès à une page, vous pouvez utiliser le code suivant:

if ($router_item = menu_get_item($path)) {
  if ($router_item['access']) {
    // The user has access to the page in $path.
  }
}

$path est le chemin de la page que vous souhaitez vérifier (par exemple, node / 1, admin / user / user).

Le code fonctionne dans Drupal 6 et les versions supérieures, et c'est celui utilisé à partir de menu_execute_active_handler () .

La raison pour laquelle je ne suggère pas d'appeler directement le rappel d'accès est parce que les arguments qui doivent être passés à cette fonction.

Le code utilisé par _menu_check_access () est le suivant (Drupal 7):

$arguments = menu_unserialize($item['access_arguments'], $map);
// As call_user_func_array is quite slow and user_access is a very common
// callback, it is worth making a special case for it.
if ($callback == 'user_access') {
  $item['access'] = (count($arguments) == 1) ? user_access($arguments[0]) : user_access($arguments[0], $arguments[1]);
}
elseif (function_exists($callback)) {
  $item['access'] = call_user_func_array($callback, $arguments);
}

Le code, qui doit être aussi générique que possible, ne gère pas directement un objet utilisateur. Cela signifie qu'il n'est pas possible de remplacer l'objet utilisateur pour l'utilisateur actuellement connecté par un autre objet utilisateur.
Le code doit être suffisamment générique pour gérer les définitions de menu telles que les suivantes:

$items['node/add/' . $type_url_str] = array(
  'title' => $type->name, 
  'title callback' => 'check_plain', 
  'page callback' => 'node_add', 
  'page arguments' => array($type->type), 
  'access callback' => 'node_access', 
  'access arguments' => array('create', $type->type), 
  'description' => $type->description, 
  'file' => 'node.pages.inc',
);

$items['node/%node'] = array(
  'title callback' => 'node_page_title', 
  'title arguments' => array(1),
  // The page callback also invokes drupal_set_title() in case
  // the menu router's title is overridden by a menu link. 
  'page callback' => 'node_page_view', 
  'page arguments' => array(1), 
  'access callback' => 'node_access', 
  'access arguments' => array('view', 1),
);

Dans les deux définitions, les arguments d'accès n'incluent pas d'objet utilisateur et node_access () dans ce cas utilise l'objet utilisateur pour l'utilisateur actuellement connecté. Dans le second cas, l'un des arguments est l'objet nœud obtenu à partir de l'URL; par exemple, si l'URL est example.com/node/1, le deuxième argument transmis au rappel d'accès est l'objet nœud pour le nœud avec l'ID nœud égal à 1.
L'écriture de code qui gère également ces cas signifierait dupliquer le code déjà existant dans Drupal. Même si vous avez dupliqué ce code, il y aurait toujours le problème des rappels d'accès qui vérifient l'accès par rapport à l'utilisateur actuellement connecté.

Si vous souhaitez vérifier si un utilisateur qui n'est pas l'utilisateur actuellement connecté peut accéder à un menu, modifiez d'abord la valeur de la variable globale $user, utilisez le code que j'ai signalé au début de ma réponse, puis restaurez la valeur de $user. Pour savoir comment modifier la valeur du global $user, vous pouvez voir Emprunter l'identité d'un autre utilisateur par programme sans entraîner la déconnexion de l'utilisateur actuellement connecté . La différence est qu'au lieu d'utiliser la valeur renvoyée par drupal_anonymous_user () , vous utilisez la valeur renvoyée par user_load () .

Essayez drupal_valid_path () .

La fonction retourne TRUEest le chemin d'accès passé car l'argument existe et l'utilisateur actuel y a accès. Donc, si vous travaillez sur Drupal 7 et que vous devez vérifier l'accès sur l'utilisateur actuellement connecté, c'est la façon la plus simple de procéder:

if (drupal_valid_path('my/path')) {
  // Your code here...
}

Appelez le access callbackqui est spécifié dans l'entrée de menu qui est responsable de la page. Cette entrée de menu est généralement créée par Drupal appelant l'implémentation de hook_menuet est stockée quelque part dans la base de données. Attention, les données renvoyées par hook_menupeuvent être modifiées par un module implémentant hook_menu_alter.

Attention, certains modules peuvent ne pas passer l'utilisateur comme un argument séparé (comme spécifié par la access argumentsclé de l'entrée de menu), mais peuvent utiliser à la $userplace l'objet global . Vous devrez vérifier cela pour chaque module que vous utilisez.

Découvrez la user_access()fonction. Voir le lien pour les paramètres spécifiés pour chaque version de Drupal. Depuis la page de documentation de Drupal 7-8:

Paramètres

$ string L'autorisation, telle que "administrer les nœuds", est en cours de vérification.

$ account (facultatif) Le compte à vérifier, s'il n'est pas indiqué, l'utilisateur actuellement connecté.

Valeur de retour

Boolean TRUE si l'utilisateur actuel a l'autorisation demandée.

Tous les contrôles d'autorisation dans Drupal doivent passer par cette fonction. De cette façon, nous garantissons un comportement cohérent et garantissons que le superutilisateur peut effectuer toutes les actions.

Si vous avez besoin de savoir si un utilisateur peut accéder à un nœud particulier et utilise un module d'accès au nœud, vous pouvez utiliser node_access () . (sans module d'accès aux nœuds, ils ont juste besoin de l'autorisation «accéder au contenu».)

Si vous souhaitez déterminer si un utilisateur peut accéder à un chemin arbitraire défini par une implémentation hook_menu (), vous devrez peut-être récupérer l'entrée de menu de la base de données et évaluer son paramètre 'access callback'.

    $node = node_load(123);

    $account = user_load(456);

    if (node_access("update", $node, $account) === TRUE) 
   {

         print "access";    
    }