/**
* Helper method for creating a new node.
*
* @param NodeInterface $referenceNode
* @param array $nodeData
* @param string $position
* @return NodeInterface
* @throws \InvalidArgumentException
*/
public function create(NodeInterface $referenceNode, array $nodeData, $position)
{
if (!in_array($position, array('before', 'into', 'after'), true)) {
throw new \InvalidArgumentException('The position should be one of the following: "before", "into", "after".', 1347133640);
}
$nodeType = $this->nodeTypeManager->getNodeType($nodeData['nodeType']);
if ($nodeType->isOfType('Neos.Neos:Document') && !isset($nodeData['properties']['uriPathSegment']) && isset($nodeData['properties']['title'])) {
$nodeData['properties']['uriPathSegment'] = $this->nodeUriPathSegmentGenerator->generateUriPathSegment($referenceNode, $nodeData['properties']['title']);
}
$proposedNodeName = isset($nodeData['nodeName']) ? $nodeData['nodeName'] : null;
$nodeData['nodeName'] = $this->nodeService->generateUniqueNodeName($this->getDesignatedParentNode($referenceNode, $position)->getPath(), $proposedNodeName);
if ($position === 'into') {
$newNode = $referenceNode->createNode($nodeData['nodeName'], $nodeType);
} else {
$parentNode = $referenceNode->getParent();
$newNode = $parentNode->createNode($nodeData['nodeName'], $nodeType);
if ($position === 'before') {
$newNode->moveBefore($referenceNode);
} else {
$newNode->moveAfter($referenceNode);
}
}
if (isset($nodeData['properties']) && is_array($nodeData['properties'])) {
foreach ($nodeData['properties'] as $propertyName => $propertyValue) {
$newNode->setProperty($propertyName, $propertyValue);
}
}
return $newNode;
}
/**
* Repair inconsistent nodes
*
* This command analyzes and repairs the node tree structure and individual nodes
* based on the current node type configuration.
*
* It is possible to execute only one or more specific checks by providing the <b>--skip</b>
* or <b>--only</b> option. See the full description of checks further below for possible check
* identifiers.
*
* The following checks will be performed:
*
* {pluginDescriptions}
* <b>Examples:</b>
*
* ./flow node:repair
*
* ./flow node:repair --node-type Neos.NodeTypes:Page
*
* ./flow node:repair --workspace user-robert --only removeOrphanNodes,removeNodesWithInvalidDimensions
*
* ./flow node:repair --skip removeUndefinedProperties
*
* @param string $nodeType Node type name, if empty update all declared node types
* @param string $workspace Workspace name, default is 'live'
* @param boolean $dryRun Don't do anything, but report actions
* @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 repairCommand($nodeType = null, $workspace = 'live', $dryRun = false, $cleanup = true, $skip = null, $only = null)
{
$this->pluginConfigurations = self::detectPlugins($this->objectManager);
if ($this->workspaceRepository->countByName($workspace) === 0) {
$this->outputLine('Workspace "%s" does not exist', array($workspace));
exit(1);
}
if ($nodeType !== null) {
if ($this->nodeTypeManager->hasNodeType($nodeType)) {
$nodeType = $this->nodeTypeManager->getNodeType($nodeType);
} else {
$this->outputLine('Node type "%s" does not exist', array($nodeType));
exit(1);
}
}
if ($dryRun) {
$this->outputLine('Dry run, not committing any changes.');
}
if (!$cleanup) {
$this->outputLine('Omitting cleanup tasks.');
}
foreach ($this->pluginConfigurations as $pluginConfiguration) {
/** @var NodeCommandControllerPluginInterface $plugin */
$plugin = $pluginConfiguration['object'];
$this->outputLine('<b>' . $plugin->getSubCommandShortDescription('repair') . '</b>');
$this->outputLine();
$plugin->invokeSubCommand('repair', $this->output, $nodeType, $workspace, $dryRun, $cleanup, $skip, $only);
$this->outputLine();
}
$this->outputLine('Node repair finished.');
}
/**
* Returns the node types that the currently authenticated user is *denied* to create within the given $referenceNode
*
* @param NodeInterface $referenceNode
* @return string[] Array of granted node type names
*/
public function getNodeTypeNamesDeniedForCreation(NodeInterface $referenceNode)
{
$privilegeSubject = new CreateNodePrivilegeSubject($referenceNode);
$allNodeTypes = $this->nodeTypeManager->getNodeTypes();
$deniedCreationNodeTypes = array();
$grantedCreationNodeTypes = array();
$abstainedCreationNodeTypes = array();
foreach ($this->securityContext->getRoles() as $role) {
/** @var CreateNodePrivilege $createNodePrivilege */
foreach ($role->getPrivilegesByType(CreateNodePrivilege::class) as $createNodePrivilege) {
if (!$createNodePrivilege->matchesSubject($privilegeSubject)) {
continue;
}
$affectedNodeTypes = $createNodePrivilege->getCreationNodeTypes() !== array() ? $createNodePrivilege->getCreationNodeTypes() : $allNodeTypes;
if ($createNodePrivilege->isGranted()) {
$grantedCreationNodeTypes = array_merge($grantedCreationNodeTypes, $affectedNodeTypes);
} elseif ($createNodePrivilege->isDenied()) {
$deniedCreationNodeTypes = array_merge($deniedCreationNodeTypes, $affectedNodeTypes);
} else {
$abstainedCreationNodeTypes = array_merge($abstainedCreationNodeTypes, $affectedNodeTypes);
}
}
}
$implicitlyDeniedNodeTypes = array_diff($abstainedCreationNodeTypes, $grantedCreationNodeTypes);
return array_merge($implicitlyDeniedNodeTypes, $deniedCreationNodeTypes);
}
/**
* Converts the nodes types to a fully structured array
* in the same structure as the schema to be created.
*
* The schema also includes abstract node types for the full inheritance information in VIE.
*
* @return object
*/
public function generateVieSchema()
{
if ($this->configuration !== null) {
return $this->configuration;
}
$nodeTypes = $this->nodeTypeManager->getNodeTypes();
foreach ($nodeTypes as $nodeTypeName => $nodeType) {
$this->readNodeTypeConfiguration($nodeTypeName, $nodeType);
}
unset($this->types['typo3:unstructured']);
foreach ($this->types as $nodeTypeName => $nodeTypeDefinition) {
$this->types[$nodeTypeName]->subtypes = $this->getAllSubtypes($nodeTypeName);
$this->types[$nodeTypeName]->ancestors = $this->getAllAncestors($nodeTypeName);
$this->removeUndeclaredTypes($this->types[$nodeTypeName]->supertypes);
$this->removeUndeclaredTypes($this->types[$nodeTypeName]->ancestors);
}
foreach ($this->properties as $property => $propertyConfiguration) {
if (isset($propertyConfiguration->domains) && is_array($propertyConfiguration->domains)) {
foreach ($propertyConfiguration->domains as $domain) {
if (preg_match('/TYPO3\\.Neos\\.NodeTypes:.*Column/', $domain)) {
$this->properties[$property]->ranges = array_keys($this->types);
}
}
}
}
// Convert the Neos.Neos:ContentCollection element to support content-collection
// TODO Move to node type definition
if (isset($this->types['typo3:Neos.Neos:ContentCollection'])) {
$this->addProperty('typo3:Neos.Neos:ContentCollection', 'typo3:content-collection', array());
$this->types['typo3:Neos.Neos:ContentCollection']->specific_properties[] = 'typo3:content-collection';
$this->properties['typo3:content-collection']->ranges = array_keys($this->types);
}
$this->configuration = (object) array('types' => (object) $this->types, 'properties' => (object) $this->properties);
return $this->configuration;
}
/**
* @test
*/
public function readNodeTypeConfigurationFillsTypeAndPropertyConfiguration()
{
$this->assertEquals($this->vieSchemaBuilder->_get('superTypeConfiguration'), array());
$this->assertEquals($this->vieSchemaBuilder->_get('types'), array());
$this->assertEquals($this->vieSchemaBuilder->_get('properties'), array());
$this->vieSchemaBuilder->_call('readNodeTypeConfiguration', 'Neos.Neos:TextWithImage', $this->nodeTypeManager->getNodeType('Neos.Neos:TextWithImage'));
$this->assertEquals(array('typo3:Neos.Neos:TextWithImage' => array('typo3:Neos.Neos:Text')), $this->vieSchemaBuilder->_get('superTypeConfiguration'));
$this->arrayHasKey('typo3:Neos.Neos:TextWithImage', $this->vieSchemaBuilder->_get('types'));
$this->assertEquals(4, count($this->vieSchemaBuilder->_get('properties')));
}
public function setUp()
{
$this->mockWorkspace = $this->getMockBuilder(Workspace::class)->disableOriginalConstructor()->getMock();
$this->nodeData = $this->getAccessibleMock(NodeData::class, array('addOrUpdate'), array('/foo/bar', $this->mockWorkspace));
$this->mockNodeType = $this->getMockBuilder(NodeType::class)->disableOriginalConstructor()->getMock();
$this->mockNodeTypeManager = $this->getMockBuilder(NodeTypeManager::class)->disableOriginalConstructor()->getMock();
$this->mockNodeTypeManager->expects($this->any())->method('getNodeType')->will($this->returnValue($this->mockNodeType));
$this->mockNodeTypeManager->expects($this->any())->method('hasNodeType')->will($this->returnValue(true));
$this->inject($this->nodeData, 'nodeTypeManager', $this->mockNodeTypeManager);
$this->mockNodeDataRepository = $this->getMockBuilder(NodeDataRepository::class)->disableOriginalConstructor()->getMock();
$this->inject($this->nodeData, 'nodeDataRepository', $this->mockNodeDataRepository);
}
/**
* @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;
}
/**
* Create a new empty site.
*
* @param string $packageKey Package Name to create
* @param string $siteName Site Name to create
* @param string $nodeType NodeType name for the root node to create
* @Flow\Validate(argumentName="$packageKey", type="\Neos\Neos\Validation\Validator\PackageKeyValidator")
* @return void
*/
public function createSiteNodeAction($packageKey, $siteName, $nodeType)
{
$nodeName = $this->nodeService->generateUniqueNodeName(SiteService::SITES_ROOT_PATH, $siteName);
if ($this->siteRepository->findOneByNodeName($nodeName)) {
$this->addFlashMessage('Error:A site with siteNodeName "%s" already exists', Message::SEVERITY_ERROR, [$nodeName], 1412372375);
$this->redirect('createSiteNode');
}
$siteNodeType = $this->nodeTypeManager->getNodeType($nodeType);
if ($siteNodeType === null || $siteNodeType->getName() === 'Neos.Neos:FallbackNode') {
$this->addFlashMessage('Error: The given node type "%s" was not found', 'Import error', Message::SEVERITY_ERROR, [$nodeType], 1412372375);
$this->redirect('createSiteNode');
}
if ($siteNodeType->isOfType('Neos.Neos:Document') === false) {
$this->addFlashMessage('Error: The given node type "%s" is not based on the superType "%s"', Message::SEVERITY_ERROR, [$nodeType, 'Neos.Neos:Document'], 1412372375);
$this->redirect('createSiteNode');
}
$rootNode = $this->nodeContextFactory->create()->getRootNode();
// We fetch the workspace to be sure it's known to the persistence manager and persist all
// so the workspace and site node are persisted before we import any nodes to it.
$rootNode->getContext()->getWorkspace();
$this->persistenceManager->persistAll();
$sitesNode = $rootNode->getNode(SiteService::SITES_ROOT_PATH);
if ($sitesNode === null) {
$sitesNode = $rootNode->createNode(NodePaths::getNodeNameFromPath(SiteService::SITES_ROOT_PATH));
}
$siteNode = $sitesNode->createNode($nodeName, $siteNodeType);
$siteNode->setProperty('title', $siteName);
$site = new Site($nodeName);
$site->setSiteResourcesPackageKey($packageKey);
$site->setState(Site::STATE_ONLINE);
$site->setName($siteName);
$this->siteRepository->add($site);
$this->addFlashMessage('Successfully created site "%s" with siteNode "%s", type "%s" and packageKey "%s"', '', null, [$siteName, $nodeName, $nodeType, $packageKey], 1412372266);
$this->unsetLastVisitedNodeAndRedirect('index');
}
/**
* @test
*/
public function inheritanceBasedConstraintsWork()
{
$testingNodeTypeWithSubnodes = $this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:NodeTypeWithSubnodes');
$testingNodeTypeThatInheritsFromDocumentType = $this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:Page');
$nodeWithChildNode = $this->rootNode->createNode('node-with-child-node', $testingNodeTypeWithSubnodes);
$nodeWithChildNode->createNode('page', $testingNodeTypeThatInheritsFromDocumentType);
$this->assertCount(2, $nodeWithChildNode->getChildNodes());
}
/**
* Render the label for the given $nodeTypeName
*
* @param string $nodeTypeName
* @throws NodeTypeNotFoundException
* @return string
*/
public function labelForNodeType($nodeTypeName)
{
if (!$this->nodeTypeManager->hasNodeType($nodeTypeName)) {
$explodedNodeTypeName = explode(':', $nodeTypeName);
return end($explodedNodeTypeName);
}
$nodeType = $this->nodeTypeManager->getNodeType($nodeTypeName);
return $nodeType->getLabel();
}
/**
* @test
*/
public function getChildNodesWithNodeTypeFilterWorks()
{
$documentNodeType = $this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:Document');
$headlineNodeType = $this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:Headline');
$imageNodeType = $this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:Image');
$node = $this->context->getRootNode()->createNode('node-with-child-node', $documentNodeType);
$node->createNode('headline', $headlineNodeType);
$node->createNode('text', $imageNodeType);
$this->assertCount(1, $node->getChildNodes('Neos.ContentRepository.Testing:Headline'));
}
/**
* 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));
}
/**
* @throws \Neos\ContentRepository\Exception\NodeTypeNotFoundException
*/
protected function createNodesForNodeSearchTest()
{
$rootNode = $this->context->getRootNode();
$newNode1 = $rootNode->createNode('test-node-1', $this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:NodeType'));
$newNode1->setProperty('test1', 'simpleTestValue');
$newNode2 = $rootNode->createNode('test-node-2', $this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:NodeType'));
$newNode2->setProperty('test2', 'simpleTestValue');
$newNode2 = $rootNode->createNode('test-node-3', $this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:NodeType'));
$newNode2->setProperty('test1', 'otherValue');
$this->persistenceManager->persistAll();
}
/**
* @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));
}
/**
* @test
*/
public function aSingleNodeExportedWithNodeDataExportCanBeImportedWithNodeDataImport()
{
$originalNode = $this->rootNode->createNode('foo', $this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:ImportExport'));
$originalNode->setProperty('description', 'Some node with a property');
$originalNode->setProperty('someDate', new \DateTime());
$this->persistenceManager->persistAll();
$exportService = new NodeExportService();
$xml = $exportService->export('/')->outputMemory();
$this->nodeDataRepository->removeAll();
$this->workspaceRepository->removeAll();
$this->saveNodesAndTearDownRootNodeAndRepository();
$this->setUpRootNodeAndRepository();
$importService = new NodeImportService();
$reader = new \XMLReader();
$reader->XML($xml);
$importService->import($reader, '/');
$importedNode = $this->rootNode->getNode('foo');
$this->assertNotNull($importedNode, 'Expected node not found');
$this->assertSame($originalNode->getIdentifier(), $importedNode->getIdentifier());
$this->assertSame($originalNode->getProperty('description'), $importedNode->getProperty('description'));
$this->assertEquals($originalNode->getProperty('someDate'), $importedNode->getProperty('someDate'));
}
/**
* Return an array with child nodes which should be automatically created
*
* @return array the key of this array is the name of the child, and the value its NodeType.
* @api
*/
public function getAutoCreatedChildNodes()
{
$this->initialize();
if (!isset($this->fullConfiguration['childNodes'])) {
return array();
}
$autoCreatedChildNodes = array();
foreach ($this->fullConfiguration['childNodes'] as $childNodeName => $childNodeConfiguration) {
if (isset($childNodeConfiguration['type'])) {
$autoCreatedChildNodes[Utility::renderValidNodeName($childNodeName)] = $this->nodeTypeManager->getNodeType($childNodeConfiguration['type']);
}
}
return $autoCreatedChildNodes;
}
/**
* 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);
}
/**
* Detects the requested node type and returns a corresponding NodeType instance.
*
* @param string $targetType
* @param array $source
* @return NodeType
*/
protected function extractNodeType($targetType, array $source)
{
if (isset($source['__nodeType'])) {
$nodeTypeName = $source['__nodeType'];
} else {
$matches = array();
preg_match(self::EXTRACT_CONTENT_TYPE_PATTERN, $targetType, $matches);
if (isset($matches['nodeType'])) {
$nodeTypeName = $matches['nodeType'];
} else {
$nodeTypeName = 'unstructured';
}
}
return $this->nodeTypeManager->getNodeType($nodeTypeName);
}
/**
* 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;
}
}
}
}
/**
* @Then /^I should get the list of all available node types as denied node types for this node from the node authorization service$/
*/
public function iShouldGetTheListOfAllAvailableNodeTypesAsDeniedNodeTypesForThisNodeFromTheNodeAuthorizationService()
{
if ($this->isolated === true) {
$this->callStepInSubProcess(__METHOD__);
} else {
$availableNodeTypes = $this->nodeTypeManager->getNodeTypes();
$deniedNodeTypeNames = $this->nodeAuthorizationService->getNodeTypeNamesDeniedForCreation($this->currentNodes[0]);
if (count($availableNodeTypes) !== count($deniedNodeTypeNames)) {
Assert::fail('The node authorization service did not return the expected amount of node type names! Got: ' . implode(', ', $deniedNodeTypeNames));
}
foreach ($availableNodeTypes as $nodeType) {
if (in_array($nodeType, $deniedNodeTypeNames) === false) {
Assert::fail('The following node type name has not been returned by the node authorization service: ' . $nodeType);
}
}
}
}
/**
* 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;
}
/**
* 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);
}
/**
* Converts the specified $source into a Node.
*
* If $source is a UUID it is expected to refer to the identifier of a NodeData record of the "live" workspace
*
* Otherwise $source has to be a valid node path:
*
* The node path must be an absolute context node path and can be specified as a string or as an array item with the
* key "__contextNodePath". The latter case is for updating existing nodes.
*
* This conversion method does not support / allow creation of new nodes because new nodes should be created through
* the createNode() method of an existing reference node.
*
* Also note that the context's "current node" is not affected by this object converter, you will need to set it to
* whatever node your "current" node is, if any.
*
* All elements in the source array which start with two underscores (like __contextNodePath) are specially treated
* by this converter.
*
* All elements in the source array which start with a *single underscore (like _hidden) are *directly* set on the Node
* object.
*
* All other elements, not being prefixed with underscore, are properties of the node.
*
* @param string|array $source Either a string or array containing the absolute context node path which identifies the node. For example "/sites/mysitecom/homepage/about@user-admin"
* @param string $targetType not used
* @param array $subProperties not used
* @param PropertyMappingConfigurationInterface $configuration
* @return mixed An object or \Neos\Error\Messages\Error if the input format is not supported or could not be converted for other reasons
* @throws NodeException
*/
public function convertFrom($source, $targetType = null, array $subProperties = array(), PropertyMappingConfigurationInterface $configuration = null)
{
if (is_string($source)) {
$source = array('__contextNodePath' => $source);
}
if (!is_array($source) || !isset($source['__contextNodePath'])) {
return new Error('Could not convert ' . gettype($source) . ' to Node object, a valid absolute context node path as a string or array is expected.', 1302879936);
}
try {
$nodePathAndContext = NodePaths::explodeContextPath($source['__contextNodePath']);
$nodePath = $nodePathAndContext['nodePath'];
$workspaceName = $nodePathAndContext['workspaceName'];
$dimensions = $nodePathAndContext['dimensions'];
} catch (\InvalidArgumentException $exception) {
return new Error('Could not convert array to Node object because the node path was invalid.', 1285162903);
}
$context = $this->contextFactory->create($this->prepareContextProperties($workspaceName, $configuration, $dimensions));
$workspace = $context->getWorkspace(false);
if (!$workspace) {
return new Error(sprintf('Could not convert the given source to Node object because the workspace "%s" as specified in the context node path does not exist.', $workspaceName), 1383577859);
}
$node = $context->getNode($nodePath);
if (!$node) {
return new Error(sprintf('Could not convert array to Node object because the node "%s" does not exist.', $nodePath), 1370502328);
}
if (isset($source['_nodeType']) && $source['_nodeType'] !== $node->getNodeType()->getName()) {
if ($context->getWorkspace()->getName() === 'live') {
throw new NodeException('Could not convert the node type in live workspace', 1429989736);
}
$oldNodeType = $node->getNodeType();
$targetNodeType = $this->nodeTypeManager->getNodeType($source['_nodeType']);
$node->setNodeType($targetNodeType);
$this->nodeService->setDefaultValues($node);
$this->nodeService->cleanUpAutoCreatedChildNodes($node, $oldNodeType);
$this->nodeService->createChildNodes($node);
}
unset($source['_nodeType']);
$this->setNodeProperties($node, $node->getNodeType(), $source, $context, $configuration);
return $node;
}
/**
* Create a new site
*
* This command allows to create a blank site with just a single empty document in the default dimension.
* The name of the site, the packageKey must be specified.
*
* If no ``nodeType`` option is specified the command will use `Neos.Neos.NodeTypes:Page` as fallback. The node type
* must already exists and have the superType ``Neos.Neos:Document``.
*
* If no ``nodeName` option is specified the command will create a unique node-name from the name of the site.
* If a node name is given it has to be unique for the setup.
*
* If the flag ``activate` is set to false new site will not be activated.
*
* @param string $name The name of the site
* @param string $packageKey The site package
* @param string $nodeType The node type to use for the site node. (Default = Neos.Neos.NodeTypes:Page)
* @param string $nodeName The name of the site node. If no nodeName is given it will be determined from the siteName.
* @param boolean $inactive The new site is not activated immediately (default = false).
* @return void
*/
public function createCommand($name, $packageKey, $nodeType = 'Neos.Neos.NodeTypes:Page', $nodeName = null, $inactive = false)
{
if ($nodeName === null) {
$nodeName = $this->nodeService->generateUniqueNodeName(SiteService::SITES_ROOT_PATH, $name);
}
if ($this->siteRepository->findOneByNodeName($nodeName)) {
$this->outputLine('<error>A site with siteNodeName "%s" already exists</error>', [$nodeName]);
$this->quit(1);
}
if ($this->packageManager->isPackageAvailable($packageKey) === false) {
$this->outputLine('<error>Could not find package "%s"</error>', [$packageKey]);
$this->quit(1);
}
$siteNodeType = $this->nodeTypeManager->getNodeType($nodeType);
if ($siteNodeType === null || $siteNodeType->getName() === 'Neos.Neos:FallbackNode') {
$this->outputLine('<error>The given node type "%s" was not found</error>', [$nodeType]);
$this->quit(1);
}
if ($siteNodeType->isOfType('Neos.Neos:Document') === false) {
$this->outputLine('<error>The given node type "%s" is not based on the superType "%s"</error>', [$nodeType, 'Neos.Neos:Document']);
$this->quit(1);
}
$rootNode = $this->nodeContextFactory->create()->getRootNode();
// We fetch the workspace to be sure it's known to the persistence manager and persist all
// so the workspace and site node are persisted before we import any nodes to it.
$rootNode->getContext()->getWorkspace();
$this->persistenceManager->persistAll();
$sitesNode = $rootNode->getNode(SiteService::SITES_ROOT_PATH);
if ($sitesNode === null) {
$sitesNode = $rootNode->createNode(NodePaths::getNodeNameFromPath(SiteService::SITES_ROOT_PATH));
}
$siteNode = $sitesNode->createNode($nodeName, $siteNodeType);
$siteNode->setProperty('title', $name);
$site = new Site($nodeName);
$site->setSiteResourcesPackageKey($packageKey);
$site->setState($inactive ? Site::STATE_OFFLINE : Site::STATE_ONLINE);
$site->setName($name);
$this->siteRepository->add($site);
$this->outputLine('Successfully created site "%s" with siteNode "%s", type "%s", packageKey "%s" and state "%s"', [$name, $nodeName, $nodeType, $packageKey, $inactive ? 'offline' : 'online']);
}
/**
* Generate the list of allowed sub-node-types per parent-node-type and child-node-name.
*
* @return array constraints
*/
protected function generateConstraints()
{
$constraints = array();
$nodeTypes = $this->nodeTypeManager->getNodeTypes(true);
/** @var NodeType $nodeType */
foreach ($nodeTypes as $nodeTypeName => $nodeType) {
$constraints[$nodeTypeName] = array('nodeTypes' => array(), 'childNodes' => array());
foreach ($nodeTypes as $innerNodeTypeName => $innerNodeType) {
if ($nodeType->allowsChildNodeType($innerNodeType)) {
$constraints[$nodeTypeName]['nodeTypes'][$innerNodeTypeName] = true;
}
}
foreach ($nodeType->getAutoCreatedChildNodes() as $key => $_x) {
foreach ($nodeTypes as $innerNodeTypeName => $innerNodeType) {
if ($nodeType->allowsGrandchildNodeType($key, $innerNodeType)) {
$constraints[$nodeTypeName]['childNodes'][$key]['nodeTypes'][$innerNodeTypeName] = true;
}
}
}
}
return $constraints;
}
/**
* Generate TypoScript prototype definitions for all node types
*
* Only fully qualified node types (e.g. MyVendor.MyPackage:NodeType) will be considered.
*
* @return string
*/
protected function generateNodeTypeDefinitions()
{
$code = '';
/** @var NodeType $nodeType */
foreach ($this->nodeTypeManager->getNodeTypes(false) as $nodeType) {
$code .= $this->generateTypoScriptForNodeType($nodeType);
}
return $code;
}
/**
* Returns the node type of this node.
*
* @return \Neos\ContentRepository\Domain\Model\NodeType
*/
public function getNodeType()
{
return $this->nodeTypeManager->getNodeType($this->nodeType);
}
/**
* @test
* @expectedException \Neos\ContentRepository\Exception\NodeTypeIsFinalException
*/
public function getNodeTypeThrowsExceptionIfFinalNodeTypeIsSubclassed()
{
$nodeTypesFixture = array('Neos.ContentRepository.Testing:Base' => array('final' => true), 'Neos.ContentRepository.Testing:Sub' => array('superTypes' => array('Neos.ContentRepository.Testing:Base' => true)));
$this->prepareNodeTypeManager($nodeTypesFixture);
$this->nodeTypeManager->getNodeType('Neos.ContentRepository.Testing:Sub');
}
/**
* Change the Node Type on the given node.
*
* @param NodeData $node
* @return void
*/
public function execute(NodeData $node)
{
$nodeType = $this->nodeTypeManager->getNodeType($this->newType);
$node->setNodeType($nodeType);
}
