Documentation (9882f28b) · Commits · lib / unicaen / utilisateur

Original line number	Diff line number	Diff line
		# Les rôles

		<!-- TOC -->
		* [Base de données](#base-de-données)
		* [Configuration](#configuration)
		* [Navigation](#navigation)
		* [Gestion des rôles](#gestion-des-rôles)
		* [Créer un rôle](#créer-un-rôle)
		* [Rôle automatique](#rôle-automatique)
		* [Filtre Ldap](#filtre-ldap)
		* [Identity provider](#identity-provider)
		<!-- TOC -->

		## Base de données

		La liste des rôles et l'association des rôles et des utilisateursdoit être définies dans la base de données.

		Scripts SQL de création des tables :
		* [PostgreSQL](../sql/schema_postgresql.sql)
		* [Oracle](../sql/schema_oracle.sql)


		## Configuration

		Il est possible de redéfinir l'entité utilisée pour gérer les rôle mais elle doit obligatoirement héritée de la classe `UnicaenUtilisateur\Entity\Db\AbstractRole`.

		```php
		use UnicaenUtilisateur\Entity\Db\Role;

		'unicaen-auth' => [
		/**
		* L'entité associée aux roles peut être spécifiée via la clef de configuration ['unicaen_auth']['role_entity_class']
		* Si elle est manquante alors la classe @see \UnicaenUtilisateur\Entity\Db\Role est utilisée
		* NB : la classe spécifiée doit hériter de @see \UnicaenUtilisateur\Entity\Db\AbstractRole
		*/
		'role_entity_class' => Role::class,
		],
		```

		## Navigation

		Un lien vers la page de gestion des utilisateurs est disponible par défaut dans le menu `Administration`.

		```php
		use UnicaenUtilisateur\Provider\Privilege\RolePrivileges;

		'navigation' => [
		'default' => [
		'home' => [
		'pages' => [
		// Pour les anciennes applications qui avaient besoin de la route "droits"
		'droits' => [
		'label' => "Droits",
		'title' => "Droits",
		'route' => "unicaen-privilege",
		'visible' => false,
		],
		// Pour les nouvelles applications qui utilisent la route "administration"
		'administration' => [
		'label' => "Administration",
		'title' => "Administration",
		'route' => "unicaen-privilege",
		'pages' => [
		[
		'label' => 'Gérer les rôles',
		'title' => 'Gérer les rôles',
		'route' => 'unicaen-role',
		'resource' => RolePrivileges::getResourceId(RolePrivileges::ROLE_AFFICHER),
		],
		],
		],
		],
		],
		],
		]
		```

		## Gestion des rôles

		### Créer un rôle

		Il faut compléter le formulaire en saisissant :
		* un identifiant ;
		* un libellé ;
		* une description (facultatif)
		* un filtre Ldap ([Rôle automatique](#rôle-automatique)).\

		Et en sélectionnant :
		* un rôle parent (facultatif) : héritage des droits ;
		* rôle par défaut ou non : rôle donné si l'utilisateur n'a acun rôle ;
		* rôle automatique ou non ([Rôle automatique](#rôle-automatique)) ;
		* rôle extérieur ou non : rôle utilisable depuis le réseau extéreieur à l'université ;
		* rôle affiché ou non : visible ou non dans l'interface.

		![](./img/img_4.png)

		### Rôle automatique

		#### Filtre Ldap

		Il y a la possibilté d'associer un filtre Ldap à un rôle. Si l'utilisateur appartient à ce filtre Ldap, le rôle lui sera automatiquement associé.

		> [!IMPORTANT]
		> Le rôle en question ne doit pas être défini comme un rôle automatique.

		#### Identity provider

		On va pouvoir également s'appuyer sur un founisseur d'identité spécifique qui va permettre d'attribuer des rôles automatiquement aux utilisateurs en fonction de critères qui seront à définir dans celui-ci.

		> [!IMPORTANT]
		> Le rôle en question doit être défini comme un rôle automatique.

		Pour mettre en place un rôle automatique, il faut créer son propre fournisseur d'identité qui doit hériter de la classe abstraite `UnicaenUtilisateur\Provider\Identity\AbstractIdentityProvider`. Cette classe impose l'implémentation de deux fonctions :
		* `computeUsersAutomatiques(string $code)` qui renvoie un tableau des utilisateurs `UnicaenUtilisateur\Entity\Db\UserInterface` associés au rôle (role_id) passé en paramètre ;
		* `computeRolesAutomatiques(?UserInterface $user = null)` qui renvoie un tableau des rôles `UnicaenUtilisateur\Entity\Db\UserRoleInterface` associés à l'utilisateur passé en paramètre.

		```php
		namespace Application\Provider\Identity;

		use UnicaenUtilisateur\Entity\Db\RoleInterface;
		use UnicaenUtilisateur\Provider\Identity\AbstractIdentityProvider;
		use UnicaenUtilisateur\Service\Role\RoleServiceAwareTrait;
		use UnicaenUtilisateur\Service\User\UserServiceAwareTrait;
		use ZfcUser\Entity\UserInterface;

		class IdentityFromFonctionProvider extends AbstractIdentityProvider
		{
		use RoleServiceAwareTrait;
		use UserServiceAwareTrait;

		/**
		* @var string[] mapping entre la fonction et le rôle automatique
		*/
		private $mapping = [
		'correspondant_annuaire' => ['A001'],
		'correspondant_laboratoire' => ['T98'],
		];

		/**
		* @param string $code
		* @return UserInterface[]\|null
		*/
		public function computeUsersAutomatiques(string $code) : ?array
		{
		/**
		* @var UserInterface[] $users
		*/
		$users = $this->userService->findByState(1);

		if(in_array($code, array_keys($this->mapping))) {
		$users = $this->userService->findByFonction($code);
		return $users;
		}

		return [];
		}

		/**
		* @param UserInterface\|null $user
		* @return RoleInterface[]
		*/
		public function computeRolesAutomatiques(?UserInterface $user = null) : array
		{
		// @var RoleInterface[] */
		$roles = [];

		if ($user === null) {
		// on récupère l'utilisateur connecté
		$user = $this->userService->getConnectedUser();
		}

		if($user) {
		foreach (array_keys($this->mapping) as $code) {
		$fonctions = $user->getIndividu()->getFonctions()->filter(function ($f) use ($code) {
		return in_array($f->getCode(), $this->mapping[$code]);
		});

		if (!$fonctions->isEmpty()) {
		$role = $this->roleService->findByRoleId($code);;
		$roles[] = $role;
		}
		}

		}

		return $roles;
		}
		}
		```

		Il faut ensuite ajouter le `provider` dans la config et il faut utiliser pour cela la clé `identity-provider` de la configuration globale du module `unicaen/utilisateur`.

		```php
		use Application\Provider\Identity\IdentityFromFonctionProvider;

		'unicaen-utilisateur' => [
		'identity-provider' => [
		IdentityFromFonctionProvider::class,
		],
		],
		```

		Mais également l'ajouter aux fournisseurs d'identité définis au niveau du module `unicaen/authentification` à l'aide de la clé de configuration `identity_provider`.

		```php
		use Application\Provider\Identity\IdentityFromFonctionProvider;

		'unicaen-auth' => [
		'identity_providers' => [
		50 => IdentityFromFonctionProvider::class,
		],
		],
		```

		> [!NOTE]
		> Identiquement au rôle manuel, les privilèges et les périmètres pourront être utilisés avec un rôle automatique provenant d'un filtre LDAP ou d'un fournisseur d'identité.
		No newline at end of file