Important:
If possible, instances of Prototype objects should always be created with the
new keyword and Singleton objects should rather be injected by some type of
Dependency Injection.
/**
* Set the routes configuration for the Neos setup and configures the routing component
* to skip initialisation, which would overwrite the specific settings again.
*
* @param ComponentContext $componentContext
* @return void
*/
public function handle(ComponentContext $componentContext)
{
$configurationSource = $this->objectManager->get(\Neos\Flow\Configuration\Source\YamlSource::class);
$routesConfiguration = $configurationSource->load($this->packageManager->getPackage('Neos.Setup')->getConfigurationPath() . ConfigurationManager::CONFIGURATION_TYPE_ROUTES);
$this->router->setRoutesConfiguration($routesConfiguration);
$componentContext->setParameter(\Neos\Flow\Mvc\Routing\RoutingComponent::class, 'skipRouterInitialization', true);
}
/**
* @param array $chainConfiguration
* @return ComponentChain
* @throws Exception
*/
public function create(array $chainConfiguration)
{
if (empty($chainConfiguration)) {
return null;
}
$arraySorter = new PositionalArraySorter($chainConfiguration);
$sortedChainConfiguration = $arraySorter->toArray();
$chainComponents = [];
foreach ($sortedChainConfiguration as $componentName => $configuration) {
$componentOptions = isset($configuration['componentOptions']) ? $configuration['componentOptions'] : [];
if (isset($configuration['chain'])) {
$component = $this->create($configuration['chain']);
} else {
if (!isset($configuration['component'])) {
throw new Exception(sprintf('Component chain could not be created because no component class name is configured for component "%s"', $componentName), 1401718283);
}
$component = $this->objectManager->get($configuration['component'], $componentOptions);
if (!$component instanceof ComponentInterface) {
throw new Exception(sprintf('Component chain could not be created because the class "%s" does not implement the ComponentInterface, in component "%s" does not implement', $configuration['component'], $componentName), 1401718283);
}
}
$chainComponents[] = $component;
}
return new ComponentChain(['components' => $chainComponents]);
}
/**
* Adds all validators that extend the AssetValidatorInterface.
*
* @return void
*/
protected function initializeObject()
{
$assetValidatorImplementationClassNames = $this->reflectionService->getAllImplementationClassNamesForInterface(AssetValidatorInterface::class);
foreach ($assetValidatorImplementationClassNames as $assetValidatorImplementationClassName) {
$this->addValidator($this->objectManager->get($assetValidatorImplementationClassName));
}
}
/**
* This object is created very early and is part of the blacklisted "Neos\Flow\Aop" namespace so we can't rely on AOP for the property injection.
*
* @param ObjectManagerInterface $objectManager
* @return void
*/
public function injectObjectManager(ObjectManagerInterface $objectManager)
{
if ($this->objectManager === null) {
$this->objectManager = $objectManager;
/** @var CacheManager $cacheManager */
$cacheManager = $this->objectManager->get(CacheManager::class);
$this->runtimeExpressionsCache = $cacheManager->getCache('Flow_Aop_RuntimeExpressions');
$this->runtimeExpressions = $this->runtimeExpressionsCache->requireOnce('Flow_Aop_RuntimeExpressions');
}
}
/**
* Execute the job
*
* A job should finish itself after successful execution using the queue methods.
*
* @param QueueInterface $queue
* @param Message $message
* @return boolean TRUE If the execution was successful
* @throws \Exception
*/
public function execute(QueueInterface $queue, Message $message)
{
$service = $this->objectManager->get($this->className);
$this->deferMethodCallAspect->setProcessingJob(true);
try {
$methodName = $this->methodName;
call_user_func_array([$service, $methodName], $this->arguments);
return true;
} catch (\Exception $exception) {
$this->deferMethodCallAspect->setProcessingJob(false);
throw $exception;
}
}
/**
* Handle an Exception thrown while rendering TypoScript according to
* settings specified in Neos.Fusion.rendering.exceptionHandler
*
* @param array $typoScriptPath
* @param \Exception $exception
* @param boolean $useInnerExceptionHandler
* @return string
* @throws InvalidConfigurationException
*/
public function handleRenderingException($typoScriptPath, \Exception $exception, $useInnerExceptionHandler = false)
{
$typoScriptConfiguration = $this->getConfigurationForPath($typoScriptPath);
if (isset($typoScriptConfiguration['__meta']['exceptionHandler'])) {
$exceptionHandlerClass = $typoScriptConfiguration['__meta']['exceptionHandler'];
$invalidExceptionHandlerMessage = 'The class "%s" is not valid for property "@exceptionHandler".';
} else {
if ($useInnerExceptionHandler === true) {
$exceptionHandlerClass = $this->settings['rendering']['innerExceptionHandler'];
} else {
$exceptionHandlerClass = $this->settings['rendering']['exceptionHandler'];
}
$invalidExceptionHandlerMessage = 'The class "%s" is not valid for setting "Neos.Fusion.rendering.exceptionHandler".';
}
$exceptionHandler = null;
if ($this->objectManager->isRegistered($exceptionHandlerClass)) {
$exceptionHandler = $this->objectManager->get($exceptionHandlerClass);
}
if ($exceptionHandler === null || !$exceptionHandler instanceof AbstractRenderingExceptionHandler) {
$message = sprintf($invalidExceptionHandlerMessage . "\n" . 'Please specify a fully qualified classname to a subclass of %2$s\\AbstractRenderingExceptionHandler.' . "\n" . 'You might implement an own handler or use one of the following:' . "\n" . '%2$s\\AbsorbingHandler' . "\n" . '%2$s\\HtmlMessageHandler' . "\n" . '%2$s\\PlainTextHandler' . "\n" . '%2$s\\ThrowingHandler' . "\n" . '%2$s\\XmlCommentHandler', $exceptionHandlerClass, 'Neos\\Fusion\\Core\\ExceptionHandlers');
throw new InvalidConfigurationException($message, 1368788926);
}
$exceptionHandler->setRuntime($this);
if (array_key_exists('__objectType', $typoScriptConfiguration)) {
$typoScriptPath .= sprintf('<%s>', $typoScriptConfiguration['__objectType']);
}
$output = $exceptionHandler->handleRenderingException($typoScriptPath, $exception);
return $output;
}
/**
* Emits a signal when an Advice is invoked
*
* The advice is not proxyable, so the signal is dispatched manually here.
*
* @param object $aspectObject
* @param string $methodName
* @param JoinPointInterface $joinPoint
* @return void
* @Flow\Signal
*/
protected function emitAdviceInvoked($aspectObject, $methodName, $joinPoint)
{
if ($this->dispatcher === null) {
$this->dispatcher = $this->objectManager->get(Dispatcher::class);
}
$this->dispatcher->dispatch(self::class, 'adviceInvoked', [$aspectObject, $methodName, $joinPoint]);
}
/**
* Returns the static value of the given operand, this might be also a global object
*
* @param mixed $expression The expression string representing the operand
* @return mixed The calculated value
*/
public function getValueForOperand($expression)
{
if (is_array($expression)) {
$result = [];
foreach ($expression as $expressionEntry) {
$result[] = $this->getValueForOperand($expressionEntry);
}
return $result;
} elseif (is_numeric($expression)) {
return $expression;
} elseif ($expression === true) {
return true;
} elseif ($expression === false) {
return false;
} elseif ($expression === null) {
return null;
} elseif (strpos($expression, 'context.') === 0) {
$objectAccess = explode('.', $expression, 3);
$globalObjectsRegisteredClassName = $this->globalObjects[$objectAccess[1]];
$globalObject = $this->objectManager->get($globalObjectsRegisteredClassName);
$this->securityContext->withoutAuthorizationChecks(function () use($globalObject, $objectAccess, &$globalObjectValue) {
$globalObjectValue = $this->getObjectValueByPath($globalObject, $objectAccess[2]);
});
return $globalObjectValue;
} else {
return trim($expression, '"\'');
}
}
/**
* Adds a setting filter to the pointcut filter composite
*
* @param string $operator The operator
* @param string $configurationPath The path to the settings option, that should be used
* @param PointcutFilterComposite $pointcutFilterComposite An instance of the pointcut filter composite. The result (ie. the custom filter) will be added to this composite object.
* @return void
*/
protected function parseDesignatorSetting($operator, $configurationPath, PointcutFilterComposite $pointcutFilterComposite)
{
$filter = new PointcutSettingFilter($configurationPath);
/** @var ConfigurationManager $configurationManager */
$configurationManager = $this->objectManager->get(ConfigurationManager::class);
$filter->injectConfigurationManager($configurationManager);
$pointcutFilterComposite->addFilter($operator, $filter);
}
/**
* Starts the shutdown sequence
*
* @param string $runlevel one of the Bootstrap::RUNLEVEL_* constants
* @return void
*/
protected function shutdown($runlevel)
{
$this->bootstrap->shutdown($runlevel);
if ($runlevel === Bootstrap::RUNLEVEL_COMPILETIME) {
$this->objectManager->get(LockManager::class)->unlockSite();
}
exit($this->response->getExitCode());
}
/**
* Emits a signal when a Request has been dispatched
*
* The action request is not proxyable, so the signal is dispatched manually here.
* The safeguard allows unit tests without the dispatcher dependency.
*
* @param ActionRequest $request
* @return void
* @Flow\Signal
*/
protected function emitRequestDispatched($request)
{
if ($this->objectManager !== null) {
$dispatcher = $this->objectManager->get(SignalSlotDispatcher::class);
if ($dispatcher !== null) {
$dispatcher->dispatch(ActionRequest::class, 'requestDispatched', [$request]);
}
}
}
/**
* @param PropertyMappingConfiguration $propertyMappingConfiguration
* @param string $dataType
* @return boolean
*/
protected function setTypeConverterForType(PropertyMappingConfiguration $propertyMappingConfiguration, $dataType)
{
if (!isset($this->typesConfiguration[$dataType]) || !isset($this->typesConfiguration[$dataType]['typeConverter'])) {
return false;
}
$typeConverter = $this->objectManager->get($this->typesConfiguration[$dataType]['typeConverter']);
$propertyMappingConfiguration->setTypeConverter($typeConverter);
$this->setTypeConverterOptionsForType($propertyMappingConfiguration, $this->typesConfiguration[$dataType]['typeConverter'], $dataType);
return true;
}
/**
* @When /^I import the last exported site$/
*/
public function iImportTheLastExportedSite()
{
// Persist any pending entity insertions (caused by lazy creation of live Workspace)
// This is a workaround which should be solved by properly isolating all read-only steps
$this->getSubContext('flow')->persistAll();
$this->resetNodeInstances();
/** @var SiteImportService $siteImportService */
$siteImportService = $this->objectManager->get(SiteImportService::class);
$siteImportService->importFromFile($this->lastExportedSiteXmlPathAndFilename);
}
/**
* Builds the needed pointcut filters for matching the policy privileges
*
* @return boolean
*/
protected function buildPointcutFilters()
{
$this->filters = [];
/** @var PolicyService $policyService */
$policyService = $this->objectManager->get(PolicyService::class);
/** @var MethodPrivilegeInterface[] $methodPrivileges */
$methodPrivileges = $policyService->getAllPrivilegesByType(MethodPrivilegeInterface::class);
foreach ($methodPrivileges as $privilege) {
$this->filters[$privilege->getCacheEntryIdentifier()] = $privilege->getPointcutFilterComposite();
}
}
/**
* Parses the request body according to the media type.
*
* @param HttpRequest $httpRequest
* @return array
*/
protected function parseRequestBody(HttpRequest $httpRequest)
{
$requestBody = $httpRequest->getContent();
if ($requestBody === null || $requestBody === '') {
return [];
}
$mediaTypeConverter = $this->objectManager->get(MediaTypeConverterInterface::class);
$propertyMappingConfiguration = new PropertyMappingConfiguration();
$propertyMappingConfiguration->setTypeConverter($mediaTypeConverter);
$propertyMappingConfiguration->setTypeConverterOption(MediaTypeConverterInterface::class, MediaTypeConverterInterface::CONFIGURATION_MEDIA_TYPE, $httpRequest->getHeader('Content-Type'));
$arguments = $this->propertyMapper->convert($requestBody, 'array', $propertyMappingConfiguration);
return $arguments;
}
/**
* Returns all class names implementing the ThumbnailGeneratorInterface.
*
* @Flow\CompileStatic
* @param ObjectManagerInterface $objectManager
* @return ThumbnailGeneratorInterface[]
*/
public static function getThumbnailGeneratorClassNames($objectManager)
{
/** @var ReflectionService $reflectionService */
$reflectionService = $objectManager->get(ReflectionService::class);
$generatorClassNames = $reflectionService->getAllImplementationClassNamesForInterface(ThumbnailGeneratorInterface::class);
$configurationManager = $objectManager->get(ConfigurationManager::class);
$generatorOptions = $configurationManager->getConfiguration('Settings', 'Neos.Media.thumbnailGenerators');
$generators = array();
foreach ($generatorClassNames as $generatorClassName) {
if (isset($generatorOptions[$generatorClassName]['disable']) && $generatorOptions[$generatorClassName]['disable'] === true) {
continue;
}
if (isset($generatorOptions[$generatorClassName]['priority'])) {
$priority = $generatorOptions[$generatorClassName]['priority'];
} else {
$priority = $generatorClassName::getPriority();
}
$generators[] = array('priority' => (int) $priority, 'className' => $generatorClassName);
}
$sorter = new PositionalArraySorter($generators, 'priority');
return array_reverse($sorter->toArray());
}
/**
* Around advice, wrapping every method of a scope session object. It redirects
* all method calls to the session object once there is one.
*
* @param JoinPointInterface $joinPoint The current join point
* @return mixed
* @Flow\Around("filter(Neos\Flow\Session\Aspect\SessionObjectMethodsPointcutFilter)")
*/
public function callMethodOnOriginalSessionObject(JoinPointInterface $joinPoint)
{
$objectName = $this->objectManager->getObjectNameByClassName(get_class($joinPoint->getProxy()));
$methodName = $joinPoint->getMethodName();
$proxy = $joinPoint->getProxy();
if (!isset($this->sessionOriginalInstances[$objectName])) {
$this->sessionOriginalInstances[$objectName] = $this->objectManager->get($objectName);
}
if ($this->sessionOriginalInstances[$objectName] === $proxy) {
return $joinPoint->getAdviceChain()->proceed($joinPoint);
} else {
return call_user_func_array([$this->sessionOriginalInstances[$objectName], $methodName], $joinPoint->getMethodArguments());
}
}
/**
* Resolve an operation, taking runtime constraints into account.
*
* @param string $operationName
* @param array|mixed $context
* @throws FlowQueryException
* @return OperationInterface the resolved operation
*/
public function resolveOperation($operationName, $context)
{
if (!isset($this->operations[$operationName])) {
throw new FlowQueryException('Operation "' . $operationName . '" not found.', 1332491837);
}
foreach ($this->operations[$operationName] as $operationClassName) {
/** @var OperationInterface $operation */
$operation = $this->objectManager->get($operationClassName);
if ($operation->canEvaluate($context)) {
return $operation;
}
}
throw new FlowQueryException('No operation which satisfies the runtime constraints found for "' . $operationName . '".', 1332491864);
}
/**
* Calls a behat step method
*
* @Flow\Internal
* @param string $testHelperObjectName
* @param string $methodName
* @param boolean $withoutSecurityChecks
*/
public function callBehatStepCommand($testHelperObjectName, $methodName, $withoutSecurityChecks = false)
{
$testHelper = $this->objectManager->get($testHelperObjectName);
$rawMethodArguments = $this->request->getExceedingArguments();
$mappedArguments = [];
for ($i = 0; $i < count($rawMethodArguments); $i += 2) {
$mappedArguments[] = $this->propertyMapper->convert($rawMethodArguments[$i + 1], $rawMethodArguments[$i]);
}
$result = null;
try {
if ($withoutSecurityChecks === true) {
$this->securityContext->withoutAuthorizationChecks(function () use($testHelper, $methodName, $mappedArguments, &$result) {
$result = call_user_func_array([$testHelper, $methodName], $mappedArguments);
});
} else {
$result = call_user_func_array([$testHelper, $methodName], $mappedArguments);
}
} catch (\Exception $exception) {
$this->outputLine('EXCEPTION: %s %d %s in %s:%s %s', [get_class($exception), $exception->getCode(), $exception->getMessage(), $exception->getFile(), $exception->getLine(), $exception->getTraceAsString()]);
return;
}
$this->output('SUCCESS: %s', [$result]);
}
/**
* Get available data source implementations
*
* @param ObjectManagerInterface $objectManager
* @return array Data source class names indexed by identifier
* @Flow\CompileStatic
* @throws NeosException
*/
public static function getDataSources($objectManager)
{
$reflectionService = $objectManager->get(ReflectionService::class);
$dataSources = array();
$dataSourceClassNames = $reflectionService->getAllImplementationClassNamesForInterface(DataSourceInterface::class);
/** @var $dataSourceClassName DataSourceInterface */
foreach ($dataSourceClassNames as $dataSourceClassName) {
$identifier = $dataSourceClassName::getIdentifier();
if (isset($dataSources[$identifier])) {
throw new NeosException(sprintf('Data source with identifier "%s" is already defined in class %s.', $identifier, $dataSourceClassName), 1414088185);
}
$dataSources[$identifier] = $dataSourceClassName;
}
return $dataSources;
}
/**
* Generate a TypoScript prototype definition for a given node type
*
* A prototype will be rendererd with the generator-class defined in the
* nodeType-configuration 'fusion.prototypeGenerator'
*
* @param NodeType $nodeType
* @return string
* @throws \Neos\Neos\Domain\Exception
*/
protected function generateTypoScriptForNodeType(NodeType $nodeType)
{
if ($nodeType->hasConfiguration('options.fusion.prototypeGenerator') && $nodeType->getConfiguration('options.fusion.prototypeGenerator') !== null) {
$generatorClassName = $nodeType->getConfiguration('options.fusion.prototypeGenerator');
if (!class_exists($generatorClassName)) {
throw new \Neos\Neos\Domain\Exception('Fusion prototype-generator Class ' . $generatorClassName . ' does not exist');
}
$generator = $this->objectManager->get($generatorClassName);
if (!$generator instanceof DefaultPrototypeGeneratorInterface) {
throw new \Neos\Neos\Domain\Exception('Fusion prototype-generator Class ' . $generatorClassName . ' does not implement interface ' . DefaultPrototypeGeneratorInterface::class);
}
return $generator->generate($nodeType);
}
return '';
}
/**
* Collects all TypeConverter implementations in a multi-dimensional array with source and target types.
*
* @return array
* @throws Exception\DuplicateTypeConverterException
* @see getTypeConverters
*/
protected function prepareTypeConverterMap()
{
$typeConverterMap = [];
$typeConverterClassNames = static::getTypeConverterImplementationClassNames($this->objectManager);
foreach ($typeConverterClassNames as $typeConverterClassName) {
$typeConverter = $this->objectManager->get($typeConverterClassName);
foreach ($typeConverter->getSupportedSourceTypes() as $supportedSourceType) {
if (isset($typeConverterMap[$supportedSourceType][$typeConverter->getSupportedTargetType()][$typeConverter->getPriority()])) {
throw new Exception\DuplicateTypeConverterException('There exist at least two converters which handle the conversion from "' . $supportedSourceType . '" to "' . $typeConverter->getSupportedTargetType() . '" with priority "' . $typeConverter->getPriority() . '": ' . get_class($this->typeConverters[$supportedSourceType][$typeConverter->getSupportedTargetType()][$typeConverter->getPriority()]) . ' and ' . get_class($typeConverter), 1297951378);
}
$typeConverterMap[$supportedSourceType][$typeConverter->getSupportedTargetType()][$typeConverter->getPriority()] = $typeConverterClassName;
}
}
return $typeConverterMap;
}
/**
* Add attribute descriptions to a given tag.
* Initializes the view helper and its arguments, and then reads out the list of arguments.
*
* @param string $className Class name where to add the attribute descriptions
* @param \SimpleXMLElement $xsdElement XML element to add the attributes to.
* @return void
*/
protected function addAttributes($className, \SimpleXMLElement $xsdElement)
{
$viewHelper = $this->objectManager->get($className);
$argumentDefinitions = $viewHelper->prepareArguments();
/** @var $argumentDefinition ArgumentDefinition */
foreach ($argumentDefinitions as $argumentDefinition) {
$xsdAttribute = $xsdElement->addChild('xsd:attribute');
$xsdAttribute['type'] = 'xsd:string';
$xsdAttribute['name'] = $argumentDefinition->getName();
$this->addDocumentation($argumentDefinition->getDescription(), $xsdAttribute);
if ($argumentDefinition->isRequired()) {
$xsdAttribute['use'] = 'required';
}
}
}
/**
* Sets the internal filters based on the given configuration.
*
* @param array $filterSettings The filter settings
* @return void
*/
protected function buildFiltersFromSettings(array $filterSettings)
{
foreach ($filterSettings as $singleFilterSettings) {
$patternType = isset($singleFilterSettings['pattern']) ? $singleFilterSettings['pattern'] : $singleFilterSettings['patternType'];
$patternClassName = $this->requestPatternResolver->resolveRequestPatternClass($patternType);
$patternOptions = isset($singleFilterSettings['patternOptions']) ? $singleFilterSettings['patternOptions'] : [];
/** @var $requestPattern RequestPatternInterface */
$requestPattern = $this->objectManager->get($patternClassName, $patternOptions);
// The following check needed for backwards compatibility:
// Previously each pattern had only one option that was set via the setPattern() method. Now options are passed to the constructor.
if (isset($singleFilterSettings['patternValue']) && is_callable([$requestPattern, 'setPattern'])) {
$requestPattern->setPattern($singleFilterSettings['patternValue']);
}
$interceptor = $this->objectManager->get($this->interceptorResolver->resolveInterceptorClass($singleFilterSettings['interceptor']));
$this->filters[] = $this->objectManager->get(RequestFilter::class, $requestPattern, $interceptor);
}
}
/**
* Get a password hashing strategy
*
* @param string $strategyIdentifier
* @return array<PasswordHashingStrategyInterface> and string
* @throws MissingConfigurationException
*/
protected function getPasswordHashingStrategyAndIdentifier($strategyIdentifier = 'default')
{
if (isset($this->passwordHashingStrategies[$strategyIdentifier])) {
return [$this->passwordHashingStrategies[$strategyIdentifier], $strategyIdentifier];
}
if ($strategyIdentifier === 'default') {
if (!isset($this->strategySettings['default'])) {
throw new MissingConfigurationException('No default hashing strategy configured', 1320758427);
}
$strategyIdentifier = $this->strategySettings['default'];
}
if (!isset($this->strategySettings[$strategyIdentifier])) {
throw new MissingConfigurationException('No hashing strategy with identifier "' . $strategyIdentifier . '" configured', 1320758776);
}
$strategyObjectName = $this->strategySettings[$strategyIdentifier];
$this->passwordHashingStrategies[$strategyIdentifier] = $this->objectManager->get($strategyObjectName);
return [$this->passwordHashingStrategies[$strategyIdentifier], $strategyIdentifier];
}
/**
* Replace resource on an asset. Takes variants and redirect handling into account.
*
* @param AssetInterface $asset
* @param PersistentResource $resource
* @param array $options
* @return void
*/
public function replaceAssetResource(AssetInterface $asset, PersistentResource $resource, array $options = [])
{
$originalAssetResource = $asset->getResource();
$asset->setResource($resource);
if (isset($options['keepOriginalFilename']) && (bool) $options['keepOriginalFilename'] === true) {
$asset->getResource()->setFilename($originalAssetResource->getFilename());
}
$uriMapping = [];
$redirectHandlerEnabled = isset($options['generateRedirects']) && (bool) $options['generateRedirects'] === true && $this->packageManager->isPackageAvailable('Neos.RedirectHandler');
if ($redirectHandlerEnabled) {
$uriMapping[$this->resourceManager->getPublicPersistentResourceUri($originalAssetResource)] = $this->resourceManager->getPublicPersistentResourceUri($asset->getResource());
}
if (method_exists($asset, 'getVariants')) {
$variants = $asset->getVariants();
/** @var AssetVariantInterface $variant */
foreach ($variants as $variant) {
$originalVariantResource = $variant->getResource();
$variant->refresh();
if (method_exists($variant, 'getAdjustments')) {
foreach ($variant->getAdjustments() as $adjustment) {
if (method_exists($adjustment, 'refit')) {
$adjustment->refit($asset);
}
}
}
if ($redirectHandlerEnabled) {
$uriMapping[$this->resourceManager->getPublicPersistentResourceUri($originalVariantResource)] = $this->resourceManager->getPublicPersistentResourceUri($variant->getResource());
}
$this->getRepository($variant)->update($variant);
}
}
if ($redirectHandlerEnabled) {
/** @var \Neos\RedirectHandler\Storage\RedirectStorageInterface $redirectStorage */
$redirectStorage = $this->objectManager->get(\Neos\RedirectHandler\Storage\RedirectStorageInterface::class);
foreach ($uriMapping as $originalUri => $newUri) {
$existingRedirect = $redirectStorage->getOneBySourceUriPathAndHost($originalUri);
if ($existingRedirect === null) {
$redirectStorage->addRedirect($originalUri, $newUri, 301);
}
}
}
$this->getRepository($asset)->update($asset);
$this->emitAssetResourceReplaced($asset);
}
/**
* Sets up security test requirements
*
* Security is based on action requests so we need a working route for the TestingProvider.
*
* @return void
*/
protected function setupSecurity()
{
$this->securityContext = $this->objectManager->get(\Neos\Flow\Security\Context::class);
if ($this->testableSecurityEnabled) {
$this->privilegeManager = $this->objectManager->get(\Neos\Flow\Security\Authorization\TestingPrivilegeManager::class);
$this->privilegeManager->setOverrideDecision(null);
$this->policyService = $this->objectManager->get(\Neos\Flow\Security\Policy\PolicyService::class);
$this->authenticationManager = $this->objectManager->get(\Neos\Flow\Security\Authentication\AuthenticationProviderManager::class);
$this->testingProvider = $this->objectManager->get(\Neos\Flow\Security\Authentication\Provider\TestingProvider::class);
$this->testingProvider->setName('TestingProvider');
$this->registerRoute('functionaltestroute', 'typo3/flow/test', array('@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Mvc\\Fixtures', '@controller' => 'Standard', '@action' => 'index', '@format' => 'html'));
$requestHandler = self::$bootstrap->getActiveRequestHandler();
$actionRequest = $this->route($requestHandler->getHttpRequest());
$this->securityContext->clearContext();
$this->securityContext->setRequest($actionRequest);
} else {
\Neos\Utility\ObjectAccess::setProperty($this->securityContext, 'authorizationChecksDisabled', true, true);
}
}
/**
* Return the node label generator class for the given node
*
* @return NodeLabelGeneratorInterface
*/
public function getNodeLabelGenerator()
{
$this->initialize();
if ($this->nodeLabelGenerator === null) {
if ($this->hasConfiguration('label.generatorClass')) {
$nodeLabelGenerator = $this->objectManager->get($this->getConfiguration('label.generatorClass'));
} elseif ($this->hasConfiguration('label') && is_string($this->getConfiguration('label'))) {
$nodeLabelGenerator = $this->objectManager->get(\Neos\ContentRepository\Domain\Model\ExpressionBasedNodeLabelGenerator::class);
$nodeLabelGenerator->setExpression($this->getConfiguration('label'));
} else {
$nodeLabelGenerator = $this->objectManager->get(\Neos\ContentRepository\Domain\Model\NodeLabelGeneratorInterface::class);
}
// TODO: Remove after deprecation phase of NodeDataLabelGeneratorInterface
if ($nodeLabelGenerator instanceof NodeDataLabelGeneratorInterface) {
$adaptor = new NodeDataLabelGeneratorAdaptor();
$adaptor->setNodeDataLabelGenerator($nodeLabelGenerator);
$nodeLabelGenerator = $adaptor;
}
$this->nodeLabelGenerator = $nodeLabelGenerator;
}
return $this->nodeLabelGenerator;
}
/**
* Shuts down this session
*
* This method must not be called manually – it is invoked by Flow's object
* management.
*
* @return void
*/
public function shutdownObject()
{
if ($this->started === true && $this->remote === false) {
if ($this->metaDataCache->has($this->sessionIdentifier)) {
// Security context can't be injected and must be retrieved manually
// because it relies on this very session object:
$securityContext = $this->objectManager->get(Context::class);
if ($securityContext->isInitialized()) {
$this->storeAuthenticatedAccountsInfo($securityContext->getAuthenticationTokens());
}
$this->putData('TYPO3_Flow_Object_ObjectManager', $this->objectManager->getSessionInstances());
$this->writeSessionMetaDataCacheEntry();
}
$this->started = false;
$decimals = (int) strlen(strrchr($this->garbageCollectionProbability, '.')) - 1;
$factor = $decimals > -1 ? $decimals * 10 : 1;
if (rand(1, 100 * $factor) <= $this->garbageCollectionProbability * $factor) {
$this->collectGarbage();
}
}
$this->request = null;
}
/**
* Dispatches a signal by calling the registered Slot methods
*
* @param string $signalClassName Name of the class containing the signal
* @param string $signalName Name of the signal
* @param array $signalArguments arguments passed to the signal method
* @return void
* @throws Exception\InvalidSlotException if the slot is not valid
* @api
*/
public function dispatch($signalClassName, $signalName, array $signalArguments = [])
{
if (!isset($this->slots[$signalClassName][$signalName])) {
return;
}
foreach ($this->slots[$signalClassName][$signalName] as $slotInformation) {
if (isset($slotInformation['object'])) {
$object = $slotInformation['object'];
} elseif (substr($slotInformation['method'], 0, 2) === '::') {
if (!isset($this->objectManager)) {
if (is_callable($slotInformation['class'] . $slotInformation['method'])) {
$object = $slotInformation['class'];
} else {
throw new Exception\InvalidSlotException(sprintf('Cannot dispatch %s::%s to class %s. The object manager is not yet available in the Signal Slot Dispatcher and therefore it cannot dispatch classes.', $signalClassName, $signalName, $slotInformation['class']), 1298113624);
}
} else {
$object = $this->objectManager->getClassNameByObjectName($slotInformation['class']);
}
$slotInformation['method'] = substr($slotInformation['method'], 2);
} else {
if (!isset($this->objectManager)) {
throw new Exception\InvalidSlotException(sprintf('Cannot dispatch %s::%s to class %s. The object manager is not yet available in the Signal Slot Dispatcher and therefore it cannot dispatch classes.', $signalClassName, $signalName, $slotInformation['class']), 1298113624);
}
if (!$this->objectManager->isRegistered($slotInformation['class'])) {
throw new Exception\InvalidSlotException('The given class "' . $slotInformation['class'] . '" is not a registered object.', 1245673367);
}
$object = $this->objectManager->get($slotInformation['class']);
}
if ($slotInformation['passSignalInformation'] === true) {
$signalArguments[] = $signalClassName . '::' . $signalName;
}
if (!method_exists($object, $slotInformation['method'])) {
throw new Exception\InvalidSlotException('The slot method ' . get_class($object) . '->' . $slotInformation['method'] . '() does not exist.', 1245673368);
}
call_user_func_array([$object, $slotInformation['method']], $signalArguments);
}
}