Finds recursively nodes by its parent and (optionally) by its node type.
|
public findByParentAndNodeTypeRecursively ( string $parentPath, string $nodeTypeFilter, |
||
| $parentPath | string | Absolute path of the parent node |
| $nodeTypeFilter | string | Filter the node type of the nodes, allows complex expressions (e.g. "Neos.Neos:Page", "!Neos.Neos:Page,Neos.Neos:Text" or NULL) |
| $workspace | The containing workspace | |
| $dimensions | array | An array of dimensions to dimension values |
| $removedNodes | boolean | If TRUE the result has ONLY removed nodes. If FALSE removed nodes are NOT inside the result. If NULL the result contains BOTH removed and non-removed nodes. (defaults to FALSE) |
| return | array<\Neos\ContentRepository\Domain\Model\NodeData> | |
/**
* Find all nodes of a specific node type
*
* @param array $nodeTypes
* @param ContentContext $context current content context, see class doc comment for details
* @return array<NodeInterface> all nodes of type $nodeType in the current $context
*/
protected function getNodes(array $nodeTypes, ContentContext $context)
{
$nodes = [];
$siteNode = $context->getCurrentSiteNode();
foreach ($this->nodeDataRepository->findByParentAndNodeTypeRecursively($siteNode->getPath(), implode(',', $nodeTypes), $context->getWorkspace()) as $nodeData) {
$nodes[] = $this->nodeFactory->createFromNodeData($nodeData, $context);
}
return $nodes;
}
/**
* @test
*/
public function findByParentAndNodeTypeRecursivelyCallsGetNodeDataForParentAndNodeTypeWithRecursiveFlag()
{
$parentPath = 'some/parent/path';
$nodeTypeFilter = 'Some.Package:SomeNodeType';
$mockWorkspace = $this->getMockBuilder(Workspace::class)->disableOriginalConstructor()->getMock();
$dimensions = array('persona' => array('everybody'), 'language' => array('de_DE', 'mul_ZZ'));
$removedNodesFlag = true;
$recursiveFlag = true;
$this->nodeDataRepository->expects($this->once())->method('getNodeDataForParentAndNodeType')->with($parentPath, $nodeTypeFilter, $mockWorkspace, $dimensions, $removedNodesFlag, $recursiveFlag)->will($this->returnValue(array()));
$this->nodeDataRepository->expects($this->once())->method('getNodeTypeFilterConstraintsForDql')->with($nodeTypeFilter)->will($this->returnValue(array('excludeNodeTypes' => array(), 'includeNodeTypes' => array($nodeTypeFilter))));
$this->nodeDataRepository->findByParentAndNodeTypeRecursively($parentPath, $nodeTypeFilter, $mockWorkspace, $dimensions, true);
}
/**
* 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);
}
/**
* Remove broken entity references
*
* This removes references from nodes to entities which don't exist anymore.
*
* @param string $workspaceName
* @param boolean $dryRun
* @return void
*/
public function removeBrokenEntityReferences($workspaceName, $dryRun)
{
$this->output->outputLine('Checking for broken entity references ...');
/** @var \Neos\ContentRepository\Domain\Model\Workspace $workspace */
$workspace = $this->workspaceRepository->findByIdentifier($workspaceName);
$nodeTypesWithEntityReferences = array();
foreach ($this->nodeTypeManager->getNodeTypes() as $nodeType) {
/** @var NodeType $nodeType */
foreach (array_keys($nodeType->getProperties()) as $propertyName) {
$propertyType = $nodeType->getPropertyType($propertyName);
if (strpos($propertyType, '\\') !== false) {
if (!isset($nodeTypesWithEntityReferences[$nodeType->getName()])) {
$nodeTypesWithEntityReferences[$nodeType->getName()] = array();
}
$nodeTypesWithEntityReferences[$nodeType->getName()][$propertyName] = $propertyType;
}
}
}
$nodesWithBrokenEntityReferences = array();
$brokenReferencesCount = 0;
foreach ($nodeTypesWithEntityReferences as $nodeTypeName => $properties) {
$nodeDatas = $this->nodeDataRepository->findByParentAndNodeTypeRecursively('/', $nodeTypeName, $workspace);
foreach ($nodeDatas as $nodeData) {
/** @var NodeData $nodeData */
foreach ($properties as $propertyName => $propertyType) {
$propertyValue = $nodeData->getProperty($propertyName);
$convertedProperty = null;
if (is_object($propertyValue)) {
$convertedProperty = $propertyValue;
}
if (is_string($propertyValue) && strlen($propertyValue) === 36) {
$convertedProperty = $this->propertyMapper->convert($propertyValue, $propertyType);
if ($convertedProperty === null) {
$nodesWithBrokenEntityReferences[$nodeData->getIdentifier()][$propertyName] = $nodeData;
$this->output->outputLine('Broken reference in "%s", property "%s" (%s) referring to %s.', array($nodeData->getPath(), $nodeData->getIdentifier(), $propertyName, $propertyType, $propertyValue));
$brokenReferencesCount++;
}
}
if ($convertedProperty instanceof Proxy) {
try {
$convertedProperty->__load();
} catch (EntityNotFoundException $e) {
$nodesWithBrokenEntityReferences[$nodeData->getIdentifier()][$propertyName] = $nodeData;
$this->output->outputLine('Broken reference in "%s", property "%s" (%s) referring to %s.', array($nodeData->getPath(), $nodeData->getIdentifier(), $propertyName, $propertyType, $propertyValue));
$brokenReferencesCount++;
}
}
}
}
}
if ($brokenReferencesCount > 0) {
$this->output->outputLine();
if (!$dryRun) {
$self = $this;
$this->askBeforeExecutingTask('Do you want to remove the broken entity references?', function () use($self, $nodesWithBrokenEntityReferences, $brokenReferencesCount, $workspaceName, $dryRun) {
foreach ($nodesWithBrokenEntityReferences as $nodeIdentifier => $properties) {
foreach ($properties as $propertyName => $nodeData) {
/** @var NodeData $nodeData */
$nodeData->setProperty($propertyName, null);
}
}
$self->output->outputLine('Removed %s broken entity reference%s.', array($brokenReferencesCount, $brokenReferencesCount > 1 ? 's' : ''));
});
} else {
$this->output->outputLine('Found %s broken entity reference%s to be removed.', array($brokenReferencesCount, $brokenReferencesCount > 1 ? 's' : ''));
}
$this->output->outputLine();
$this->persistenceManager->persistAll();
}
}
