|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
/** |
|
4
|
|
|
* File containing the RelationProcessor class. |
|
5
|
|
|
* |
|
6
|
|
|
* @copyright Copyright (C) eZ Systems AS. All rights reserved. |
|
7
|
|
|
* @license For full copyright and license information view LICENSE file distributed with this source code. |
|
8
|
|
|
*/ |
|
9
|
|
|
namespace eZ\Publish\Core\Repository\Helper; |
|
10
|
|
|
|
|
11
|
|
|
use eZ\Publish\API\Repository\Exceptions\NotFoundException; |
|
12
|
|
|
use eZ\Publish\SPI\Persistence\Handler; |
|
13
|
|
|
use eZ\Publish\API\Repository\Values\ContentType\ContentType; |
|
14
|
|
|
use eZ\Publish\Core\Repository\Values\Content\Relation; |
|
15
|
|
|
use eZ\Publish\Core\FieldType\Value as BaseValue; |
|
16
|
|
|
use eZ\Publish\SPI\FieldType\FieldType as SPIFieldType; |
|
17
|
|
|
use eZ\Publish\SPI\Persistence\Content\Relation\CreateStruct as SPIRelationCreateStruct; |
|
18
|
|
|
use Psr\Log\LoggerAwareTrait; |
|
19
|
|
|
use Psr\Log\NullLogger; |
|
20
|
|
|
|
|
21
|
|
|
/** |
|
22
|
|
|
* RelationProcessor is an internal service used for handling field relations upon Content creation or update. |
|
23
|
|
|
* |
|
24
|
|
|
* @internal Meant for internal use by Repository. |
|
25
|
|
|
*/ |
|
26
|
|
|
class RelationProcessor |
|
27
|
|
|
{ |
|
28
|
|
|
use LoggerAwareTrait; |
|
29
|
|
|
|
|
30
|
|
|
/** |
|
31
|
|
|
* @var \eZ\Publish\SPI\Persistence\Handler |
|
32
|
|
|
*/ |
|
33
|
|
|
protected $persistenceHandler; |
|
34
|
|
|
|
|
35
|
|
|
/** |
|
36
|
|
|
* Setups service with reference to repository object that created it & corresponding handler. |
|
37
|
|
|
* |
|
38
|
|
|
* @param \eZ\Publish\SPI\Persistence\Handler $handler |
|
39
|
|
|
*/ |
|
40
|
|
|
public function __construct(Handler $handler) |
|
41
|
|
|
{ |
|
42
|
|
|
$this->persistenceHandler = $handler; |
|
43
|
|
|
$this->logger = new NullLogger(); |
|
44
|
|
|
} |
|
45
|
|
|
|
|
46
|
|
|
/** |
|
47
|
|
|
* Appends destination Content ids of given $fieldValue to the $relation array. |
|
48
|
|
|
* |
|
49
|
|
|
* If $fieldValue contains Location ids, the will be converted to the Content id that Location encapsulates. |
|
50
|
|
|
* |
|
51
|
|
|
* @param array $relations |
|
52
|
|
|
* @param array $locationIdToContentIdMapping An array with Location Ids as keys and corresponding Content Id as values |
|
53
|
|
|
* @param \eZ\Publish\SPI\FieldType\FieldType $fieldType |
|
54
|
|
|
* @param \eZ\Publish\Core\FieldType\Value $fieldValue Accepted field value. |
|
55
|
|
|
* @param string $fieldDefinitionId |
|
56
|
|
|
*/ |
|
57
|
|
|
public function appendFieldRelations( |
|
58
|
|
|
array &$relations, |
|
59
|
|
|
array &$locationIdToContentIdMapping, |
|
60
|
|
|
SPIFieldType $fieldType, |
|
61
|
|
|
BaseValue $fieldValue, |
|
62
|
|
|
$fieldDefinitionId |
|
63
|
|
|
) { |
|
64
|
|
|
foreach ($fieldType->getRelations($fieldValue) as $relationType => $destinationIds) { |
|
65
|
|
|
if ($relationType === Relation::FIELD) { |
|
66
|
|
|
if (!isset($relations[$relationType][$fieldDefinitionId])) { |
|
67
|
|
|
$relations[$relationType][$fieldDefinitionId] = array(); |
|
68
|
|
|
} |
|
69
|
|
|
$relations[$relationType][$fieldDefinitionId] += array_flip($destinationIds); |
|
70
|
|
|
} elseif ($relationType & (Relation::LINK | Relation::EMBED)) { |
|
71
|
|
|
// Using bitwise operators as Legacy Stack stores COMMON, LINK and EMBED relation types |
|
72
|
|
|
// in the same entry using bitmask |
|
73
|
|
|
if (!isset($relations[$relationType])) { |
|
74
|
|
|
$relations[$relationType] = array(); |
|
75
|
|
|
} |
|
76
|
|
|
|
|
77
|
|
|
if (isset($destinationIds['locationIds'])) { |
|
78
|
|
|
foreach ($destinationIds['locationIds'] as $locationId) { |
|
79
|
|
|
try { |
|
80
|
|
|
if (!isset($locationIdToContentIdMapping[$locationId])) { |
|
81
|
|
|
$location = $this->persistenceHandler->locationHandler()->load($locationId); |
|
82
|
|
|
$locationIdToContentIdMapping[$locationId] = $location->contentId; |
|
83
|
|
|
} |
|
84
|
|
|
|
|
85
|
|
|
$relations[$relationType][$locationIdToContentIdMapping[$locationId]] = true; |
|
86
|
|
|
} catch (NotFoundException $e) { |
|
87
|
|
|
$this->logger->error('Invalid relation: destination location not found', [ |
|
88
|
|
|
'fieldDefinitionId' => $fieldDefinitionId, |
|
89
|
|
|
'locationId' => $locationId, |
|
90
|
|
|
]); |
|
91
|
|
|
} |
|
92
|
|
|
} |
|
93
|
|
|
} |
|
94
|
|
|
|
|
95
|
|
|
if (isset($destinationIds['contentIds'])) { |
|
96
|
|
|
$relations[$relationType] += array_flip($destinationIds['contentIds']); |
|
97
|
|
|
} |
|
98
|
|
|
} |
|
99
|
|
|
} |
|
100
|
|
|
} |
|
101
|
|
|
|
|
102
|
|
|
/** |
|
103
|
|
|
* Persists relation data for a content version. |
|
104
|
|
|
* |
|
105
|
|
|
* This method creates new relations and deletes removed relations. |
|
106
|
|
|
* |
|
107
|
|
|
* @param array $inputRelations |
|
108
|
|
|
* @param mixed $sourceContentId |
|
109
|
|
|
* @param mixed $sourceContentVersionNo |
|
110
|
|
|
* @param \eZ\Publish\API\Repository\Values\ContentType\ContentType $contentType |
|
111
|
|
|
* @param \eZ\Publish\API\Repository\Values\Content\Relation[] $existingRelations An array of existing relations for Content version (empty when creating new content) |
|
112
|
|
|
*/ |
|
113
|
|
|
public function processFieldRelations( |
|
114
|
|
|
array $inputRelations, |
|
115
|
|
|
$sourceContentId, |
|
116
|
|
|
$sourceContentVersionNo, |
|
117
|
|
|
ContentType $contentType, |
|
118
|
|
|
array $existingRelations = array() |
|
119
|
|
|
) { |
|
120
|
|
|
// Map existing relations for easier handling |
|
121
|
|
|
$mappedRelations = array(); |
|
122
|
|
|
foreach ($existingRelations as $relation) { |
|
123
|
|
|
if ($relation->type === Relation::FIELD) { |
|
124
|
|
|
$fieldDefinition = $contentType->getFieldDefinition($relation->sourceFieldDefinitionIdentifier); |
|
125
|
|
|
if ($fieldDefinition !== null) { |
|
126
|
|
|
$mappedRelations[$relation->type][$fieldDefinition->id][$relation->destinationContentInfo->id] = $relation; |
|
127
|
|
|
} |
|
128
|
|
|
} |
|
129
|
|
|
// Using bitwise AND as Legacy Stack stores COMMON, LINK and EMBED relation types |
|
130
|
|
|
// in the same entry using bitmask |
|
131
|
|
View Code Duplication |
if ($relation->type & Relation::LINK) { |
|
|
|
|
|
|
132
|
|
|
$mappedRelations[Relation::LINK][$relation->destinationContentInfo->id] = $relation; |
|
133
|
|
|
} |
|
134
|
|
View Code Duplication |
if ($relation->type & Relation::EMBED) { |
|
|
|
|
|
|
135
|
|
|
$mappedRelations[Relation::EMBED][$relation->destinationContentInfo->id] = $relation; |
|
136
|
|
|
} |
|
137
|
|
|
} |
|
138
|
|
|
|
|
139
|
|
|
// Add new relations |
|
140
|
|
|
foreach ($inputRelations as $relationType => $relationData) { |
|
141
|
|
|
if ($relationType === Relation::FIELD) { |
|
142
|
|
|
foreach ($relationData as $fieldDefinitionId => $contentIds) { |
|
143
|
|
|
foreach (array_keys($contentIds) as $destinationContentId) { |
|
144
|
|
|
if (isset($mappedRelations[$relationType][$fieldDefinitionId][$destinationContentId])) { |
|
145
|
|
|
unset($mappedRelations[$relationType][$fieldDefinitionId][$destinationContentId]); |
|
146
|
|
View Code Duplication |
} else { |
|
|
|
|
|
|
147
|
|
|
$this->persistenceHandler->contentHandler()->addRelation( |
|
148
|
|
|
new SPIRelationCreateStruct( |
|
149
|
|
|
array( |
|
150
|
|
|
'sourceContentId' => $sourceContentId, |
|
151
|
|
|
'sourceContentVersionNo' => $sourceContentVersionNo, |
|
152
|
|
|
'sourceFieldDefinitionId' => $fieldDefinitionId, |
|
153
|
|
|
'destinationContentId' => $destinationContentId, |
|
154
|
|
|
'type' => $relationType, |
|
155
|
|
|
) |
|
156
|
|
|
) |
|
157
|
|
|
); |
|
158
|
|
|
} |
|
159
|
|
|
} |
|
160
|
|
|
} |
|
161
|
|
|
} elseif ($relationType === Relation::LINK || $relationType === Relation::EMBED) { |
|
162
|
|
|
foreach (array_keys($relationData) as $destinationContentId) { |
|
163
|
|
|
if (isset($mappedRelations[$relationType][$destinationContentId])) { |
|
164
|
|
|
unset($mappedRelations[$relationType][$destinationContentId]); |
|
165
|
|
View Code Duplication |
} else { |
|
|
|
|
|
|
166
|
|
|
$this->persistenceHandler->contentHandler()->addRelation( |
|
167
|
|
|
new SPIRelationCreateStruct( |
|
168
|
|
|
array( |
|
169
|
|
|
'sourceContentId' => $sourceContentId, |
|
170
|
|
|
'sourceContentVersionNo' => $sourceContentVersionNo, |
|
171
|
|
|
'sourceFieldDefinitionId' => null, |
|
172
|
|
|
'destinationContentId' => $destinationContentId, |
|
173
|
|
|
'type' => $relationType, |
|
174
|
|
|
) |
|
175
|
|
|
) |
|
176
|
|
|
); |
|
177
|
|
|
} |
|
178
|
|
|
} |
|
179
|
|
|
} |
|
180
|
|
|
} |
|
181
|
|
|
|
|
182
|
|
|
// Remove relations not present in input set |
|
183
|
|
|
foreach ($mappedRelations as $relationType => $relationData) { |
|
184
|
|
|
foreach ($relationData as $relationEntry) { |
|
185
|
|
|
switch ($relationType) { |
|
186
|
|
|
case Relation::FIELD: |
|
187
|
|
|
foreach ($relationEntry as $relation) { |
|
188
|
|
|
$this->persistenceHandler->contentHandler()->removeRelation( |
|
189
|
|
|
$relation->id, |
|
190
|
|
|
$relationType |
|
191
|
|
|
); |
|
192
|
|
|
} |
|
193
|
|
|
break; |
|
194
|
|
|
case Relation::LINK: |
|
195
|
|
|
case Relation::EMBED: |
|
196
|
|
|
$this->persistenceHandler->contentHandler()->removeRelation( |
|
197
|
|
|
$relationEntry->id, |
|
198
|
|
|
$relationType |
|
199
|
|
|
); |
|
200
|
|
|
} |
|
201
|
|
|
} |
|
202
|
|
|
} |
|
203
|
|
|
} |
|
204
|
|
|
} |
|
205
|
|
|
|
ezsystems /
ezpublish-kernel
Loading history...
Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation.
You can also find more detailed suggestions in the “Code” section of your repository.