1
|
|
|
<?php |
2
|
|
|
|
3
|
|
|
declare(strict_types=1); |
4
|
|
|
|
5
|
|
|
namespace TheCodingMachine\TDBM\Utils; |
6
|
|
|
|
7
|
|
|
use Doctrine\DBAL\Schema\Column; |
8
|
|
|
use Doctrine\DBAL\Schema\Index; |
9
|
|
|
use Doctrine\DBAL\Schema\Schema; |
10
|
|
|
use Doctrine\DBAL\Schema\Table; |
11
|
|
|
use Doctrine\DBAL\Schema\ForeignKeyConstraint; |
12
|
|
|
use Doctrine\DBAL\Types\Type; |
13
|
|
|
use JsonSerializable; |
14
|
|
|
use Mouf\Database\SchemaAnalyzer\SchemaAnalyzer; |
15
|
|
|
use PhpParser\Comment\Doc; |
16
|
|
|
use Ramsey\Uuid\Uuid; |
17
|
|
|
use TheCodingMachine\TDBM\AbstractTDBMObject; |
18
|
|
|
use TheCodingMachine\TDBM\AlterableResultIterator; |
19
|
|
|
use TheCodingMachine\TDBM\ConfigurationInterface; |
20
|
|
|
use TheCodingMachine\TDBM\InnerResultIterator; |
21
|
|
|
use TheCodingMachine\TDBM\ResultIterator; |
22
|
|
|
use TheCodingMachine\TDBM\SafeFunctions; |
23
|
|
|
use TheCodingMachine\TDBM\Schema\ForeignKey; |
24
|
|
|
use TheCodingMachine\TDBM\Schema\ForeignKeys; |
25
|
|
|
use TheCodingMachine\TDBM\TDBMException; |
26
|
|
|
use TheCodingMachine\TDBM\TDBMSchemaAnalyzer; |
27
|
|
|
use TheCodingMachine\TDBM\TDBMService; |
28
|
|
|
use TheCodingMachine\TDBM\Utils\Annotation\AbstractTraitAnnotation; |
29
|
|
|
use TheCodingMachine\TDBM\Utils\Annotation\AddInterfaceOnDao; |
30
|
|
|
use TheCodingMachine\TDBM\Utils\Annotation\AddTrait; |
31
|
|
|
use TheCodingMachine\TDBM\Utils\Annotation\AddTraitOnDao; |
32
|
|
|
use TheCodingMachine\TDBM\Utils\Annotation\AnnotationParser; |
33
|
|
|
use TheCodingMachine\TDBM\Utils\Annotation\AddInterface; |
34
|
|
|
use Laminas\Code\Generator\AbstractMemberGenerator; |
35
|
|
|
use Laminas\Code\Generator\ClassGenerator; |
36
|
|
|
use Laminas\Code\Generator\DocBlock\Tag; |
37
|
|
|
use Laminas\Code\Generator\DocBlock\Tag\GenericTag; |
38
|
|
|
use Laminas\Code\Generator\DocBlock\Tag\ParamTag; |
39
|
|
|
use Laminas\Code\Generator\DocBlock\Tag\ReturnTag; |
40
|
|
|
use Laminas\Code\Generator\DocBlock\Tag\ThrowsTag; |
41
|
|
|
use Laminas\Code\Generator\DocBlock\Tag\VarTag; |
42
|
|
|
use Laminas\Code\Generator\DocBlockGenerator; |
43
|
|
|
use Laminas\Code\Generator\FileGenerator; |
44
|
|
|
use Laminas\Code\Generator\MethodGenerator; |
45
|
|
|
use Laminas\Code\Generator\ParameterGenerator; |
46
|
|
|
use Laminas\Code\Generator\PropertyGenerator; |
47
|
|
|
|
48
|
|
|
use function implode; |
49
|
|
|
use function strtolower; |
50
|
|
|
use function var_export; |
51
|
|
|
|
52
|
|
|
/** |
53
|
|
|
* This class represents a bean. |
54
|
|
|
*/ |
55
|
|
|
class BeanDescriptor implements BeanDescriptorInterface |
56
|
|
|
{ |
57
|
|
|
/** |
58
|
|
|
* @var Table |
59
|
|
|
*/ |
60
|
|
|
private $table; |
61
|
|
|
|
62
|
|
|
/** |
63
|
|
|
* @var SchemaAnalyzer |
64
|
|
|
*/ |
65
|
|
|
private $schemaAnalyzer; |
66
|
|
|
|
67
|
|
|
/** |
68
|
|
|
* @var Schema |
69
|
|
|
*/ |
70
|
|
|
private $schema; |
71
|
|
|
|
72
|
|
|
/** |
73
|
|
|
* @var AbstractBeanPropertyDescriptor[] |
74
|
|
|
*/ |
75
|
|
|
private $beanPropertyDescriptors = []; |
76
|
|
|
|
77
|
|
|
/** |
78
|
|
|
* @var TDBMSchemaAnalyzer |
79
|
|
|
*/ |
80
|
|
|
private $tdbmSchemaAnalyzer; |
81
|
|
|
|
82
|
|
|
/** |
83
|
|
|
* @var NamingStrategyInterface |
84
|
|
|
*/ |
85
|
|
|
private $namingStrategy; |
86
|
|
|
/** |
87
|
|
|
* @var string |
88
|
|
|
*/ |
89
|
|
|
private $beanNamespace; |
90
|
|
|
/** |
91
|
|
|
* @var string |
92
|
|
|
*/ |
93
|
|
|
private $generatedBeanNamespace; |
94
|
|
|
/** |
95
|
|
|
* @var AnnotationParser |
96
|
|
|
*/ |
97
|
|
|
private $annotationParser; |
98
|
|
|
/** |
99
|
|
|
* @var string |
100
|
|
|
*/ |
101
|
|
|
private $daoNamespace; |
102
|
|
|
/** |
103
|
|
|
* @var string |
104
|
|
|
*/ |
105
|
|
|
private $generatedDaoNamespace; |
106
|
|
|
/** |
107
|
|
|
* @var string |
108
|
|
|
*/ |
109
|
|
|
private $resultIteratorNamespace; |
110
|
|
|
/** |
111
|
|
|
* @var string |
112
|
|
|
*/ |
113
|
|
|
private $generatedResultIteratorNamespace; |
114
|
|
|
/** |
115
|
|
|
* @var CodeGeneratorListenerInterface |
116
|
|
|
*/ |
117
|
|
|
private $codeGeneratorListener; |
118
|
|
|
/** |
119
|
|
|
* @var ConfigurationInterface |
120
|
|
|
*/ |
121
|
|
|
private $configuration; |
122
|
|
|
/** |
123
|
|
|
* @var BeanRegistry |
124
|
|
|
*/ |
125
|
|
|
private $registry; |
126
|
|
|
/** |
127
|
|
|
* @var MethodDescriptorInterface[][] |
128
|
|
|
*/ |
129
|
|
|
private $descriptorsByMethodName = []; |
130
|
|
|
/** |
131
|
|
|
* @var DirectForeignKeyMethodDescriptor[]|null |
132
|
|
|
*/ |
133
|
|
|
private $directForeignKeysDescriptors = null; |
134
|
|
|
/** |
135
|
|
|
* @var PivotTableMethodsDescriptor[]|null |
136
|
|
|
*/ |
137
|
|
|
private $pivotTableDescriptors = null; |
138
|
|
|
|
139
|
|
|
public function __construct( |
140
|
|
|
Table $table, |
141
|
|
|
string $beanNamespace, |
142
|
|
|
string $generatedBeanNamespace, |
143
|
|
|
string $daoNamespace, |
144
|
|
|
string $generatedDaoNamespace, |
145
|
|
|
string $resultIteratorNamespace, |
146
|
|
|
string $generatedResultIteratorNamespace, |
147
|
|
|
SchemaAnalyzer $schemaAnalyzer, |
148
|
|
|
Schema $schema, |
149
|
|
|
TDBMSchemaAnalyzer $tdbmSchemaAnalyzer, |
150
|
|
|
NamingStrategyInterface $namingStrategy, |
151
|
|
|
AnnotationParser $annotationParser, |
152
|
|
|
CodeGeneratorListenerInterface $codeGeneratorListener, |
153
|
|
|
ConfigurationInterface $configuration, |
154
|
|
|
BeanRegistry $registry |
155
|
|
|
) { |
156
|
|
|
$this->table = $table; |
157
|
|
|
$this->beanNamespace = $beanNamespace; |
158
|
|
|
$this->generatedBeanNamespace = $generatedBeanNamespace; |
159
|
|
|
$this->daoNamespace = $daoNamespace; |
160
|
|
|
$this->generatedDaoNamespace = $generatedDaoNamespace; |
161
|
|
|
$this->resultIteratorNamespace = $resultIteratorNamespace; |
162
|
|
|
$this->generatedResultIteratorNamespace = $generatedResultIteratorNamespace; |
163
|
|
|
$this->schemaAnalyzer = $schemaAnalyzer; |
164
|
|
|
$this->schema = $schema; |
165
|
|
|
$this->tdbmSchemaAnalyzer = $tdbmSchemaAnalyzer; |
166
|
|
|
$this->namingStrategy = $namingStrategy; |
167
|
|
|
$this->annotationParser = $annotationParser; |
168
|
|
|
$this->codeGeneratorListener = $codeGeneratorListener; |
169
|
|
|
$this->configuration = $configuration; |
170
|
|
|
$this->registry = $registry; |
171
|
|
|
} |
172
|
|
|
|
173
|
|
|
public function initBeanPropertyDescriptors(): void |
174
|
|
|
{ |
175
|
|
|
$this->beanPropertyDescriptors = $this->getProperties($this->table); |
176
|
|
|
|
177
|
|
|
//init the list of method names with regular properties names |
178
|
|
|
foreach ($this->beanPropertyDescriptors as $beanPropertyDescriptor) { |
179
|
|
|
$this->checkForDuplicate($beanPropertyDescriptor); |
180
|
|
|
} |
181
|
|
|
} |
182
|
|
|
|
183
|
|
|
/** |
184
|
|
|
* Returns the foreign-key the column is part of, if any. null otherwise. |
185
|
|
|
* |
186
|
|
|
* @param Table $table |
187
|
|
|
* @param Column $column |
188
|
|
|
* |
189
|
|
|
* @return ForeignKeyConstraint|null |
190
|
|
|
*/ |
191
|
|
|
private function isPartOfForeignKey(Table $table, Column $column): ?ForeignKeyConstraint |
192
|
|
|
{ |
193
|
|
|
$localColumnName = $column->getName(); |
194
|
|
|
foreach ($table->getForeignKeys() as $foreignKey) { |
195
|
|
|
foreach ($foreignKey->getUnquotedLocalColumns() as $columnName) { |
196
|
|
|
if ($columnName === $localColumnName) { |
197
|
|
|
return $foreignKey; |
198
|
|
|
} |
199
|
|
|
} |
200
|
|
|
} |
201
|
|
|
|
202
|
|
|
return null; |
203
|
|
|
} |
204
|
|
|
|
205
|
|
|
/** |
206
|
|
|
* @return AbstractBeanPropertyDescriptor[] |
207
|
|
|
*/ |
208
|
|
|
public function getBeanPropertyDescriptors(): array |
209
|
|
|
{ |
210
|
|
|
return $this->beanPropertyDescriptors; |
211
|
|
|
} |
212
|
|
|
|
213
|
|
|
/** |
214
|
|
|
* Returns the list of columns that are not nullable and not autogenerated for a given table and its parent. |
215
|
|
|
* |
216
|
|
|
* @return AbstractBeanPropertyDescriptor[] |
217
|
|
|
*/ |
218
|
|
|
public function getConstructorProperties(): array |
219
|
|
|
{ |
220
|
|
|
$constructorProperties = array_filter($this->beanPropertyDescriptors, static function (AbstractBeanPropertyDescriptor $property) { |
221
|
|
|
return !$property instanceof InheritanceReferencePropertyDescriptor && $property->isCompulsory() && !$property->isReadOnly(); |
222
|
|
|
}); |
223
|
|
|
|
224
|
|
|
return $constructorProperties; |
225
|
|
|
} |
226
|
|
|
|
227
|
|
|
/** |
228
|
|
|
* Returns the list of columns that have default values for a given table. |
229
|
|
|
* |
230
|
|
|
* @return AbstractBeanPropertyDescriptor[] |
231
|
|
|
*/ |
232
|
|
|
public function getPropertiesWithDefault(): array |
233
|
|
|
{ |
234
|
|
|
$properties = $this->getPropertiesForTable($this->table); |
235
|
|
|
$defaultProperties = array_filter($properties, function (AbstractBeanPropertyDescriptor $property) { |
236
|
|
|
return $property->hasDefault(); |
237
|
|
|
}); |
238
|
|
|
|
239
|
|
|
return $defaultProperties; |
240
|
|
|
} |
241
|
|
|
|
242
|
|
|
/** |
243
|
|
|
* Returns the list of properties exposed as getters and setters in this class. |
244
|
|
|
* |
245
|
|
|
* @return AbstractBeanPropertyDescriptor[] |
246
|
|
|
*/ |
247
|
|
|
public function getExposedProperties(): array |
248
|
|
|
{ |
249
|
|
|
$exposedProperties = array_filter($this->beanPropertyDescriptors, function (AbstractBeanPropertyDescriptor $property) { |
250
|
|
|
return !$property instanceof InheritanceReferencePropertyDescriptor && $property->getTable()->getName() === $this->table->getName(); |
251
|
|
|
}); |
252
|
|
|
|
253
|
|
|
return $exposedProperties; |
254
|
|
|
} |
255
|
|
|
|
256
|
|
|
/** |
257
|
|
|
* Returns the list of properties for this table (including parent tables). |
258
|
|
|
* |
259
|
|
|
* @param Table $table |
260
|
|
|
* |
261
|
|
|
* @return AbstractBeanPropertyDescriptor[] |
262
|
|
|
*/ |
263
|
|
|
private function getProperties(Table $table): array |
264
|
|
|
{ |
265
|
|
|
// Security check: a table MUST have a primary key |
266
|
|
|
TDBMDaoGenerator::getPrimaryKeyColumnsOrFail($table); |
267
|
|
|
|
268
|
|
|
$parentRelationship = $this->schemaAnalyzer->getParentRelationship($table->getName()); |
269
|
|
|
if ($parentRelationship) { |
270
|
|
|
$parentTable = $this->schema->getTable($parentRelationship->getForeignTableName()); |
271
|
|
|
$properties = $this->getProperties($parentTable); |
272
|
|
|
// we merge properties by overriding property names. |
273
|
|
|
$localProperties = $this->getPropertiesForTable($table); |
274
|
|
|
foreach ($localProperties as $name => $property) { |
275
|
|
|
// We do not override properties if this is a primary key! |
276
|
|
|
if (!$property instanceof InheritanceReferencePropertyDescriptor && $property->isPrimaryKey()) { |
277
|
|
|
continue; |
278
|
|
|
} |
279
|
|
|
$properties[$name] = $property; |
280
|
|
|
} |
281
|
|
|
} else { |
282
|
|
|
$properties = $this->getPropertiesForTable($table); |
283
|
|
|
} |
284
|
|
|
|
285
|
|
|
return $properties; |
286
|
|
|
} |
287
|
|
|
|
288
|
|
|
/** |
289
|
|
|
* Returns the list of properties for this table (ignoring parent tables). |
290
|
|
|
* |
291
|
|
|
* @param Table $table |
292
|
|
|
* |
293
|
|
|
* @return AbstractBeanPropertyDescriptor[] |
294
|
|
|
*/ |
295
|
|
|
private function getPropertiesForTable(Table $table): array |
296
|
|
|
{ |
297
|
|
|
$parentRelationship = $this->schemaAnalyzer->getParentRelationship($table->getName()); |
298
|
|
|
if ($parentRelationship) { |
299
|
|
|
$ignoreColumns = $parentRelationship->getUnquotedForeignColumns(); |
300
|
|
|
} else { |
301
|
|
|
$ignoreColumns = []; |
302
|
|
|
} |
303
|
|
|
|
304
|
|
|
$beanPropertyDescriptors = []; |
305
|
|
|
foreach ($table->getColumns() as $column) { |
306
|
|
|
if (in_array($column->getName(), $ignoreColumns, true)) { |
307
|
|
|
continue; |
308
|
|
|
} |
309
|
|
|
|
310
|
|
|
$fk = $this->isPartOfForeignKey($table, $column); |
311
|
|
|
if ($fk !== null) { |
312
|
|
|
// Check that previously added descriptors are not added on same FK (can happen with multi key FK). |
313
|
|
|
foreach ($beanPropertyDescriptors as $beanDescriptor) { |
314
|
|
|
if ($beanDescriptor instanceof ObjectBeanPropertyDescriptor && $beanDescriptor->getForeignKey() === $fk) { |
315
|
|
|
continue 2; |
316
|
|
|
} |
317
|
|
|
} |
318
|
|
|
$propertyDescriptor = new ObjectBeanPropertyDescriptor($table, $fk, $this->namingStrategy, $this->beanNamespace, $this->annotationParser, $this->registry->getBeanForTableName($fk->getForeignTableName()), $this->resultIteratorNamespace); |
319
|
|
|
// Check that this property is not an inheritance relationship |
320
|
|
|
$parentRelationship = $this->schemaAnalyzer->getParentRelationship($table->getName()); |
321
|
|
|
if ($parentRelationship !== null && $parentRelationship->getName() === $fk->getName()) { |
322
|
|
|
$beanPropertyDescriptors[] = new InheritanceReferencePropertyDescriptor( |
323
|
|
|
$table, |
324
|
|
|
$column, |
325
|
|
|
$this->namingStrategy, |
326
|
|
|
$this->annotationParser, |
327
|
|
|
$propertyDescriptor |
328
|
|
|
); |
329
|
|
|
} else { |
330
|
|
|
$beanPropertyDescriptors[] = $propertyDescriptor; |
331
|
|
|
} |
332
|
|
|
} else { |
333
|
|
|
$beanPropertyDescriptors[] = new ScalarBeanPropertyDescriptor($table, $column, $this->namingStrategy, $this->annotationParser); |
334
|
|
|
} |
335
|
|
|
} |
336
|
|
|
|
337
|
|
|
// Now, let's get the name of all properties and let's check there is no duplicate. |
338
|
|
|
/* @var $names AbstractBeanPropertyDescriptor[] */ |
339
|
|
|
$names = []; |
340
|
|
|
foreach ($beanPropertyDescriptors as $beanDescriptor) { |
341
|
|
|
$name = $beanDescriptor->getGetterName(); |
342
|
|
|
if (isset($names[$name])) { |
343
|
|
|
$names[$name]->useAlternativeName(); |
344
|
|
|
$beanDescriptor->useAlternativeName(); |
345
|
|
|
} else { |
346
|
|
|
$names[$name] = $beanDescriptor; |
347
|
|
|
} |
348
|
|
|
} |
349
|
|
|
|
350
|
|
|
// Final check (throw exceptions if problem arises) |
351
|
|
|
$names = []; |
352
|
|
|
foreach ($beanPropertyDescriptors as $beanDescriptor) { |
353
|
|
|
$name = $beanDescriptor->getGetterName(); |
354
|
|
|
if (isset($names[$name])) { |
355
|
|
|
throw new TDBMException('Unsolvable name conflict while generating method name "' . $name . '"'); |
356
|
|
|
} else { |
357
|
|
|
$names[$name] = $beanDescriptor; |
358
|
|
|
} |
359
|
|
|
} |
360
|
|
|
|
361
|
|
|
// Last step, let's rebuild the list with a map: |
362
|
|
|
$beanPropertyDescriptorsMap = []; |
363
|
|
|
foreach ($beanPropertyDescriptors as $beanDescriptor) { |
364
|
|
|
$beanPropertyDescriptorsMap[$beanDescriptor->getVariableName()] = $beanDescriptor; |
365
|
|
|
} |
366
|
|
|
|
367
|
|
|
return $beanPropertyDescriptorsMap; |
368
|
|
|
} |
369
|
|
|
|
370
|
|
|
private function generateBeanConstructor(): MethodGenerator |
371
|
|
|
{ |
372
|
|
|
$constructorProperties = $this->getConstructorProperties(); |
373
|
|
|
|
374
|
|
|
$constructor = new MethodGenerator('__construct', [], MethodGenerator::FLAG_PUBLIC); |
375
|
|
|
$constructorDocBlock = new DocBlockGenerator('The constructor takes all compulsory arguments.'); |
376
|
|
|
$constructorDocBlock->setWordWrap(false); |
377
|
|
|
$constructor->setDocBlock($constructorDocBlock); |
378
|
|
|
|
379
|
|
|
$assigns = []; |
380
|
|
|
$parentConstructorArguments = []; |
381
|
|
|
|
382
|
|
|
foreach ($constructorProperties as $property) { |
383
|
|
|
$parameter = new ParameterGenerator(ltrim($property->getSafeVariableName(), '$')); |
384
|
|
|
if ($property->isTypeHintable()) { |
385
|
|
|
$parameter->setType($property->getPhpType()); |
386
|
|
|
} |
387
|
|
|
$constructor->setParameter($parameter); |
388
|
|
|
|
389
|
|
|
$constructorDocBlock->setTag($property->getParamAnnotation()); |
390
|
|
|
|
391
|
|
|
if ($property->getTable()->getName() === $this->table->getName()) { |
392
|
|
|
$assigns[] = $property->getConstructorAssignCode()."\n"; |
393
|
|
|
} else { |
394
|
|
|
$parentConstructorArguments[] = $property->getSafeVariableName(); |
395
|
|
|
} |
396
|
|
|
} |
397
|
|
|
|
398
|
|
|
$parentConstructorCode = sprintf("parent::__construct(%s);\n", implode(', ', $parentConstructorArguments)); |
399
|
|
|
|
400
|
|
|
foreach ($this->getPropertiesWithDefault() as $property) { |
401
|
|
|
$assigns[] = $property->assignToDefaultCode()."\n"; |
402
|
|
|
} |
403
|
|
|
|
404
|
|
|
$body = $parentConstructorCode . implode('', $assigns); |
405
|
|
|
|
406
|
|
|
$constructor->setBody($body); |
407
|
|
|
|
408
|
|
|
return $constructor; |
409
|
|
|
} |
410
|
|
|
|
411
|
|
|
/** |
412
|
|
|
* Returns the descriptors of one-to-many relationships (the foreign keys pointing on this beans) |
413
|
|
|
* |
414
|
|
|
* @return DirectForeignKeyMethodDescriptor[] |
415
|
|
|
*/ |
416
|
|
|
private function getDirectForeignKeysDescriptors(): array |
417
|
|
|
{ |
418
|
|
|
if ($this->directForeignKeysDescriptors !== null) { |
419
|
|
|
return $this->directForeignKeysDescriptors; |
420
|
|
|
} |
421
|
|
|
$fks = $this->tdbmSchemaAnalyzer->getIncomingForeignKeys($this->table->getName()); |
422
|
|
|
|
423
|
|
|
$descriptors = []; |
424
|
|
|
|
425
|
|
|
foreach ($fks as $fk) { |
426
|
|
|
$desc = new DirectForeignKeyMethodDescriptor($fk, $this->table, $this->namingStrategy, $this->annotationParser, $this->beanNamespace, $this->resultIteratorNamespace); |
427
|
|
|
$this->checkForDuplicate($desc); |
428
|
|
|
$descriptors[] = $desc; |
429
|
|
|
} |
430
|
|
|
|
431
|
|
|
$this->directForeignKeysDescriptors = $descriptors; |
432
|
|
|
return $this->directForeignKeysDescriptors; |
433
|
|
|
} |
434
|
|
|
|
435
|
|
|
/** |
436
|
|
|
* @return PivotTableMethodsDescriptor[] |
437
|
|
|
*/ |
438
|
|
|
private function getPivotTableDescriptors(): array |
439
|
|
|
{ |
440
|
|
|
if ($this->pivotTableDescriptors !== null) { |
441
|
|
|
return $this->pivotTableDescriptors; |
442
|
|
|
} |
443
|
|
|
$descs = []; |
444
|
|
|
foreach ($this->schemaAnalyzer->detectJunctionTables(true) as $table) { |
445
|
|
|
// There are exactly 2 FKs since this is a pivot table. |
446
|
|
|
$fks = array_values($table->getForeignKeys()); |
447
|
|
|
|
448
|
|
|
if ($fks[0]->getForeignTableName() === $this->table->getName()) { |
449
|
|
|
list($localFk, $remoteFk) = $fks; |
450
|
|
|
$desc = new PivotTableMethodsDescriptor($table, $localFk, $remoteFk, $this->namingStrategy, $this->annotationParser, $this->beanNamespace, $this->resultIteratorNamespace); |
451
|
|
|
$this->checkForDuplicate($desc); |
452
|
|
|
$descs[] = $desc; |
453
|
|
|
} |
454
|
|
|
if ($fks[1]->getForeignTableName() === $this->table->getName()) { |
455
|
|
|
list($remoteFk, $localFk) = $fks; |
456
|
|
|
$desc = new PivotTableMethodsDescriptor($table, $localFk, $remoteFk, $this->namingStrategy, $this->annotationParser, $this->beanNamespace, $this->resultIteratorNamespace); |
457
|
|
|
$this->checkForDuplicate($desc); |
458
|
|
|
$descs[] = $desc; |
459
|
|
|
} |
460
|
|
|
} |
461
|
|
|
|
462
|
|
|
$this->pivotTableDescriptors = $descs; |
463
|
|
|
return $this->pivotTableDescriptors; |
464
|
|
|
} |
465
|
|
|
|
466
|
|
|
/** |
467
|
|
|
* Check the method name isn't already used and flag the associated descriptors to use their alternative names if it is the case |
468
|
|
|
*/ |
469
|
|
|
private function checkForDuplicate(MethodDescriptorInterface $descriptor): void |
470
|
|
|
{ |
471
|
|
|
$name = strtolower($descriptor->getName()); |
472
|
|
|
if (!isset($this->descriptorsByMethodName[$name])) { |
473
|
|
|
$this->descriptorsByMethodName[$name] = []; |
474
|
|
|
} |
475
|
|
|
$this->descriptorsByMethodName[$name][] = $descriptor; |
476
|
|
|
$descriptors = $this->descriptorsByMethodName[$name]; |
477
|
|
|
if (count($descriptors) > 1) { |
478
|
|
|
$properties = array_filter($descriptors, function ($descriptor) { |
479
|
|
|
return $descriptor instanceof AbstractBeanPropertyDescriptor; |
480
|
|
|
}); |
481
|
|
|
$renameProperties = count($properties) > 1; |
482
|
|
|
|
483
|
|
|
foreach ($descriptors as $descriptor) { |
484
|
|
|
if ($renameProperties || !$descriptor instanceof AbstractBeanPropertyDescriptor) { |
485
|
|
|
$descriptor->useAlternativeName(); |
486
|
|
|
} |
487
|
|
|
} |
488
|
|
|
} |
489
|
|
|
} |
490
|
|
|
|
491
|
|
|
/** |
492
|
|
|
* Returns the list of method descriptors (and applies the alternative name if needed). |
493
|
|
|
* |
494
|
|
|
* @return RelationshipMethodDescriptorInterface[] |
495
|
|
|
*/ |
496
|
|
|
public function getMethodDescriptors(): array |
497
|
|
|
{ |
498
|
|
|
$directForeignKeyDescriptors = $this->getDirectForeignKeysDescriptors(); |
499
|
|
|
$pivotTableDescriptors = $this->getPivotTableDescriptors(); |
500
|
|
|
|
501
|
|
|
return array_merge($directForeignKeyDescriptors, $pivotTableDescriptors); |
502
|
|
|
} |
503
|
|
|
|
504
|
|
|
public function generateJsonSerialize(): MethodGenerator |
505
|
|
|
{ |
506
|
|
|
$tableName = $this->table->getName(); |
507
|
|
|
$parentFk = $this->schemaAnalyzer->getParentRelationship($tableName); |
508
|
|
|
|
509
|
|
|
$method = new MethodGenerator('jsonSerialize'); |
510
|
|
|
$method->setDocBlock(new DocBlockGenerator( |
511
|
|
|
'Serializes the object for JSON encoding.', |
512
|
|
|
null, |
513
|
|
|
[ |
514
|
|
|
new ParamTag('$stopRecursion', ['bool'], 'Parameter used internally by TDBM to stop embedded objects from embedding other objects.'), |
515
|
|
|
new ReturnTag(['array']) |
516
|
|
|
] |
517
|
|
|
)); |
518
|
|
|
$method->setParameter(new ParameterGenerator('stopRecursion', 'bool', false)); |
519
|
|
|
|
520
|
|
|
/* |
521
|
|
|
* Set jsonSerialize's mixed return type for php >= 8 |
522
|
|
|
*/ |
523
|
|
|
if (version_compare(PHP_VERSION, '8.0.0', '>=')) { |
524
|
|
|
$method->setReturnType("mixed"); |
525
|
|
|
} |
526
|
|
|
|
527
|
|
|
if ($parentFk !== null) { |
528
|
|
|
$body = '$array = parent::jsonSerialize($stopRecursion);'; |
529
|
|
|
} else { |
530
|
|
|
$body = '$array = [];'; |
531
|
|
|
} |
532
|
|
|
|
533
|
|
|
foreach ($this->getExposedProperties() as $beanPropertyDescriptor) { |
534
|
|
|
$propertyCode = $beanPropertyDescriptor->getJsonSerializeCode(); |
535
|
|
|
if (!empty($propertyCode)) { |
536
|
|
|
$body .= PHP_EOL . $propertyCode; |
537
|
|
|
} |
538
|
|
|
} |
539
|
|
|
|
540
|
|
|
// Many2many relationships |
541
|
|
|
foreach ($this->getMethodDescriptors() as $methodDescriptor) { |
542
|
|
|
$methodCode = $methodDescriptor->getJsonSerializeCode(); |
543
|
|
|
if (!empty($methodCode)) { |
544
|
|
|
$body .= PHP_EOL . $methodCode; |
545
|
|
|
} |
546
|
|
|
} |
547
|
|
|
|
548
|
|
|
$body .= PHP_EOL . 'return $array;'; |
549
|
|
|
|
550
|
|
|
$method->setBody($body); |
551
|
|
|
|
552
|
|
|
return $method; |
553
|
|
|
} |
554
|
|
|
|
555
|
|
|
/** |
556
|
|
|
* Returns as an array the class we need to extend from and the list of use statements. |
557
|
|
|
* |
558
|
|
|
* @param ForeignKeyConstraint|null $parentFk |
559
|
|
|
* @return string[] |
560
|
|
|
*/ |
561
|
|
|
private function generateExtendsAndUseStatements(ForeignKeyConstraint $parentFk = null): array |
562
|
|
|
{ |
563
|
|
|
$classes = []; |
564
|
|
|
if ($parentFk !== null) { |
565
|
|
|
$extends = $this->namingStrategy->getBeanClassName($parentFk->getForeignTableName()); |
566
|
|
|
$classes[] = $extends; |
567
|
|
|
} |
568
|
|
|
|
569
|
|
|
foreach ($this->getBeanPropertyDescriptors() as $beanPropertyDescriptor) { |
570
|
|
|
$className = $beanPropertyDescriptor->getClassName(); |
571
|
|
|
if (null !== $className) { |
572
|
|
|
$classes[] = $className; |
573
|
|
|
} |
574
|
|
|
} |
575
|
|
|
|
576
|
|
|
foreach ($this->getMethodDescriptors() as $descriptor) { |
577
|
|
|
$classes = array_merge($classes, $descriptor->getUsedClasses()); |
578
|
|
|
} |
579
|
|
|
|
580
|
|
|
$classes = array_unique($classes); |
581
|
|
|
|
582
|
|
|
return $classes; |
583
|
|
|
} |
584
|
|
|
|
585
|
|
|
/** |
586
|
|
|
* Returns the representation of the PHP bean file with all getters and setters. |
587
|
|
|
* |
588
|
|
|
* @return ?FileGenerator |
589
|
|
|
*/ |
590
|
|
|
public function generatePhpCode(): ?FileGenerator |
591
|
|
|
{ |
592
|
|
|
$file = new FileGenerator(); |
593
|
|
|
$class = new ClassGenerator(); |
594
|
|
|
$class->setAbstract(true); |
595
|
|
|
$file->setClass($class); |
596
|
|
|
$file->setNamespace($this->generatedBeanNamespace); |
597
|
|
|
|
598
|
|
|
$tableName = $this->table->getName(); |
599
|
|
|
$baseClassName = $this->namingStrategy->getBaseBeanClassName($tableName); |
600
|
|
|
$className = $this->namingStrategy->getBeanClassName($tableName); |
601
|
|
|
$parentFk = $this->schemaAnalyzer->getParentRelationship($this->table->getName()); |
602
|
|
|
|
603
|
|
|
$classes = $this->generateExtendsAndUseStatements($parentFk); |
604
|
|
|
|
605
|
|
|
foreach ($classes as $useClass) { |
606
|
|
|
$file->setUse($this->beanNamespace.'\\'.$useClass); |
607
|
|
|
} |
608
|
|
|
|
609
|
|
|
/*$uses = array_map(function ($className) { |
610
|
|
|
return 'use '.$this->beanNamespace.'\\'.$className.";\n"; |
611
|
|
|
}, $classes); |
612
|
|
|
$use = implode('', $uses);*/ |
613
|
|
|
|
614
|
|
|
$extends = $this->getExtendedBeanClassName(); |
615
|
|
|
if ($extends === null) { |
616
|
|
|
$class->setExtendedClass(AbstractTDBMObject::class); |
617
|
|
|
$file->setUse(AbstractTDBMObject::class); |
618
|
|
|
} else { |
619
|
|
|
/** @var class-string $extends */ |
620
|
|
|
$class->setExtendedClass($extends); |
621
|
|
|
} |
622
|
|
|
|
623
|
|
|
$file->setUse(ResultIterator::class); |
624
|
|
|
$file->setUse(AlterableResultIterator::class); |
625
|
|
|
$file->setUse(Uuid::class); |
626
|
|
|
$file->setUse(JsonSerializable::class); |
627
|
|
|
$file->setUse(ForeignKeys::class); |
628
|
|
|
|
629
|
|
|
$class->setName($baseClassName); |
630
|
|
|
|
631
|
|
|
$file->setDocBlock(new DocBlockGenerator( |
632
|
|
|
'This file has been automatically generated by TDBM.', |
633
|
|
|
<<<EOF |
634
|
|
|
DO NOT edit this file, as it might be overwritten. |
635
|
|
|
If you need to perform changes, edit the $className class instead! |
636
|
|
|
EOF |
637
|
|
|
)); |
638
|
|
|
|
639
|
|
|
$class->setDocBlock(new DocBlockGenerator("The $baseClassName class maps the '$tableName' table in database.")); |
640
|
|
|
|
641
|
|
|
/** @var AddInterface[] $addInterfaceAnnotations */ |
642
|
|
|
$addInterfaceAnnotations = $this->annotationParser->getTableAnnotations($this->table)->findAnnotations(AddInterface::class); |
643
|
|
|
|
644
|
|
|
$interfaces = [ JsonSerializable::class ]; |
645
|
|
|
foreach ($addInterfaceAnnotations as $annotation) { |
646
|
|
|
/** @phpstan-var class-string $className */ |
647
|
|
|
$className = $annotation->getName(); |
648
|
|
|
$interfaces[] = $className; |
649
|
|
|
} |
650
|
|
|
|
651
|
|
|
$class->setImplementedInterfaces($interfaces); |
652
|
|
|
|
653
|
|
|
$this->registerTraits($class, AddTrait::class); |
654
|
|
|
|
655
|
|
|
$method = $this->generateBeanConstructor(); |
656
|
|
|
$method = $this->codeGeneratorListener->onBaseBeanConstructorGenerated($method, $this, $this->configuration, $class); |
657
|
|
|
if ($method) { |
658
|
|
|
$class->addMethodFromGenerator($this->generateBeanConstructor()); |
659
|
|
|
} |
660
|
|
|
|
661
|
|
|
$fks = []; |
662
|
|
|
foreach ($this->getExposedProperties() as $property) { |
663
|
|
|
if ($property instanceof ObjectBeanPropertyDescriptor) { |
664
|
|
|
$fks[] = $property->getForeignKey(); |
665
|
|
|
} |
666
|
|
|
[$getter, $setter] = $property->getGetterSetterCode(); |
667
|
|
|
[$getter, $setter] = $this->codeGeneratorListener->onBaseBeanPropertyGenerated($getter, $setter, $property, $this, $this->configuration, $class); |
668
|
|
|
if ($getter !== null) { |
669
|
|
|
$class->addMethodFromGenerator($getter); |
670
|
|
|
} |
671
|
|
|
if ($setter !== null) { |
672
|
|
|
$class->addMethodFromGenerator($setter); |
673
|
|
|
} |
674
|
|
|
} |
675
|
|
|
|
676
|
|
|
$pivotTableMethodsDescriptors = []; |
677
|
|
|
foreach ($this->getMethodDescriptors() as $methodDescriptor) { |
678
|
|
|
if ($methodDescriptor instanceof DirectForeignKeyMethodDescriptor) { |
679
|
|
|
[$method] = $methodDescriptor->getCode(); |
680
|
|
|
$method = $this->codeGeneratorListener->onBaseBeanOneToManyGenerated($method, $methodDescriptor, $this, $this->configuration, $class); |
681
|
|
|
if ($method) { |
682
|
|
|
$class->addMethodFromGenerator($method); |
683
|
|
|
} |
684
|
|
|
} elseif ($methodDescriptor instanceof PivotTableMethodsDescriptor) { |
685
|
|
|
$pivotTableMethodsDescriptors[] = $methodDescriptor; |
686
|
|
|
[ $getter, $adder, $remover, $has, $setter ] = $methodDescriptor->getCode(); |
687
|
|
|
$methods = $this->codeGeneratorListener->onBaseBeanManyToManyGenerated($getter, $adder, $remover, $has, $setter, $methodDescriptor, $this, $this->configuration, $class); |
688
|
|
|
foreach ($methods as $method) { |
689
|
|
|
if ($method) { |
690
|
|
|
$class->addMethodFromGenerator($method); |
691
|
|
|
} |
692
|
|
|
} |
693
|
|
|
} else { |
694
|
|
|
throw new \RuntimeException('Unexpected instance'); // @codeCoverageIgnore |
695
|
|
|
} |
696
|
|
|
} |
697
|
|
|
|
698
|
|
|
$manyToManyRelationshipCode = $this->generateGetManyToManyRelationshipDescriptorCode($pivotTableMethodsDescriptors); |
699
|
|
|
if ($manyToManyRelationshipCode !== null) { |
700
|
|
|
$class->addMethodFromGenerator($manyToManyRelationshipCode); |
701
|
|
|
} |
702
|
|
|
$manyToManyRelationshipKeysCode = $this->generateGetManyToManyRelationshipDescriptorKeysCode($pivotTableMethodsDescriptors); |
703
|
|
|
if ($manyToManyRelationshipKeysCode !== null) { |
704
|
|
|
$class->addMethodFromGenerator($manyToManyRelationshipKeysCode); |
705
|
|
|
} |
706
|
|
|
|
707
|
|
|
$foreignKeysProperty = new PropertyGenerator('foreignKeys'); |
708
|
|
|
$foreignKeysProperty->setStatic(true); |
709
|
|
|
$foreignKeysProperty->setVisibility(AbstractMemberGenerator::VISIBILITY_PRIVATE); |
710
|
|
|
$foreignKeysProperty->setDocBlock(new DocBlockGenerator(null, null, [new VarTag(null, ['\\'.ForeignKeys::class])])); |
711
|
|
|
$class->addPropertyFromGenerator($foreignKeysProperty); |
712
|
|
|
|
713
|
|
|
$method = $this->generateGetForeignKeys($fks); |
714
|
|
|
$class->addMethodFromGenerator($method); |
715
|
|
|
|
716
|
|
|
$method = $this->generateJsonSerialize(); |
717
|
|
|
$method = $this->codeGeneratorListener->onBaseBeanJsonSerializeGenerated($method, $this, $this->configuration, $class); |
718
|
|
|
if ($method !== null) { |
719
|
|
|
$class->addMethodFromGenerator($method); |
720
|
|
|
} |
721
|
|
|
|
722
|
|
|
$class->addMethodFromGenerator($this->generateGetUsedTablesCode()); |
723
|
|
|
$onDeleteCode = $this->generateOnDeleteCode(); |
724
|
|
|
if ($onDeleteCode) { |
725
|
|
|
$class->addMethodFromGenerator($onDeleteCode); |
726
|
|
|
} |
727
|
|
|
$cloneCode = $this->generateCloneCode($pivotTableMethodsDescriptors); |
728
|
|
|
$cloneCode = $this->codeGeneratorListener->onBaseBeanCloneGenerated($cloneCode, $this, $this->configuration, $class); |
729
|
|
|
if ($cloneCode) { |
730
|
|
|
$class->addMethodFromGenerator($cloneCode); |
731
|
|
|
} |
732
|
|
|
|
733
|
|
|
$file = $this->codeGeneratorListener->onBaseBeanGenerated($file, $this, $this->configuration); |
734
|
|
|
|
735
|
|
|
return $file; |
736
|
|
|
} |
737
|
|
|
|
738
|
|
|
private function registerTraits(ClassGenerator $class, string $annotationClass): void |
739
|
|
|
{ |
740
|
|
|
/** @var AbstractTraitAnnotation[] $addTraitAnnotations */ |
741
|
|
|
$addTraitAnnotations = $this->annotationParser->getTableAnnotations($this->table)->findAnnotations($annotationClass); |
742
|
|
|
|
743
|
|
|
foreach ($addTraitAnnotations as $annotation) { |
744
|
|
|
$class->addTrait($annotation->getName()); |
745
|
|
|
} |
746
|
|
|
|
747
|
|
|
foreach ($addTraitAnnotations as $annotation) { |
748
|
|
|
foreach ($annotation->getInsteadOf() as $method => $replacedTrait) { |
749
|
|
|
$class->addTraitOverride($method, $replacedTrait); |
750
|
|
|
} |
751
|
|
|
foreach ($annotation->getAs() as $method => $replacedMethod) { |
752
|
|
|
$class->addTraitAlias($method, $replacedMethod); |
753
|
|
|
} |
754
|
|
|
} |
755
|
|
|
} |
756
|
|
|
|
757
|
|
|
/** |
758
|
|
|
* Writes the representation of the PHP DAO file. |
759
|
|
|
* |
760
|
|
|
* @return ?FileGenerator |
761
|
|
|
*/ |
762
|
|
|
public function generateDaoPhpCode(): ?FileGenerator |
763
|
|
|
{ |
764
|
|
|
$file = new FileGenerator(); |
765
|
|
|
$class = new ClassGenerator(); |
766
|
|
|
$class->setAbstract(true); |
767
|
|
|
$file->setClass($class); |
768
|
|
|
$file->setNamespace($this->generatedDaoNamespace); |
769
|
|
|
|
770
|
|
|
$tableName = $this->table->getName(); |
771
|
|
|
|
772
|
|
|
$primaryKeyColumns = TDBMDaoGenerator::getPrimaryKeyColumnsOrFail($this->table); |
773
|
|
|
|
774
|
|
|
list($defaultSort, $defaultSortDirection) = $this->getDefaultSortColumnFromAnnotation($this->table); |
775
|
|
|
|
776
|
|
|
$className = $this->namingStrategy->getDaoClassName($tableName); |
777
|
|
|
$baseClassName = $this->namingStrategy->getBaseDaoClassName($tableName); |
778
|
|
|
$beanClassWithoutNameSpace = $this->namingStrategy->getBeanClassName($tableName); |
779
|
|
|
$beanClassName = $this->beanNamespace.'\\'.$beanClassWithoutNameSpace; |
780
|
|
|
$resultIteratorClassWithoutNameSpace = $this->getResultIteratorClassName(); |
781
|
|
|
$resultIteratorClass = $this->resultIteratorNamespace.'\\'.$resultIteratorClassWithoutNameSpace; |
782
|
|
|
|
783
|
|
|
$findByDaoCodeMethods = $this->generateFindByDaoCode($this->beanNamespace, $beanClassWithoutNameSpace, $class); |
784
|
|
|
|
785
|
|
|
$usedBeans[] = $beanClassName; |
|
|
|
|
786
|
|
|
// Let's suppress duplicates in used beans (if any) |
787
|
|
|
$usedBeans = array_flip(array_flip($usedBeans)); |
788
|
|
|
foreach ($usedBeans as $usedBean) { |
789
|
|
|
$class->addUse($usedBean); |
790
|
|
|
} |
791
|
|
|
|
792
|
|
|
$file->setDocBlock(new DocBlockGenerator( |
793
|
|
|
<<<EOF |
794
|
|
|
This file has been automatically generated by TDBM. |
795
|
|
|
DO NOT edit this file, as it might be overwritten. |
796
|
|
|
If you need to perform changes, edit the $className class instead! |
797
|
|
|
EOF |
798
|
|
|
)); |
799
|
|
|
|
800
|
|
|
$file->setNamespace($this->generatedDaoNamespace); |
801
|
|
|
|
802
|
|
|
$class->addUse(TDBMService::class); |
803
|
|
|
$class->addUse(ResultIterator::class); |
804
|
|
|
$class->addUse(TDBMException::class); |
805
|
|
|
|
806
|
|
|
$class->setName($baseClassName); |
807
|
|
|
|
808
|
|
|
$class->setDocBlock(new DocBlockGenerator("The $baseClassName class will maintain the persistence of $beanClassWithoutNameSpace class into the $tableName table.")); |
809
|
|
|
|
810
|
|
|
/** @var AddInterfaceOnDao[] $addInterfaceOnDaoAnnotations */ |
811
|
|
|
$addInterfaceOnDaoAnnotations = $this->annotationParser->getTableAnnotations($this->table)->findAnnotations(AddInterfaceOnDao::class); |
812
|
|
|
|
813
|
|
|
$interfaces = []; |
814
|
|
|
foreach ($addInterfaceOnDaoAnnotations as $annotation) { |
815
|
|
|
/** @phpstan-var class-string $className */ |
816
|
|
|
$className = $annotation->getName(); |
817
|
|
|
$interfaces[] = $className; |
818
|
|
|
} |
819
|
|
|
|
820
|
|
|
$class->setImplementedInterfaces($interfaces); |
821
|
|
|
|
822
|
|
|
$this->registerTraits($class, AddTraitOnDao::class); |
823
|
|
|
|
824
|
|
|
$tdbmServiceProperty = new PropertyGenerator('tdbmService'); |
825
|
|
|
$tdbmServiceProperty->setDocBlock(new DocBlockGenerator(null, null, [new VarTag(null, ['\\'.TDBMService::class])])); |
826
|
|
|
$class->addPropertyFromGenerator($tdbmServiceProperty); |
827
|
|
|
|
828
|
|
|
$defaultSortProperty = new PropertyGenerator('defaultSort', $defaultSort); |
829
|
|
|
$defaultSortProperty->setDocBlock(new DocBlockGenerator('The default sort column.', null, [new VarTag(null, ['string', 'null'])])); |
830
|
|
|
$class->addPropertyFromGenerator($defaultSortProperty); |
831
|
|
|
|
832
|
|
|
$defaultSortPropertyDirection = new PropertyGenerator('defaultDirection', $defaultSort && $defaultSortDirection ? $defaultSortDirection : 'asc'); |
833
|
|
|
$defaultSortPropertyDirection->setDocBlock(new DocBlockGenerator('The default sort direction.', null, [new VarTag(null, ['string'])])); |
834
|
|
|
$class->addPropertyFromGenerator($defaultSortPropertyDirection); |
835
|
|
|
|
836
|
|
|
$constructorMethod = new MethodGenerator( |
837
|
|
|
'__construct', |
838
|
|
|
[ new ParameterGenerator('tdbmService', TDBMService::class) ], |
839
|
|
|
MethodGenerator::FLAG_PUBLIC, |
840
|
|
|
'$this->tdbmService = $tdbmService;', |
841
|
|
|
'Sets the TDBM service used by this DAO.' |
842
|
|
|
); |
843
|
|
|
$constructorMethod = $this->codeGeneratorListener->onBaseDaoConstructorGenerated($constructorMethod, $this, $this->configuration, $class); |
844
|
|
|
if ($constructorMethod !== null) { |
845
|
|
|
$class->addMethodFromGenerator($constructorMethod); |
846
|
|
|
} |
847
|
|
|
|
848
|
|
|
$saveMethod = new MethodGenerator( |
849
|
|
|
'save', |
850
|
|
|
[ new ParameterGenerator('obj', $beanClassName) ], |
851
|
|
|
MethodGenerator::FLAG_PUBLIC, |
852
|
|
|
'$this->tdbmService->save($obj);', |
853
|
|
|
(new DocBlockGenerator( |
854
|
|
|
"Persist the $beanClassWithoutNameSpace instance.", |
855
|
|
|
null, |
856
|
|
|
[ |
857
|
|
|
new ParamTag('obj', [$beanClassWithoutNameSpace], 'The bean to save.') |
858
|
|
|
] |
859
|
|
|
))->setWordWrap(false) |
860
|
|
|
); |
861
|
|
|
$saveMethod->setReturnType('void'); |
862
|
|
|
|
863
|
|
|
$saveMethod = $this->codeGeneratorListener->onBaseDaoSaveGenerated($saveMethod, $this, $this->configuration, $class); |
864
|
|
|
if ($saveMethod !== null) { |
865
|
|
|
$class->addMethodFromGenerator($saveMethod); |
866
|
|
|
} |
867
|
|
|
|
868
|
|
|
$findAllBody = <<<EOF |
869
|
|
|
if (\$this->defaultSort) { |
870
|
|
|
\$orderBy = '$tableName.'.\$this->defaultSort.' '.\$this->defaultDirection; |
871
|
|
|
} else { |
872
|
|
|
\$orderBy = null; |
873
|
|
|
} |
874
|
|
|
return \$this->tdbmService->findObjects('$tableName', null, [], \$orderBy, [], null, \\$beanClassName::class, \\$resultIteratorClass::class); |
875
|
|
|
EOF; |
876
|
|
|
|
877
|
|
|
$findAllMethod = new MethodGenerator( |
878
|
|
|
'findAll', |
879
|
|
|
[], |
880
|
|
|
MethodGenerator::FLAG_PUBLIC, |
881
|
|
|
$findAllBody, |
882
|
|
|
(new DocBlockGenerator("Get all $beanClassWithoutNameSpace records."))->setWordWrap(false) |
883
|
|
|
); |
884
|
|
|
$findAllMethod->setReturnType($resultIteratorClass); |
885
|
|
|
$findAllMethod = $this->codeGeneratorListener->onBaseDaoFindAllGenerated($findAllMethod, $this, $this->configuration, $class); |
886
|
|
|
if ($findAllMethod !== null) { |
887
|
|
|
$class->addMethodFromGenerator($findAllMethod); |
888
|
|
|
} |
889
|
|
|
|
890
|
|
|
if (count($primaryKeyColumns) > 0) { |
891
|
|
|
$lazyLoadingParameterName = 'lazyLoading'; |
892
|
|
|
$parameters = []; |
893
|
|
|
$parametersTag = []; |
894
|
|
|
$primaryKeyFilter = []; |
895
|
|
|
|
896
|
|
|
foreach ($primaryKeyColumns as $primaryKeyColumn) { |
897
|
|
|
if ($primaryKeyColumn === $lazyLoadingParameterName) { |
898
|
|
|
throw new TDBMException('Primary Column name `' . $lazyLoadingParameterName . '` is not allowed.'); |
899
|
|
|
} |
900
|
|
|
$phpType = TDBMDaoGenerator::dbalTypeToPhpType($this->table->getColumn($primaryKeyColumn)->getType()); |
901
|
|
|
$parameters[] = new ParameterGenerator($primaryKeyColumn, $phpType); |
902
|
|
|
$parametersTag[] = new ParamTag($primaryKeyColumn, [$phpType]); |
903
|
|
|
$primaryKeyFilter[] = "'$primaryKeyColumn' => \$$primaryKeyColumn"; |
904
|
|
|
} |
905
|
|
|
$parameters[] = new ParameterGenerator($lazyLoadingParameterName, 'bool', false); |
906
|
|
|
$parametersTag[] = new ParamTag($lazyLoadingParameterName, ['bool'], 'If set to true, the object will not be loaded right away. Instead, it will be loaded when you first try to access a method of the object.'); |
907
|
|
|
$parametersTag[] = new ReturnTag(['\\'.$beanClassName]); |
908
|
|
|
$parametersTag[] = new ThrowsTag('\\'.TDBMException::class); |
909
|
|
|
|
910
|
|
|
$getByIdMethod = new MethodGenerator( |
911
|
|
|
'getById', |
912
|
|
|
$parameters, |
913
|
|
|
MethodGenerator::FLAG_PUBLIC, |
914
|
|
|
"return \$this->tdbmService->findObjectByPk('$tableName', [" . implode(', ', $primaryKeyFilter) . "], [], \$$lazyLoadingParameterName, \\$beanClassName::class, \\$resultIteratorClass::class);", |
915
|
|
|
(new DocBlockGenerator( |
916
|
|
|
"Get $beanClassWithoutNameSpace specified by its ID (its primary key).", |
917
|
|
|
'If the primary key does not exist, an exception is thrown.', |
918
|
|
|
$parametersTag |
919
|
|
|
))->setWordWrap(false) |
920
|
|
|
); |
921
|
|
|
$getByIdMethod->setReturnType($beanClassName); |
922
|
|
|
$getByIdMethod = $this->codeGeneratorListener->onBaseDaoGetByIdGenerated($getByIdMethod, $this, $this->configuration, $class); |
923
|
|
|
if ($getByIdMethod) { |
924
|
|
|
$class->addMethodFromGenerator($getByIdMethod); |
925
|
|
|
} |
926
|
|
|
} |
927
|
|
|
|
928
|
|
|
$deleteMethodBody = <<<EOF |
929
|
|
|
if (\$cascade === true) { |
930
|
|
|
\$this->tdbmService->deleteCascade(\$obj); |
931
|
|
|
} else { |
932
|
|
|
\$this->tdbmService->delete(\$obj); |
933
|
|
|
} |
934
|
|
|
EOF; |
935
|
|
|
|
936
|
|
|
|
937
|
|
|
$deleteMethod = new MethodGenerator( |
938
|
|
|
'delete', |
939
|
|
|
[ |
940
|
|
|
new ParameterGenerator('obj', $beanClassName), |
941
|
|
|
new ParameterGenerator('cascade', 'bool', false) |
942
|
|
|
], |
943
|
|
|
MethodGenerator::FLAG_PUBLIC, |
944
|
|
|
$deleteMethodBody, |
945
|
|
|
(new DocBlockGenerator( |
946
|
|
|
"Get all $beanClassWithoutNameSpace records.", |
947
|
|
|
null, |
948
|
|
|
[ |
949
|
|
|
new ParamTag('obj', ['\\'.$beanClassName], 'The object to delete'), |
950
|
|
|
new ParamTag('cascade', ['bool'], 'If true, it will delete all objects linked to $obj'), |
951
|
|
|
] |
952
|
|
|
))->setWordWrap(false) |
953
|
|
|
); |
954
|
|
|
$deleteMethod->setReturnType('void'); |
955
|
|
|
$deleteMethod = $this->codeGeneratorListener->onBaseDaoDeleteGenerated($deleteMethod, $this, $this->configuration, $class); |
956
|
|
|
if ($deleteMethod !== null) { |
957
|
|
|
$class->addMethodFromGenerator($deleteMethod); |
958
|
|
|
} |
959
|
|
|
|
960
|
|
|
$findMethodBody = <<<EOF |
961
|
|
|
if (\$this->defaultSort && \$orderBy == null) { |
962
|
|
|
\$orderBy = '$tableName.'.\$this->defaultSort.' '.\$this->defaultDirection; |
963
|
|
|
} |
964
|
|
|
return \$this->tdbmService->findObjects('$tableName', \$filter, \$parameters, \$orderBy, \$additionalTablesFetch, \$mode, \\$beanClassName::class, \\$resultIteratorClass::class); |
965
|
|
|
EOF; |
966
|
|
|
|
967
|
|
|
|
968
|
|
|
$findMethod = new MethodGenerator( |
969
|
|
|
'find', |
970
|
|
|
[ |
971
|
|
|
(new ParameterGenerator('filter'))->setDefaultValue(null), |
972
|
|
|
new ParameterGenerator('parameters', 'array', []), |
973
|
|
|
(new ParameterGenerator('orderBy'))->setDefaultValue(null), |
974
|
|
|
new ParameterGenerator('additionalTablesFetch', 'array', []), |
975
|
|
|
(new ParameterGenerator('mode', '?int'))->setDefaultValue(null), |
976
|
|
|
], |
977
|
|
|
MethodGenerator::FLAG_PROTECTED, |
978
|
|
|
$findMethodBody, |
979
|
|
|
(new DocBlockGenerator( |
980
|
|
|
"Get all $beanClassWithoutNameSpace records.", |
981
|
|
|
null, |
982
|
|
|
[ |
983
|
|
|
new ParamTag('filter', ['mixed'], 'The filter bag (see TDBMService::findObjects for complete description)'), |
984
|
|
|
new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the filter'), |
985
|
|
|
new ParamTag('orderBy', ['mixed'], 'The order string'), |
986
|
|
|
new ParamTag('additionalTablesFetch', ['string[]'], 'A list of additional tables to fetch (for performance improvement)'), |
987
|
|
|
new ParamTag('mode', ['int', 'null'], 'Either TDBMService::MODE_ARRAY or TDBMService::MODE_CURSOR (for large datasets). Defaults to TDBMService::MODE_ARRAY.') |
988
|
|
|
] |
989
|
|
|
))->setWordWrap(false) |
990
|
|
|
); |
991
|
|
|
$findMethod->setReturnType($resultIteratorClass); |
992
|
|
|
$findMethod = $this->codeGeneratorListener->onBaseDaoFindGenerated($findMethod, $this, $this->configuration, $class); |
993
|
|
|
if ($findMethod !== null) { |
994
|
|
|
$class->addMethodFromGenerator($findMethod); |
995
|
|
|
} |
996
|
|
|
|
997
|
|
|
$findFromSqlMethodBody = <<<EOF |
998
|
|
|
if (\$this->defaultSort && \$orderBy == null) { |
999
|
|
|
\$orderBy = '$tableName.'.\$this->defaultSort.' '.\$this->defaultDirection; |
1000
|
|
|
} |
1001
|
|
|
return \$this->tdbmService->findObjectsFromSql('$tableName', \$from, \$filter, \$parameters, \$orderBy, \$mode, \\$beanClassName::class, \\$resultIteratorClass::class); |
1002
|
|
|
EOF; |
1003
|
|
|
|
1004
|
|
|
$findFromSqlMethod = new MethodGenerator( |
1005
|
|
|
'findFromSql', |
1006
|
|
|
[ |
1007
|
|
|
new ParameterGenerator('from', 'string'), |
1008
|
|
|
(new ParameterGenerator('filter'))->setDefaultValue(null), |
1009
|
|
|
new ParameterGenerator('parameters', 'array', []), |
1010
|
|
|
(new ParameterGenerator('orderBy'))->setDefaultValue(null), |
1011
|
|
|
new ParameterGenerator('additionalTablesFetch', 'array', []), |
1012
|
|
|
(new ParameterGenerator('mode', '?int'))->setDefaultValue(null), |
1013
|
|
|
], |
1014
|
|
|
MethodGenerator::FLAG_PROTECTED, |
1015
|
|
|
$findFromSqlMethodBody, |
1016
|
|
|
(new DocBlockGenerator( |
1017
|
|
|
"Get a list of $beanClassWithoutNameSpace specified by its filters.", |
1018
|
|
|
"Unlike the `find` method that guesses the FROM part of the statement, here you can pass the \$from part. |
1019
|
|
|
|
1020
|
|
|
You should not put an alias on the main table name. So your \$from variable should look like: |
1021
|
|
|
|
1022
|
|
|
\"$tableName JOIN ... ON ...\"", |
1023
|
|
|
[ |
1024
|
|
|
new ParamTag('from', ['string'], 'The sql from statement'), |
1025
|
|
|
new ParamTag('filter', ['mixed'], 'The filter bag (see TDBMService::findObjects for complete description)'), |
1026
|
|
|
new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the filter'), |
1027
|
|
|
new ParamTag('orderBy', ['mixed'], 'The order string'), |
1028
|
|
|
new ParamTag('additionalTablesFetch', ['string[]'], 'A list of additional tables to fetch (for performance improvement)'), |
1029
|
|
|
new ParamTag('mode', ['int', 'null'], 'Either TDBMService::MODE_ARRAY or TDBMService::MODE_CURSOR (for large datasets). Defaults to TDBMService::MODE_ARRAY.') |
1030
|
|
|
] |
1031
|
|
|
))->setWordWrap(false) |
1032
|
|
|
); |
1033
|
|
|
$findFromSqlMethod->setReturnType($resultIteratorClass); |
1034
|
|
|
$findFromSqlMethod = $this->codeGeneratorListener->onBaseDaoFindFromSqlGenerated($findFromSqlMethod, $this, $this->configuration, $class); |
1035
|
|
|
if ($findFromSqlMethod !== null) { |
1036
|
|
|
$class->addMethodFromGenerator($findFromSqlMethod); |
1037
|
|
|
} |
1038
|
|
|
|
1039
|
|
|
$findFromRawSqlMethodBody = <<<EOF |
1040
|
|
|
return \$this->tdbmService->findObjectsFromRawSql('$tableName', \$sql, \$parameters, \$mode, \\$beanClassName::class, \$countSql, \\$resultIteratorClass::class); |
1041
|
|
|
EOF; |
1042
|
|
|
|
1043
|
|
|
$findFromRawSqlMethod = new MethodGenerator( |
1044
|
|
|
'findFromRawSql', |
1045
|
|
|
[ |
1046
|
|
|
new ParameterGenerator('sql', 'string'), |
1047
|
|
|
new ParameterGenerator('parameters', 'array', []), |
1048
|
|
|
(new ParameterGenerator('countSql', '?string'))->setDefaultValue(null), |
1049
|
|
|
(new ParameterGenerator('mode', '?int'))->setDefaultValue(null), |
1050
|
|
|
], |
1051
|
|
|
MethodGenerator::FLAG_PROTECTED, |
1052
|
|
|
$findFromRawSqlMethodBody, |
1053
|
|
|
(new DocBlockGenerator( |
1054
|
|
|
"Get a list of $beanClassWithoutNameSpace from a SQL query.", |
1055
|
|
|
"Unlike the `find` and `findFromSql` methods, here you can pass the whole \$sql query. |
1056
|
|
|
|
1057
|
|
|
You should not put an alias on the main table name, and select its columns using `*`. So the SELECT part of you \$sql should look like: |
1058
|
|
|
|
1059
|
|
|
\"SELECT $tableName .* FROM ...\"", |
1060
|
|
|
[ |
1061
|
|
|
new ParamTag('sql', ['string'], 'The sql query'), |
1062
|
|
|
new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the query'), |
1063
|
|
|
new ParamTag('countSql', ['string', 'null'], 'The sql query that provides total count of rows (automatically computed if not provided)'), |
1064
|
|
|
new ParamTag('mode', ['int', 'null'], 'Either TDBMService::MODE_ARRAY or TDBMService::MODE_CURSOR (for large datasets). Defaults to TDBMService::MODE_ARRAY.') |
1065
|
|
|
] |
1066
|
|
|
))->setWordWrap(false) |
1067
|
|
|
); |
1068
|
|
|
$findFromRawSqlMethod->setReturnType($resultIteratorClass); |
1069
|
|
|
$findFromRawSqlMethod = $this->codeGeneratorListener->onBaseDaoFindFromRawSqlGenerated($findFromRawSqlMethod, $this, $this->configuration, $class); |
1070
|
|
|
if ($findFromRawSqlMethod !== null) { |
1071
|
|
|
$class->addMethodFromGenerator($findFromRawSqlMethod); |
1072
|
|
|
} |
1073
|
|
|
|
1074
|
|
|
$findOneMethodBody = <<<EOF |
1075
|
|
|
return \$this->tdbmService->findObject('$tableName', \$filter, \$parameters, \$additionalTablesFetch, \\$beanClassName::class, \\$resultIteratorClass::class); |
1076
|
|
|
EOF; |
1077
|
|
|
|
1078
|
|
|
|
1079
|
|
|
$findOneMethod = new MethodGenerator( |
1080
|
|
|
'findOne', |
1081
|
|
|
[ |
1082
|
|
|
(new ParameterGenerator('filter'))->setDefaultValue(null), |
1083
|
|
|
new ParameterGenerator('parameters', 'array', []), |
1084
|
|
|
new ParameterGenerator('additionalTablesFetch', 'array', []), |
1085
|
|
|
], |
1086
|
|
|
MethodGenerator::FLAG_PROTECTED, |
1087
|
|
|
$findOneMethodBody, |
1088
|
|
|
(new DocBlockGenerator( |
1089
|
|
|
"Get a single $beanClassWithoutNameSpace specified by its filters.", |
1090
|
|
|
null, |
1091
|
|
|
[ |
1092
|
|
|
new ParamTag('filter', ['mixed'], 'The filter bag (see TDBMService::findObjects for complete description)'), |
1093
|
|
|
new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the filter'), |
1094
|
|
|
new ParamTag('additionalTablesFetch', ['string[]'], 'A list of additional tables to fetch (for performance improvement)'), |
1095
|
|
|
new ReturnTag(['\\'.$beanClassName, 'null']) |
1096
|
|
|
] |
1097
|
|
|
))->setWordWrap(false) |
1098
|
|
|
); |
1099
|
|
|
$findOneMethod->setReturnType("?$beanClassName"); |
1100
|
|
|
$findOneMethod = $this->codeGeneratorListener->onBaseDaoFindOneGenerated($findOneMethod, $this, $this->configuration, $class); |
1101
|
|
|
if ($findOneMethod !== null) { |
1102
|
|
|
$class->addMethodFromGenerator($findOneMethod); |
1103
|
|
|
} |
1104
|
|
|
|
1105
|
|
|
$findOneFromSqlMethodBody = <<<EOF |
1106
|
|
|
return \$this->tdbmService->findObjectFromSql('$tableName', \$from, \$filter, \$parameters, \\$beanClassName::class, \\$resultIteratorClass::class); |
1107
|
|
|
EOF; |
1108
|
|
|
|
1109
|
|
|
$findOneFromSqlMethod = new MethodGenerator( |
1110
|
|
|
'findOneFromSql', |
1111
|
|
|
[ |
1112
|
|
|
new ParameterGenerator('from', 'string'), |
1113
|
|
|
(new ParameterGenerator('filter'))->setDefaultValue(null), |
1114
|
|
|
new ParameterGenerator('parameters', 'array', []), |
1115
|
|
|
], |
1116
|
|
|
MethodGenerator::FLAG_PROTECTED, |
1117
|
|
|
$findOneFromSqlMethodBody, |
1118
|
|
|
(new DocBlockGenerator( |
1119
|
|
|
"Get a single $beanClassWithoutNameSpace specified by its filters.", |
1120
|
|
|
"Unlike the `findOne` method that guesses the FROM part of the statement, here you can pass the \$from part. |
1121
|
|
|
|
1122
|
|
|
You should not put an alias on the main table name. So your \$from variable should look like: |
1123
|
|
|
|
1124
|
|
|
\"$tableName JOIN ... ON ...\"", |
1125
|
|
|
[ |
1126
|
|
|
new ParamTag('from', ['string'], 'The sql from statement'), |
1127
|
|
|
new ParamTag('filter', ['mixed'], 'The filter bag (see TDBMService::findObjects for complete description)'), |
1128
|
|
|
new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the filter'), |
1129
|
|
|
new ReturnTag(['\\'.$beanClassName, 'null']) |
1130
|
|
|
] |
1131
|
|
|
))->setWordWrap(false) |
1132
|
|
|
); |
1133
|
|
|
$findOneFromSqlMethod->setReturnType("?$beanClassName"); |
1134
|
|
|
$findOneFromSqlMethod = $this->codeGeneratorListener->onBaseDaoFindOneFromSqlGenerated($findOneFromSqlMethod, $this, $this->configuration, $class); |
1135
|
|
|
if ($findOneFromSqlMethod !== null) { |
1136
|
|
|
$class->addMethodFromGenerator($findOneFromSqlMethod); |
1137
|
|
|
} |
1138
|
|
|
|
1139
|
|
|
|
1140
|
|
|
$setDefaultSortMethod = new MethodGenerator( |
1141
|
|
|
'setDefaultSort', |
1142
|
|
|
[ |
1143
|
|
|
new ParameterGenerator('defaultSort', 'string'), |
1144
|
|
|
], |
1145
|
|
|
MethodGenerator::FLAG_PUBLIC, |
1146
|
|
|
'$this->defaultSort = $defaultSort;', |
1147
|
|
|
new DocBlockGenerator( |
1148
|
|
|
"Sets the default column for default sorting.", |
1149
|
|
|
null, |
1150
|
|
|
[ |
1151
|
|
|
new ParamTag('defaultSort', ['string']), |
1152
|
|
|
] |
1153
|
|
|
) |
1154
|
|
|
); |
1155
|
|
|
$setDefaultSortMethod->setReturnType('void'); |
1156
|
|
|
$setDefaultSortMethod = $this->codeGeneratorListener->onBaseDaoSetDefaultSortGenerated($setDefaultSortMethod, $this, $this->configuration, $class); |
1157
|
|
|
if ($setDefaultSortMethod !== null) { |
1158
|
|
|
$class->addMethodFromGenerator($setDefaultSortMethod); |
1159
|
|
|
} |
1160
|
|
|
|
1161
|
|
|
foreach ($findByDaoCodeMethods as $method) { |
1162
|
|
|
$class->addMethodFromGenerator($method); |
1163
|
|
|
} |
1164
|
|
|
|
1165
|
|
|
$file = $this->codeGeneratorListener->onBaseDaoGenerated($file, $this, $this->configuration); |
1166
|
|
|
|
1167
|
|
|
return $file; |
1168
|
|
|
} |
1169
|
|
|
|
1170
|
|
|
/** |
1171
|
|
|
* Writes the representation of the PHP ResultIterator file. |
1172
|
|
|
*/ |
1173
|
|
|
public function generateResultIteratorPhpCode(): ?FileGenerator |
1174
|
|
|
{ |
1175
|
|
|
$file = new FileGenerator(); |
1176
|
|
|
$class = new ClassGenerator(); |
1177
|
|
|
$class->setAbstract(true); |
1178
|
|
|
$file->setClass($class); |
1179
|
|
|
$file->setNamespace($this->generatedResultIteratorNamespace); |
1180
|
|
|
|
1181
|
|
|
$tableName = $this->table->getName(); |
1182
|
|
|
|
1183
|
|
|
$classNameWithoutNamespace = $this->namingStrategy->getResultIteratorClassName($tableName); |
1184
|
|
|
$className = $this->namingStrategy->getResultIteratorClassName($tableName); |
|
|
|
|
1185
|
|
|
$baseClassName = $this->namingStrategy->getBaseResultIteratorClassName($tableName); |
1186
|
|
|
$beanClassWithoutNameSpace = $this->namingStrategy->getBeanClassName($tableName); |
1187
|
|
|
$beanClassName = $this->beanNamespace.'\\'.$beanClassWithoutNameSpace; |
1188
|
|
|
|
1189
|
|
|
$file->setDocBlock(new DocBlockGenerator( |
1190
|
|
|
<<<EOF |
1191
|
|
|
This file has been automatically generated by TDBM. |
1192
|
|
|
DO NOT edit this file, as it might be overwritten. |
1193
|
|
|
If you need to perform changes, edit the $classNameWithoutNamespace class instead! |
1194
|
|
|
EOF |
1195
|
|
|
)); |
1196
|
|
|
$class->setName($baseClassName); |
1197
|
|
|
$extends = $this->getExtendedResultIteratorClassName(); |
1198
|
|
|
if ($extends === null) { |
1199
|
|
|
$class->addUse(ResultIterator::class); |
1200
|
|
|
$class->setExtendedClass(ResultIterator::class); |
1201
|
|
|
} else { |
1202
|
|
|
$class->addUse($this->resultIteratorNamespace . '\\' . $extends); |
1203
|
|
|
/** @var class-string $extends */ |
1204
|
|
|
$class->setExtendedClass($extends); |
1205
|
|
|
} |
1206
|
|
|
|
1207
|
|
|
$class->setDocBlock((new DocBlockGenerator( |
1208
|
|
|
"The $baseClassName class will iterate over results of $beanClassWithoutNameSpace class.", |
1209
|
|
|
null, |
1210
|
|
|
[new Tag\MethodTag('getIterator', ['\\' . $beanClassName . '[]']), new Tag\MethodTag('toArray', ['\\' . $beanClassName . '[]'])] |
1211
|
|
|
))->setWordWrap(false)); |
1212
|
|
|
|
1213
|
|
|
$file = $this->codeGeneratorListener->onBaseResultIteratorGenerated($file, $this, $this->configuration); |
1214
|
|
|
|
1215
|
|
|
return $file; |
1216
|
|
|
} |
1217
|
|
|
|
1218
|
|
|
/** |
1219
|
|
|
* Tries to find a @defaultSort annotation in one of the columns. |
1220
|
|
|
* |
1221
|
|
|
* @param Table $table |
1222
|
|
|
* |
1223
|
|
|
* @return mixed[] First item: column name, Second item: column order (asc/desc) |
1224
|
|
|
*/ |
1225
|
|
|
private function getDefaultSortColumnFromAnnotation(Table $table): array |
1226
|
|
|
{ |
1227
|
|
|
$defaultSort = null; |
1228
|
|
|
$defaultSortDirection = null; |
1229
|
|
|
foreach ($table->getColumns() as $column) { |
1230
|
|
|
$comments = $column->getComment(); |
1231
|
|
|
$matches = []; |
1232
|
|
|
if ($comments !== null && preg_match('/@defaultSort(\((desc|asc)\))*/', $comments, $matches) != 0) { |
1233
|
|
|
$defaultSort = $column->getName(); |
1234
|
|
|
if (count($matches) === 3) { |
1235
|
|
|
$defaultSortDirection = $matches[2]; |
1236
|
|
|
} else { |
1237
|
|
|
$defaultSortDirection = 'ASC'; |
1238
|
|
|
} |
1239
|
|
|
} |
1240
|
|
|
} |
1241
|
|
|
|
1242
|
|
|
return [$defaultSort, $defaultSortDirection]; |
1243
|
|
|
} |
1244
|
|
|
|
1245
|
|
|
/** |
1246
|
|
|
* @param string $beanNamespace |
1247
|
|
|
* @param string $beanClassName |
1248
|
|
|
* |
1249
|
|
|
* @return MethodGenerator[] |
1250
|
|
|
*/ |
1251
|
|
|
private function generateFindByDaoCode(string $beanNamespace, string $beanClassName, ClassGenerator $class): array |
1252
|
|
|
{ |
1253
|
|
|
$methods = []; |
1254
|
|
|
foreach ($this->removeDuplicateIndexes($this->table->getIndexes()) as $index) { |
1255
|
|
|
if (!$index->isPrimary()) { |
1256
|
|
|
$method = $this->generateFindByDaoCodeForIndex($index, $beanNamespace, $beanClassName); |
1257
|
|
|
|
1258
|
|
|
if ($method !== null) { |
1259
|
|
|
$method = $this->codeGeneratorListener->onBaseDaoFindByIndexGenerated($method, $index, $this, $this->configuration, $class); |
1260
|
|
|
if ($method !== null) { |
1261
|
|
|
$methods[] = $method; |
1262
|
|
|
} |
1263
|
|
|
} |
1264
|
|
|
} |
1265
|
|
|
} |
1266
|
|
|
usort($methods, static function (MethodGenerator $methodA, MethodGenerator $methodB) { |
1267
|
|
|
return $methodA->getName() <=> $methodB->getName(); |
1268
|
|
|
}); |
1269
|
|
|
|
1270
|
|
|
return $methods; |
1271
|
|
|
} |
1272
|
|
|
|
1273
|
|
|
/** |
1274
|
|
|
* Remove identical indexes (indexes on same columns) |
1275
|
|
|
* |
1276
|
|
|
* @param Index[] $indexes |
1277
|
|
|
* @return Index[] |
1278
|
|
|
*/ |
1279
|
|
|
private function removeDuplicateIndexes(array $indexes): array |
1280
|
|
|
{ |
1281
|
|
|
$indexesByKey = []; |
1282
|
|
|
foreach ($indexes as $index) { |
1283
|
|
|
$key = implode('__`__', $index->getUnquotedColumns()); |
1284
|
|
|
// Unique Index have precedence over non unique one |
1285
|
|
|
if (!isset($indexesByKey[$key]) || $index->isUnique()) { |
1286
|
|
|
$indexesByKey[$key] = $index; |
1287
|
|
|
} |
1288
|
|
|
} |
1289
|
|
|
|
1290
|
|
|
return array_values($indexesByKey); |
1291
|
|
|
} |
1292
|
|
|
|
1293
|
|
|
/** |
1294
|
|
|
* @param Index $index |
1295
|
|
|
* @param string $beanNamespace |
1296
|
|
|
* @param string $beanClassName |
1297
|
|
|
* |
1298
|
|
|
* @return MethodGenerator|null |
1299
|
|
|
*/ |
1300
|
|
|
private function generateFindByDaoCodeForIndex(Index $index, string $beanNamespace, string $beanClassName): ?MethodGenerator |
1301
|
|
|
{ |
1302
|
|
|
$columns = $index->getColumns(); |
1303
|
|
|
$usedBeans = []; |
1304
|
|
|
|
1305
|
|
|
/** |
1306
|
|
|
* The list of elements building this index (expressed as columns or foreign keys) |
1307
|
|
|
* @var AbstractBeanPropertyDescriptor[] |
1308
|
|
|
*/ |
1309
|
|
|
$elements = []; |
1310
|
|
|
|
1311
|
|
|
foreach ($columns as $column) { |
1312
|
|
|
$fk = $this->isPartOfForeignKey($this->table, $this->table->getColumn($column)); |
1313
|
|
|
if ($fk !== null) { |
1314
|
|
|
if (!isset($elements[$fk->getName()])) { |
1315
|
|
|
$elements[$fk->getName()] = new ObjectBeanPropertyDescriptor($this->table, $fk, $this->namingStrategy, $this->beanNamespace, $this->annotationParser, $this->registry->getBeanForTableName($fk->getForeignTableName()), $this->resultIteratorNamespace); |
1316
|
|
|
} |
1317
|
|
|
} else { |
1318
|
|
|
$elements[] = new ScalarBeanPropertyDescriptor($this->table, $this->table->getColumn($column), $this->namingStrategy, $this->annotationParser); |
1319
|
|
|
} |
1320
|
|
|
} |
1321
|
|
|
$elements = array_values($elements); |
1322
|
|
|
|
1323
|
|
|
// If the index is actually only a foreign key, let's bypass it entirely. |
1324
|
|
|
if (count($elements) === 1 && $elements[0] instanceof ObjectBeanPropertyDescriptor) { |
1325
|
|
|
return null; |
1326
|
|
|
} |
1327
|
|
|
|
1328
|
|
|
$parameters = []; |
1329
|
|
|
//$functionParameters = []; |
1330
|
|
|
$first = true; |
1331
|
|
|
/** @var AbstractBeanPropertyDescriptor $element */ |
1332
|
|
|
foreach ($elements as $element) { |
1333
|
|
|
$parameter = new ParameterGenerator(ltrim($element->getSafeVariableName(), '$')); |
1334
|
|
|
if (!$first && !($element->isCompulsory() && $index->isUnique())) { |
1335
|
|
|
$parameterType = '?'; |
1336
|
|
|
//$functionParameter = '?'; |
1337
|
|
|
} else { |
1338
|
|
|
$parameterType = ''; |
1339
|
|
|
//$functionParameter = ''; |
1340
|
|
|
} |
1341
|
|
|
$parameterType .= $element->getPhpType(); |
1342
|
|
|
$parameter->setType($parameterType); |
1343
|
|
|
if (!$first && !($element->isCompulsory() && $index->isUnique())) { |
1344
|
|
|
$parameter->setDefaultValue(null); |
1345
|
|
|
} |
1346
|
|
|
//$functionParameter .= $element->getPhpType(); |
1347
|
|
|
$elementClassName = $element->getClassName(); |
1348
|
|
|
if ($elementClassName) { |
1349
|
|
|
$usedBeans[] = $beanNamespace.'\\'.$elementClassName; |
1350
|
|
|
} |
1351
|
|
|
//$functionParameter .= ' '.$element->getVariableName(); |
1352
|
|
|
if ($first) { |
1353
|
|
|
$first = false; |
1354
|
|
|
} /*else { |
1355
|
|
|
$functionParameter .= ' = null'; |
1356
|
|
|
}*/ |
1357
|
|
|
//$functionParameters[] = $functionParameter; |
1358
|
|
|
$parameters[] = $parameter; |
1359
|
|
|
} |
1360
|
|
|
|
1361
|
|
|
//$functionParametersString = implode(', ', $functionParameters); |
1362
|
|
|
|
1363
|
|
|
$count = 0; |
1364
|
|
|
|
1365
|
|
|
$params = []; |
1366
|
|
|
$filterArrayCode = ''; |
1367
|
|
|
$commentArguments = []; |
1368
|
|
|
$first = true; |
1369
|
|
|
foreach ($elements as $element) { |
1370
|
|
|
$params[] = $element->getParamAnnotation(); |
1371
|
|
|
if ($element instanceof ScalarBeanPropertyDescriptor) { |
1372
|
|
|
$typeName = $element->getDatabaseType()->getName(); |
1373
|
|
|
if ($typeName === Type::DATETIME_IMMUTABLE) { |
|
|
|
|
1374
|
|
|
$filterArrayCode .= sprintf( |
1375
|
|
|
" %s => \$this->tdbmService->getConnection()->convertToDatabaseValue(%s, %s),\n", |
1376
|
|
|
var_export($element->getColumnName(), true), |
1377
|
|
|
$element->getSafeVariableName(), |
1378
|
|
|
var_export($typeName, true) |
1379
|
|
|
); |
1380
|
|
|
} else { |
1381
|
|
|
$filterArrayCode .= ' '.var_export($element->getColumnName(), true).' => '.$element->getSafeVariableName().",\n"; |
1382
|
|
|
} |
1383
|
|
|
} elseif ($element instanceof ObjectBeanPropertyDescriptor) { |
1384
|
|
|
$foreignKey = $element->getForeignKey(); |
1385
|
|
|
$columns = SafeFunctions::arrayCombine($foreignKey->getUnquotedLocalColumns(), $foreignKey->getUnquotedForeignColumns()); |
1386
|
|
|
++$count; |
1387
|
|
|
$foreignTable = $this->schema->getTable($foreignKey->getForeignTableName()); |
1388
|
|
|
foreach ($columns as $localColumn => $foreignColumn) { |
1389
|
|
|
// TODO: a foreign key could point to another foreign key. In this case, there is no getter for the pointed column. We don't support this case. |
1390
|
|
|
$targetedElement = new ScalarBeanPropertyDescriptor($foreignTable, $foreignTable->getColumn($foreignColumn), $this->namingStrategy, $this->annotationParser); |
1391
|
|
|
if ($first || $element->isCompulsory() && $index->isUnique()) { |
1392
|
|
|
// First parameter for index is not nullable |
1393
|
|
|
$filterArrayCode .= ' '.var_export($localColumn, true).' => '.$element->getSafeVariableName().'->'.$targetedElement->getGetterName()."(),\n"; |
1394
|
|
|
} else { |
1395
|
|
|
// Other parameters for index is not nullable |
1396
|
|
|
$filterArrayCode .= ' '.var_export($localColumn, true).' => ('.$element->getSafeVariableName().' !== null) ? '.$element->getSafeVariableName().'->'.$targetedElement->getGetterName()."() : null,\n"; |
1397
|
|
|
} |
1398
|
|
|
} |
1399
|
|
|
} |
1400
|
|
|
$commentArguments[] = substr($element->getSafeVariableName(), 1); |
1401
|
|
|
if ($first) { |
1402
|
|
|
$first = false; |
1403
|
|
|
} |
1404
|
|
|
} |
1405
|
|
|
|
1406
|
|
|
//$paramsString = implode("\n", $params); |
1407
|
|
|
|
1408
|
|
|
|
1409
|
|
|
$methodName = $this->namingStrategy->getFindByIndexMethodName($index, $elements); |
1410
|
|
|
|
1411
|
|
|
$method = new MethodGenerator($methodName); |
1412
|
|
|
|
1413
|
|
|
if ($index->isUnique()) { |
1414
|
|
|
$parameters[] = new ParameterGenerator('additionalTablesFetch', 'array', []); |
1415
|
|
|
$params[] = new ParamTag('additionalTablesFetch', [ 'string[]' ], 'A list of additional tables to fetch (for performance improvement)'); |
1416
|
|
|
$params[] = new ReturnTag([ '\\'.$beanNamespace.'\\'.$beanClassName, 'null' ]); |
1417
|
|
|
$method->setReturnType('?\\'.$beanNamespace.'\\'.$beanClassName); |
1418
|
|
|
|
1419
|
|
|
$docBlock = new DocBlockGenerator("Get a $beanClassName filtered by ".implode(', ', $commentArguments). '.', null, $params); |
1420
|
|
|
$docBlock->setWordWrap(false); |
1421
|
|
|
|
1422
|
|
|
$body = "\$filter = [ |
1423
|
|
|
".$filterArrayCode."]; |
1424
|
|
|
return \$this->findOne(\$filter, [], \$additionalTablesFetch); |
1425
|
|
|
"; |
1426
|
|
|
} else { |
1427
|
|
|
$parameters[] = (new ParameterGenerator('orderBy'))->setDefaultValue(null); |
1428
|
|
|
$params[] = new ParamTag('orderBy', [ 'mixed' ], 'The order string'); |
1429
|
|
|
$parameters[] = new ParameterGenerator('additionalTablesFetch', 'array', []); |
1430
|
|
|
$params[] = new ParamTag('additionalTablesFetch', [ 'string[]' ], 'A list of additional tables to fetch (for performance improvement)'); |
1431
|
|
|
$parameters[] = (new ParameterGenerator('mode', '?int'))->setDefaultValue(null); |
1432
|
|
|
$params[] = new ParamTag('mode', [ 'int', 'null' ], 'Either TDBMService::MODE_ARRAY or TDBMService::MODE_CURSOR (for large datasets). Defaults to TDBMService::MODE_ARRAY.'); |
1433
|
|
|
$method->setReturnType($this->resultIteratorNamespace . '\\' . $this->getResultIteratorClassName()); |
1434
|
|
|
|
1435
|
|
|
$docBlock = new DocBlockGenerator("Get a list of $beanClassName filtered by ".implode(', ', $commentArguments).".", null, $params); |
1436
|
|
|
$docBlock->setWordWrap(false); |
1437
|
|
|
|
1438
|
|
|
$body = "\$filter = [ |
1439
|
|
|
".$filterArrayCode."]; |
1440
|
|
|
return \$this->find(\$filter, [], \$orderBy, \$additionalTablesFetch, \$mode); |
1441
|
|
|
"; |
1442
|
|
|
} |
1443
|
|
|
|
1444
|
|
|
$method->setParameters($parameters); |
1445
|
|
|
$method->setDocBlock($docBlock); |
1446
|
|
|
$method->setBody($body); |
1447
|
|
|
|
1448
|
|
|
return $method; |
1449
|
|
|
} |
1450
|
|
|
|
1451
|
|
|
/** |
1452
|
|
|
* Generates the code for the getUsedTable protected method. |
1453
|
|
|
* |
1454
|
|
|
* @return MethodGenerator |
1455
|
|
|
*/ |
1456
|
|
|
private function generateGetUsedTablesCode(): MethodGenerator |
1457
|
|
|
{ |
1458
|
|
|
$hasParentRelationship = $this->schemaAnalyzer->getParentRelationship($this->table->getName()) !== null; |
1459
|
|
|
if ($hasParentRelationship) { |
1460
|
|
|
$code = sprintf('$tables = parent::getUsedTables(); |
1461
|
|
|
$tables[] = %s; |
1462
|
|
|
|
1463
|
|
|
return $tables;', var_export($this->table->getName(), true)); |
1464
|
|
|
} else { |
1465
|
|
|
$code = sprintf(' return [ %s ];', var_export($this->table->getName(), true)); |
1466
|
|
|
} |
1467
|
|
|
|
1468
|
|
|
$method = new MethodGenerator('getUsedTables'); |
1469
|
|
|
$method->setDocBlock(new DocBlockGenerator( |
1470
|
|
|
'Returns an array of used tables by this bean (from parent to child relationship).', |
1471
|
|
|
null, |
1472
|
|
|
[new ReturnTag(['string[]'])] |
1473
|
|
|
)); |
1474
|
|
|
$method->setReturnType('array'); |
1475
|
|
|
$method->setBody($code); |
1476
|
|
|
|
1477
|
|
|
return $method; |
1478
|
|
|
} |
1479
|
|
|
|
1480
|
|
|
private function generateOnDeleteCode(): ?MethodGenerator |
1481
|
|
|
{ |
1482
|
|
|
$setRefsToNullCode = ['parent::onDelete();']; |
1483
|
|
|
$relationships = $this->getPropertiesForTable($this->table); |
1484
|
|
|
foreach ($relationships as $relationship) { |
1485
|
|
|
if ($relationship instanceof ObjectBeanPropertyDescriptor) { |
1486
|
|
|
$tdbmFk = ForeignKey::createFromFk($relationship->getForeignKey()); |
1487
|
|
|
$foreignTableName = $tdbmFk->getForeignTableName(); |
1488
|
|
|
$setRefsToNullCode[] = sprintf( |
1489
|
|
|
'$this->setRef(%s, %s, %s, %s, %s);', |
1490
|
|
|
var_export($tdbmFk->getCacheKey(), true), |
1491
|
|
|
'null', |
1492
|
|
|
var_export($this->table->getName(), true), |
1493
|
|
|
'\\' . $this->beanNamespace . '\\' . $this->namingStrategy->getBeanClassName($foreignTableName) . '::class', |
1494
|
|
|
'\\' . $this->resultIteratorNamespace . '\\' . $this->namingStrategy->getResultIteratorClassName($foreignTableName) . '::class' |
1495
|
|
|
); |
1496
|
|
|
} |
1497
|
|
|
} |
1498
|
|
|
|
1499
|
|
|
if (count($setRefsToNullCode) === 1) { |
1500
|
|
|
return null; |
1501
|
|
|
} |
1502
|
|
|
|
1503
|
|
|
$method = new MethodGenerator('onDelete'); |
1504
|
|
|
$method->setDocBlock(new DocBlockGenerator('Method called when the bean is removed from database.')); |
1505
|
|
|
$method->setReturnType('void'); |
1506
|
|
|
$method->setBody(implode(PHP_EOL, $setRefsToNullCode)); |
1507
|
|
|
|
1508
|
|
|
return $method; |
1509
|
|
|
} |
1510
|
|
|
|
1511
|
|
|
/** |
1512
|
|
|
* @param PivotTableMethodsDescriptor[] $pivotTableMethodsDescriptors |
1513
|
|
|
* @return MethodGenerator |
1514
|
|
|
*/ |
1515
|
|
|
private function generateGetManyToManyRelationshipDescriptorCode(array $pivotTableMethodsDescriptors): ?MethodGenerator |
1516
|
|
|
{ |
1517
|
|
|
if (empty($pivotTableMethodsDescriptors)) { |
1518
|
|
|
return null; |
1519
|
|
|
} |
1520
|
|
|
|
1521
|
|
|
$method = new MethodGenerator('_getManyToManyRelationshipDescriptor'); |
1522
|
|
|
$method->setVisibility(AbstractMemberGenerator::VISIBILITY_PUBLIC); |
1523
|
|
|
$method->setDocBlock(new DocBlockGenerator( |
1524
|
|
|
'Get the paths used for many to many relationships methods.', |
1525
|
|
|
null, |
1526
|
|
|
[new GenericTag('internal')] |
1527
|
|
|
)); |
1528
|
|
|
$method->setReturnType(ManyToManyRelationshipPathDescriptor::class); |
1529
|
|
|
|
1530
|
|
|
$parameter = new ParameterGenerator('pathKey'); |
1531
|
|
|
$parameter->setType('string'); |
1532
|
|
|
$method->setParameter($parameter); |
1533
|
|
|
|
1534
|
|
|
$code = 'switch ($pathKey) {'."\n"; |
1535
|
|
|
foreach ($pivotTableMethodsDescriptors as $pivotTableMethodsDescriptor) { |
1536
|
|
|
$code .= ' case '.var_export($pivotTableMethodsDescriptor->getManyToManyRelationshipKey(), true).":\n"; |
1537
|
|
|
$code .= ' return '.$pivotTableMethodsDescriptor->getManyToManyRelationshipInstantiationCode().";\n"; |
1538
|
|
|
} |
1539
|
|
|
$code .= " default:\n"; |
1540
|
|
|
$code .= " return parent::_getManyToManyRelationshipDescriptor(\$pathKey);\n"; |
1541
|
|
|
$code .= "}\n"; |
1542
|
|
|
|
1543
|
|
|
$method->setBody($code); |
1544
|
|
|
|
1545
|
|
|
return $method; |
1546
|
|
|
} |
1547
|
|
|
|
1548
|
|
|
/** |
1549
|
|
|
* @param PivotTableMethodsDescriptor[] $pivotTableMethodsDescriptors |
1550
|
|
|
* @return MethodGenerator |
1551
|
|
|
*/ |
1552
|
|
|
private function generateGetManyToManyRelationshipDescriptorKeysCode(array $pivotTableMethodsDescriptors): ?MethodGenerator |
1553
|
|
|
{ |
1554
|
|
|
if (empty($pivotTableMethodsDescriptors)) { |
1555
|
|
|
return null; |
1556
|
|
|
} |
1557
|
|
|
|
1558
|
|
|
$method = new MethodGenerator('_getManyToManyRelationshipDescriptorKeys'); |
1559
|
|
|
$method->setVisibility(AbstractMemberGenerator::VISIBILITY_PUBLIC); |
1560
|
|
|
$method->setReturnType('array'); |
1561
|
|
|
$method->setDocBlock(new DocBlockGenerator( |
1562
|
|
|
'Returns the list of keys supported for many to many relationships', |
1563
|
|
|
null, |
1564
|
|
|
[new GenericTag('internal'), new ReturnTag('string[]')] |
1565
|
|
|
)); |
1566
|
|
|
|
1567
|
|
|
$keys = []; |
1568
|
|
|
foreach ($pivotTableMethodsDescriptors as $pivotTableMethodsDescriptor) { |
1569
|
|
|
$keys[] = var_export($pivotTableMethodsDescriptor->getManyToManyRelationshipKey(), true); |
1570
|
|
|
} |
1571
|
|
|
|
1572
|
|
|
$code = 'return array_merge(parent::_getManyToManyRelationshipDescriptorKeys(), ['.implode(', ', $keys).']);'; |
1573
|
|
|
|
1574
|
|
|
$method->setBody($code); |
1575
|
|
|
|
1576
|
|
|
return $method; |
1577
|
|
|
} |
1578
|
|
|
|
1579
|
|
|
/** |
1580
|
|
|
* @param PivotTableMethodsDescriptor[] $pivotTableMethodsDescriptors |
1581
|
|
|
* @return MethodGenerator |
1582
|
|
|
*/ |
1583
|
|
|
private function generateCloneCode(array $pivotTableMethodsDescriptors): MethodGenerator |
1584
|
|
|
{ |
1585
|
|
|
$precode = ''; |
1586
|
|
|
$postcode = ''; |
1587
|
|
|
|
1588
|
|
|
foreach ($this->beanPropertyDescriptors as $beanPropertyDescriptor) { |
1589
|
|
|
$postcode .= $beanPropertyDescriptor->getCloneRule(); |
1590
|
|
|
} |
1591
|
|
|
|
1592
|
|
|
//cloning many to many relationships |
1593
|
|
|
foreach ($pivotTableMethodsDescriptors as $beanMethodDescriptor) { |
1594
|
|
|
$precode .= $beanMethodDescriptor->getCloneRule()."\n"; |
1595
|
|
|
} |
1596
|
|
|
|
1597
|
|
|
$method = new MethodGenerator('__clone'); |
1598
|
|
|
$method->setBody($precode."parent::__clone();\n".$postcode); |
1599
|
|
|
|
1600
|
|
|
return $method; |
1601
|
|
|
} |
1602
|
|
|
|
1603
|
|
|
/** |
1604
|
|
|
* Returns the bean class name (without the namespace). |
1605
|
|
|
* |
1606
|
|
|
* @return string |
1607
|
|
|
*/ |
1608
|
|
|
public function getBeanClassName(): string |
1609
|
|
|
{ |
1610
|
|
|
return $this->namingStrategy->getBeanClassName($this->table->getName()); |
1611
|
|
|
} |
1612
|
|
|
|
1613
|
|
|
/** |
1614
|
|
|
* Returns the base bean class name (without the namespace). |
1615
|
|
|
* |
1616
|
|
|
* @return string |
1617
|
|
|
*/ |
1618
|
|
|
public function getBaseBeanClassName(): string |
1619
|
|
|
{ |
1620
|
|
|
return $this->namingStrategy->getBaseBeanClassName($this->table->getName()); |
1621
|
|
|
} |
1622
|
|
|
|
1623
|
|
|
/** |
1624
|
|
|
* Returns the DAO class name (without the namespace). |
1625
|
|
|
* |
1626
|
|
|
* @return string |
1627
|
|
|
*/ |
1628
|
|
|
public function getDaoClassName(): string |
1629
|
|
|
{ |
1630
|
|
|
return $this->namingStrategy->getDaoClassName($this->table->getName()); |
1631
|
|
|
} |
1632
|
|
|
|
1633
|
|
|
/** |
1634
|
|
|
* Returns the base DAO class name (without the namespace). |
1635
|
|
|
* |
1636
|
|
|
* @return string |
1637
|
|
|
*/ |
1638
|
|
|
public function getBaseDaoClassName(): string |
1639
|
|
|
{ |
1640
|
|
|
return $this->namingStrategy->getBaseDaoClassName($this->table->getName()); |
1641
|
|
|
} |
1642
|
|
|
|
1643
|
|
|
/** |
1644
|
|
|
* Returns the ResultIterator class name (without the namespace). |
1645
|
|
|
* |
1646
|
|
|
* @return string |
1647
|
|
|
*/ |
1648
|
|
|
public function getResultIteratorClassName(): string |
1649
|
|
|
{ |
1650
|
|
|
return $this->namingStrategy->getResultIteratorClassName($this->table->getName()); |
1651
|
|
|
} |
1652
|
|
|
|
1653
|
|
|
/** |
1654
|
|
|
* Returns the base ResultIterator class name (without the namespace). |
1655
|
|
|
* |
1656
|
|
|
* @return string |
1657
|
|
|
*/ |
1658
|
|
|
public function getBaseResultIteratorClassName(): string |
1659
|
|
|
{ |
1660
|
|
|
return $this->namingStrategy->getBaseResultIteratorClassName($this->table->getName()); |
1661
|
|
|
} |
1662
|
|
|
|
1663
|
|
|
/** |
1664
|
|
|
* Returns the table used to build this bean. |
1665
|
|
|
* |
1666
|
|
|
* @return Table |
1667
|
|
|
*/ |
1668
|
|
|
public function getTable(): Table |
1669
|
|
|
{ |
1670
|
|
|
return $this->table; |
1671
|
|
|
} |
1672
|
|
|
|
1673
|
|
|
/** |
1674
|
|
|
* Returns the extended bean class name (without the namespace), or null if the bean is not extended. |
1675
|
|
|
* |
1676
|
|
|
* @return string |
1677
|
|
|
*/ |
1678
|
|
|
public function getExtendedBeanClassName(): ?string |
1679
|
|
|
{ |
1680
|
|
|
$parentFk = $this->schemaAnalyzer->getParentRelationship($this->table->getName()); |
1681
|
|
|
if ($parentFk !== null) { |
1682
|
|
|
return $this->namingStrategy->getBeanClassName($parentFk->getForeignTableName()); |
1683
|
|
|
} |
1684
|
|
|
return null; |
1685
|
|
|
} |
1686
|
|
|
|
1687
|
|
|
/** |
1688
|
|
|
* Returns the extended result iterator class name (without the namespace), or null if the result iterator is not extended. |
1689
|
|
|
*/ |
1690
|
|
|
public function getExtendedResultIteratorClassName(): ?string |
1691
|
|
|
{ |
1692
|
|
|
$parentFk = $this->schemaAnalyzer->getParentRelationship($this->table->getName()); |
1693
|
|
|
if ($parentFk !== null) { |
1694
|
|
|
return $this->namingStrategy->getResultIteratorClassName($parentFk->getForeignTableName()); |
1695
|
|
|
} |
1696
|
|
|
return null; |
1697
|
|
|
} |
1698
|
|
|
|
1699
|
|
|
/** |
1700
|
|
|
* @return string |
1701
|
|
|
*/ |
1702
|
|
|
public function getBeanNamespace(): string |
1703
|
|
|
{ |
1704
|
|
|
return $this->beanNamespace; |
1705
|
|
|
} |
1706
|
|
|
|
1707
|
|
|
/** |
1708
|
|
|
* @return string |
1709
|
|
|
*/ |
1710
|
|
|
public function getGeneratedBeanNamespace(): string |
1711
|
|
|
{ |
1712
|
|
|
return $this->generatedBeanNamespace; |
1713
|
|
|
} |
1714
|
|
|
|
1715
|
|
|
/** |
1716
|
|
|
* @param ForeignKeyConstraint[] $fks |
1717
|
|
|
*/ |
1718
|
|
|
private function generateGetForeignKeys(array $fks): MethodGenerator |
1719
|
|
|
{ |
1720
|
|
|
$fkArray = []; |
1721
|
|
|
|
1722
|
|
|
foreach ($fks as $fk) { |
1723
|
|
|
$tdbmFk = ForeignKey::createFromFk($fk); |
1724
|
|
|
$fkArray[$tdbmFk->getCacheKey()] = [ |
1725
|
|
|
ForeignKey::FOREIGN_TABLE => $fk->getForeignTableName(), |
1726
|
|
|
ForeignKey::LOCAL_COLUMNS => $fk->getUnquotedLocalColumns(), |
1727
|
|
|
ForeignKey::FOREIGN_COLUMNS => $fk->getUnquotedForeignColumns(), |
1728
|
|
|
]; |
1729
|
|
|
} |
1730
|
|
|
|
1731
|
|
|
ksort($fkArray); |
1732
|
|
|
foreach ($fkArray as $tableFks) { |
1733
|
|
|
ksort($tableFks); |
1734
|
|
|
} |
1735
|
|
|
|
1736
|
|
|
$code = <<<EOF |
1737
|
|
|
if (\$tableName === %s) { |
1738
|
|
|
if (self::\$foreignKeys === null) { |
1739
|
|
|
self::\$foreignKeys = new ForeignKeys(%s); |
1740
|
|
|
} |
1741
|
|
|
return self::\$foreignKeys; |
1742
|
|
|
} |
1743
|
|
|
return parent::getForeignKeys(\$tableName); |
1744
|
|
|
EOF; |
1745
|
|
|
$code = sprintf($code, var_export($this->getTable()->getName(), true), $this->psr2VarExport($fkArray, ' ')); |
1746
|
|
|
|
1747
|
|
|
$method = new MethodGenerator('getForeignKeys'); |
1748
|
|
|
$method->setVisibility(AbstractMemberGenerator::VISIBILITY_PROTECTED); |
1749
|
|
|
$method->setStatic(true); |
1750
|
|
|
$method->setDocBlock(new DocBlockGenerator('Internal method used to retrieve the list of foreign keys attached to this bean.')); |
1751
|
|
|
$method->setReturnType(ForeignKeys::class); |
1752
|
|
|
|
1753
|
|
|
$parameter = new ParameterGenerator('tableName'); |
1754
|
|
|
$parameter->setType('string'); |
1755
|
|
|
$method->setParameter($parameter); |
1756
|
|
|
|
1757
|
|
|
|
1758
|
|
|
$method->setBody($code); |
1759
|
|
|
|
1760
|
|
|
return $method; |
1761
|
|
|
} |
1762
|
|
|
|
1763
|
|
|
/** |
1764
|
|
|
* @param mixed $var |
1765
|
|
|
* @param string $indent |
1766
|
|
|
* @return string |
1767
|
|
|
*/ |
1768
|
|
|
private function psr2VarExport($var, string $indent=''): string |
1769
|
|
|
{ |
1770
|
|
|
if (is_array($var)) { |
1771
|
|
|
$indexed = array_keys($var) === range(0, count($var) - 1); |
1772
|
|
|
$r = []; |
1773
|
|
|
foreach ($var as $key => $value) { |
1774
|
|
|
$r[] = "$indent " |
1775
|
|
|
. ($indexed ? '' : $this->psr2VarExport($key) . ' => ') |
1776
|
|
|
. $this->psr2VarExport($value, "$indent "); |
1777
|
|
|
} |
1778
|
|
|
return "[\n" . implode(",\n", $r) . "\n" . $indent . ']'; |
1779
|
|
|
} |
1780
|
|
|
return var_export($var, true); |
1781
|
|
|
} |
1782
|
|
|
} |
1783
|
|
|
|