/** * @param string $searchWord * @param Site $selectedSite * @return void */ public function searchForNodeAction($searchWord, Site $selectedSite = NULL) { $documentNodeTypes = $this->nodeTypeManager->getSubNodeTypes('TYPO3.Neos:Document'); $shortcutNodeType = $this->nodeTypeManager->getNodeType('TYPO3.Neos:Shortcut'); $nodeTypes = array_diff($documentNodeTypes, array($shortcutNodeType)); $sites = array(); $activeSites = $this->siteRepository->findOnline(); foreach ($selectedSite ? array($selectedSite) : $activeSites as $site) { /** @var Site $site */ $contextProperties = array('workspaceName' => 'live', 'currentSite' => $site); $contentDimensionPresets = $this->contentDimensionPresetSource->getAllPresets(); if (count($contentDimensionPresets) > 0) { $mergedContentDimensions = array(); foreach ($contentDimensionPresets as $contentDimensionIdentifier => $contentDimension) { $mergedContentDimensions[$contentDimensionIdentifier] = array($contentDimension['default']); foreach ($contentDimension['presets'] as $contentDimensionPreset) { $mergedContentDimensions[$contentDimensionIdentifier] = array_merge($mergedContentDimensions[$contentDimensionIdentifier], $contentDimensionPreset['values']); } $mergedContentDimensions[$contentDimensionIdentifier] = array_values(array_unique($mergedContentDimensions[$contentDimensionIdentifier])); } $contextProperties['dimensions'] = $mergedContentDimensions; } /** @var ContentContext $liveContext */ $liveContext = $this->contextFactory->create($contextProperties); $firstActiveDomain = $site->getFirstActiveDomain(); $nodes = $this->nodeSearchService->findByProperties($searchWord, $nodeTypes, $liveContext, $liveContext->getCurrentSiteNode()); if (count($nodes) > 0) { $sites[$site->getNodeName()] = array('site' => $site, 'domain' => $firstActiveDomain ? $firstActiveDomain->getHostPattern() : $this->request->getHttpRequest()->getUri()->getHost(), 'nodes' => $nodes); } } $this->view->assignMultiple(array('searchWord' => $searchWord, 'protocol' => $this->request->getHttpRequest()->getUri()->getScheme(), 'selectedSite' => $selectedSite, 'sites' => $sites, 'activeSites' => $activeSites)); }
/** * @param QueryInterface $query * @param $nodeTypeFilter * @return array */ protected function getNodeTypeFilterConstraints(QueryInterface $query, $nodeTypeFilter) { $includeNodeTypeConstraints = array(); $excludeNodeTypeConstraints = array(); $nodeTypeFilterParts = Arrays::trimExplode(',', $nodeTypeFilter); foreach ($nodeTypeFilterParts as $nodeTypeFilterPart) { $nodeTypeFilterPart = trim($nodeTypeFilterPart); if (strpos($nodeTypeFilterPart, '!') === 0) { $negate = true; $nodeTypeFilterPart = substr($nodeTypeFilterPart, 1); } else { $negate = false; } $nodeTypeFilterPartSubTypes = array_merge(array($nodeTypeFilterPart), $this->nodeTypeManager->getSubNodeTypes($nodeTypeFilterPart, false)); foreach ($nodeTypeFilterPartSubTypes as $nodeTypeFilterPartSubType) { if ($negate === true) { $excludeNodeTypeConstraints[] = $query->logicalNot($query->equals('nodeType', $nodeTypeFilterPartSubType)); } else { $includeNodeTypeConstraints[] = $query->equals('nodeType', $nodeTypeFilterPartSubType); } } } $constraints = $excludeNodeTypeConstraints; if (count($includeNodeTypeConstraints) > 0) { $constraints[] = $query->logicalOr($includeNodeTypeConstraints); } return $constraints; }
/** * @param NodeInterface $node * @param NodeType $nodeType * @return boolean */ public function isNodeOfType(NodeInterface $node, NodeType $nodeType) { if ($node->getNodeType()->getName() === $nodeType->getName()) { return true; } $subNodeTypes = $this->nodeTypeManager->getSubNodeTypes($nodeType->getName()); return isset($subNodeTypes[$node->getNodeType()->getName()]); }
/** * Shows a list of nodes * * @param string $searchTerm An optional search term used for filtering the list of nodes * @param string $workspaceName Name of the workspace to search in, "live" by default * @param array $dimensions Optional list of dimensions and their values which should be used for querying * @param array $nodeTypes A list of node types the list should be filtered by * @param NodeInterface $contextNode a node to use as context for the search * @return string */ public function indexAction($searchTerm = '', $workspaceName = 'live', array $dimensions = array(), array $nodeTypes = array('TYPO3.Neos:Document'), NodeInterface $contextNode = null) { $searchableNodeTypeNames = array(); foreach ($nodeTypes as $nodeTypeName) { if (!$this->nodeTypeManager->hasNodeType($nodeTypeName)) { $this->throwStatus(400, sprintf('Unknown node type "%s"', $nodeTypeName)); } $searchableNodeTypeNames[$nodeTypeName] = $nodeTypeName; /** @var NodeType $subNodeType */ foreach ($this->nodeTypeManager->getSubNodeTypes($nodeTypeName, false) as $subNodeTypeName => $subNodeType) { $searchableNodeTypeNames[$subNodeTypeName] = $subNodeTypeName; } } $contentContext = $this->createContentContext($workspaceName, $dimensions); $nodes = $this->nodeSearchService->findByProperties($searchTerm, $searchableNodeTypeNames, $contentContext, $contextNode); $this->view->assign('nodes', $nodes); }
/** * Search a page, needed for internal links. * * @deprecated will be removed with 3.0, use Service/NodesController->indexAction() instead * @param string $query * @return void */ public function searchPageAction($query) { $searchResult = array(); $documentNodeTypes = $this->nodeTypeManager->getSubNodeTypes('TYPO3.Neos:Document'); /** @var NodeInterface $node */ foreach ($this->nodeSearchService->findByProperties($query, $documentNodeTypes, $this->createContext('live')) as $node) { $searchResult[$node->getPath()] = $this->processNodeForEditorPlugins($node); } $this->view->assign('value', array('searchResult' => $searchResult, 'success' => true)); }
/** * The preprocessed node type schema contains everything we need for the UI: * * - "nodeTypes" contains the original (merged) node type schema * - "inheritanceMap.subTypes" contains for every parent type the transitive list of subtypes * - "constraints" contains for each node type, the list of allowed child node types; normalizing * whitelists and blacklists: * - [node type] * - nodeTypes: * [child node type name]: TRUE * - childNodes: * - [child node name] * - nodeTypes: * [child node type name]: TRUE * * @return array the node type schema ready to be used by the JavaScript code */ public function generateNodeTypeSchema() { $schema = array('inheritanceMap' => array('subTypes' => array()), 'nodeTypes' => array(), 'constraints' => $this->generateConstraints()); $nodeTypes = $this->nodeTypeManager->getNodeTypes(TRUE); /** @var NodeType $nodeType */ foreach ($nodeTypes as $nodeTypeName => $nodeType) { if ($nodeType->isAbstract() === FALSE) { $configuration = $nodeType->getFullConfiguration(); $this->flattenAlohaFormatOptions($configuration); $schema['nodeTypes'][$nodeTypeName] = $configuration; $schema['nodeTypes'][$nodeTypeName]['label'] = $nodeType->getLabel(); } $schema['inheritanceMap']['subTypes'][$nodeTypeName] = array(); foreach ($this->nodeTypeManager->getSubNodeTypes($nodeType->getName(), TRUE) as $subNodeType) { /** @var NodeType $subNodeType */ $schema['inheritanceMap']['subTypes'][$nodeTypeName][] = $subNodeType->getName(); } } return $schema; }
/** * @param string|array $nodeTypes * @return PropertyConditionGenerator */ public function nodeIsOfType($nodeTypes) { $propertyConditionGenerator = new PropertyConditionGenerator('nodeType'); if (!is_array($nodeTypes)) { $nodeTypes = array($nodeTypes); } $expandedNodeTypeNames = array(); foreach ($nodeTypes as $nodeTypeName) { $subNodeTypes = $this->nodeTypeManager->getSubNodeTypes($nodeTypeName, false); $expandedNodeTypeNames = array_merge($expandedNodeTypeNames, array($nodeTypeName), array_keys($subNodeTypes)); } return $propertyConditionGenerator->in(array_unique($expandedNodeTypeNames)); }
/** * Reorder child nodes for the given node type * * @param NodeType $nodeType * @param string $workspaceName * @param boolean $dryRun * @return void */ protected function reorderChildNodesByNodeType(NodeType $nodeType, $workspaceName, $dryRun) { $nodeTypes = $this->nodeTypeManager->getSubNodeTypes($nodeType->getName(), false); $nodeTypes[$nodeType->getName()] = $nodeType; if ($this->nodeTypeManager->hasNodeType((string) $nodeType)) { $nodeType = $this->nodeTypeManager->getNodeType((string) $nodeType); $nodeTypeNames[$nodeType->getName()] = $nodeType; } else { $this->output->outputLine('Node type "%s" does not exist', array((string) $nodeType)); exit(1); } /** @var $nodeType NodeType */ foreach ($nodeTypes as $nodeTypeName => $nodeType) { $childNodes = $nodeType->getAutoCreatedChildNodes(); if ($childNodes === array()) { continue; } foreach ($this->getNodeDataByNodeTypeAndWorkspace($nodeTypeName, $workspaceName) as $nodeData) { /** @var NodeInterface $childNodeBefore */ $childNodeBefore = null; $context = $this->nodeFactory->createContextMatchingNodeData($nodeData); $node = $this->nodeFactory->createFromNodeData($nodeData, $context); if (!$node instanceof NodeInterface) { continue; } foreach ($childNodes as $childNodeName => $childNodeType) { $childNode = $node->getNode($childNodeName); if ($childNode) { if ($childNodeBefore) { if ($dryRun === false) { if ($childNodeBefore->getIndex() >= $childNode->getIndex()) { $childNode->moveAfter($childNodeBefore); $this->output->outputLine('Moved node named "%s" after node named "%s" in "%s"', array($childNodeName, $childNodeBefore->getName(), $node->getPath())); } } else { $this->output->outputLine('Should move node named "%s" after node named "%s" in "%s"', array($childNodeName, $childNodeBefore->getName(), $node->getPath())); } } } else { $this->output->outputLine('Missing child node named "%s" in "%s".', array($childNodeName, $node->getPath())); } $childNodeBefore = $childNode; } } } }
/** * Fetch a PluginView definition that matches the specified controller and action combination * * @param string $controllerObjectName * @param string $actionName * @return PluginViewDefinition * @throws Neos\Exception if more than one PluginView matches the given controller/action pair */ public function getPluginViewDefinitionByAction($controllerObjectName, $actionName) { $pluginNodeTypes = $this->nodeTypeManager->getSubNodeTypes('TYPO3.Neos:Plugin', false); $matchingPluginViewDefinitions = array(); foreach ($pluginNodeTypes as $pluginNodeType) { /** @var $pluginViewDefinition PluginViewDefinition */ foreach ($this->getPluginViewDefinitionsByPluginNodeType($pluginNodeType) as $pluginViewDefinition) { if ($pluginViewDefinition->matchesControllerActionPair($controllerObjectName, $actionName) !== true) { continue; } $matchingPluginViewDefinitions[] = $pluginViewDefinition; } } if (count($matchingPluginViewDefinitions) > 1) { throw new Neos\Exception(sprintf('More than one PluginViewDefinition found for controller "%s", action "%s":%s', $controllerObjectName, $actionName, chr(10) . implode(chr(10), $matchingPluginViewDefinitions)), 1377597671); } return count($matchingPluginViewDefinitions) > 0 ? current($matchingPluginViewDefinitions) : null; }
/** * @test */ public function getSubNodeTypesWithoutIncludeAbstractContainsNoAbstractNodeTypes() { $nodeTypes = $this->nodeTypeManager->getSubNodeTypes('TYPO3.TYPO3CR.Testing:ContentObject', false); $this->assertArrayNotHasKey('TYPO3.TYPO3CR.Testing:AbstractType', $nodeTypes); }