PHP FlowQuery\FlowQuery类代码示例

 /**
  * {@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;
 }