HistoriqueListener.php 4.56 KB
Newer Older
1
<?php
2

3
4
namespace UnicaenApp\ORM\Event\Listeners;

5
use Doctrine\Common\EventSubscriber;
6
7
8
use Doctrine\ORM\Event\LifecycleEventArgs;
use Doctrine\ORM\Event\PreUpdateEventArgs;
use Doctrine\ORM\Events;
9
use RuntimeException;
10
use UnicaenApp\Entity\HistoriqueAwareInterface;
11
use UnicaenAuth\Entity\Db\AbstractUser;
12
use Zend\Authentication\AuthenticationService;
13
14

/**
15
16
 * Listener Doctrine.
 *
17
18
 * Renseigne si besoin l'heure et l'auteur de la création/modification
 * de toute entité dont la classe implémente HistoriqueAwareInterface.
19
20
 *
 * Déclenchement : avant que l'enregistrement ne soit persisté (création) ou mis à jour (update).
21
22
 *
 * @author Bertrand GAUTHIER <bertrand.gauthier at unicaen.fr>
23
 * @see HistoriqueAwareInterface
24
 */
25
class HistoriqueListener implements EventSubscriber
26
{
27
28
29
30
    /**
     * @var AuthenticationService
     */
    private $authenticationService;
31
32
33
34
35
36

    /**
     * @var mixed
     */
    protected $identity;

37
38
39
40
41
42
43
44
    /**
     * @param AuthenticationService $authenticationService
     */
    public function setAuthenticationService(AuthenticationService $authenticationService)
    {
        $this->authenticationService = $authenticationService;
    }

45
46
    /**
     * @param LifecycleEventArgs $args
47
     * @throws RuntimeException Aucun utilisateur disponible pour en faire l'auteur de la création/modification
48
49
50
51
52
53
     */
    protected function updateHistorique(LifecycleEventArgs $args)
    {
        $entity = $args->getEntity();

        // l'entité doit implémenter l'interface requise
54
        if (! $entity instanceof HistoriqueAwareInterface) {
55
56
57
58
59
60
61
62
63
            return;
        }

        $now = new \DateTime();

        if (null === $entity->getHistoCreation()) {
            $entity->setHistoCreation($now);
        }

64
65
66
67
68
69
70
71
72
73
74
        // on tente d'abord d'obtenir l'utilisateur connecté pour en faire l'auteur de la création/modification.
        $user = $this->getAuthenticatedUser();
        // si aucun utilisateur connecté n'est disponible, on utilise l'éventuel auteur existant
        if (null === $user) {
            $user = $entity->getHistoCreateur();
        }
        // si nous ne disposons d'aucun utilisateur, basta!
        if (null === $user) {
            throw new RuntimeException("Aucun utilisateur disponible pour en faire l'auteur de la création/modification.");
        }

75
76
77
78
79
80
        if (null === $entity->getHistoCreateur()) {
            $entity->setHistoCreateur($user);
        }

        $entity->setHistoModificateur($user);
        $entity->setHistoModification($now);
81
        /* ce bloc a été mis en commentaire car il est inutile: cf. 2 lignes précédentes !
82
        if (null === $entity->getHistoDestruction() && null === $entity->getHistoDestructeur()) {
83
84
            $entity
                ->setHistoModification($now)
85
86
                ->setHistoModificateur($user);
        }
87
        */
88
89
90
91
92
93

        if (null !== $entity->getHistoDestruction() && null === $entity->getHistoDestructeur()) {
            $entity->setHistoDestructeur($user);
        }
    }

94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
    /**
     * Recherche l'utilisateur connecté pour l'utiliser comme auteur de la création/modification.
     *
     * @return AbstractUser
     */
    private function getAuthenticatedUser()
    {
        $user = null;

        if (($identity = $this->getIdentity())) {
            if (isset($identity['db']) && $identity['db'] instanceof AbstractUser) {
                /* @var $user AbstractUser */
                $user = $identity['db'];
            }
        }

        return $user;
    }

113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
    /**
     * @param LifecycleEventArgs $args
     */
    public function prePersist(LifecycleEventArgs $args)
    {
        $this->updateHistorique($args);
    }

    /**
     * @param PreUpdateEventArgs $args
     */
    public function preUpdate(PreUpdateEventArgs $args)
    {
        $this->updateHistorique($args);
    }

    /**
130
     * Injecte l'identité authentifiée courante.
131
132
     *
     * @param mixed $identity
133
     * @return self
134
135
136
137
138
139
140
141
142
     */
    public function setIdentity($identity)
    {
        $this->identity = $identity;

        return $this;
    }

    /**
143
     * Retourne l'identité authentifiée courante.
144
145
146
147
148
149
     *
     * @return mixed
     */
    public function getIdentity()
    {
        if (null === $this->identity) {
150
            $authenticationService = $this->authenticationService;
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
            if ($authenticationService->hasIdentity()) {
                $this->identity = $authenticationService->getIdentity();
            }
        }

        return $this->identity;
    }

    /**
     * {@inheritdoc}
     */
    public function getSubscribedEvents()
    {
        return [Events::prePersist, Events::preUpdate];
    }
}