/**
* @return void
*/
protected function initializeAction()
{
$this->objects = $this->widgetConfiguration['objects'];
$this->configuration = Arrays::arrayMergeRecursiveOverrule($this->configuration, $this->widgetConfiguration['configuration'], true);
$this->numberOfPages = (int) ceil(count($this->objects) / (int) $this->configuration['itemsPerPage']);
$this->maximumNumberOfLinks = (int) $this->configuration['maximumNumberOfLinks'];
}
/**
*
* @param string $type
* @param boolean $showHiddenProperties if TRUE, the hidden properties are shown as configured in settings "supertypeResolver.hiddenProperties" are shown as well. FALSE by default
* @return array
* @throws \TYPO3\Form\Exception\TypeDefinitionNotFoundException if a type definition was not found
* @internal
*/
public function getMergedTypeDefinition($type, $showHiddenProperties = FALSE)
{
if (!isset($this->configuration[$type])) {
throw new \TYPO3\Form\Exception\TypeDefinitionNotFoundException(sprintf('Type "%s" not found. Probably some configuration is missing.', $type), 1325686909);
}
$mergedTypeDefinition = array();
if (isset($this->configuration[$type]['superTypes'])) {
foreach ($this->configuration[$type]['superTypes'] as $superTypeName => $enabled) {
// Skip unset node types
if ($enabled === FALSE || $enabled === NULL) {
continue;
}
// Make this setting backwards compatible with old array schema (deprecated since 2.0)
if (!is_bool($enabled)) {
$superTypeName = $enabled;
}
$mergedTypeDefinition = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($mergedTypeDefinition, $this->getMergedTypeDefinition($superTypeName, $showHiddenProperties));
}
}
$mergedTypeDefinition = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($mergedTypeDefinition, $this->configuration[$type]);
unset($mergedTypeDefinition['superTypes']);
if ($showHiddenProperties === FALSE && isset($this->settings['supertypeResolver']['hiddenProperties']) && is_array($this->settings['supertypeResolver']['hiddenProperties'])) {
foreach ($this->settings['supertypeResolver']['hiddenProperties'] as $propertyName) {
unset($mergedTypeDefinition[$propertyName]);
}
}
return $mergedTypeDefinition;
}
/**
* This method walks through the view configuration and applies
* matching configurations in the order of their specifity score.
* Possible options are currently the viewObjectName to specify
* a different class that will be used to create the view and
* an array of options that will be set on the view object.
*
* @param \TYPO3\Flow\Mvc\ActionRequest $request
* @return array
*/
public function getViewConfiguration(ActionRequest $request)
{
$cacheIdentifier = $this->createCacheIdentifier($request);
$viewConfiguration = $this->cache->get($cacheIdentifier);
if ($viewConfiguration === false) {
$configurations = $this->configurationManager->getConfiguration('Views');
$requestMatcher = new RequestMatcher($request);
$context = new Context($requestMatcher);
$matchingConfigurations = array();
foreach ($configurations as $order => $configuration) {
$requestMatcher->resetWeight();
if (!isset($configuration['requestFilter'])) {
$matchingConfigurations[$order]['configuration'] = $configuration;
$matchingConfigurations[$order]['weight'] = $order;
} else {
$result = $this->eelEvaluator->evaluate($configuration['requestFilter'], $context);
if ($result === false) {
continue;
}
$matchingConfigurations[$order]['configuration'] = $configuration;
$matchingConfigurations[$order]['weight'] = $requestMatcher->getWeight() + $order;
}
}
usort($matchingConfigurations, function ($configuration1, $configuration2) {
return $configuration1['weight'] > $configuration2['weight'];
});
$viewConfiguration = array();
foreach ($matchingConfigurations as $key => $matchingConfiguration) {
$viewConfiguration = Arrays::arrayMergeRecursiveOverrule($viewConfiguration, $matchingConfiguration['configuration']);
}
$this->cache->set($cacheIdentifier, $viewConfiguration);
}
return $viewConfiguration;
}
/**
* @param string $version
* @param boolean $loadJQuery
* @param boolean $loadEmberData
* @param boolean $minified
* @return string
* @throws \Exception
*/
public function render($version = NULL, $loadJQuery = FALSE, $loadEmberData = FALSE, $minified = TRUE)
{
$defaults = $this->getConfigurationArray('defaults', $version, $minified);
$version = $this->findVersionToLoad($version);
// Make sure the requested version has Ember-data configured
if ($loadEmberData && $this->settings['versions'][$version]['hasData'] === FALSE) {
throw new \Exception(sprintf('Version %s has no Ember-data configured', $version));
}
// Merge defaults and version configuration (version configuration overrides defaults)
$configuration = Arrays::arrayMergeRecursiveOverrule($defaults, $this->getConfigurationArray($version, $version, $minified), FALSE, FALSE);
// Remove jQuery
if ($loadJQuery === FALSE && isset($configuration['requirements']['jquery'])) {
unset($configuration['requirements']['jquery']);
}
// Build the includes array
$includes = array();
foreach ($configuration['requirements'] as $requirement) {
$includes[] = $requirement['path'];
}
$includes[] = $this->getResourcePath($this->settings['paths']['ember'], $version, $minified);
if ($loadEmberData === TRUE) {
$includes[] = $this->getResourcePath($this->settings['paths']['ember-data'], $version, $minified);
}
// Generate script tags
$baseUrl = $this->resourcePublisher->getStaticResourcesWebBaseUri();
$includes = array_map(function ($file) use($baseUrl) {
return sprintf('<script src="%sPackages/%s"></script>', $baseUrl, $file);
}, $includes);
return implode('', $includes);
}
/**
* Construct a couch DB connection from basic connection parameters for one
* given database.
*
* @param string $host
* @param integer $port
* @param string $username
* @param string $password
* @param array $options
*/
public function __construct($host, $port = 5984, $username = NULL, $password = NULL, array $options = array())
{
$this->options['host'] = (string) $host;
$this->options['port'] = (int) $port;
$this->options['username'] = $username;
$this->options['password'] = $password;
$this->options = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($this->options, $options, TRUE);
}
/**
* Merges the given context properties with sane defaults for the context implementation.
*
* @param array $contextProperties
* @return array
*/
protected function mergeContextPropertiesWithDefaults(array $contextProperties)
{
$contextProperties = $this->removeDeprecatedProperties($contextProperties);
$defaultContextProperties = array('workspaceName' => 'live', 'currentDateTime' => $this->now, 'dimensions' => array(), 'targetDimensions' => array(), 'invisibleContentShown' => FALSE, 'removedContentShown' => FALSE, 'inaccessibleContentShown' => FALSE, 'currentSite' => NULL, 'currentDomain' => NULL);
$mergedProperties = Arrays::arrayMergeRecursiveOverrule($defaultContextProperties, $contextProperties, TRUE);
$this->mergeDimensionValues($contextProperties, $mergedProperties);
$this->mergeTargetDimensionContextProperties($contextProperties, $mergedProperties, $defaultContextProperties);
return $mergedProperties;
}
/**
* @param Request $httpRequest
* @param array $matchResults
* @return ActionRequest
*/
protected function createActionRequest(Request $httpRequest, array $matchResults = NULL)
{
$actionRequest = new ActionRequest($httpRequest);
if ($matchResults !== NULL) {
$requestArguments = $actionRequest->getArguments();
$mergedArguments = Arrays::arrayMergeRecursiveOverrule($requestArguments, $matchResults);
$actionRequest->setArguments($mergedArguments);
}
return $actionRequest;
}
/**
* Executes this task
*
* @param \TYPO3\Surf\Domain\Model\Node $node
* @param \TYPO3\Surf\Domain\Model\Application $application
* @param \TYPO3\Surf\Domain\Model\Deployment $deployment
* @param array $options
* @return void
* @throws \TYPO3\Surf\Exception\TaskExecutionException
*/
public function execute(Node $node, Application $application, Deployment $deployment, array $options = array())
{
parent::execute($node, $application, $deployment, $options);
$settingsPatch = \Symfony\Component\Yaml\Yaml::parse(file_get_contents($this->resourcePath . '/Settings.yaml'));
$settings = (array) \Symfony\Component\Yaml\Yaml::parse(FLOW_PATH_ROOT . '/Configuration/Settings.yaml');
$settings = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($settings, $settingsPatch);
$patchedSettings = $this->temporaryPath . '/Settings.yaml';
file_put_contents($patchedSettings, \Symfony\Component\Yaml\Yaml::dump($settings, 999));
$patchedSettingsTargetPath = $deployment->getApplicationReleasePath($application) . '/Configuration/Settings.yaml';
$this->copy($patchedSettings, $patchedSettingsTargetPath);
}
/**
* @test
*/
public function ignoredClassesCanBeOverwrittenBySettings()
{
$object = new ApplicationContext('Development');
$this->assertEquals('TYPO3\\Flow\\Core\\ApplicationContext prototype object', Debugger::renderDump($object, 10, TRUE));
Debugger::clearState();
$currentConfiguration = ObjectAccess::getProperty($this->configurationManager, 'configurations', TRUE);
$configurationOverwrite['Settings']['TYPO3']['Flow']['error']['debugger']['ignoredClasses']['TYPO3\\\\Flow\\\\Core\\\\.*'] = FALSE;
$newConfiguration = Arrays::arrayMergeRecursiveOverrule($currentConfiguration, $configurationOverwrite);
ObjectAccess::setProperty($this->configurationManager, 'configurations', $newConfiguration, TRUE);
$this->assertContains('rootContextString', Debugger::renderDump($object, 10, TRUE));
}
/**
* @param string $persistenceIdentifier the persistence identifier for the form.
* @param string $factoryClass The fully qualified class name of the factory (which has to implement \TYPO3\Form\Factory\FormFactoryInterface)
* @param string $presetName name of the preset to use
* @param array $overrideConfiguration factory specific configuration
* @return string the rendered form
*/
public function render($persistenceIdentifier = NULL, $factoryClass = 'TYPO3\\Form\\Factory\\ArrayFormFactory', $presetName = 'default', array $overrideConfiguration = array())
{
if (isset($persistenceIdentifier)) {
$overrideConfiguration = Arrays::arrayMergeRecursiveOverrule($this->formPersistenceManager->load($persistenceIdentifier), $overrideConfiguration);
}
$factory = $this->objectManager->get($factoryClass);
$formDefinition = $factory->build($overrideConfiguration, $presetName);
$response = new Response($this->controllerContext->getResponse());
$form = $formDefinition->bind($this->controllerContext->getRequest(), $response);
return $form->render();
}
/**
* Merges the given context properties with sane defaults for the context implementation.
*
* @param array $contextProperties
* @return array
*/
protected function mergeContextPropertiesWithDefaults(array $contextProperties)
{
$contextProperties = $this->removeDeprecatedProperties($contextProperties);
$defaultContextProperties = array('workspaceName' => 'live', 'currentDateTime' => $this->now, 'dimensions' => array(), 'targetDimensions' => array(), 'invisibleContentShown' => false, 'removedContentShown' => false, 'inaccessibleContentShown' => false, 'currentSite' => null, 'currentDomain' => null);
if (!isset($contextProperties['currentSite'])) {
$defaultContextProperties = $this->setDefaultSiteAndDomainFromCurrentRequest($defaultContextProperties);
}
$mergedProperties = Arrays::arrayMergeRecursiveOverrule($defaultContextProperties, $contextProperties, true);
$this->mergeDimensionValues($contextProperties, $mergedProperties);
$this->mergeTargetDimensionContextProperties($contextProperties, $mergedProperties, $defaultContextProperties);
return $mergedProperties;
}
/**
* @param string $grantType One of this' interface GRANT_TYPE_* constants
* @param array $additionalParameters Additional parameters for the request
* @return mixed
* @throws \Flowpack\OAuth2\Client\Exception
* @see http://tools.ietf.org/html/rfc6749#section-4.1.3
*/
protected function requestAccessToken($grantType, $additionalParameters = array())
{
$parameters = array('grant_type' => $grantType, 'client_id' => $this->clientIdentifier, 'client_secret' => $this->clientSecret);
$parameters = Arrays::arrayMergeRecursiveOverrule($parameters, $additionalParameters, FALSE, FALSE);
$request = Request::create(new Uri($this->endpointUri), 'POST', $parameters);
$request->setHeader('Content-Type', 'application/x-www-form-urlencoded');
$response = $this->requestEngine->sendRequest($request);
if ($response->getStatusCode() !== 200) {
throw new OAuth2Exception(sprintf('The response when requesting the access token was not as expected, code and message was: %d %s', $response->getStatusCode(), $response->getContent()), 1383749757);
}
$responseComponents = json_decode($response->getContent(), true);
return $responseComponents['access_token'];
}
/**
* @return void
*/
protected function initializeAction()
{
$this->parentNode = $this->widgetConfiguration['parentNode'];
$this->nodes = $this->widgetConfiguration['nodes'];
$this->nodeTypeFilter = $this->widgetConfiguration['nodeTypeFilter'] ?: null;
$this->configuration = Arrays::arrayMergeRecursiveOverrule($this->configuration, $this->widgetConfiguration['configuration'], true);
$this->maximumNumberOfNodes = $this->configuration['maximumNumberOfNodes'];
$numberOfNodes = $this->parentNode === null ? count($this->nodes) : $this->parentNode->getNumberOfChildNodes($this->nodeTypeFilter);
if ($this->maximumNumberOfNodes > 0 && $numberOfNodes > $this->maximumNumberOfNodes) {
$numberOfNodes = $this->maximumNumberOfNodes;
}
$this->numberOfPages = ceil($numberOfNodes / (int) $this->configuration['itemsPerPage']);
$this->maximumNumberOfLinks = (int) $this->configuration['maximumNumberOfLinks'];
}
/**
* @param JobConfigurationInterface $jobConfiguration
* @param string $persistenceIdentifier the persistence identifier for the form.
* @param string $factoryClass The fully qualified class name of the factory (which has to implement \TYPO3\Form\Factory\FormFactoryInterface)
* @param string $presetName name of the preset to use
* @param array $overrideConfiguration factory specific configuration
* @return string the rendered form
*/
public function render(JobConfigurationInterface $jobConfiguration, $persistenceIdentifier = null, $factoryClass = 'TYPO3\\Form\\Factory\\ArrayFormFactory', $presetName = 'default', array $overrideConfiguration = [])
{
if (isset($persistenceIdentifier)) {
$overrideConfiguration = Arrays::arrayMergeRecursiveOverrule($this->formPersistenceManager->load($persistenceIdentifier), $overrideConfiguration);
}
$factory = $this->objectManager->get($factoryClass);
/** @var FormDefinition $formDefinition */
$formDefinition = $factory->build($overrideConfiguration, $presetName);
ObjectAccess::setProperty($formDefinition, 'identifier', 'options', true);
$this->postProcessFormDefinition($jobConfiguration, $formDefinition);
$response = new Response($this->controllerContext->getResponse());
$form = $formDefinition->bind($this->controllerContext->getRequest(), $response);
$form->getRequest()->setArgumentNamespace('--options');
return $form->render();
}
/**
* Merges the TYPO3.Ice settings with the current settings before calling the render() method
*
* @return string
*/
public function initializeArgumentsAndRender()
{
$settings = $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'TYPO3.Ice');
if ($this->controllerContext->getRequest()->getControllerPackageKey() !== 'TYPO3.Ice') {
$packageSettings = $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, $this->controllerContext->getRequest()->getControllerPackageKey());
if (!empty($packageSettings['extendIceSettings'])) {
$settings = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($settings, $packageSettings);
} else {
$settings = $packageSettings;
}
}
if (isset($settings['projectElementTypes'])) {
$supertypeResolver = new \TYPO3\Ice\Utility\SupertypeResolver($settings['projectElementTypes']);
$settings['projectElementTypes'] = $supertypeResolver->getCompleteMergedTypeDefinition(TRUE);
}
$this->settings = $settings;
return parent::initializeArgumentsAndRender();
}
/**
*
* @param string $objectName
* @param array $overrideProperties
* @param boolean $addObjectToPersistence
* @return object
*/
public function buildObject($objectName, $overrideProperties = array(), $addObjectToPersistence = FALSE)
{
if (!isset($this->fixtureDefinitions[$objectName])) {
throw new \Exception('Object name ' . $objectName . ' not configured in fixture definitions');
}
$properties = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($this->fixtureDefinitions[$objectName], $overrideProperties);
$className = isset($properties['__type']) ? $properties['__type'] : $this->baseType;
unset($properties['__type']);
$object = new $className();
foreach ($properties as $propertyName => $propertyValue) {
if (\TYPO3\Flow\Reflection\ObjectAccess::isPropertySettable($object, $propertyName)) {
\TYPO3\Flow\Reflection\ObjectAccess::setProperty($object, $propertyName, $propertyValue);
}
}
$this->setCustomProperties($object, $properties, $addObjectToPersistence);
if ($addObjectToPersistence) {
$this->addObjectToPersistence($object);
}
return $object;
}
/**
*
* @param string $type
* @param boolean $showHiddenProperties if TRUE, the hidden properties are shown as configured in settings "supertypeResolver.hiddenProperties" are shown as well. FALSE by default
* @return array
* @throws \TYPO3\Ice\Exception\TypeDefinitionNotFoundException if a type definition was not found
* @internal
*/
public function getMergedTypeDefinition($type, $showHiddenProperties = FALSE)
{
if (isset($this->configuration[$type])) {
$mergedTypeDefinition = array();
if (isset($this->configuration[$type]['superTypes'])) {
foreach ($this->configuration[$type]['superTypes'] as $superType) {
$mergedTypeDefinition = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($mergedTypeDefinition, $this->getMergedTypeDefinition($superType, $showHiddenProperties));
}
}
$mergedTypeDefinition = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($mergedTypeDefinition, $this->configuration[$type]);
unset($mergedTypeDefinition['superTypes']);
if ($showHiddenProperties === FALSE && isset($this->settings['supertypeResolver']['hiddenProperties']) && is_array($this->settings['supertypeResolver']['hiddenProperties'])) {
foreach ($this->settings['supertypeResolver']['hiddenProperties'] as $propertyName) {
unset($mergedTypeDefinition[$propertyName]);
}
}
return $mergedTypeDefinition;
} else {
throw new \TYPO3\Ice\Exception\TypeDefinitionNotFoundException(sprintf('Type "%s" not found. Probably some configuration is missing.', $type), 1325686909);
}
}
/**
* Returns an ActionRequest which referred to this request, if any.
*
* The referring request is not set or determined automatically but must be
* explicitly set through the corresponding internal argument "__referrer".
* This mechanism is used by Flow's form and validation mechanisms.
*
* @return ActionRequest the referring request, or NULL if no referrer found
*/
public function getReferringRequest()
{
if ($this->referringRequest !== null) {
return $this->referringRequest;
}
if (!isset($this->internalArguments['__referrer'])) {
return null;
}
if (is_array($this->internalArguments['__referrer'])) {
$referrerArray = $this->internalArguments['__referrer'];
$referringRequest = new ActionRequest($this->getHttpRequest());
$arguments = array();
if (isset($referrerArray['arguments'])) {
$serializedArgumentsWithHmac = $referrerArray['arguments'];
$serializedArguments = $this->hashService->validateAndStripHmac($serializedArgumentsWithHmac);
$arguments = unserialize(base64_decode($serializedArguments));
unset($referrerArray['arguments']);
}
$referringRequest->setArguments(Arrays::arrayMergeRecursiveOverrule($arguments, $referrerArray));
return $referringRequest;
} else {
$this->referringRequest = $this->internalArguments['__referrer'];
}
return $this->referringRequest;
}
/**
* Loads the specified configuration file and returns its content as an
* array. If the file does not exist or could not be loaded, an empty
* array is returned
*
* @param string $pathAndFilename Full path and filename of the file to load, excluding the file extension (ie. ".yaml")
* @param boolean $allowSplitSource If TRUE, the type will be used as a prefix when looking for configuration files
* @return array
* @throws \TYPO3\Flow\Configuration\Exception\ParseErrorException
*/
public function load($pathAndFilename, $allowSplitSource = false)
{
$pathsAndFileNames = array($pathAndFilename . '.yaml');
if ($allowSplitSource === true) {
$splitSourcePathsAndFileNames = glob($pathAndFilename . '.*.yaml');
if ($splitSourcePathsAndFileNames !== false) {
sort($splitSourcePathsAndFileNames);
$pathsAndFileNames = array_merge($pathsAndFileNames, $splitSourcePathsAndFileNames);
}
}
$configuration = array();
foreach ($pathsAndFileNames as $pathAndFilename) {
if (is_file($pathAndFilename)) {
try {
if ($this->usePhpYamlExtension) {
$loadedConfiguration = @yaml_parse_file($pathAndFilename);
if ($loadedConfiguration === false) {
throw new \TYPO3\Flow\Configuration\Exception\ParseErrorException('A parse error occurred while parsing file "' . $pathAndFilename . '".', 1391894094);
}
} else {
$loadedConfiguration = Yaml::parse($pathAndFilename);
}
if (is_array($loadedConfiguration)) {
$configuration = Arrays::arrayMergeRecursiveOverrule($configuration, $loadedConfiguration);
}
} catch (\TYPO3\Flow\Error\Exception $exception) {
throw new \TYPO3\Flow\Configuration\Exception\ParseErrorException('A parse error occurred while parsing file "' . $pathAndFilename . '". Error message: ' . $exception->getMessage(), 1232014321);
}
}
}
return $configuration;
}
/**
* Return the mapping which would be sent to the server as array
*
* @return array
*/
public function asArray()
{
return array($this->type->getName() => Arrays::arrayMergeRecursiveOverrule(array('dynamic_templates' => $this->getDynamicTemplates(), 'properties' => $this->getProperties()), $this->fullMapping));
}
/**
* @param string $nodeTypeName
* @param array $configuration
* @throws \TYPO3\Neos\Exception
* @return void
*/
protected function addEditorDefaultsToNodeTypeConfiguration($nodeTypeName, &$configuration)
{
if (isset($configuration['properties']) && is_array($configuration['properties'])) {
foreach ($configuration['properties'] as $propertyName => &$propertyConfiguration) {
if (!isset($propertyConfiguration['type'])) {
continue;
}
$type = $propertyConfiguration['type'];
if (!isset($this->dataTypesDefaultConfiguration[$type])) {
continue;
}
if (!isset($propertyConfiguration['ui']['inspector'])) {
continue;
}
$defaultConfigurationFromDataType = $this->dataTypesDefaultConfiguration[$type];
// FIRST STEP: Figure out which editor should be used
// - Default: editor as configured from the data type
// - Override: editor as configured from the property configuration.
if (isset($propertyConfiguration['ui']['inspector']['editor'])) {
$editor = $propertyConfiguration['ui']['inspector']['editor'];
} elseif (isset($defaultConfigurationFromDataType['editor'])) {
$editor = $defaultConfigurationFromDataType['editor'];
} else {
throw new \TYPO3\Neos\Exception('Could not find editor for ' . $propertyName . ' in node type ' . $nodeTypeName, 1436809123);
}
// SECOND STEP: Build up the full inspector configuration by merging:
// - take configuration from editor defaults
// - take configuration from dataType
// - take configuration from properties (NodeTypes)
$mergedInspectorConfiguration = array();
if (isset($this->editorDefaultConfiguration[$editor])) {
$mergedInspectorConfiguration = $this->editorDefaultConfiguration[$editor];
}
$mergedInspectorConfiguration = Arrays::arrayMergeRecursiveOverrule($mergedInspectorConfiguration, $defaultConfigurationFromDataType);
$mergedInspectorConfiguration = Arrays::arrayMergeRecursiveOverrule($mergedInspectorConfiguration, $propertyConfiguration['ui']['inspector']);
$propertyConfiguration['ui']['inspector'] = $mergedInspectorConfiguration;
$propertyConfiguration['ui']['inspector']['editor'] = $editor;
}
}
}
/**
* Set the "context node" this operation was working on.
*
* @param NodeInterface $node
* @return void
*/
public function setNode(NodeInterface $node)
{
$this->nodeIdentifier = $node->getIdentifier();
$this->workspaceName = $node->getContext()->getWorkspaceName();
$this->dimension = $node->getContext()->getDimensions();
$context = $node->getContext();
if ($context instanceof ContentContext && $context->getCurrentSite() !== null) {
$siteIdentifier = $this->persistenceManager->getIdentifierByObject($context->getCurrentSite());
} else {
$siteIdentifier = null;
}
$this->data = Arrays::arrayMergeRecursiveOverrule($this->data, array('nodeContextPath' => $node->getContextPath(), 'nodeLabel' => $node->getLabel(), 'nodeType' => $node->getNodeType()->getName(), 'site' => $siteIdentifier));
$node = self::getClosestAggregateNode($node);
if ($node !== null) {
$this->documentNodeIdentifier = $node->getIdentifier();
$this->data = Arrays::arrayMergeRecursiveOverrule($this->data, array('documentNodeContextPath' => $node->getContextPath(), 'documentNodeLabel' => $node->getLabel(), 'documentNodeType' => $node->getNodeType()->getName()));
}
}
/**
* Initialize action, and merge settings if needed
*
* @return void
*/
public function initializeAction()
{
if ($this->request->getControllerPackageKey() !== 'TYPO3.Ice' && !empty($this->settings['extendIceSettings'])) {
$this->settings = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'TYPO3.Ice'), $this->settings);
}
}
/**
* @param array $contextProperties
* @param array $mergedProperties
* @return void
* @throws InvalidNodeContextException
*/
protected function mergeDimensionValues(array $contextProperties, array &$mergedProperties)
{
$dimensions = $this->getAvailableDimensions();
foreach ($dimensions as $dimension) {
/** @var ContentDimension $dimension */
$identifier = $dimension->getIdentifier();
$values = array($dimension->getDefault());
if (isset($contextProperties['dimensions'][$identifier])) {
if (!is_array($contextProperties['dimensions'][$identifier])) {
throw new InvalidNodeContextException(sprintf('The given dimension fallback chain for "%s" should be an array of string, but "%s" was given.', $identifier, gettype($contextProperties['dimensions'][$identifier])), 1407417930);
}
$values = Arrays::arrayMergeRecursiveOverrule($values, $contextProperties['dimensions'][$identifier]);
}
$mergedProperties['dimensions'][$identifier] = $values;
}
}
/**
* Tries to load the reflection data from the compile time cache.
*
* The compile time cache is only supported for Development context and thus
* this function will return in any other context.
*
* If no reflection data was found, this method will at least load the precompiled
* reflection data of any possible frozen package. Even if precompiled reflection
* data could be loaded, FALSE will be returned in order to signal that other
* packages still need to be reflected.
*
* @return boolean TRUE if reflection data could be loaded, otherwise FALSE
*/
protected function loadClassReflectionCompiletimeCache()
{
$data = $this->reflectionDataCompiletimeCache->get('ReflectionData');
if ($data !== false) {
foreach ($data as $propertyName => $propertyValue) {
$this->{$propertyName} = $propertyValue;
}
return true;
}
if (!$this->context->isDevelopment()) {
return false;
}
$useIgBinary = extension_loaded('igbinary');
foreach ($this->packageManager->getActivePackages() as $packageKey => $package) {
if (!$this->packageManager->isPackageFrozen($packageKey)) {
continue;
}
$pathAndFilename = $this->getPrecompiledReflectionStoragePath() . $packageKey . '.dat';
if (!file_exists($pathAndFilename)) {
continue;
}
$data = $useIgBinary ? igbinary_unserialize(file_get_contents($pathAndFilename)) : unserialize(file_get_contents($pathAndFilename));
foreach ($data as $propertyName => $propertyValue) {
$this->{$propertyName} = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($this->{$propertyName}, $propertyValue);
}
}
return false;
}
/**
* @param array $properties
*/
public function __construct(array $properties)
{
$this->properties = Arrays::arrayMergeRecursiveOverrule($this->properties, $properties);
}
/**
* Tries to load the 'TYPO3.Flow.error.debugger.ignoredClasses' setting
* to build a regular expression that can be used to filter ignored class names
* If settings can't be loaded it uses self::$ignoredClassesFallback.
*
* @return string
*/
public static function getIgnoredClassesRegex()
{
if (self::$ignoredClassesRegex !== '') {
return self::$ignoredClassesRegex;
}
$ignoredClassesConfiguration = self::$ignoredClassesFallback;
$ignoredClasses = array();
if (self::$objectManager instanceof ObjectManagerInterface) {
$configurationManager = self::$objectManager->get('TYPO3\\Flow\\Configuration\\ConfigurationManager');
if ($configurationManager instanceof ConfigurationManager) {
$ignoredClassesFromSettings = $configurationManager->getConfiguration('Settings', 'TYPO3.Flow.error.debugger.ignoredClasses');
if (is_array($ignoredClassesFromSettings)) {
$ignoredClassesConfiguration = Arrays::arrayMergeRecursiveOverrule($ignoredClassesConfiguration, $ignoredClassesFromSettings);
}
}
}
foreach ($ignoredClassesConfiguration as $classNamePattern => $active) {
if ($active === TRUE) {
$ignoredClasses[] = $classNamePattern;
}
}
self::$ignoredClassesRegex = sprintf('/^%s$/xs', implode('$|^', $ignoredClasses));
return self::$ignoredClassesRegex;
}
/**
* Will get called by the constructor to initialize this view.
*
* @return void
*/
public function initializeReport($reportKey)
{
$this->configuration = Arrays::arrayMergeRecursiveOverrule($this->settings['General'], $this->settings[$reportKey]);
$this->setContentTypeHeader();
$this->setContentDispositionHeader();
}
/**
* Return the json array for a given locale, sourceCatalog, xliffPath and package.
* The json will be cached.
*
* @param Locale $locale The locale
* @return Result
* @throws Exception
*/
public function getCachedJson(Locale $locale)
{
$cacheIdentifier = md5($locale);
if ($this->xliffToJsonTranslationsCache->has($cacheIdentifier)) {
$json = $this->xliffToJsonTranslationsCache->get($cacheIdentifier);
} else {
$labels = [];
$localeChain = $this->localizationService->getLocaleChain($locale);
foreach ($this->packagesRegisteredForAutoInclusion as $packageKey => $sourcesToBeIncluded) {
if (!is_array($sourcesToBeIncluded)) {
continue;
}
$translationBasePath = Files::concatenatePaths([$this->packageManager->getPackage($packageKey)->getResourcesPath(), $this->xliffBasePath]);
// We merge labels in the chain from the worst choice to best choice
foreach (array_reverse($localeChain) as $allowedLocale) {
$localeSourcePath = Files::getNormalizedPath(Files::concatenatePaths([$translationBasePath, $allowedLocale]));
foreach ($sourcesToBeIncluded as $sourceName) {
foreach (glob($localeSourcePath . $sourceName . '.xlf') as $xliffPathAndFilename) {
$xliffPathInfo = pathinfo($xliffPathAndFilename);
$sourceName = str_replace($localeSourcePath, '', $xliffPathInfo['dirname'] . '/' . $xliffPathInfo['filename']);
$labels = Arrays::arrayMergeRecursiveOverrule($labels, $this->parseXliffToArray($xliffPathAndFilename, $packageKey, $sourceName));
}
}
}
}
$json = json_encode($labels);
$this->xliffToJsonTranslationsCache->set($cacheIdentifier, $json);
}
return $json;
}
/**
* Assigns a value to a node or a property in the object tree, specified by the object path array.
*
* @param array $objectPathArray The object path, specifying the node / property to set
* @param mixed $value The value to assign, is a non-array type or an array with __eelExpression etc.
* @param array $objectTree The current (sub-) tree, used internally - don't specify!
* @return array The modified object tree
*/
protected function setValueInObjectTree(array $objectPathArray, $value, &$objectTree = null)
{
if ($objectTree === null) {
$objectTree =& $this->objectTree;
}
$currentKey = array_shift($objectPathArray);
if ((int) $currentKey > 0) {
$currentKey = (int) $currentKey;
}
if (empty($objectPathArray)) {
// last part of the iteration, setting the final value
if (isset($objectTree[$currentKey]) && $value === null) {
unset($objectTree[$currentKey]);
} elseif (isset($objectTree[$currentKey]) && is_array($objectTree[$currentKey])) {
if (is_array($value)) {
$objectTree[$currentKey] = \TYPO3\Flow\Utility\Arrays::arrayMergeRecursiveOverrule($objectTree[$currentKey], $value);
} else {
$objectTree[$currentKey]['__value'] = $value;
$objectTree[$currentKey]['__eelExpression'] = null;
$objectTree[$currentKey]['__objectType'] = null;
}
} else {
$objectTree[$currentKey] = $value;
}
} else {
// we still need to traverse further down
if (isset($objectTree[$currentKey]) && !is_array($objectTree[$currentKey])) {
// the element one-level-down is already defined, but it is NOT an array. So we need to convert the simple type to __value
$objectTree[$currentKey] = array('__value' => $objectTree[$currentKey], '__eelExpression' => null, '__objectType' => null);
} elseif (!isset($objectTree[$currentKey])) {
$objectTree[$currentKey] = array();
}
$this->setValueInObjectTree($objectPathArray, $value, $objectTree[$currentKey]);
}
return $objectTree;
}
