Welcome to the Cookbook

Vous ne voulez pas utiliser un modèle Utilisateur pour vous authentifier ? Pas de problème, modifiez ce comportement en configurant cette variable avec le nom du modèle que vous voulez utiliser.

<?php
    $this->Auth->userModel = 'Membre';
?>

1. <?php
2. $this->Auth->userModel = 'Membre';
3. ?>

Pour outrepasser les champs utilisateur et mot de passe utilisés par défaut pour l'authentification.

<?php
    $this->Auth->fields = array('username' => 'email', 'password' => 'motdepasse');
?>

1. <?php
2. $this->Auth->fields = array('username' => 'email', 'password' => 'motdepasse');
3. ?>

Utilisez cette propriété pour ajouter des contraintes supplémentaires afin que l'authentification réussisse.

<?php
    $this->Auth->userScope = array('Utilisateur.actif' => true);
?>

1. <?php
2. $this->Auth->userScope = array('Utilisateur.actif' => true);
3. ?>

Vous pouvez changer l'adresse de connexion par défaut /users/login par toute action de votre choix.

<?php
    $this->Auth->loginAction = array('admin' => false, 'controller' => 'membres', 'action' => 'login');
?>

1. <?php
2. $this->Auth->loginAction = array('admin' => false, 'controller' => 'membres', 'action' => 'login');
3. ?>

Le Composant Auth mémorise quelle paire contrôleur/action vous essayiez d'obtenir avant que l'on vous demande de vous authentifier, en stockant cette valeur dans la Session, sous la clé Auth.redirect. Cependant, si cette valeur de session n'est pas définie (par exemple, si vous arrivez à la page d'identification depuis un lien externe), alors l'utilisateur sera redirigé à l'URL spécifiée dans loginRedirect.

Exemple :

<?php
    $this->Auth->loginRedirect = array('controller' => 'membres', 'action' => 'accueil');
?>

1. <?php
2. $this->Auth->loginRedirect = array('controller' => 'membres', 'action' => 'accueil');
3. ?>

Vous pouvez également spécifier où vous voulez que l'utilisateur soit redirigé après sa déconnexion, ayant pour action par défaut l'action de login.

<?php
    $this->Auth->logoutRedirect = array(Configure::read('Routing.admin') => false, 'controller' => 'membres', 'action' => 'logout');
?>

1. <?php
2. $this->Auth->logoutRedirect = array(Configure::read('Routing.admin') => false, 'controller' => 'membres', 'action' => 'logout');
3. ?>

Change le message d'erreur par défaut affiché lorsque quelqu'un ne s'authentifie pas correctement.

<?php
    $this->Auth->loginError = "Non, vous vous êtes trompé! Ce n'est pas le bon mot de passe!";
?>

1. <?php
2. $this->Auth->loginError = "Non, vous vous êtes trompé! Ce n'est pas le bon mot de passe!";
3. ?>

Change le message d'erreur par défaut affiché lorsque quelqu'un essaye d'accéder à une ressource ou une action qu'il n'est pas autorisé à accéder.

<?php
    $this->Auth->authError = "Désolé, vous n'avez pas les droits suffisants.";
?>

1. <?php
2. $this->Auth->authError = "Désolé, vous n'avez pas les droits suffisants.";
3. ?>

Normalement, le Composant Auth vous redirige automatiquement dès lors qu'il vous authentifie. Parfois, vous souhaitez faire d'autres vérifications avant de rediriger les utilisateurs :

<?php
	function beforeFilter() {
		...
		$this->Auth->autoRedirect = false;
	}

	...

	function login() {
	//-- le code de cette fonction ne s'exécute que lorsque autoRedirect est défini à false (i.e. dans un beforeFilter).
		if ($this->Auth->user()) {
			if (!empty($this->data['Utilisateur']['se_souvenir_de_moi'])) {
				$cookie = array();
				$cookie['nom'] = $this->data['Utilisateur']['nom'];
				$cookie['motdepasse'] = $this->data['Utilisateur']['motdepasse'];
				$this->Cookie->write('Auth.Utilisateur', $cookie, true, '+2 weeks');
				unset($this->data['Utilisateur']['se_souvenir_de_moi']);
			}
			$this->redirect($this->Auth->redirect());
		}
		if (empty($this->data)) {
			$cookie = $this->Cookie->read('Auth.Utilisateur');
			if (!is_null($cookie)) {
				if ($this->Auth->login($cookie)) {
					//  Efface le message auth, seulement si nous l'utilisons
					$this->Session->del('Message.auth');
					$this->redirect($this->Auth->redirect());
				}
			}
		}
    }
?>

1. <?php
2. function beforeFilter() {
3. ...
4. $this->Auth->autoRedirect = false;
5. }
6. ...
7. function login() {
8. //-- le code de cette fonction ne s'exécute que lorsque autoRedirect est défini à false (i.e. dans un beforeFilter).
9. if ($this->Auth->user()) {
10. if (!empty($this->data['Utilisateur']['se_souvenir_de_moi'])) {
11. $cookie = array();
12. $cookie['nom'] = $this->data['Utilisateur']['nom'];
13. $cookie['motdepasse'] = $this->data['Utilisateur']['motdepasse'];
14. $this->Cookie->write('Auth.Utilisateur', $cookie, true, '+2 weeks');
15. unset($this->data['Utilisateur']['se_souvenir_de_moi']);
16. }
17. $this->redirect($this->Auth->redirect());
18. }
19. if (empty($this->data)) {
20. $cookie = $this->Cookie->read('Auth.Utilisateur');
21. if (!is_null($cookie)) {
22. if ($this->Auth->login($cookie)) {
23. // Efface le message auth, seulement si nous l'utilisons
24. $this->Session->del('Message.auth');
25. $this->redirect($this->Auth->redirect());
26. }
27. }
28. }
29. }
30. ?>

Le code de la fonction login ne s'exécutera pas sauf si vous définissez $autoRedirect à false dans un beforeFilter. Le code présent dans la fonction de login ne s'exécutera qu'après un essai d'authentification. C'est le meilleur endroit pour déterminer si oui ou non une connexion réussie a été effectuée par le Composant Auth (vous aurez peut-être envie d'enregistrer la dernière date d'authentification réussie, etc.).

Normalement, le Composant Auth essaiera de vérifier que les critères de login que vous avez saisis sont exacts, en les comparant à ce qui a été stocké dans votre modèle utilisateur. Cependant, vous voudrez peut-être certaines fois effectuer du traitement additionnel, en déterminant vos propres critères. En assignant à cette variable l'une des nombreuses valeurs possibles, vous pouvez faire différentes choses. En voici quelques-unes, parmi les plus communes, que vous souhaiterez peut-être utiliser.

<?php
    $this->Auth->authorize = 'controller';
?>

1. <?php
2. $this->Auth->authorize = 'controller';
3. ?>

Lorsque authorize est défini à 'controller', vous aurez besoin d'ajouter une méthode appelée isAuthorized() à votre contrôleur. Cette méthode vous permet de faire plus de vérifications d'authentification et de retourner ensuite soit true, soit false.

<?php
    function isAuthorized() {
        if ($this->action == 'delete') {
            if ($this->Auth->user('role') == 'admin') {
                return true;
            } else {
                return false;
            }
        }

        return true;
    }
?>

1. <?php
2. function isAuthorized() {
3. if ($this->action == 'delete') {
4. if ($this->Auth->user('role') == 'admin') {
5. return true;
6. } else {
7. return false;
8. }
9. }
10. return true;
11. }
12. ?>

Souvenez-vous que cette méthode sera inspectée, après que vous ayez déjà passé la vérification d'authentification simple du modèle utilisateur.

<?php
    $this->Auth->authorize = 'model';
?>

1. <?php
2. $this->Auth->authorize = 'model';
3. ?>

Vous ne souhaitez rien ajouter à votre contrôleur et peut-être utiliser les ACO's ? Vous pouvez demander au Composant Auth d'appeler une méthode, nommée isAuthorized(), dans votre modèle utilisateur, pour faire le même genre de choses :

<?php
    class Utilisateur extends AppModel {
        ...

        function isAuthorized($utilisateur, $controleur, $action) {

            switch ($action) {
                case 'default':
                    return false;
                    break;
                case 'delete':
                    if ($utilisateur['Utilisateur']['role'] == 'admin') {
                        return true;
                    }
                    break;
            }
        }
    }
?>

1. <?php
2. class Utilisateur extends AppModel {
3. ...
4. function isAuthorized($utilisateur, $controleur, $action) {
5. switch ($action) {
6. case 'default':
7. return false;
8. break;
9. case 'delete':
10. if ($utilisateur['Utilisateur']['role'] == 'admin') {
11. return true;
12. }
13. break;
14. }
15. }
16. }
17. ?>

Enfin, vous pouvez utiliser authorize avec les actions, comme montré ci-dessous :

<?php
    $this->Auth->authorize = 'actions';
?>

1. <?php
2. $this->Auth->authorize = 'actions';
3. ?>

En utilisant actions, Auth utilisera l'ACL et vérifiera avec AclComponent::check(). Une fonction isAuthorized n'est pas nésessaire.

<?php
    $this->Auth->authorize = 'crud';
?>

1. <?php
2. $this->Auth->authorize = 'crud';
3. ?>

En utilisant crud, Auth utilisera l'ACL et vérifiera avec AclComponent::check(). Les actions devraient correspondre aux CRUD (voir mapActions).

Nom de la clé du tableau de session où l'enregistrement de l'utilisateur actuellement authentifié est stocké.

Par défaut, vaut "Auth", donc si non spécifié, l'enregistrement est stocké dans "Auth.{nom $modeleUtilisateur}".

<?php
    $this->Auth->sessionKey = 'Autorise';
?>

1. <?php
2. $this->Auth->sessionKey = 'Autorise';
3. ?>

Si vous faites des requêtes Ajax ou Javascript qui nécessitent des sessions authentifiées, donnez à cette variable le nom d'un élément de vue que vous souhaiteriez rendre et retourner quand vous avez une session invalide ou expirée.

Comme dans toute partie de CakePHP, soyez certains d'avoir jeté une œil à la classe AuthComponent dans l'API, pour avoir une vision plus approfondie du composant Auth.

Cette variable contient une référence à l'objet responsable du hashage des mots de passe, s'il est nécessaire de changer/surcharger le mécanisme de hashage des mots de passe par défaut. Voyez Changer le type de cryptage pour plus d'info.

Si vous utilisez le contrôle d'accès basé sur les actions, ceci définit la façon dont sont déterminés les chemins vers les nœuds ACO de l'action. Si, par exemple, tous les nœuds de contrôleur sont imbriqués sous un nœud ACO nommé 'Controllers', $actionPath devrait être défini à 'Controllers/'.