UserContext.php

<?php

namespace UnicaenAuth\Service;

use Zend\ServiceManager\ServiceLocatorAwareInterface;
use Zend\ServiceManager\ServiceLocatorAwareTrait;
use Zend\Session\Container as SessionContainer;
use Zend\Permissions\Acl\Role\RoleInterface;
use ZfcUser\Entity\UserInterface;
use UnicaenAuth\Entity\Ldap\People;
use UnicaenAuth\Acl\NamedRole;

/**
 * Service centralisant des méthodes utiles concernant l'utilisateur authentifié.
 *
 * @author Laurent LÉCLUSE <laurent.lecluse at unicaen.fr>
 */
class UserContext implements ServiceLocatorAwareInterface
{
    use ServiceLocatorAwareTrait;

    /**
     * @var mixed
     */
    protected $identity;
    
    /**
     * @var array 
     */
    protected $identityRoles;
    
    /**
     * @var SessionContainer
     */
    protected $sessionContainer;

    /**
     * Retourne l'utilisateur BDD courant
     *
     * @return UserInterface
     */
    public function getDbUser()
    {
        if (($identity = $this->getIdentity())) {
            if (isset($identity['db']) && $identity['db'] instanceof UserInterface) {
                return $identity['db'];
            }
        }
        
        return null;
    }

    /**
     * Retourne l'utilisateur LDAP courant
     *
     * @return People
     */
    public function getLdapUser()
    {
        if (($identity = $this->getIdentity())) {
            if (isset($identity['ldap']) && $identity['ldap'] instanceof People) {
                return $identity['ldap'];
            }
        }
        
        return null;
    }

    /**
     * Retourne les données d'identité correspondant à l'utilisateur courant.
     *
     * @return mixed
     */
    public function getIdentity()
    {
        if (null === $this->identity) {
            $authenticationService = $this->getServiceLocator()->get('Zend\Authentication\AuthenticationService');
            if ($authenticationService->hasIdentity()) {
                $this->identity = $authenticationService->getIdentity();
            }
        }
        
        return $this->identity;
    }
    
    /**
     * Retourne les rôles de l'utilisateur courant.
     * 
     * @return array
     */
    public function getIdentityRoles()
    {
        if (null === $this->identityRoles) {
            $authorize = $this->getServiceLocator()->get('BjyAuthorize\Service\Authorize');
            $identityProvider = $authorize->getIdentityProvider();
            $this->identityRoles = $identityProvider->getIdentityRoles();
        }
        
        return $this->identityRoles;
    }
    
    /**
     * Retourne les rôles de l'utilisateur courant qui peuvent être sélectionnés.
     * 
     * @return array
     */
    public function getSelectableIdentityRoles()
    {
        $filter = function($r) { return !($r instanceof NamedRole && !$r->getSelectable()); };
        $roles  = array_filter($this->getIdentityRoles(), $filter);
        
        return $roles;
    }
    
    /**
     * Si un utilisateur est authentifié, retourne le rôle utilisateur sélectionné, 
     * ou alors le premier sélectionnable si aucun n'a été sélectionné.
     * 
     * @return mixed
     */
    public function getSelectedIdentityRole()
    {
        if (null === $this->getSessionContainer()->selectedIdentityRole) {
            if ($this->getIdentity()) {
                $roles = $this->getSelectableIdentityRoles();
                $this->setSelectedIdentityRole(reset($roles));
            }
        }
        
        return $this->normalizedIdentityRole($this->getSessionContainer()->selectedIdentityRole);
    }
    
    /**
     * Mémorise en session le rôle spécifié comme étant le rôle courant de l'utilisateur.
     * NB: seul l'id du rôle est mémorisé en session.
     * 
     * @param RoleInterface|string $role
     * @return \UnicaenAuth\Service\UserContext
     */
    public function setSelectedIdentityRole($role)
    {
        if ($role) {
            if (!$this->isRoleValid($role)) {
                throw new \Common\Exception\RuntimeException("Rôle spécifié invalide.");
            }
            if ($role instanceof RoleInterface) {
                $role = $role->getRoleId();
            }
            $this->getSessionContainer()->selectedIdentityRole = $role;
        }
        else {
            unset($this->getSessionContainer()->selectedIdentityRole);
        }
        
        return $this;
    }
    
    /**
     * Recherche le role spécifié parmi les rôles connus au format objets.
     * 
     * @param mixed $role 
     * @return mixed Role trouvé au format objet dans la mesure du possible
     */
    protected function normalizedIdentityRole($role)
    {
        if (!$role || is_object($role)) {
            return $role;
        }
        
        foreach ($this->getIdentityRoles() as $r) {
            if ($r instanceof RoleInterface && $role === $r->getRoleId()) {
                return $r;
            }
            if ($role === $r) {
                return $r;
            }
        }
        
        return $role;
    }
    
    /**
     * Teste si le rôle spécifié fait partie des rôles disponibles.
     * 
     * @param mixed $role
     * @return boolean
     */
    protected function isRoleValid($role)
    {
        if ($role instanceof RoleInterface) {
            $role = $role->getRoleId();
        }
        
        foreach ($this->getIdentityRoles() as $r) {
            if ($r instanceof RoleInterface) {
                $r = $r->getRoleId();
            }
            if ($role === $r) {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Retourne le stockage en session utilisé pour mémoriser le profil 
     * sélectionné par l'utilsateur.
     * 
     * @return SessionContainer
     */
    protected function getSessionContainer()
    {
        if (null === $this->sessionContainer) {
            $this->sessionContainer = new SessionContainer(get_class());
        }
        
        return $this->sessionContainer;
    }
}