Chain.php 4.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
<?php

namespace UnicaenAuth\Authentication\Storage;

use Zend\Authentication\Storage\StorageInterface;
use Zend\EventManager\EventManagerInterface;
use Zend\EventManager\EventManagerAwareInterface;
use Zend\EventManager\EventManager;

/**
 * Implémentation d'une chaîne de responsabilité permettant à plusieurs sources
 * de fournir les données sur l'identité authentifiée éventuelle.
13
 *
14
15
16
17
18
19
20
21
22
23
 * Exemples de sources disponibles :
 *  - Ldap (annuaire LDAP)
 *  - Db (table des utilisateurs en base de données)
 *
 * @author Bertrand GAUTHIER <bertrand.gauthier at unicaen.fr>
 * @see ChainEvent
 * @see \UnicaenAuth\Service\ChainAuthenticationStorageServiceFactory
 * @see Ldap
 * @see Db
 */
24
class Chain implements StorageInterface, EventManagerAwareInterface
25
26
27
28
29
{
    /**
     * @var StorageInterface
     */
    protected $storage;
30

31
    /**
32
     * @var EventManagerInterface
33
34
     */
    protected $eventManager;
35

36
37
38
39
    /**
     * @var ChainEvent
     */
    protected $event;
40

41
42
43
44
    /**
     * @var array
     */
    protected $resolvedIdentity;
45

46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
    /**
     * Returns true if and only if storage is empty
     *
     * @throws \Zend\Authentication\Exception\ExceptionInterface If it is impossible to determine whether storage is empty
     * @return bool
     */
    public function isEmpty()
    {
        return $this->getStorage()->isEmpty();
    }

    /**
     * Returns the contents of storage
     *
     * Behavior is undefined when storage is empty.
     *
     * @throws \Zend\Authentication\Exception\ExceptionInterface If reading contents from storage is impossible
     * @return mixed
     */
    public function read()
    {
67
68
69
        if (null !== $this->resolvedIdentity) {
            return $this->resolvedIdentity;
        }
70

71
        $e = $this->getEvent();
72
73
        $e->setName('read');
        $this->getEventManager()->triggerEvent($e);
74

75
        $identity = $e->getContents();
76

77
78
79
80
81
82
        if ($identity) {
            $this->resolvedIdentity = $identity;
        }
        else {
            $this->resolvedIdentity = null;
        }
83

84
        return $this->resolvedIdentity;
85
86
87
88
89
90
91
92
93
94
95
96
    }

    /**
     * Writes $contents to storage
     *
     * @param  mixed $contents
     * @throws \Zend\Authentication\Exception\ExceptionInterface If writing $contents to storage is impossible
     * @return void
     */
    public function write($contents)
    {
        $this->getStorage()->write($contents);
97

98
        $e = $this->getEvent();
99
        $e->setName('write');
100
        $e->setParams(compact('contents'));
101
        $this->getEventManager()->triggerEvent($e);
102
103
104
105
106
107
108
109
110
111
112
    }

    /**
     * Clears contents from storage
     *
     * @throws \Zend\Authentication\Exception\ExceptionInterface If clearing contents from storage is impossible
     * @return void
     */
    public function clear()
    {
        $this->getStorage()->clear();
113

114
        $e = $this->getEvent();
115
116
        $e->setName('clear');
        $this->getEventManager()->triggerEvent($e);
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
    }

    /**
     * getStorage
     *
     * @return StorageInterface
     */
    public function getStorage()
    {
        if (null === $this->storage) {
            $this->setStorage(new \Zend\Authentication\Storage\Session());
        }
        return $this->storage;
    }

    /**
     * setStorage
     *
     * @param StorageInterface $storage
     * @return self
     */
    public function setStorage(StorageInterface $storage)
    {
        $this->storage = $storage;
        return $this;
    }
143

144
    /**
145
     * {@inheritdoc}
146
147
148
     */
    public function setEventManager(EventManagerInterface $eventManager)
    {
149
        $eventManager->setIdentifiers([
150
151
            __CLASS__,
            get_called_class(),
152
        ]);
153
154
155
        $this->eventManager = $eventManager;
        return $this;
    }
156

157
158
159
160
161
162
163
164
165
166
167
    /**
     * Retrieve the event manager
     *
     * Lazy-loads an EventManager instance if none registered.
     *
     * @return EventManagerInterface
     */
    public function getEventManager()
    {
        return $this->eventManager;
    }
168

169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
    /**
     * @return ChainEvent
     */
    public function getEvent()
    {
        if (null === $this->event) {
            $this->event = new ChainEvent();
        }
        return $this->event;
    }

    /**
     * @param ChainEvent $event
     * @return self
     */
    public function setEvent(ChainEvent $event)
    {
        $this->event = $event;
        return $this;
    }
}