17.6 Manipulation des comptes utilisateur

Ce chapitre a pour but de montrer, par l'utilisation des méthodes et fonctions les plus courantes, la manipulation des utilisateurs "interne".

Ce chapitre ne décrit pas la manipulation des utilisateurs réseaux disponibles avec le module "dynacase-networkuser".

17.6.1 Création d'un utilisateur

La création d'un utilisateur peut être fait à l'aide de la famille IUSER.

Les comptes utilisateurs sont gérés par la classe Account. La famille IUSER permet de faire le lien entre le compte "système" (classe Account) et le document (famille IUSER).

Un utilisateur est identifié par un numéro unique. Ce numéro est renseigné par l'attribut us_whatid du document IUSER. Il correspond à l'attribut "id" de la classe Account.

Code minimaliste pour créer un utilisateur via les documents.

include_once("FDL/Class.Doc.php");
$iUser=createDoc("",'IUSER');
if ($iUser) {
    $iUser->setValue("us_login","jean.martin");
    $iUser->setValue("us_lname","martin");
    $iUser->setValue("us_fname","jean");
    $iUser->setValue("us_passwd1","secret");
    $iUser->setValue("us_passwd2","secret"); // nécessaire de doubler à cause des contraintes
    $err=$iUser->store();
    if (!$err) {
      print "nouvel utilisateur n°".$iUser->getValue("us_whatid"); // affichage de l'identifiant système
    } else {
      print "\nerreur:$err";
    }
}

17.6.2 Correspondance entre compte User et document IUSER

Pour récupérer le compte système à partir du document IUSER :

$user=$userDoc->getAccount();
if ($user->id != $doc->getValue("us_whatid") ) {
    // ce n'est pas normal
}

Si vous ne disposez que de l'identifiant documentaire vous pouvez aussi utiliser la méthode setFid de la classe Account:

$user=new Account();
$user->setFid($docUserId);
if ($user->isAffected()) {
   print $user->login;
}

A l'inverse pour récupérer l'objet documentaire à partir du compte système, vous pouvez utiliser l'attribut "fid".

$user=new Account();
$user->setLoginName("john.doe");
if ($user->isAffected()) {
  $doc=new_doc("", $user->fid);
}

Attributs de correspondance : Compte User ⇔ Document IUSER

Compte User Document IUSER
id us_whatid
login us_login
mail us_mail
firstname us_fname
lastname us_lname
fid id

Exemple de création d'utilisateur via la classe Account

$user=new Account();
$user->login='jean.dupond';
$user->firstname='Jean';
$user->lastname='Dupond';
$user->password_new='secret';
$err=$user->add();
if ($err) {
  error_log($err);
} else {
  print "Nouvel utilisateur n°".$user->id;
}

17.6.3 Groupe d'utilisateurs

La famille IGROUP permet de rajouter des utilisateurs dans des groupes.

La famille IGROUP comme la famille IUSER utilise la classe Account pour identifier les groupes "système".

Comme la famille IUSER, la famille IGROUP dispose de la méthode IGROUP::getAccount() pour récupérer l'objet Account correspondant

17.6.3.1 Correspondance Compte Groupe ⇔ Document IGROUP

Compte Groupe Document IGROUP
id us_whatid
login us_login
lastname grp_name
fid id

Le compte "Account" d'un groupe a toujours son attribut "accounttype" à "G".

17.6.3.2 Ajout d'un utilisateur à un groupe

Utilisation de Dcp\Family\IGROUP::insertDocument().

Ajout de l'utilisateur n°1009 dans le groupe GDEFAULT :

include_once("FDL/Class.Doc.php");
 
$dbaccess = getDbAccess();
 
$group = new_Doc($dbaccess,"GDEFAULT");
$user = new_Doc($dbaccess,1009); // 1009 est la référence documentaire de l'utilisateur
 
printf("ajout de l'utilisateur %s [%d] au groupe %s [%d]\n",
       $user->getTitle(),$user->id,$group->getTitle(),$group->id);
 
printf("liste des groupes avant\n");
print_r($user->getTValue("us_idgroup"));
 
$err=$group->insertDocument($user->initid);
print "Error:$err\n";
 
printf("liste des groupes apres\n");
print_r($user->getTValue("us_idgroup"));

17.6.3.3 Suppression d'utilisateur dans un groupe

Utilisation de Dcp\Family\IGROUP::removeDocument().

include_once("FDL/Class.Doc.php");
 
$dbaccess=getDbAccess();
 
$group=new_Doc($dbaccess,"GDEFAULT");
$user=new_Doc($dbaccess,1009);
 
printf("suppression de l'utilisateur %s [%d] du groupe %s [%d]\n",
       $user->getTitle(),$user->id,$group->getTitle(),$group->id);
 
printf("liste des groupes avant\n");
print_r($user->getTValue("us_idgroup"));
 
$err=$group->removeDocument($user->initid);
print "Error:$err\n";
 
printf("liste des groupes apres\n");
print_r($user->getTValue("us_idgroup"));

17.6.3.4 Récupération des membres d'un groupe

À partir de l'objet "Account" d'un groupe : Account::getAllMembers().

Exemple d'utilisation :

$docGroup=new_Doc("", "GDEFAULT");
$group=$docGroup->getAccount();
$members=$group->getAllMembers();
$userDocIdList=array();
foreach ($members as $user) {
    printf("%s) %s\n", $user["id"],$user["login"]);
    $userDocIdList[]=$user["fid"];
}
print "---\n";
// recherche des documents `IUSER` correspondants
$documentList=new DocumentList();
$documentList->addDocumentIdentificators($userDocIdList);
foreach ($documentList as $docid=>$docIUser) {
    printf("%s)%s\n", $docIUser->id,  $docIUser->getTitle());
}

17.6.4 Rôles

La famille ROLE permet d'associer des rôles à des utilisateurs ou à des groupes.

La famille ROLE comme la famille IUSER utilise la classe Account pour identifier les groupes "système".

Comme la famille IUSER, la famille ROLE dispose de la méthode ROLE::getAccount() pour récupérer l'objet Account correspondant

17.6.4.1 Correspondance Compte Rôle ⇔ Document ROLE

Compte Rôle Document ROLE
id us_whatid
login role_login
lastname role_name
fid id

17.6.5 Récupération des utilisateurs associés à un rôle

Comme pour les groupes, à partir de l'objet "Account" d'un rôle : Account::getAllMember().

Exemple d'utilisation :

$docRole=new_Doc("", "TST_ROLE");
$members=$docRole->getAccount()->getAllMembers();
$userDocIdList=array();
foreach ($members as $user) {
  printf("%s) %s\n", $user["id"],$user["login"]);
  $userDocIdList[]=$user["fid"];
}
print "---\n";
// recherche des documents `IUSER` correspondants
$documentList=new DocumentList();
$documentList->addDocumentIdentificators($userDocIdList);
foreach ($documentList as $docid=>$docIUser) {
  printf("%s)%s\n", $docIUser->id,  $docIUser->getTitle());
}

17.6.6 Récupération des rôles d'un utilisateur

À partir de l'objet "Account" , méthode Account::getAllRoles()

Exemple d'utilisation :

$user=new Account('');
$user->setLoginName('john.doe');
if ($user->isAffected()) {
  $roles=$user->getAllRoles();
  foreach ($roles as $aRole) {
    printf("%d)%s\n", $aRole["id"],$aRole["login"]); 
  }
}

17.6.7 Suppléants et titulaires

Affectation d'un suppléant à un utilisateur et récupérations des titulaires.

$user=new Account(); 
$user->setLoginName("j1"); 
if ($user->isAffected()) { 
  $err=$user->setSubstitute("j2"); // J1 est le titulaire de J2 
                                //(J2 est suppléant de J1) 
} 
$user->setLoginName("j3"); 
if ($user->isAffected()) { 
  $err=$user->setSubstitute("j2");// J3 est le titulaire de J2 
} 
$user->setLoginName("j2"); 
$incumbents=$user->getIncumbents(); // J2 a comme titulaire J1 et J3 
foreach ($incumbents as $key=> $aIncumbent) { 
  printf("%d)%s\n", $key,Account::getDisplayName($aIncumbent)); 
}

Résultat :

www-data@luke:~$ ./wsh.php --api=testSubstitute
0)j1 Doe 
1)j3 Doe

17.6.8 Recherche de comptes

Il est possible de rechercher les comptes suivant leurs critères d'appartenance à des rôles ou des groupes. La classe SearchAccount permet de réaliser facilement la recherche de compte. Le résultat de cette recherche peut retourner des utilisateurs, des groupes ou des rôles.

17.6.8.1 Recherche des utilisateurs par rôle

Pour indiquer le filtre d'un rôle, il faut utiliser, la méthode ::addRoleFilter(). Cette méthode prend en argument la référence du rôle. La référence correspond à l'attribut 'role_login' du document ou à l'attribut login de l'objet Account. Il ne correspond pas au nom logique du document.

$searchAccount = new SearchAccount();
$searchAccount->addRoleFilter('writter');
$searchAccount->setObjectReturn($searchAccount::returnAccount);
/**
 * @var \AccountList $accountList
 */
$accountList = $searchAccount->search();
/**
 * @var \Account $account
 */
foreach ($accountList as $account) {
  $login = $account->login;
  print "$login\n";
}
 

Pour rechercher à partir du nom logique du document rôle, il faut utiliser la méthode ::docName2login de correspondance fournie par la classe.

$searchAccount->addRoleFilter($searchAccount->docName2login('TST_ROLEWRITTER'));

La méthode SearchAccount::setObjectReturn() permet d'indiquer le type de résultat obtenu par la méthode SearchAccount::search(). Par défaut cela retourne un objet AccountList qui est un itérateur sur des objets Account. Il est possible d'indiquer SearchAccount::returnDocument, pour que la méthode SearchAccount::search() retourne un objet DocumentList qui donnera les documents correspondants

$searchAccount = new SearchAccount();
$searchAccount->addRoleFilter($searchAccount->docName2login('TST_ROLEWRITTER'));
$searchAccount->setObjectReturn($searchAccount::returnDocument);
/**
 * @var \DocumentList $documentList
 */
$documentList = $searchAccount->search();
/**
 * @var \Doc $doc
 */
foreach ($documentList as $doc) {
  $login = $doc->getValue("us_login");
  print "$login\n";
}

Si on précise plusieurs rôles séparés par un espace, cela indiquera une disjonction (OU).

$searchAccount->addRoleFilter("writter controller");

indique que les comptes recherchés ont le rôle "writter" ou "controller".

Cette écriture est équivalente à :

$searchAccounts->addRoleFilter("writter");
$searchAccount->addRoleFilter("controller");

La condition d'appartenance à plusieurs rôles n'est pas disponible avec cette méthode. Ce filtre peut retourner des groupes ou des utilisateurs.

17.6.8.2 Recherche des utilisateurs par groupe

La méthode ::addGroupFilter() est équivalent à ::addRoleFilter(). Elle permet de rechercher parmi les comptes qui appartiennent à différents groupes. Si cette méthode est combinée à la méthode ::addRoleFilter() cela indique tous les comptes qui appartiennent à un des groupes cités ou à un des rôles cités.

$searchAccounts->addGroupFilter("all"); // tous les utilisateurs du groupe "all"

La recherche par groupe recherche aussi les comptes dans les sous-groupes. Ce filtre peut retourner des groupes ou des utilisateurs.

17.6.8.3 Recherche sur des critères de compte

La méthode ::addFilter() permet d'ajouter des filtres sur les caractéristiques des comptes:

  • login
  • firstname
  • lastname
  • mail
  • accounttype
  • status

 

$mailExpr='test';
$searchAccount = new SearchAccount();
$searchAccount->addFilter("mail ~ '%s'", $mailExpr); // filtre les mail qui contiennent test
$accountList = $searchAccount->search();
foreach ($accountList as $account) {
  printf("%s => %s\n ", $account->login, $account->mail);
}

La méthode SearchAccount::addFilter() ajoute une condition supplémentaire sur le filtre. Le premier argument est la partie statique du filtre et les suivants sont les arguments du filtre comme pour sprintf.

Au contraire de SearchAccount::addGroupFilter() ou SearchAccount::addRoleFilter() les filtres sont autant de critères ajoutés à la condition finale.

La méthode SearchAccount::setTypeReturn() permet de préciser le type de compte à retourner : Utilisateur, Groupe ou Rôle.

$searchAccount->setTypeFilter($searchAccount::userType) ; // limité aux utilisateurs
$searchAccount->setTypeFilter($searchAccount::userType | $searchAccount::groupType ) ;// limité aux utilisateurs et aux groupes
$searchAccount->setTypeFilter($searchAccount::roleType) ; // limité aux rôles

Le paramètre est une combinaison des 3 constantes userType, groupType et roleType.

Par défaut, les comptes retournés ne sont pas liés aux privilèges du document associé. Si on désire ne rechercher que parmi les comptes que l'utilisateur courant a le droit de voir il faut rajouter l'appel à la méthode SearchAccount::useViewControl() avant l'appel à SearchAccount::search().

$searchAccount->useViewControl(true);

17.6.9 Spécialisation des documents utilisateurs

Les documents système "utilisateur" (famille IUSER) peuvent être dérivés pour ajouter des informations fonctionnelles ou pour ajouter des informations techniques dans le cas d'un backend d'authentification spécifique.

La famille IUSER n'impose pas de contrainte de syntaxe sur le login. La seule contrainte est que ce "login" doit être unique parmi tous les comptes (utilisateurs, groupes et rôles). Si vous voulez ajouter une contrainte de syntaxe sur votre famille "utilisateur" dérivé de IUSER vous devez surcharger la méthode IUSER::constraintLogin() qui est une méthode contrainte.

Exemple :

 // constraint to limit login to 6 characters
public function constraintLogin($login)
 {
        //only six alpha num
        $err = '';
        if (!preg_match("/^[a-z0-9]{6}$/i", $login)) {
            $err = _("the login must have six characters");
        }
        // must verify unicity also
        if (!$err) return parent::constraintLogin($login);
        return $err;
 }

Attention: lorsque la famille IUSER est dérivée, il faut reprendre et adapter le paramétrage en terme de sécurité (profil, contrôle de vue) en fonction de vos besoins.

Source : Advanced/Persistance/user.md Dynacase Platform 3.2 | Core Manuel de référence, version 3.2 édition 13, © Anakeen Labs <labs@anakeen.com>
×
Publié sous licence CC (http://creativecommons.org/licenses/by-nc-sa/2.0/fr/) par Anakeen [www.anakeen.com]
Attribution Vous devez créditer l'Oeuvre, intégrer un lien vers la licence et indiquer si des modifications ont été effectuées à l'Oeuvre. Vous devez indiquer ces informations par tous les moyens possibles mais vous ne pouvez pas suggérer que l'Offrant vous soutient ou soutient la façon dont vous avez utilisé son Oeuvre.
Pas d’Utilisation Commerciale Vous n'êtes pas autoriser à faire un usage commercial de cette Oeuvre, tout ou partie du matériel la composant.
Partage dans les Mêmes Conditions Dans le cas où vous effectuez un remix, que vous transformez, ou créez à partir du matériel composant l'Oeuvre originale, vous devez diffuser l'Oeuvre modifiée dans les même conditions, c'est à dire avec la même licence avec laquelle l'Oeuvre originale a été diffusée.
mis à jour