/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the arguments for this operation.
* First argument is property to filter by, must be of reference of references type.
* Second is object to filter by, must be Node.
* @return mixed
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
if (!isset($arguments[0]) || empty($arguments[0])) {
throw new \TYPO3\Eel\FlowQuery\FlowQueryException('FilterByReference() needs reference property name by which nodes should be filtered', 1332492263);
} elseif (!isset($arguments[1]) || empty($arguments[1])) {
throw new \TYPO3\Eel\FlowQuery\FlowQueryException('FilterByReference() needs object by which nodes should be filtered', 1332493263);
} else {
$nodes = $flowQuery->getContext();
$filterByPropertyPath = $arguments[0];
/** @var Node $object */
$object = $arguments[1];
$filteredNodes = array();
/** @var Node $node */
foreach ($nodes as $node) {
$propertyValue = $node->getProperty($filterByPropertyPath);
if (is_array($propertyValue)) {
if (in_array($object, $propertyValue)) {
$filteredNodes[] = $node;
}
} else {
if ($object == $propertyValue) {
$filteredNodes[] = $node;
}
}
}
$flowQuery->setContext($filteredNodes);
}
}
/**
* Tests on a tree:
*
* a
* a1
* a2
* b (TestingNodeType)
* b1 (TestingNodeType)
* b1a
* b2
* b3 (TestingNodeTypeWithSubnodes)
* b3a (TestingNodeType)
* b3b
*
* @test
* @dataProvider closestOperationDataProvider
*/
public function closestOperationTests($currentNodePath, $nodeTypeFilter, $expectedNodePath)
{
$nodeTypeManager = $this->objectManager->get('TYPO3\\TYPO3CR\\Domain\\Service\\NodeTypeManager');
$testNodeType1 = $nodeTypeManager->getNodeType('TYPO3.TYPO3CR.Testing:NodeType');
$testNodeType2 = $nodeTypeManager->getNodeType('TYPO3.TYPO3CR.Testing:NodeTypeWithSubnodes');
$rootNode = $this->node->getNode('/');
$nodeA = $rootNode->createNode('a');
$nodeA->createNode('a1');
$nodeA->createNode('a2');
$nodeB = $rootNode->createNode('b', $testNodeType1);
$nodeB1 = $nodeB->createNode('b1', $testNodeType1);
$nodeB1->createNode('b1a');
$nodeB->createNode('b2');
$nodeB3 = $nodeB->createNode('b3', $testNodeType2);
$nodeB3->createNode('b3a', $testNodeType1);
$nodeB3->createNode('b3b');
$currentNode = $rootNode->getNode($currentNodePath);
$q = new FlowQuery(array($currentNode));
$actualNode = $q->closest($nodeTypeFilter)->get(0);
if ($expectedNodePath === null) {
if ($actualNode !== null) {
$this->fail('Expected resulting node to be NULL');
}
$this->assertNull($actualNode);
} else {
$this->assertSame($expectedNodePath, $actualNode->getPath());
}
}
/**
* @Flow\Before("method(TYPO3\Neos\Controller\Backend\ContentController->uploadAssetAction())")
* @param JoinPointInterface $joinPoint The current join point
* @return void
*/
public function rewriteSiteAssetCollection(JoinPointInterface $joinPoint)
{
if ($this->lookupNodeFilter === NULL || $this->lookupPropertyName === NULL) {
return;
}
/** @var ContentController $contentController */
$contentController = $joinPoint->getProxy();
/** @var ActionRequest $actionRequest */
$actionRequest = ObjectAccess::getProperty($contentController, 'request', TRUE);
$nodeContextPath = $actionRequest->getInternalArgument('__node');
if ($nodeContextPath === NULL) {
return;
}
$node = $this->propertyMapper->convert($nodeContextPath, NodeInterface::class);
$flowQuery = new FlowQuery(array($node));
/** @var NodeInterface $documentNode */
$documentNode = $flowQuery->closest($this->lookupNodeFilter)->get(0);
if (!$documentNode->hasProperty($this->lookupPropertyName)) {
return;
}
/** @var AssetCollection $assetCollection */
$assetCollection = $this->assetCollectionRepository->findByIdentifier($documentNode->getProperty($this->lookupPropertyName));
if ($assetCollection === NULL) {
return;
}
/** @var Asset $asset */
$asset = $joinPoint->getMethodArgument('asset');
$assetCollection->addAsset($asset);
$this->assetCollectionRepository->update($assetCollection);
}
/**
* Tests on a tree:
*
* a
* a1
* b
* b1 (TestingNodeType)
* b1a
* c
*
* @test
* @dataProvider hasOperationDataProvider()
*/
public function hasOperationTests(array $currentNodePaths, $subject, array $expectedNodePaths)
{
$nodeTypeManager = $this->objectManager->get('TYPO3\\TYPO3CR\\Domain\\Service\\NodeTypeManager');
$testNodeType1 = $nodeTypeManager->getNodeType('TYPO3.TYPO3CR.Testing:NodeType');
$rootNode = $this->node->getNode('/');
$nodeA = $rootNode->createNode('a');
$nodeA->createNode('a1');
$nodeB = $rootNode->createNode('b');
$nodeB1 = $nodeB->createNode('b1', $testNodeType1);
$nodeB1->createNode('b1a');
$rootNode->createNode('c');
$currentNodes = array();
foreach ($currentNodePaths as $currentNodePath) {
$currentNodes[] = $rootNode->getNode($currentNodePath);
}
if (is_array($subject)) {
$subjectNodes = array();
foreach ($subject as $subjectNodePath) {
$subjectNodes[] = $rootNode->getNode($subjectNodePath);
}
$subject = $subjectNodes;
}
$q = new FlowQuery($currentNodes);
$result = $q->has($subject)->get();
if ($expectedNodePaths === array()) {
$this->assertEmpty($result);
} else {
foreach ($expectedNodePaths as $expectedNodePath) {
$expectedNode = $rootNode->getNode($expectedNodePath);
if (!in_array($expectedNode, $result)) {
$this->fail(sprintf('Expected result to contain node "%s"', $expectedNodePath));
}
}
}
}
/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the arguments for this operation
* @return void
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
$output = array();
$outputNodePaths = array();
$until = array();
foreach ($flowQuery->getContext() as $contextNode) {
$prevNodes = $this->getPrevForNode($contextNode);
if (isset($arguments[0]) && !empty($arguments[0])) {
$untilQuery = new FlowQuery($prevNodes);
$untilQuery->pushOperation('filter', array($arguments[0]));
$until = $untilQuery->get();
}
if (isset($until) && !empty($until)) {
$until = end($until);
$prevNodes = $this->getNodesUntil($prevNodes, $until);
}
if (is_array($prevNodes)) {
foreach ($prevNodes as $prevNode) {
if ($prevNode !== NULL && !isset($outputNodePaths[$prevNode->getPath()])) {
$outputNodePaths[$prevNode->getPath()] = TRUE;
$output[] = $prevNode;
}
}
}
}
$flowQuery->setContext($output);
if (isset($arguments[1]) && !empty($arguments[1])) {
$flowQuery->pushOperation('filter', array($arguments[1]));
}
}
/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the arguments for this operation
* @return void
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
$output = array();
$outputNodePaths = array();
foreach ($flowQuery->getContext() as $contextNode) {
$siteNode = $contextNode->getContext()->getCurrentSiteNode();
$parentNodes = $this->getParents($contextNode, $siteNode);
if (isset($arguments[0]) && !empty($arguments[0] && isset($parentNodes[0]))) {
$untilQuery = new FlowQuery(array($parentNodes[0]));
$untilQuery->pushOperation('closest', array($arguments[0]));
$until = $untilQuery->get();
}
if (isset($until) && is_array($until) && !empty($until) && isset($until[0])) {
$parentNodes = $this->getNodesUntil($parentNodes, $until[0]);
}
if (is_array($parentNodes)) {
foreach ($parentNodes as $parentNode) {
if ($parentNode !== null && !isset($outputNodePaths[$parentNode->getPath()])) {
$outputNodePaths[$parentNode->getPath()] = true;
$output[] = $parentNode;
}
}
}
}
$flowQuery->setContext($output);
if (isset($arguments[1]) && !empty($arguments[1])) {
$flowQuery->pushOperation('filter', $arguments[1]);
}
}
/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the arguments for this operation
* @return mixed
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
if (!isset($arguments[0]) || empty($arguments[0])) {
throw new \TYPO3\Eel\FlowQuery\FlowQueryException('sort() needs property name by which nodes should be sorted', 1332492263);
} else {
$nodes = $flowQuery->getContext();
$sortByPropertyPath = $arguments[0];
$sortOrder = 'DESC';
if (isset($arguments[1]) && !empty($arguments[1]) && in_array($arguments[1], array('ASC', 'DESC'))) {
$sortOrder = $arguments[1];
}
$sortedNodes = array();
$sortSequence = array();
$nodesByIdentifier = array();
/** @var Node $node */
foreach ($nodes as $node) {
$propertyValue = $node->getProperty($sortByPropertyPath);
// \TYPO3\Flow\var_dump($propertyValue);
if ($propertyValue instanceof \DateTime) {
$propertyValue = $propertyValue->getTimestamp();
}
$sortSequence[$node->getIdentifier()] = $propertyValue;
$nodesByIdentifier[$node->getIdentifier()] = $node;
}
if ($sortOrder === 'DESC') {
arsort($sortSequence);
} else {
asort($sortSequence);
}
foreach ($sortSequence as $nodeIdentifier => $value) {
$sortedNodes[] = $nodesByIdentifier[$nodeIdentifier];
}
$flowQuery->setContext($sortedNodes);
}
}
/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the arguments for this operation.
* First argument is property to filter by, must be DateTime.
* Second is Date operand, must be DateTime object.
* And third is a compare operator: '<' or '>', '>' by default
* @return mixed
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
if (!isset($arguments[0]) || empty($arguments[0])) {
throw new \TYPO3\Eel\FlowQuery\FlowQueryException('filterByDate() needs property name by which nodes should be filtered', 1332492263);
} elseif (!isset($arguments[1]) || empty($arguments[1])) {
throw new \TYPO3\Eel\FlowQuery\FlowQueryException('filterByDate() needs date value by which nodes should be filtered', 1332493263);
} else {
$nodes = $flowQuery->getContext();
$filterByPropertyPath = $arguments[0];
$date = $arguments[1];
$compareOperator = '>';
if (isset($arguments[2]) && !empty($arguments[2]) && in_array($arguments[2], array('<', '>'))) {
$compareOperator = $arguments[2];
}
$filteredNodes = array();
/** @var Node $node */
foreach ($nodes as $node) {
$propertyValue = $node->getProperty($filterByPropertyPath);
if ($compareOperator == '>') {
if ($propertyValue > $date) {
$filteredNodes[] = $node;
}
}
if ($compareOperator == '<') {
if ($propertyValue < $date) {
$filteredNodes[] = $node;
}
}
}
$flowQuery->setContext($filteredNodes);
}
}
/**
* @test
*/
public function parentsFollowedByFirstMatchesInnermostNodeOnRootline()
{
$teaserText = $this->node->getNode('teaser/dummy42');
$q = new FlowQuery(array($teaserText));
$actual = iterator_to_array($q->parents('[someSpecialProperty]')->first());
$expected = array($this->node->getNode('teaser'));
$this->assertTrue($expected === $actual);
}
/**
* Helper method to retrieve the closest document for a node
*
* @param NodeInterface $node
* @return NodeInterface
*/
public function getClosestDocument(NodeInterface $node)
{
if ($node->getNodeType()->isOfType('TYPO3.Neos:Document')) {
return $node;
}
$flowQuery = new FlowQuery(array($node));
return $flowQuery->closest('[instanceof TYPO3.Neos:Document]')->get(0);
}
/**
* {@inheritdoc}
*
* @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
* @param array $arguments Ignored for this operation
* @return void
*/
public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
{
$context = $flowQuery->getContext();
if (isset($context[0])) {
$flowQuery->setContext(array($context[0]));
} else {
$flowQuery->setContext(array());
}
}
/**
* {@inheritdoc}
*
* @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
* @param array $arguments Ignored for this operation
* @return void
*/
public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
{
$context = $flowQuery->getContext();
if (count($context) > 0) {
$flowQuery->setContext(array(end($context)));
} else {
$flowQuery->setContext(array());
}
}
/**
* {@inheritdoc}
*
* @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
* @param array $arguments filter arguments for this operation
* @return void|integer with the number of elements
*/
public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
{
if (count($arguments) == 0) {
return count($flowQuery->getContext());
} else {
$flowQuery->pushOperation('count', array());
$flowQuery->pushOperation('filter', $arguments);
}
}
/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments A mandatory start and optional end index in the context, negative indices indicate an offset from the start or end respectively
* @return void
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
$context = $flowQuery->getContext();
if (isset($arguments[0]) && isset($arguments[1])) {
$context = array_slice($context, (int) $arguments[0], (int) $arguments[1] - (int) $arguments[0]);
} elseif (isset($arguments[0])) {
$context = array_slice($context, (int) $arguments[0]);
}
$flowQuery->setContext($context);
}
/**
* @param NodeInterface $node A document node
* @return string
*/
public function render(NodeInterface $node)
{
$output = '/' . $node->getLabel();
$flowQuery = new FlowQuery(array($node));
$nodes = $flowQuery->parents('[instanceof TYPO3.Neos:Document]')->get();
/** @var NodeInterface $node */
foreach ($nodes as $node) {
$output = '/' . $node->getLabel() . $output;
}
return $output;
}
/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments A mandatory start and optional end index in the context, negative indices indicate an offset from the start or end respectively
* @return void
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
$context = $flowQuery->getContext();
if ($context instanceof \Iterator) {
$context = iterator_to_array($context);
}
if (isset($arguments[0]) && isset($arguments[1])) {
$context = array_slice($context, (int) $arguments[0], (int) $arguments[1] - (int) $arguments[0]);
} elseif (isset($arguments[0])) {
$context = array_slice($context, (int) $arguments[0]);
}
$flowQuery->setContext($context);
}
/**
* Evaluate the property name filter by traversing to the child object. We only support
* nested objects right now
*
* @param \TYPO3\Eel\FlowQuery\FlowQuery $query
* @param string $propertyNameFilter
* @return void
*/
protected function evaluatePropertyNameFilter(\TYPO3\Eel\FlowQuery\FlowQuery $query, $propertyNameFilter)
{
$resultObjects = array();
$resultObjectHashes = array();
foreach ($query->getContext() as $element) {
$subProperty = \TYPO3\Flow\Reflection\ObjectAccess::getPropertyPath($element, $propertyNameFilter);
if (is_object($subProperty) && !isset($resultObjectHashes[spl_object_hash($subProperty)])) {
$resultObjectHashes[spl_object_hash($subProperty)] = TRUE;
$resultObjects[] = $subProperty;
}
}
$query->setContext($resultObjects);
}
/**
* {@inheritdoc}
*
* @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the elements to add (as array in index 0)
* @return void
*/
public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
{
$output = array();
foreach ($flowQuery->getContext() as $element) {
$output[] = $element;
}
if (isset($arguments[0])) {
foreach ($arguments[0] as $element) {
$output[] = $element;
}
}
$flowQuery->setContext($output);
}
/**
* {@inheritdoc}
*
* @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the context index to fetch from
* @return mixed
*/
public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
{
$context = $flowQuery->getContext();
if (isset($arguments[0])) {
$index = $arguments[0];
if (isset($context[$index])) {
return $context[$index];
} else {
return null;
}
} else {
return $context;
}
}
/**
* {@inheritdoc}
*
* @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the property path to use (in index 0)
* @return mixed
*/
public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
{
if (!isset($arguments[0]) || empty($arguments[0])) {
throw new \TYPO3\Eel\FlowQuery\FlowQueryException('property() must be given an attribute name when used on objects, fetching all attributes is not supported.', 1332492263);
} else {
$context = $flowQuery->getContext();
if (!isset($context[0])) {
return null;
}
$element = $context[0];
$propertyPath = $arguments[0];
return \TYPO3\Flow\Reflection\ObjectAccess::getPropertyPath($element, $propertyPath);
}
}
/**
* @return string
*/
public final function getList()
{
$context = $this->contextFactory->create(['workspaceName' => 'live']);
$flowQuery = new FlowQuery([$context->getRootNode()]);
$events = $flowQuery->find('[instanceof Nieuwenhuizen.BuJitsuDo:Article]')->get();
$result['articles'] = [];
usort($events, function (NodeInterface $a, NodeInterface $b) {
return $this->sortNodesSelection($a, $b, 'publicationDate', false);
});
foreach ($events as $event) {
$result['articles'][] = $this->buildSingleItemJson($event);
}
return $result;
}
/**
* @param NodeInterface $node
* @return array
*/
protected function breadcrumbNodesForNode(NodeInterface $node)
{
$documentNodes = [];
$flowQuery = new FlowQuery(array($node));
$nodes = array_reverse($flowQuery->parents('[instanceof TYPO3.Neos:Document]')->get());
/** @var NodeInterface $node */
foreach ($nodes as $documentNode) {
$documentNodes[] = $documentNode;
}
if ($node->getNodeType()->isOfType('TYPO3.Neos:Document')) {
$documentNodes[] = $node;
}
return $documentNodes;
}
/**
* @return array
*/
public function buildItems()
{
$output = array();
$dimension = $this->getDimension();
foreach ($this->getPresetsInCorrectOrder() as $presetName => $presetConfiguration) {
$q = new FlowQuery(array($this->currentNode));
$nodeInOtherDimension = $q->context(array('dimensions' => array($dimension => $presetConfiguration['values']), 'targetDimensions' => array($dimension => reset($presetConfiguration['values']))))->get(0);
if ($nodeInOtherDimension !== NULL && $this->isNodeHidden($nodeInOtherDimension)) {
$nodeInOtherDimension = NULL;
}
$item = array('node' => $nodeInOtherDimension, 'state' => $this->calculateItemState($nodeInOtherDimension), 'label' => $presetConfiguration['label'], 'presetName' => $presetName, 'preset' => $presetConfiguration);
$output[] = $item;
}
return $output;
}
/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the arguments for this operation
* @return void
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
$output = array();
$outputNodePaths = array();
foreach ($flowQuery->getContext() as $contextNode) {
$prevNode = $this->getPrevForNode($contextNode);
if ($prevNode !== NULL && !isset($outputNodePaths[$prevNode->getPath()])) {
$outputNodePaths[$prevNode->getPath()] = TRUE;
$output[] = $prevNode;
}
}
$flowQuery->setContext($output);
if (isset($arguments[0]) && !empty($arguments[0])) {
$flowQuery->pushOperation('filter', $arguments);
}
}
/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery The FlowQuery object
* @param array $arguments The arguments for this operation
* @return void
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
if (!isset($arguments[0]) || !is_array($arguments[0])) {
throw new \TYPO3\Eel\FlowQuery\FlowQueryException('context() requires an array argument of context properties', 1398030427);
}
$output = array();
foreach ($flowQuery->getContext() as $contextNode) {
$contextProperties = $contextNode->getContext()->getProperties();
$modifiedContext = $this->contextFactory->create(array_merge($contextProperties, $arguments[0]));
$nodeInModifiedContext = $modifiedContext->getNodeByIdentifier($contextNode->getIdentifier());
if ($nodeInModifiedContext !== null) {
$output[$nodeInModifiedContext->getPath()] = $nodeInModifiedContext;
}
}
$flowQuery->setContext(array_values($output));
}
/**
* @param array $nodes
*/
public function assignNodes(array $nodes)
{
$data = array();
foreach ($nodes as $node) {
if ($node->getPath() !== '/') {
$q = new FlowQuery(array($node));
$closestDocumentNode = $q->closest('[instanceof TYPO3.Neos:Document]')->get(0);
if ($closestDocumentNode !== NULL) {
$data[] = array('nodeContextPath' => $node->getContextPath(), 'documentNodeContextPath' => $closestDocumentNode->getContextPath());
} else {
$this->systemLogger->log('You have a node that is no longer connected to a parent. Path: ' . $node->getPath() . ' (Identifier: ' . $node->getIdentifier() . ')');
}
}
}
$this->assign('value', array('data' => $data, 'success' => TRUE));
}
/**
* {@inheritdoc}
*
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the arguments for this operation
* @return void
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
$output = array();
$outputNodePaths = array();
foreach ($flowQuery->getContext() as $contextNode) {
$parentNode = $contextNode->getParent();
if ($parentNode !== null && !isset($outputNodePaths[$parentNode->getPath()])) {
$output[] = $parentNode;
$outputNodePaths[$parentNode->getPath()] = true;
}
}
$flowQuery->setContext($output);
if (isset($arguments[0]) && !empty($arguments[0])) {
$flowQuery->pushOperation('filter', $arguments);
}
}
/**
* {@inheritdoc}
*
* @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the elements to add (as array in index 0)
* @return void
*/
public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
{
$output = array();
foreach ($flowQuery->getContext() as $element) {
$output[] = $element;
}
if (isset($arguments[0])) {
if (is_array($arguments[0]) || $arguments[0] instanceof \Traversable) {
foreach ($arguments[0] as $element) {
$output[] = $element;
}
} else {
$output[] = $arguments[0];
}
}
$flowQuery->setContext($output);
}
/**
* {@inheritdoc}
*
* @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the arguments for this operation
* @return mixed|null if the operation is final, the return value
*/
public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
{
$output = array();
$outputNodePaths = array();
foreach ($flowQuery->getContext() as $contextNode) {
foreach ($contextNode->getChildNodes() as $childNode) {
if (!isset($outputNodePaths[$childNode->getPath()])) {
$output[] = $childNode;
$outputNodePaths[$childNode->getPath()] = TRUE;
}
}
}
$flowQuery->setContext($output);
if (isset($arguments[0]) && !empty($arguments[0])) {
$flowQuery->pushOperation('filter', $arguments);
}
}
/**
* @param FlowQuery $flowQuery the FlowQuery object
* @param array $arguments the arguments for this operation
* @return void
*/
public function evaluate(FlowQuery $flowQuery, array $arguments)
{
$user = false;
if (count($arguments) > 0 && is_string($arguments[0])) {
$user = $this->apiConnector->fetchUser($arguments[0]);
}
if ($user) {
$groups = $this->apiConnector->fetchGroups();
$user['memberships'] = array_filter($groups, function ($group) use($user) {
return in_array($user['name'], $group['members']) && isset($group['neos_group_type']) && !empty($group['neos_group_type']);
});
$user['additionalProperties'] = array_filter($user, function ($key) {
return strpos($key, 'neos_') === 0;
}, ARRAY_FILTER_USE_KEY);
}
$flowQuery->setContext($user);
}
