1
|
|
|
<?php |
2
|
|
|
/** |
3
|
|
|
* Copyright (C) 2018 Gerrit Addiks. |
4
|
|
|
* This package (including this file) was released under the terms of the GPL-3.0. |
5
|
|
|
* You should have received a copy of the GNU General Public License along with this program. |
6
|
|
|
* If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy. |
7
|
|
|
* @license GPL-3.0 |
8
|
|
|
* @author Gerrit Addiks <[email protected]> |
9
|
|
|
*/ |
10
|
|
|
|
11
|
|
|
namespace Addiks\RDMBundle\Doctrine; |
12
|
|
|
|
13
|
|
|
use Addiks\RDMBundle\Hydration\EntityHydratorInterface; |
14
|
|
|
use Addiks\RDMBundle\Mapping\Drivers\MappingDriverInterface; |
15
|
|
|
use Addiks\RDMBundle\Mapping\EntityMappingInterface; |
16
|
|
|
use Addiks\RDMBundle\DataLoader\DataLoaderInterface; |
17
|
|
|
use Doctrine\ORM\Event\LifecycleEventArgs; |
18
|
|
|
use Doctrine\ORM\Mapping\ClassMetadata; |
19
|
|
|
use Doctrine\ORM\Tools\SchemaTool; |
20
|
|
|
use Doctrine\ORM\Tools\Event\GenerateSchemaTableEventArgs; |
21
|
|
|
use Doctrine\ORM\Event\LoadClassMetadataEventArgs; |
22
|
|
|
use Doctrine\ORM\EntityManagerInterface; |
23
|
|
|
use Doctrine\ORM\UnitOfWork; |
24
|
|
|
use Doctrine\DBAL\Schema\Table; |
25
|
|
|
use Doctrine\ORM\Event\PostFlushEventArgs; |
26
|
|
|
use Doctrine\ORM\Proxy\Proxy; |
27
|
|
|
use Doctrine\DBAL\Schema\Column; |
28
|
|
|
use PDOException; |
29
|
|
|
use Doctrine\DBAL\Exception\ConnectionException; |
30
|
|
|
|
31
|
|
|
/** |
32
|
|
|
* Hooks into the event's of doctrine2-ORM and forwards the entities to other objects. |
33
|
|
|
*/ |
34
|
|
|
final class EventListener |
35
|
|
|
{ |
36
|
|
|
|
37
|
|
|
/** |
38
|
|
|
* @var EntityHydratorInterface |
39
|
|
|
*/ |
40
|
|
|
private $entityHydrator; |
41
|
|
|
|
42
|
|
|
/** |
43
|
|
|
* @var MappingDriverInterface |
44
|
|
|
*/ |
45
|
|
|
private $mappingDriver; |
46
|
|
|
|
47
|
|
|
/** |
48
|
|
|
* @var DataLoaderInterface |
49
|
|
|
*/ |
50
|
|
|
private $dbalDataLoader; |
51
|
|
|
|
52
|
|
|
/** |
53
|
|
|
* @var array<class-string, bool> |
|
|
|
|
54
|
|
|
*/ |
55
|
10 |
|
private $hasRdmMappingForClass = array(); |
56
|
|
|
|
57
|
|
|
public function __construct( |
58
|
|
|
EntityHydratorInterface $entityHydrator, |
59
|
|
|
MappingDriverInterface $mappingDriver, |
60
|
10 |
|
DataLoaderInterface $dbalDataLoader |
61
|
10 |
|
) { |
62
|
10 |
|
$this->entityHydrator = $entityHydrator; |
63
|
|
|
$this->mappingDriver = $mappingDriver; |
64
|
|
|
$this->dbalDataLoader = $dbalDataLoader; |
65
|
3 |
|
} |
66
|
|
|
|
67
|
|
|
public function postLoad(LifecycleEventArgs $arguments): void |
68
|
3 |
|
{ |
69
|
|
|
/** @var object $entity */ |
70
|
|
|
$entity = $arguments->getEntity(); |
|
|
|
|
71
|
3 |
|
|
72
|
|
|
/** @var EntityManagerInterface $entityManager */ |
73
|
3 |
|
$entityManager = $arguments->getEntityManager(); |
|
|
|
|
74
|
|
|
|
75
|
|
|
$this->entityHydrator->hydrateEntity($entity, $entityManager); |
76
|
3 |
|
} |
77
|
|
|
|
78
|
|
|
public function prePersist(LifecycleEventArgs $arguments): void |
79
|
3 |
|
{ |
80
|
|
|
/** @var object $entity */ |
81
|
|
|
$entity = $arguments->getEntity(); |
|
|
|
|
82
|
3 |
|
|
83
|
|
|
/** @var EntityManagerInterface $entityManager */ |
84
|
3 |
|
$entityManager = $arguments->getEntityManager(); |
|
|
|
|
85
|
3 |
|
|
86
|
|
|
if (!($entity instanceof Proxy)) { |
87
|
|
|
$this->entityHydrator->assertHydrationOnEntity($entity, $entityManager); |
88
|
|
|
} |
89
|
5 |
|
} |
90
|
|
|
|
91
|
|
|
public function postFlush(PostFlushEventArgs $arguments): void |
92
|
5 |
|
{ |
93
|
|
|
/** @var EntityManagerInterface $entityManager */ |
94
|
|
|
$entityManager = $arguments->getEntityManager(); |
|
|
|
|
95
|
5 |
|
|
96
|
|
|
/** @var UnitOfWork $unitOfWork */ |
97
|
|
|
$unitOfWork = $entityManager->getUnitOfWork(); |
98
|
5 |
|
|
99
|
5 |
|
/** @param class-string $className */ |
100
|
1 |
|
foreach ($unitOfWork->getIdentityMap() as $className => $entities) { |
101
|
|
|
if (!$this->hasRdmMappingForClass($className)) { |
102
|
|
|
continue; |
103
|
4 |
|
} |
104
|
|
|
|
105
|
|
|
foreach ($entities as $entity) { |
106
|
4 |
|
/** @var object $entity */ |
107
|
4 |
|
|
108
|
|
|
if (!$this->isUnitializedProxy($entity)) { |
109
|
|
|
if ($unitOfWork->isScheduledForDelete($entity)) { |
110
|
|
|
$this->dbalDataLoader->removeDBALDataForEntity($entity, $entityManager); |
111
|
4 |
|
|
112
|
|
|
} else { |
113
|
|
|
$this->dbalDataLoader->storeDBALDataForEntity($entity, $entityManager); |
114
|
|
|
} |
115
|
|
|
} |
116
|
|
|
} |
117
|
|
|
} |
118
|
5 |
|
} |
119
|
|
|
|
120
|
|
|
public function loadClassMetadata(LoadClassMetadataEventArgs $arguments): void |
121
|
5 |
|
{ |
122
|
|
|
/** @var EntityManagerInterface $entityManager */ |
123
|
|
|
$entityManager = $arguments->getEntityManager(); |
124
|
5 |
|
|
125
|
|
|
/** @var ClassMetadata $classMetadata */ |
126
|
5 |
|
$classMetadata = $arguments->getClassMetadata(); |
127
|
|
|
|
128
|
|
|
try { |
129
|
|
|
$this->dbalDataLoader->prepareOnMetadataLoad($entityManager, $classMetadata); |
130
|
|
|
|
131
|
|
|
} catch (PDOException | ConnectionException $exception) { |
132
|
|
|
var_dump($exception->getMessage()); |
|
|
|
|
133
|
|
|
if (!str_contains($exception->getMessage(), 'No such file or directory')) { |
134
|
|
|
throw $exception; |
135
|
|
|
} |
136
|
2 |
|
} |
137
|
|
|
} |
138
|
|
|
|
139
|
2 |
|
/** |
140
|
|
|
* Invoked when doctrine has generated a table-definition in the target-schema. |
141
|
|
|
* Collects the additional schema-columns from the mapping and add's them to the table. |
142
|
2 |
|
* |
143
|
|
|
* Dispatched in: |
144
|
|
|
* @see SchemaTool::getSchemaFromMetadata |
145
|
2 |
|
*/ |
146
|
|
|
public function postGenerateSchemaTable(GenerateSchemaTableEventArgs $arguments): void |
147
|
|
|
{ |
148
|
2 |
|
/** @var Table $table */ |
149
|
|
|
$table = $arguments->getClassTable(); |
150
|
2 |
|
|
151
|
|
|
/** @var ClassMetadata $classMetadata */ |
152
|
2 |
|
$classMetadata = $arguments->getClassMetadata(); |
153
|
|
|
|
154
|
2 |
|
/** @var class-string $className */ |
155
|
|
|
$className = $classMetadata->getName(); |
156
|
|
|
|
157
|
|
|
/** @var ?EntityMappingInterface $entityMapping */ |
158
|
2 |
|
$entityMapping = $this->mappingDriver->loadRDMMetadataForClass($className); |
159
|
|
|
|
160
|
2 |
|
if ($entityMapping instanceof EntityMappingInterface) { |
161
|
2 |
|
/** @var array<Column> $additionalColumns */ |
162
|
|
|
$additionalColumns = $entityMapping->collectDBALColumns(); |
163
|
2 |
|
|
164
|
2 |
|
foreach ($additionalColumns as $column) { |
165
|
|
|
/** @var Column $column */ |
166
|
|
|
|
167
|
|
|
/** @var string $columnName */ |
168
|
|
|
$columnName = $column->getName(); |
169
|
|
|
|
170
|
|
|
if (!$table->hasColumn($columnName)) { |
171
|
|
|
|
172
|
5 |
|
/** @var array<string, mixed> $columnConfig */ |
173
|
|
|
$columnConfig = $column->toArray(); |
174
|
5 |
|
unset($columnConfig['name']); |
175
|
|
|
|
176
|
5 |
|
$table->addColumn( |
177
|
|
|
$columnName, |
178
|
|
|
$column->getType()->getName(), |
179
|
5 |
|
$columnConfig |
180
|
5 |
|
); |
181
|
|
|
} |
182
|
|
|
} |
183
|
5 |
|
} |
184
|
5 |
|
} |
185
|
|
|
|
186
|
|
|
/** @param class-string $className */ |
|
|
|
|
187
|
5 |
|
private function hasRdmMappingForClass(string $className): bool |
188
|
|
|
{ |
189
|
|
|
if (!isset($this->hasRdmMappingForClass[$className])) { |
190
|
|
|
/** @var class-string $currentClassName */ |
191
|
|
|
$currentClassName = $className; |
192
|
|
|
|
193
|
4 |
|
do { |
194
|
|
|
$this->hasRdmMappingForClass[$className] = is_object( |
195
|
|
|
$this->mappingDriver->loadRDMMetadataForClass($currentClassName) |
196
|
4 |
|
); |
197
|
|
|
|
198
|
4 |
|
$currentClassName = current(class_parents($currentClassName)); |
199
|
|
|
} while (class_exists($currentClassName) && !$this->hasRdmMappingForClass[$className]); |
200
|
|
|
} |
201
|
|
|
|
202
|
4 |
|
return $this->hasRdmMappingForClass[$className]; |
203
|
|
|
} |
204
|
|
|
|
205
|
|
|
/** |
206
|
|
|
* @param object $entity |
207
|
|
|
*/ |
208
|
|
|
private function isUnitializedProxy($entity): bool |
209
|
|
|
{ |
210
|
|
|
/** @var bool $isUnitializedProxy */ |
211
|
|
|
$isUnitializedProxy = false; |
212
|
|
|
|
213
|
|
|
if ($entity instanceof Proxy && !$entity->__isInitialized()) { |
214
|
|
|
$isUnitializedProxy = true; |
215
|
|
|
} |
216
|
|
|
|
217
|
|
|
return $isUnitializedProxy; |
218
|
|
|
} |
219
|
|
|
|
220
|
|
|
} |
221
|
|
|
|