/**
  * @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'];
 }
Beispiel #2
0
 /**
  *
  * @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 \Neos\Form\Exception\TypeDefinitionNotFoundException if a type definition was not found
  * @internal
  */
 public function getMergedTypeDefinition($type, $showHiddenProperties = false)
 {
     if (!isset($this->configuration[$type])) {
         throw new \Neos\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 = \Neos\Utility\Arrays::arrayMergeRecursiveOverrule($mergedTypeDefinition, $this->getMergedTypeDefinition($superTypeName, $showHiddenProperties));
         }
     }
     $mergedTypeDefinition = \Neos\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;
 }
 /**
  * @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;
 }
Beispiel #4
0
 /**
  * @param string $persistenceIdentifier the persistence identifier for the form.
  * @param string $factoryClass The fully qualified class name of the factory (which has to implement \Neos\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 = \Neos\Form\Factory\ArrayFormFactory::class, $presetName = 'default', array $overrideConfiguration = null)
 {
     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();
 }
 /**
  * @test
  */
 public function ignoredClassesCanBeOverwrittenBySettings()
 {
     $object = new ApplicationContext('Development');
     $this->assertEquals(sprintf('%s prototype object', ApplicationContext::class), Debugger::renderDump($object, 10, true));
     Debugger::clearState();
     $currentConfiguration = ObjectAccess::getProperty($this->configurationManager, 'configurations', true);
     $configurationOverwrite['Settings']['Neos']['Flow']['error']['debugger']['ignoredClasses']['Neos\\\\Flow\\\\Core\\\\.*'] = false;
     $newConfiguration = Arrays::arrayMergeRecursiveOverrule($currentConfiguration, $configurationOverwrite);
     ObjectAccess::setProperty($this->configurationManager, 'configurations', $newConfiguration, true);
     $this->assertContains('rootContextString', Debugger::renderDump($object, 10, 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);
     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;
 }
 /**
  * Iterate through the segments of the current request path
  * find the corresponding module configuration and set controller & action
  * accordingly
  *
  * @param string $value
  * @return boolean|integer
  */
 protected function matchValue($value)
 {
     $format = pathinfo($value, PATHINFO_EXTENSION);
     if ($format !== '') {
         $value = substr($value, 0, strlen($value) - strlen($format) - 1);
     }
     $segments = Arrays::trimExplode('/', $value);
     $currentModuleBase = $this->settings['modules'];
     if ($segments === array() || !isset($currentModuleBase[$segments[0]])) {
         return self::MATCHRESULT_NOSUCHMODULE;
     }
     $modulePath = array();
     $level = 0;
     $moduleConfiguration = null;
     $moduleController = null;
     $moduleAction = 'index';
     foreach ($segments as $segment) {
         if (isset($currentModuleBase[$segment])) {
             $modulePath[] = $segment;
             $moduleConfiguration = $currentModuleBase[$segment];
             if (isset($moduleConfiguration['controller'])) {
                 $moduleController = $moduleConfiguration['controller'];
             } else {
                 $moduleController = null;
             }
             if (isset($moduleConfiguration['submodules'])) {
                 $currentModuleBase = $moduleConfiguration['submodules'];
             } else {
                 $currentModuleBase = array();
             }
         } else {
             if ($level === count($segments) - 1) {
                 $moduleMethods = array_change_key_case(array_flip(get_class_methods($moduleController)), CASE_LOWER);
                 if (array_key_exists($segment . 'action', $moduleMethods)) {
                     $moduleAction = $segment;
                     break;
                 }
             }
             return self::MATCHRESULT_NOSUCHMODULE;
         }
         $level++;
     }
     if ($moduleController === null) {
         return self::MATCHRESULT_NOCONTROLLER;
     }
     $this->value = array('module' => implode('/', $modulePath), 'controller' => $moduleController, 'action' => $moduleAction);
     if ($format !== '') {
         $this->value['format'] = $format;
     }
     return self::MATCHRESULT_FOUND;
 }
 /**
  * @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 array $module
  * @return mixed
  * @throws DisabledModuleException
  */
 public function indexAction(array $module)
 {
     $moduleRequest = new ActionRequest($this->request);
     $moduleRequest->setArgumentNamespace('moduleArguments');
     $moduleRequest->setControllerObjectName($module['controller']);
     $moduleRequest->setControllerActionName($module['action']);
     if (isset($module['format'])) {
         $moduleRequest->setFormat($module['format']);
     }
     if ($this->request->hasArgument($moduleRequest->getArgumentNamespace()) === true && is_array($this->request->getArgument($moduleRequest->getArgumentNamespace()))) {
         $moduleRequest->setArguments($this->request->getArgument($moduleRequest->getArgumentNamespace()));
     }
     foreach ($this->request->getPluginArguments() as $argumentNamespace => $argument) {
         $moduleRequest->setArgument('--' . $argumentNamespace, $argument);
     }
     $modules = explode('/', $module['module']);
     $moduleConfiguration = Arrays::getValueByPath($this->settings['modules'], implode('.submodules.', $modules));
     $moduleConfiguration['path'] = $module['module'];
     if (!$this->menuHelper->isModuleEnabled($moduleConfiguration['path'])) {
         throw new DisabledModuleException(sprintf('The module "%s" is disabled. You can enable it with the "enabled" flag in Settings.yaml.', $module['module']), 1437148922);
     }
     $moduleBreadcrumb = array();
     $path = array();
     foreach ($modules as $moduleIdentifier) {
         array_push($path, $moduleIdentifier);
         $config = Arrays::getValueByPath($this->settings['modules'], implode('.submodules.', $path));
         $moduleBreadcrumb[implode('/', $path)] = $config;
     }
     $moduleRequest->setArgument('__moduleConfiguration', $moduleConfiguration);
     $moduleResponse = new Response($this->response);
     $this->dispatcher->dispatch($moduleRequest, $moduleResponse);
     if ($moduleResponse->hasHeader('Location')) {
         $this->redirectToUri($moduleResponse->getHeader('Location'), 0, $moduleResponse->getStatusCode());
     } elseif ($moduleRequest->getFormat() !== 'html') {
         $mediaType = MediaTypes::getMediaTypeFromFilename('file.' . $moduleRequest->getFormat());
         if ($mediaType !== 'application/octet-stream') {
             $this->controllerContext->getResponse()->setHeader('Content-Type', $mediaType);
         }
         return $moduleResponse->getContent();
     } else {
         $user = $this->partyService->getAssignedPartyOfAccount($this->securityContext->getAccount());
         $sites = $this->menuHelper->buildSiteList($this->controllerContext);
         $this->view->assignMultiple(array('moduleClass' => implode('-', $modules), 'moduleContents' => $moduleResponse->getContent(), 'title' => $moduleRequest->hasArgument('title') ? $moduleRequest->getArgument('title') : $moduleConfiguration['label'], 'rootModule' => array_shift($modules), 'submodule' => array_shift($modules), 'moduleConfiguration' => $moduleConfiguration, 'moduleBreadcrumb' => $moduleBreadcrumb, 'user' => $user, 'modules' => $this->menuHelper->buildModuleList($this->controllerContext), 'sites' => $sites));
     }
 }
 /**
  * Iterate through the configured modules, find the matching module and set
  * the route path accordingly
  *
  * @param array $value (contains action, controller and package of the module controller)
  * @return boolean
  */
 protected function resolveValue($value)
 {
     if (is_array($value)) {
         $this->value = isset($value['@action']) && $value['@action'] !== 'index' ? $value['@action'] : '';
         if ($this->value !== '' && isset($value['@format'])) {
             $this->value .= '.' . $value['@format'];
         }
         $exceedingArguments = array();
         foreach ($value as $argumentKey => $argumentValue) {
             if (substr($argumentKey, 0, 1) !== '@' && substr($argumentKey, 0, 2) !== '__') {
                 $exceedingArguments[$argumentKey] = $argumentValue;
             }
         }
         if ($exceedingArguments !== array()) {
             $exceedingArguments = Arrays::removeEmptyElementsRecursively($exceedingArguments);
             $exceedingArguments = $this->persistenceManager->convertObjectsToIdentityArrays($exceedingArguments);
             $queryString = http_build_query(array($this->name => $exceedingArguments), null, '&');
             if ($queryString !== '') {
                 $this->value .= '?' . $queryString;
             }
         }
     }
     return true;
 }
 /**
  * Checks if the given $nodeType is allowed as a childNode of the given $childNodeName
  * (which must be auto-created in $this NodeType).
  *
  * Only allowed to be called if $childNodeName is auto-created.
  *
  * @param string $childNodeName The name of a configured childNode of this NodeType
  * @param NodeType $nodeType The NodeType to check constraints for.
  * @return boolean TRUE if the $nodeType is allowed as grandchild node, FALSE otherwise.
  * @throws \InvalidArgumentException If the given $childNodeName is not configured to be auto-created in $this.
  */
 public function allowsGrandchildNodeType($childNodeName, NodeType $nodeType)
 {
     $autoCreatedChildNodes = $this->getAutoCreatedChildNodes();
     if (!isset($autoCreatedChildNodes[$childNodeName])) {
         throw new \InvalidArgumentException('The method "allowsGrandchildNodeType" can only be used on auto-created childNodes, given $childNodeName "' . $childNodeName . '" is not auto-created.', 1403858395);
     }
     $constraints = $autoCreatedChildNodes[$childNodeName]->getConfiguration('constraints.nodeTypes') ?: array();
     $childNodeConfiguration = [];
     foreach ($this->getConfiguration('childNodes') as $name => $configuration) {
         $childNodeConfiguration[Utility::renderValidNodeName($name)] = $configuration;
     }
     $childNodeConstraintConfiguration = ObjectAccess::getPropertyPath($childNodeConfiguration, $childNodeName . '.constraints.nodeTypes') ?: array();
     $constraints = Arrays::arrayMergeRecursiveOverrule($constraints, $childNodeConstraintConfiguration);
     return $this->isNodeTypeAllowedByConstraints($nodeType, $constraints);
 }
 /**
  * Create a new user
  *
  * This command creates a new user which has access to the backend user interface.
  *
  * More specifically, this command will create a new user and a new account at the same time. The created account
  * is, by default, a Neos backend account using the the "Typo3BackendProvider" for authentication. The given username
  * will be used as an account identifier for that new account.
  *
  * If an authentication provider name is specified, the new account will be created for that provider instead.
  *
  * Roles for the new user can optionally be specified as a comma separated list. For all roles provided by
  * Neos, the role namespace "Neos.Neos:" can be omitted.
  *
  * @param string $username The username of the user to be created, used as an account identifier for the newly created account
  * @param string $password Password of the user to be created
  * @param string $firstName First name of the user to be created
  * @param string $lastName Last name of the user to be created
  * @param string $roles A comma separated list of roles to assign. Examples: "Editor, Acme.Foo:Reviewer"
  * @param string $authenticationProvider Name of the authentication provider to use for the new account. Example: "Typo3BackendProvider"
  * @return void
  */
 public function createCommand($username, $password, $firstName, $lastName, $roles = null, $authenticationProvider = null)
 {
     $user = $this->userService->getUser($username, $authenticationProvider);
     if ($user instanceof User) {
         $this->outputLine('The username "%s" is already in use', array($username));
         $this->quit(1);
     }
     try {
         if ($roles === null) {
             $user = $this->userService->createUser($username, $password, $firstName, $lastName, null, $authenticationProvider);
         } else {
             $roleIdentifiers = Arrays::trimExplode(',', $roles);
             $user = $this->userService->createUser($username, $password, $firstName, $lastName, $roleIdentifiers, $authenticationProvider);
         }
         $roleIdentifiers = array();
         foreach ($user->getAccounts() as $account) {
             /** @var Account $account */
             foreach ($account->getRoles() as $role) {
                 /** @var Role $role */
                 $roleIdentifiers[$role->getIdentifier()] = true;
             }
         }
         $roleIdentifiers = array_keys($roleIdentifiers);
         if (count($roleIdentifiers) === 0) {
             $this->outputLine('Created user "%s".', array($username));
             $this->outputLine('<b>Please note that this user currently does not have any roles assigned.</b>');
         } else {
             $this->outputLine('Created user "%s" and assigned the following role%s: %s.', array($username, count($roleIdentifiers) > 1 ? 's' : '', implode(', ', $roleIdentifiers)));
         }
     } catch (\Exception $exception) {
         $this->outputLine($exception->getMessage());
         $this->quit(1);
     }
 }
 /**
  * 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] = 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;
 }
 /**
  * Kickstart a new command controller
  *
  * Creates a new command controller with the given name in the specified
  * package. The generated controller class already contains an example command.
  *
  * @param string $packageKey The package key of the package for the new controller
  * @param string $controllerName The name for the new controller. This may also be a comma separated list of controller names.
  * @param boolean $force Overwrite any existing controller.
  * @return string
  * @see neos.kickstarter:kickstart:actioncontroller
  */
 public function commandControllerCommand($packageKey, $controllerName, $force = false)
 {
     $this->validatePackageKey($packageKey);
     if (!$this->packageManager->isPackageAvailable($packageKey)) {
         $this->outputLine('Package "%s" is not available.', array($packageKey));
         exit(2);
     }
     $generatedFiles = array();
     $controllerNames = Arrays::trimExplode(',', $controllerName);
     foreach ($controllerNames as $currentControllerName) {
         $generatedFiles += $this->generatorService->generateCommandController($packageKey, $currentControllerName, $force);
     }
     $this->outputLine(implode(PHP_EOL, $generatedFiles));
 }
Beispiel #15
0
 /**
  * Transforms the convoluted _FILES superglobal into a manageable form.
  *
  * @param array $convolutedFiles The _FILES superglobal
  * @return array Untangled files
  */
 protected function untangleFilesArray(array $convolutedFiles)
 {
     $untangledFiles = [];
     $fieldPaths = [];
     foreach ($convolutedFiles as $firstLevelFieldName => $fieldInformation) {
         if (!is_array($fieldInformation['error'])) {
             $fieldPaths[] = [$firstLevelFieldName];
         } else {
             $newFieldPaths = $this->calculateFieldPaths($fieldInformation['error'], $firstLevelFieldName);
             array_walk($newFieldPaths, function (&$value) {
                 $value = explode('/', $value);
             });
             $fieldPaths = array_merge($fieldPaths, $newFieldPaths);
         }
     }
     foreach ($fieldPaths as $fieldPath) {
         if (count($fieldPath) === 1) {
             $fileInformation = $convolutedFiles[$fieldPath[0]];
         } else {
             $fileInformation = [];
             foreach ($convolutedFiles[$fieldPath[0]] as $key => $subStructure) {
                 $fileInformation[$key] = Arrays::getValueByPath($subStructure, array_slice($fieldPath, 1));
             }
         }
         if (isset($fileInformation['error']) && $fileInformation['error'] !== \UPLOAD_ERR_NO_FILE) {
             $untangledFiles = Arrays::setValueByPath($untangledFiles, $fieldPath, $fileInformation);
         }
     }
     return $untangledFiles;
 }
 /**
  * @Then /^I can (not )?call the method "([^"]*)" of class "([^"]*)"(?: with arguments "([^"]*)")?$/
  */
 public function iCanCallTheMethodOfClassWithArguments($not, $methodName, $className, $arguments = '')
 {
     if ($this->isolated === true) {
         $this->callStepInSubProcess(__METHOD__, sprintf(' %s %s %s %s %s %s %s %s', 'string', escapeshellarg(trim($not)), 'string', escapeshellarg($methodName), 'string', escapeshellarg($className), 'string', escapeshellarg($arguments)));
     } else {
         $this->setupSecurity();
         $instance = $this->objectManager->get($className);
         try {
             $result = call_user_func_array([$instance, $methodName], Arrays::trimExplode(',', $arguments));
             if ($not === 'not') {
                 Assert::fail('Method should not be callable');
             }
             return $result;
         } catch (AccessDeniedException $exception) {
             if ($not !== 'not') {
                 throw $exception;
             }
         }
     }
 }
 /**
  * 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 = [];
         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;
 }
Beispiel #18
0
 /**
  * @test
  */
 public function arrayMergeRecursiveCallbackConvertsSimpleValuesWithGivenClosureAndReturnedSimpleTypesOverwrite()
 {
     $inputArray1 = ['k1' => 'v1', 'k2' => ['k2.1' => 'v2.1'], 'k3' => ['k3.1' => 'value']];
     $inputArray2 = ['k2' => 'v2.2', 'k3' => null];
     $expected = ['k1' => 'v1', 'k2' => ['k2.1' => 'v2.1', '__convertedValue' => 'v2.2'], 'k3' => null];
     $actual = Arrays::arrayMergeRecursiveOverruleWithCallback($inputArray1, $inputArray2, function ($simpleType) {
         if ($simpleType === null) {
             return null;
         }
         return ['__convertedValue' => $simpleType];
     });
     $this->assertSame($expected, $actual);
 }
 /**
  * Checks whether $routeValues can be resolved to a corresponding uri.
  * If all Route Parts can resolve one or more of the $routeValues, TRUE is
  * returned and $this->matchingURI contains the generated URI (excluding
  * protocol and host).
  *
  * @param array $routeValues An array containing key/value pairs to be resolved to uri segments
  * @return boolean TRUE if this Route corresponds to the given $routeValues, otherwise FALSE
  * @throws InvalidRoutePartValueException
  */
 public function resolves(array $routeValues)
 {
     $this->resolvedUriPath = null;
     if ($this->uriPattern === null) {
         return false;
     }
     if (!$this->isParsed) {
         $this->parse();
     }
     $resolvedUriPath = '';
     $remainingDefaults = $this->defaults;
     $requireOptionalRouteParts = false;
     $matchingOptionalUriPortion = '';
     /** @var $routePart RoutePartInterface */
     foreach ($this->routeParts as $routePart) {
         if (!$routePart->resolve($routeValues)) {
             if (!$routePart->hasDefaultValue()) {
                 return false;
             }
         }
         if ($routePart->getName() !== null) {
             $remainingDefaults = Arrays::unsetValueByPath($remainingDefaults, $routePart->getName());
         }
         $routePartValue = null;
         if ($routePart->hasValue()) {
             $routePartValue = $routePart->getValue();
             if (!is_string($routePartValue)) {
                 throw new InvalidRoutePartValueException('RoutePart::getValue() must return a string after calling RoutePart::resolve(), got ' . (is_object($routePartValue) ? get_class($routePartValue) : gettype($routePartValue)) . ' for RoutePart "' . get_class($routePart) . '" in Route "' . $this->getName() . '".');
             }
         }
         $routePartDefaultValue = $routePart->getDefaultValue();
         if ($routePartDefaultValue !== null && !is_string($routePartDefaultValue)) {
             throw new InvalidRoutePartValueException('RoutePart::getDefaultValue() must return a string, got ' . (is_object($routePartDefaultValue) ? get_class($routePartDefaultValue) : gettype($routePartDefaultValue)) . ' for RoutePart "' . get_class($routePart) . '" in Route "' . $this->getName() . '".');
         }
         if (!$routePart->isOptional()) {
             $resolvedUriPath .= $routePart->hasValue() ? $routePartValue : $routePartDefaultValue;
             $requireOptionalRouteParts = false;
             continue;
         }
         if ($routePart->hasValue() && strtolower($routePartValue) !== strtolower($routePartDefaultValue)) {
             $matchingOptionalUriPortion .= $routePartValue;
             $requireOptionalRouteParts = true;
         } else {
             $matchingOptionalUriPortion .= $routePartDefaultValue;
         }
         if ($requireOptionalRouteParts) {
             $resolvedUriPath .= $matchingOptionalUriPortion;
             $matchingOptionalUriPortion = '';
         }
     }
     if ($this->compareAndRemoveMatchingDefaultValues($remainingDefaults, $routeValues) !== true) {
         return false;
     }
     if (isset($routeValues['@format']) && $routeValues['@format'] === '') {
         unset($routeValues['@format']);
     }
     // add query string
     if (count($routeValues) > 0) {
         $routeValues = Arrays::removeEmptyElementsRecursively($routeValues);
         $routeValues = $this->persistenceManager->convertObjectsToIdentityArrays($routeValues);
         if (!$this->appendExceedingArguments) {
             $internalArguments = $this->extractInternalArguments($routeValues);
             if ($routeValues !== []) {
                 return false;
             }
             $routeValues = $internalArguments;
         }
         $queryString = http_build_query($routeValues, null, '&');
         if ($queryString !== '') {
             $resolvedUriPath .= strpos($resolvedUriPath, '?') !== false ? '&' . $queryString : '?' . $queryString;
         }
     }
     $this->resolvedUriPath = $resolvedUriPath;
     return true;
 }
 /**
  * @return string
  */
 public function editPreviewAction()
 {
     $this->response->setHeader('Content-Type', 'application/json');
     $configuration = new PositionalArraySorter(Arrays::getValueByPath($this->settings, 'userInterface.editPreviewModes'));
     return json_encode($configuration->toArray());
 }
 /**
  * Reconstitues related entities to an unserialized object in __wakeup.
  * Used in __wakeup methods of proxy classes.
  *
  * Note: This method adds code which ignores objects of type Neos\Flow\ResourceManagement\ResourcePointer in order to provide
  * backwards compatibility data generated with Flow 2.2.x which still provided that class.
  *
  * @return void
  */
 private function Flow_setRelatedEntities()
 {
     if (property_exists($this, 'Flow_Persistence_RelatedEntities') && is_array($this->Flow_Persistence_RelatedEntities)) {
         $persistenceManager = Bootstrap::$staticObjectManager->get(PersistenceManagerInterface::class);
         foreach ($this->Flow_Persistence_RelatedEntities as $entityInformation) {
             if ($entityInformation['entityType'] === ResourcePointer::class) {
                 continue;
             }
             $entity = $persistenceManager->getObjectByIdentifier($entityInformation['identifier'], $entityInformation['entityType'], true);
             if (isset($entityInformation['entityPath'])) {
                 $this->{$entityInformation['propertyName']} = Arrays::setValueByPath($this->{$entityInformation['propertyName']}, $entityInformation['entityPath'], $entity);
             } else {
                 $this->{$entityInformation['propertyName']} = $entity;
             }
         }
         unset($this->Flow_Persistence_RelatedEntities);
     }
 }
 /**
  * @param array $additionalOptions
  * @return array
  * @throws InvalidConfigurationException
  */
 protected function getOptionsMergedWithDefaults(array $additionalOptions = array())
 {
     $defaultOptions = Arrays::getValueByPath($this->settings, 'image.defaultOptions');
     if (!is_array($defaultOptions)) {
         $defaultOptions = array();
     }
     if ($additionalOptions !== array()) {
         $defaultOptions = Arrays::arrayMergeRecursiveOverrule($defaultOptions, $additionalOptions);
     }
     $quality = isset($defaultOptions['quality']) ? (int) $defaultOptions['quality'] : 90;
     if ($quality < 0 || $quality > 100) {
         throw new InvalidConfigurationException(sprintf('Setting "Neos.Media.image.defaultOptions.quality" allow only value between 0 and 100, current value: %s', $quality), 1404982574);
     }
     $defaultOptions['jpeg_quality'] = $quality;
     // png_compression_level should be an integer between 0 and 9 and inverse to the quality level given. So quality 100 should result in compression 0.
     $defaultOptions['png_compression_level'] = 9 - ceil($quality * 9 / 100);
     return $defaultOptions;
 }
 /**
  * Invokes the Factory defined in the object configuration of the specified object in order
  * to build an instance. Arguments which were defined in the object configuration are
  * passed to the factory method.
  *
  * @param string $objectName Name of the object to build
  * @return object The built object
  */
 protected function buildObjectByFactory($objectName)
 {
     $factory = $this->get($this->objects[$objectName]['f'][0]);
     $factoryMethodName = $this->objects[$objectName]['f'][1];
     $factoryMethodArguments = [];
     foreach ($this->objects[$objectName]['fa'] as $index => $argumentInformation) {
         switch ($argumentInformation['t']) {
             case ObjectConfigurationArgument::ARGUMENT_TYPES_SETTING:
                 $settingPath = explode('.', $argumentInformation['v']);
                 $factoryMethodArguments[$index] = Arrays::getValueByPath($this->allSettings, $settingPath);
                 break;
             case ObjectConfigurationArgument::ARGUMENT_TYPES_STRAIGHTVALUE:
                 $factoryMethodArguments[$index] = $argumentInformation['v'];
                 break;
             case ObjectConfigurationArgument::ARGUMENT_TYPES_OBJECT:
                 $factoryMethodArguments[$index] = $this->get($argumentInformation['v']);
                 break;
         }
     }
     if (count($factoryMethodArguments) === 0) {
         return $factory->{$factoryMethodName}();
     } else {
         return call_user_func_array([$factory, $factoryMethodName], $factoryMethodArguments);
     }
 }
 /**
  * A method which runs the task implemented by the plugin for the given command
  *
  * @param string $controllerCommandName Name of the command in question, for example "repair"
  * @param ConsoleOutput $output An instance of ConsoleOutput which can be used for output or dialogues
  * @param NodeType $nodeType Only handle this node type (if specified)
  * @param string $workspaceName Only handle this workspace (if specified)
  * @param boolean $dryRun If TRUE, don't do any changes, just simulate what you would do
  * @param boolean $cleanup If FALSE, cleanup tasks are skipped
  * @param string $skip Skip the given check or checks (comma separated)
  * @param string $only Only execute the given check or checks (comma separated)
  * @return void
  */
 public function invokeSubCommand($controllerCommandName, ConsoleOutput $output, NodeType $nodeType = null, $workspaceName = 'live', $dryRun = false, $cleanup = true, $skip = null, $only = null)
 {
     $this->output = $output;
     $commandMethods = ['generateUriPathSegments' => ['cleanup' => false], 'removeContentDimensionsFromRootAndSitesNode' => ['cleanup' => true]];
     $skipCommandNames = Arrays::trimExplode(',', $skip === null ? '' : $skip);
     $onlyCommandNames = Arrays::trimExplode(',', $only === null ? '' : $only);
     switch ($controllerCommandName) {
         case 'repair':
             foreach ($commandMethods as $commandMethodName => $commandMethodConfiguration) {
                 if (in_array($commandMethodName, $skipCommandNames)) {
                     continue;
                 }
                 if ($onlyCommandNames !== [] && !in_array($commandMethodName, $onlyCommandNames)) {
                     continue;
                 }
                 if (!$cleanup && $commandMethodConfiguration['cleanup']) {
                     continue;
                 }
                 $this->{$commandMethodName}($workspaceName, $dryRun, $nodeType);
             }
     }
 }
 /**
  * Sets labels for global NodeType elements like tabs and groups and the general label.
  *
  * @param string $nodeTypeLabelIdPrefix
  * @param array $configuration
  * @return void
  */
 protected function setGlobalUiElementLabels($nodeTypeName, array &$configuration)
 {
     $nodeTypeLabelIdPrefix = $this->generateNodeTypeLabelIdPrefix($nodeTypeName);
     if ($this->shouldFetchTranslation($configuration['ui'])) {
         $configuration['ui']['label'] = $this->getInspectorElementTranslationId($nodeTypeLabelIdPrefix, 'ui', 'label');
     }
     if (isset($configuration['ui']['help']['message']) && $this->shouldFetchTranslation($configuration['ui']['help'], 'message')) {
         $configuration['ui']['help']['message'] = $this->getInspectorElementTranslationId($nodeTypeLabelIdPrefix, 'ui', 'help.message');
     }
     if (isset($configuration['ui']['help'])) {
         $configurationThumbnail = isset($configuration['ui']['help']['thumbnail']) ? $configuration['ui']['help']['thumbnail'] : null;
         $thumbnailUrl = $this->resolveHelpMessageThumbnail($nodeTypeName, $configurationThumbnail);
         if ($thumbnailUrl !== '') {
             $configuration['ui']['help']['thumbnail'] = $thumbnailUrl;
         }
     }
     $inspectorConfiguration = Arrays::getValueByPath($configuration, 'ui.inspector');
     if (is_array($inspectorConfiguration)) {
         foreach ($inspectorConfiguration as $elementTypeName => $elementTypeItems) {
             foreach ($elementTypeItems as $elementName => $elementConfiguration) {
                 if (!is_array($elementConfiguration) || !$this->shouldFetchTranslation($elementConfiguration)) {
                     continue;
                 }
                 $translationLabelId = $this->getInspectorElementTranslationId($nodeTypeLabelIdPrefix, $elementTypeName, $elementName);
                 $configuration['ui']['inspector'][$elementTypeName][$elementName]['label'] = $translationLabelId;
             }
         }
     }
 }
 /**
  * Merges two policy configuration arrays.
  *
  * @param array $firstConfigurationArray
  * @param array $secondConfigurationArray
  * @return array
  */
 protected function mergePolicyConfiguration(array $firstConfigurationArray, array $secondConfigurationArray)
 {
     $result = Arrays::arrayMergeRecursiveOverrule($firstConfigurationArray, $secondConfigurationArray);
     if (!isset($result['roles'])) {
         return $result;
     }
     foreach ($result['roles'] as $roleIdentifier => $roleConfiguration) {
         if (!isset($firstConfigurationArray['roles'][$roleIdentifier]['privileges']) || !isset($secondConfigurationArray['roles'][$roleIdentifier]['privileges'])) {
             continue;
         }
         $result['roles'][$roleIdentifier]['privileges'] = array_merge($firstConfigurationArray['roles'][$roleIdentifier]['privileges'], $secondConfigurationArray['roles'][$roleIdentifier]['privileges']);
     }
     return $result;
 }
 /**
  * Move a settings path from "source" to "destination"; best to be used when package names change.
  *
  * @param string $sourcePath
  * @param string $destinationPath
  */
 protected function moveSettingsPaths($sourcePath, $destinationPath)
 {
     $this->processConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, function (array &$configuration) use($sourcePath, $destinationPath) {
         $sourceConfigurationValue = Arrays::getValueByPath($configuration, $sourcePath);
         $destinationConfigurationValue = Arrays::getValueByPath($configuration, $destinationPath);
         if ($sourceConfigurationValue !== null) {
             // source exists, so we need to move source to destination.
             if ($destinationConfigurationValue !== null) {
                 // target exists as well; we need to MERGE source and target.
                 $destinationConfigurationValue = Arrays::arrayMergeRecursiveOverrule($sourceConfigurationValue, $destinationConfigurationValue);
             } else {
                 // target does NOT exist; we directly set target = source
                 $destinationConfigurationValue = $sourceConfigurationValue;
             }
             // set the config on the new path
             $configuration = Arrays::setValueByPath($configuration, $destinationPath, $destinationConfigurationValue);
             // Unset the old configuration
             $configuration = Arrays::unsetValueByPath($configuration, $sourcePath);
             // remove empty keys before our removed key (if it exists)
             $sourcePathExploded = explode('.', $sourcePath);
             for ($length = count($sourcePathExploded) - 1; $length > 0; $length--) {
                 $temporaryPath = array_slice($sourcePathExploded, 0, $length);
                 $valueAtPath = Arrays::getValueByPath($configuration, $temporaryPath);
                 if (empty($valueAtPath)) {
                     $configuration = Arrays::unsetValueByPath($configuration, $temporaryPath);
                 } else {
                     break;
                 }
             }
         }
     }, true);
 }
 /**
  * @param NodeInterface $rootNode
  * @param array<\Neos\ContentRepository\Domain\Model\NodeData> $nodes
  * @return array
  */
 public function collectParentNodeData(NodeInterface $rootNode, array $nodes)
 {
     $nodeCollection = array();
     $addNode = function ($node, $matched) use($rootNode, &$nodeCollection) {
         /** @var NodeInterface $node */
         $path = str_replace('/', '.children.', substr($node->getPath(), strlen($rootNode->getPath()) + 1));
         if ($path !== '') {
             $nodeCollection = Arrays::setValueByPath($nodeCollection, $path . '.node', $node);
             if ($matched === true) {
                 $nodeCollection = Arrays::setValueByPath($nodeCollection, $path . '.matched', true);
             }
         }
     };
     $findParent = function ($node) use(&$findParent, &$addNode) {
         /** @var NodeInterface $node */
         $parent = $node->getParent();
         if ($parent !== null) {
             $addNode($parent, false);
             $findParent($parent);
         }
     };
     foreach ($nodes as $node) {
         $addNode($node, true);
         $findParent($node);
     }
     $treeNodes = array();
     $self = $this;
     $collectTreeNodeData = function (&$treeNodes, $node) use(&$collectTreeNodeData, $self) {
         $children = array();
         if (isset($node['children'])) {
             foreach ($node['children'] as $childNode) {
                 $collectTreeNodeData($children, $childNode);
             }
         }
         $treeNodes[] = $self->collectTreeNodeData($node['node'], true, $children, $children !== array(), isset($node['matched']));
     };
     foreach ($nodeCollection as $firstLevelNode) {
         $collectTreeNodeData($treeNodes, $firstLevelNode);
     }
     return $treeNodes;
 }
 /**
  * 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 ParseErrorException
  */
 public function load($pathAndFilename, $allowSplitSource = false)
 {
     $pathsAndFileNames = [$pathAndFilename . '.yaml'];
     if ($allowSplitSource === true) {
         $splitSourcePathsAndFileNames = glob($pathAndFilename . '.*.yaml');
         if ($splitSourcePathsAndFileNames !== false) {
             sort($splitSourcePathsAndFileNames);
             $pathsAndFileNames = array_merge($pathsAndFileNames, $splitSourcePathsAndFileNames);
         }
     }
     $configuration = [];
     foreach ($pathsAndFileNames as $pathAndFilename) {
         if (is_file($pathAndFilename)) {
             try {
                 if ($this->usePhpYamlExtension) {
                     if (strpos($pathAndFilename, 'resource://') === 0) {
                         $yaml = file_get_contents($pathAndFilename);
                         $loadedConfiguration = @yaml_parse($yaml);
                         unset($yaml);
                     } else {
                         $loadedConfiguration = @yaml_parse_file($pathAndFilename);
                     }
                     if ($loadedConfiguration === false) {
                         throw new 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 (Exception $exception) {
                 throw new ParseErrorException('A parse error occurred while parsing file "' . $pathAndFilename . '". Error message: ' . $exception->getMessage(), 1232014321);
             }
         }
     }
     return $configuration;
 }
Beispiel #30
0
 /**
  * Get the preset configuration by $presetName, taking the preset hierarchy
  * (specified by *parentPreset*) into account.
  *
  * @param string $presetName name of the preset to get the configuration for
  * @return array the preset configuration
  * @throws \Neos\Form\Exception\PresetNotFoundException if preset with the name $presetName was not found
  * @api
  */
 public function getPresetConfiguration($presetName)
 {
     if (!isset($this->formSettings['presets'][$presetName])) {
         throw new \Neos\Form\Exception\PresetNotFoundException(sprintf('The Preset "%s" was not found underneath TYPO3: Form: presets.', $presetName), 1332170104);
     }
     $preset = $this->formSettings['presets'][$presetName];
     if (isset($preset['parentPreset'])) {
         $parentPreset = $this->getPresetConfiguration($preset['parentPreset']);
         unset($preset['parentPreset']);
         $preset = \Neos\Utility\Arrays::arrayMergeRecursiveOverrule($parentPreset, $preset);
     }
     return $preset;
 }