Konfiguration

TypeMapping

Um eigene ReferenceResolver verwenden zu können, sollte sich eine ähnliche Konfiguration wie die folgende in dem TypeMapping der obersten Ebene befinden:

'referenceResolver' => [
	'stuttgart.*' => 'SP\Suttgart\Controller\ReferenceResolver'
]

Für Handler sieht dies so aus:

'referenceResolverHandler' => [
	'stuttgart.*' => 'SP\Suttgart\Controller\ReferenceResolver\Handler'
]

ReferenceResolver für eine Komponente registrieren

Um für eine Komponente einen oder mehrere ReferenceResolver zu registrieren, muss sich in der Konfiguration dieser Komponente eine ähnlich Struktur wie diese befinden:

'modelFactory' => [
	'handler' => [
		'referenceResolverManager' => [
			'resolverTypes' => [
				'internalTeaser'
			]
		]
	]
]

ReferenceResolver-Handler für eine Komponente registrieren

Einem ReferenceResolver können wie folgt bestimmte Handler angehangen werden:

'modelFactory' => [
	'handler' => [
		'referenceResolverManager' => [
			'resolverConfig' => [
				'internalTeaser' => [
					'handler' => [
						'stuttgartInternalImageLegendOverride' => [
							'type' => 'stuttgart.internalImageLegendOverrideHandler'
						]
					]
				]
			]
		]
	]
]

Daten an Handler von ReferenceResolvern übergeben

Dort, wo ein Handler für einen ReferenceResolver definiert wird, können ebenfalls Daten definiert werden, die durch \SP\Util\Objects::apply übergeben werden:

'modelFactory' => [
	'handler' => [
		'referenceResolverManager' => [
			'resolverConfig' => [
				'internalTeaser' => [
					'handler' => [
						'stuttgartInternalSymbolicPicture' => [
							'type' => 'stuttgart.internalSymbolicPictureResolverHandler',
							'forceSymbolicPicture' => true
						]
					]
				]
			]
		]
	]
]

Der Handler muss dafür über Getter- und Setter-Methoden für diese Daten verfügen.

Teil-Auflösung durch andere ReferenceResolver

Es ist möglich, in einem Resolver durch die Funktion resolvePartial(string $key, \SP\SiteKit\Model\Reference\Reference $reference) die Auflösung von Teil-Aspekten einem anderen Resolver zu überlassen. An welchen Resolver dies geleitet wird, muss über den übergebenen $key konfiguriert werden.

$content = $this->resolvePartial('content', $reference);
return [
	'content' => [
		'type' => 'internalContentDelegator',
	]
];

Die Konfiguration, die sich unter diesem Schlüssel befindet wird an den neuen Resolver übergeben und überschreibt dabei gegebenenfalls dessen Konfiguration.

Die Attribute einer Reference werden bei der Übergabe (es handelt sich um eine neue Instanz) an den neuen Resolver werden auf den Schlüssel “konkretisiert” - es wird also aus

"attributes" => [
	"showImage" => true,
	"size" => "cardsSmall",
	"content" => [
		"showImage" => false
	]
]

lediglich

"attributes" => [
	"showImage" => false
]

Delegation von ReferenceResolvern

Ein ReferenceResolver, der entweder von \SP\SiteKit\Controller\ReferenceResolver\InternalResolverDelegator oder \SP\SiteKit\Controller\ReferenceResolver\InternalResolverDelegator erbt, delegiert das Auflösen der Referenz komplett an einen anderen Resolver. Die Zuordnung findet anhand des Aggregates statt und wird über die Konfiguration gesteuert.

Gegeben sei dieses Aggregat:

"model" => [
	"items" => [
		[
			"modelType" => "reference.resource",
			"objectType" => "content",
			"url" => "/musterseiten/abschnitte/text.php",
			"ies" => [
				"id" => "100060100000001218-1015"
			],
			"attributes" => [
				"resolverType" => "standard",
				"standard" => [
					"imageLegend" => "manueller Linktext"
				]
			]
		]
	]
]

Der per Konfiguration festgelegte ReferenceResolver ist der SP\SiteKit\Controller\ReferenceResolver\InternalTeaserDelegator. Dieser delegiert an die verschiedenen Arten von Teaser-Resolvern. Dazu wird in erster Instanz das Attribut resolverType verwendet. Befindet sich in der Konfiguration nun unter dem Schlüssel delegates ein Item, in dem dieser ResolverType eingetragen ist, wird an den Resolver delegiert, der für diesen Typen konfiguriert ist. Gibt es mehrere solcher Items, wird der geringere Wert der order preferiert.

return [
	'delegates' => [
		'standard' => [
			'resolverTypes' => ['standard'],
			'order' => 1
		]
	],

	'standard' => [
		'type' => 'internalStandardTeaser'
	]
];

Wenn es das Attribut ‘resolverType’ nicht gibt oder kein passender ‘resolverType’ gefunden wird, wird der objectType auf die selbe Weise zur Delegation verwendet.

return [
	'delegates' => [
		'news' => [
			'resolverTypes' => ['news'],
			'objectTypes' => ['news', 'stuttgart-currentNotification'],
			'order' => 1
		]
	],

	'news' => [
		'type' => 'content.teaser.news'
	]
];

Sowohl für resolverTypes, als auch für objectTypes ist es möglich, den Wert '*' als Wildcard zu definieren.

return [
	'delegates' => [
		'news' => [
			'resolverTypes' => ['news'],
			'order' => 1
		],
		'standard' => [
			'resolverTypes' => ['*'],
			'order' => 10
		]
	]
];

Dieser Konfiguration nach werden alle Referenzen, die nicht den ResolverType news haben, mit dem Resolver, der für den Schlüssel standard konfiguriert ist, delegiert. Allerdings nur, wenn diese einen ResolverType definieren. Soll dies auch für alle anderen gelten, so muss '*' statt für resolverTypes für objectTypes definiert werden.

Anwendung von Attributen für delegierte ReferenceResolver

Zunächst werden alle Attribute unter dem Schlüssel ** an den delegierten Resolver übergeben. Anschließend wird alles, was sich unter dem Schlüssel des Resolvers, an den delegiert wird, befindet auf diese Attribute angewand und diese gegebenenfalls überschrieben.

"attributes" => [
	"**" => [
		"imageLegend" => "Genereller Linktext"
	],
	"standard" => [
		"imageLegend" => "Linktext für Standard-Teaser"
	]
]

Daraus würde sich für einen Resolver des Schlüssels standard die folgenden Attribute ergeben:

"attributes" => [
	"imageLegend" => "Linktext für Standard-Teaser"
]

Anwendung von Konfigurationen für delegierte ReferenceResolver

Die Konfiguration verhält sich equivalent zu den Attributen mit Ausnahme der superglobalen Schlüssel.

Superglobale Schlüssel

Attribute können unter dem superglobalen Schlüssel '*' definiert werden, um sie an jeden Resolver, der über resolvePartial oder delegate aufgerufen wird weiter zu geben.

Wie oft eine Teilauflösung oder Delegation geschieht, ist nicht bei der Erstellung des Aggregats abzusehen. Damit die Attribute dennoch bei dem korrekten Resolver ankommen, gibt es diese Wildcard. Angenommen, es wird eine Kachel aufgelöst. Diese hat eine Teilauflösung für ihren Inhalt zu einem Content-Delegator, der feststellt, es handelt sich um einen Teaser und delegiert weiter an einen Teaser-Delegator und der an den StandardTeaserResolver. Um nun diesem StandardTeaserResolver mit zu teilen, der Teaser soll sich in einem neuen Tab öffnen, würden folgende Attribute ausreichen:

"attributes" => [
	"content" => [
		"resolverType" => "teaser"
	],
	"*" => [
		"newTab" => true
	]
]

Um allerdings Kollisionen mit anderen Resolvern zu vermeiden, sollte versucht werden, den Wirkungsbereich so weit wie möglich einzugrenzen:

"attributes" => [
	"content" => [
		"resolverType" => "teaser",
		"*" => [
			"teaser" => [
				"*" => [
					"newTab" => true
				]
			]
		]
	]
]

So gilt der erste superglobale Schlüssel erst ab der ersten Teilauflösung und der zweite erst ab dem Teaser-Delegator. Sollte die Kachel beispielsweise noch einen Link enthalten, der über einen Resolver aufgelöst wird, der ebenfalls auf das Attribut newTab hört, würde er auf diese Weise unbeeinflusst bleiben.

Superglobale Werte werden immer vor allen anderen angewandt! Das heißt, dass sie von genauer spezifizierten Attributen überschrieben werden!