Return all non-abstract node types which have a certain $superType, without
the $superType itself.
|
public getSubNodeTypes ( string $superTypeName, boolean $includeAbstractNodeTypes = true ) : array |
||
| $superTypeName | string | |
| $includeAbstractNodeTypes | boolean | Whether to include abstract node types, defaults to TRUE |
| return | array |
|
/**
* @param QueryInterface $query
* @param $nodeTypeFilter
* @return array
*/
protected function getNodeTypeFilterConstraints(QueryInterface $query, $nodeTypeFilter)
{
$includeNodeTypeConstraints = [];
$excludeNodeTypeConstraints = [];
$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([$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;
}
/**
* 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('Neos.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 string $workspaceName
* @param boolean $dryRun
* @param NodeType $nodeType
* @return void
*/
protected function reorderChildNodesByNodeType($workspaceName, $dryRun, NodeType $nodeType)
{
$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;
}
}
}
}
/**
* Return child nodes of specified node for usage in a TreeLoader based on filter
*
* @param Node $node The node to find child nodes for
* @param string $term
* @param string $nodeType
* @return void
*/
public function filterChildNodesForTreeAction(Node $node, $term, $nodeType)
{
$nodeTypes = strlen($nodeType) > 0 ? array($nodeType) : array_keys($this->nodeTypeManager->getSubNodeTypes('Neos.Neos:Document', false));
$context = $node->getContext();
if ($term !== '') {
$nodes = $this->nodeSearchService->findByProperties($term, $nodeTypes, $context, $node);
} else {
$nodes = array();
$nodeDataRecords = $this->nodeDataRepository->findByParentAndNodeTypeRecursively($node->getPath(), implode(',', $nodeTypes), $context->getWorkspace(), $context->getDimensions());
foreach ($nodeDataRecords as $nodeData) {
$matchedNode = $this->nodeFactory->createFromNodeData($nodeData, $context);
if ($matchedNode !== null) {
$nodes[$matchedNode->getPath()] = $matchedNode;
}
}
}
$this->view->assignFilteredChildNodes($node, $nodes);
}
/**
* 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('Neos.Neos:Plugin', false);
$matchingPluginViewDefinitions = [];
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;
}
/**
* Shows a list of nodes
*
* @param string $searchTerm An optional search term used for filtering the list of nodes
* @param array $nodeIdentifiers An optional list of node identifiers
* @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 = '', array $nodeIdentifiers = array(), $workspaceName = 'live', array $dimensions = array(), array $nodeTypes = array('Neos.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);
if ($nodeIdentifiers === array()) {
$nodes = $this->nodeSearchService->findByProperties($searchTerm, $searchableNodeTypeNames, $contentContext, $contextNode);
} else {
$nodes = array_map(function ($identifier) use($contentContext) {
return $contentContext->getNodeByIdentifier($identifier);
}, $nodeIdentifiers);
}
$this->view->assign('nodes', $nodes);
}
/**
* @test
*/
public function getSubNodeTypesWithoutIncludeAbstractContainsNoAbstractNodeTypes()
{
$nodeTypes = $this->nodeTypeManager->getSubNodeTypes('Neos.ContentRepository.Testing:ContentObject', false);
$this->assertArrayNotHasKey('Neos.ContentRepository.Testing:AbstractType', $nodeTypes);
}
/**
* Create a new site form.
*
* @param Site $site Site to create
* @Flow\IgnoreValidation("$site")
* @return void
*/
public function newSiteAction(Site $site = null)
{
$sitePackages = $this->packageManager->getFilteredPackages('active', null, 'neos-site');
$documentNodeTypes = $this->nodeTypeManager->getSubNodeTypes('Neos.Neos:Document', false);
$this->view->assignMultiple(array('sitePackages' => $sitePackages, 'documentNodeTypes' => $documentNodeTypes, 'site' => $site, 'generatorServiceIsAvailable' => $this->packageManager->isPackageActive('Neos.SiteKickstarter')));
}
