UserContext.php 5.57 KB
Newer Older
1
2
3
4
5
<?php

namespace UnicaenAuth\Service;

use Zend\ServiceManager\ServiceLocatorAwareInterface;
6
7
use Zend\ServiceManager\ServiceLocatorAwareTrait;
use Zend\Session\Container as SessionContainer;
8
use Zend\Permissions\Acl\Role\RoleInterface;
9
10
use ZfcUser\Entity\UserInterface;
use UnicaenAuth\Entity\Ldap\People;
11
use UnicaenAuth\Acl\NamedRole;
12
13

/**
14
 * Service centralisant des méthodes utiles concernant l'utilisateur authentifié.
15
16
17
18
19
 *
 * @author Laurent LÉCLUSE <laurent.lecluse at unicaen.fr>
 */
class UserContext implements ServiceLocatorAwareInterface
{
20
    use ServiceLocatorAwareTrait;
21
22
23
24
25

    /**
     * @var mixed
     */
    protected $identity;
26
    
27
    /**
28
     * @var array 
29
     */
30
31
32
33
34
35
    protected $identityRoles;
    
    /**
     * @var SessionContainer
     */
    protected $sessionContainer;
36
37
38
39
40
41
42
43
44
45
46
47
48

    /**
     * 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'];
            }
        }
49
        
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
        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'];
            }
        }
65
        
66
67
68
69
        return null;
    }

    /**
70
     * Retourne les données d'identité correspondant à l'utilisateur courant.
71
     *
72
     * @return mixed
73
     */
74
    public function getIdentity()
75
    {
76
77
78
79
80
81
        if (null === $this->identity) {
            $authenticationService = $this->getServiceLocator()->get('Zend\Authentication\AuthenticationService');
            if ($authenticationService->hasIdentity()) {
                $this->identity = $authenticationService->getIdentity();
            }
        }
82
        
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
        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();
        }
98
        
99
100
101
102
103
104
105
106
107
108
109
110
        return $this->identityRoles;
    }
    
    /**
     * Retourne les rôles de l'utilisateur courant qui peuvent être sélectionnés.
     * 
     * @return array
     */
    public function getSelectableIdentityRoles()
    {
        return array_filter(
                $this->getIdentityRoles(), 
111
                function($r) { return !($r instanceof NamedRole && !$r->getSelectable()); });
112
113
114
    }
    
    /**
115
116
     * 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é.
117
118
119
120
121
122
     * 
     * @return mixed
     */
    public function getSelectedIdentityRole()
    {
        if (null === $this->getSessionContainer()->selectedIdentityRole) {
123
124
125
126
            if ($this->getIdentity()) {
                $roles = $this->getSelectableIdentityRoles();
                $this->getSessionContainer()->selectedIdentityRole = reset($roles) ?: null;
            }
127
        }
128
        
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
        return $this->getSessionContainer()->selectedIdentityRole;
    }
    
    /**
     * Mémorise le rôle courant de l'utilisateur.
     * 
     * @param mixed $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.");
            }
144
            $this->getSessionContainer()->selectedIdentityRole = $this->normalizedIdentityRole($role);
145
146
147
148
        }
        else {
            unset($this->getSessionContainer()->selectedIdentityRole);
        }
149
        
150
151
        return $this;
    }
152
    
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
    /**
     * 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 (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;
    }
    
177
    /**
178
179
180
181
     * Teste si le rôle spécifié fait partie des rôles disponibles.
     * 
     * @param mixed $role
     * @return boolean
182
     */
183
    protected function isRoleValid($role)
184
    {
185
        foreach ($this->getIdentityRoles() as $r) {
186
            if ($r instanceof RoleInterface) {
187
188
189
190
191
192
                $r = $r->getRoleId();
            }
            if ($role === $r) {
                return true;
            }
        }
193
        
194
195
196
197
198
199
200
201
202
203
204
205
206
207
        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());
        }
208
        
209
        return $this->sessionContainer;
210
211
    }
}