UtilisateurController.php 6.28 KB
Newer Older
1
2
3
4
<?php

namespace UnicaenAuth\Controller;

5
use Exception;
6
7
8
9
use UnicaenApp\Exception\RuntimeException;
use UnicaenApp\Mapper\Ldap\People as LdapPeopleMapper;
use UnicaenAuth\Entity\Db\AbstractUser;
use UnicaenAuth\Entity\Shibboleth\ShibUser;
10
use UnicaenAuth\Formatter\RoleFormatter;
11
use UnicaenAuth\Options\ModuleOptions;
12
use UnicaenAuth\Service\Traits\ShibServiceAwareTrait;
13
use UnicaenAuth\Service\Traits\UserContextServiceAwareTrait;
14
15
use UnicaenAuth\Service\UserContext;
use Zend\Authentication\AuthenticationService;
16
use Zend\Http\Request;
17
use Zend\Http\Response;
18
use Zend\Mvc\Controller\AbstractActionController;
19
use Zend\Mvc\Plugin\FlashMessenger\FlashMessenger;
20
use ZfcUser\Mapper\UserInterface;
21
22
23

/**
 * @author Bertrand GAUTHIER <bertrand.gauthier at unicaen.fr>
24
25
 *
 * @method FlashMessenger flashMessenger()
26
 */
27
class UtilisateurController extends AbstractActionController
28
{
29
    use UserContextServiceAwareTrait;
30
    use ShibServiceAwareTrait;
31

32
33
34
35
36
    /**
     * @var LdapPeopleMapper
     */
    protected $ldapPeopleMapper;

37
38
39
40
41
42
43
44
45
    /**
     * @param LdapPeopleMapper $ldapPeopleMapper
     */
    public function setLdapPeopleMapper(LdapPeopleMapper $ldapPeopleMapper)
    {
        $this->ldapPeopleMapper = $ldapPeopleMapper;
    }

    /**
46
     * @var UserInterface
47
48
49
50
51
52
     */
    private $userMapper;

    /**
     * @var AuthenticationService
     */
53
    protected $authenticationService;
54
55
56
57

    /**
     * @var ModuleOptions
     */
58
    protected $options;
59
60

    /**
61
     * @param UserInterface $userMapper
62
     */
63
    public function setUserMapper(UserInterface $userMapper)
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
    {
        $this->userMapper = $userMapper;
    }

    /**
     * @param AuthenticationService $authenticationService
     */
    public function setAuthenticationService(AuthenticationService $authenticationService)
    {
        $this->authenticationService = $authenticationService;
    }

    /**
     * @param ModuleOptions $options
     */
    public function setOptions(ModuleOptions $options)
    {
        $this->options = $options;
    }

84
85
86
    /**
     * Traite les requêtes AJAX POST de sélection d'un profil utilisateur.
     * La sélection est mémorisé en session par le service AuthUserContext.
87
88
89
     *
     * @param bool $addFlashMessage
     * @return bool|string
90
     */
91
    public function selectionnerProfilAction($addFlashMessage = true)
92
    {
93
94
95
96
97
98
        $request = $this->getRequest();
        if (! $request instanceof Request) {
            exit(1);
        }
        if (! $request->isXmlHttpRequest()) {
            return $this->redirect()->toRoute('home');
99
        }
100
        
101
        $role = $request->getPost('role');
102
103
        
        if ($role) {
104
            $this->serviceUserContext->setSelectedIdentityRole($role);
105
        }
106

107
        if ($addFlashMessage) {
108
109
            $message = sprintf(
                "Vous endossez à présent le rôle utilisateur '<strong>%s</strong>'.",
110
                $this->serviceUserContext->getSelectedIdentityRoleToString()
111
            );
112
            $this->flashMessenger()->setNamespace('UnicaenAuth/success')->addMessage($message);
113
        }
114
115

        return false;
116
    }
117

118
    /**
119
120
121
122
     * Usurpe l'identité d'un autre utilisateur.
     *
     * @return Response
     */
123
    public function usurperIdentiteAction(): Response
124
125
126
127
128
129
    {
        $request = $this->getRequest();
        if (! $request instanceof Request) {
            exit(1);
        }

130
131
        $usernameUsurpe = $request->getQuery('identity', $request->getPost('identity'));
        if (! $usernameUsurpe) {
132
133
134
            return $this->redirect()->toRoute('home');
        }

135
136
137
138
139
140
141
142
143
        $utilisateurUsurpe = $this->getUserMapper()->findByUsername($usernameUsurpe); /** @var AbstractUser $utilisateurUsurpe */
        if ($utilisateurUsurpe === null) {
            $this->flashMessenger()->addErrorMessage(
                "La demande d'usurpation du compte '$usernameUsurpe' a échoué car aucun compte utilisateur correspondant " .
                "n'a été trouvé."
            );
            return $this->redirect()->toRoute('home');
        }

144
145
146
        $sessionIdentity = $this->serviceUserContext->usurperIdentite($usernameUsurpe);
        if ($sessionIdentity !== null) {
            // cuisine spéciale si l'utilisateur courant s'est authentifié via Shibboleth
147
            $this->usurperIdentiteShib($utilisateurUsurpe);
148
149
        }

150
151
        return $this->redirect()->toRoute('home');
    }
152

153
154
155
    /**
     * Cuisine spéciale pour l'usurpation si l'utilisateur courant s'est authentifié via Shibboleth.
     *
156
     * @param AbstractUser $utilisateurUsurpe Utilisateur à usurper
157
     */
158
    protected function usurperIdentiteShib(AbstractUser $utilisateurUsurpe)
159
160
    {
        $currentIdentityArray = $this->serviceUserContext->getIdentity();
161

162
163
        if (isset($currentIdentityArray['shib']) && $currentIdentityArray['shib'] instanceof ShibUser) {
            $fromShibUser = $currentIdentityArray['shib'];
164
            $this->shibService->activateUsurpation($fromShibUser, $utilisateurUsurpe);
165
        }
166
    }
167

168
169
170
171
172
173
174
175
    /**
     * Met fin à l'usurpation d'identité en cours éventuelle.
     *
     * @return Response
     */
    public function stopperUsurpationAction(): Response
    {
        $this->serviceUserContext->stopperUsurpation();
176

177
        // cuisine spéciale si l'utilisateur courant s'est authentifié via Shibboleth
178
        $this->stopperUsurpationIdentiteShib();
179
180
181
182
183

        return $this->redirect()->toRoute('home');
    }

    /**
184
     * Cuisine spéciale pour stopper l'usurpation si l'utilisateur courant s'est authentifié via Shibboleth.
185
     */
186
    protected function stopperUsurpationIdentiteShib()
187
    {
188
        $currentIdentityArray = $this->serviceUserContext->getIdentity();
189

190
191
192
        if (isset($currentIdentityArray['shib']) && $currentIdentityArray['shib'] instanceof ShibUser) {
            $this->shibService->deactivateUsurpation();
        }
193
194
195
    }

    /**
196
     * @return UserInterface
197
     */
198
    public function getUserMapper(): UserInterface
199
    {
200
        return $this->userMapper;
201
202
203
204
    }

    /**
     * @return UserContext
205
     * @deprecated Utiliser $this->serviceUserContext directement, svp.
206
     */
207
    protected function getAuthUserContextService(): UserContext
208
    {
209
        return $this->serviceUserContext;
210
    }
211
212
213
214

    /**
     * @return LdapPeopleMapper
     */
215
    public function getLdapPeopleMapper(): LdapPeopleMapper
216
    {
217
        return $this->ldapPeopleMapper;
218
    }
219
}