PHP JoinPointInterface::getMethodArgument方法代码示例

 /**
  * @Flow\Around("method(TYPO3\TYPO3CR\Domain\Model\NodeType->__construct())")
  * @return void
  */
 public function enrichNodeTypeConfiguration(JoinPointInterface $joinPoint)
 {
     $configuration = $joinPoint->getMethodArgument('configuration');
     $nodeTypeName = $joinPoint->getMethodArgument('name');
     $this->addEditorDefaultsToNodeTypeConfiguration($nodeTypeName, $configuration);
     $this->addLabelsToNodeTypeConfiguration($nodeTypeName, $configuration);
     $joinPoint->setMethodArgument('configuration', $configuration);
     $joinPoint->getAdviceChain()->proceed($joinPoint);
 }

 /**
  * This changes how TagBuilder->addAttribute() method works.
  * When attribute's value is NULL or FALSE, it does *unset* the value.
  * Otherwise addAttribute() method is called as usually.
  *
  * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint
  * @Flow\Around("method(TYPO3\Fluid\Core\ViewHelper\TagBuilder->addAttribute())")
  * @return void
  */
 public function catchAddAttribute(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint)
 {
     if (null === $joinPoint->getMethodArgument('attributeValue') || false === $joinPoint->getMethodArgument('attributeValue')) {
         /** @var \TYPO3\Fluid\Core\ViewHelper\TagBuilder $tagBuilder */
         $tagBuilder = $joinPoint->getProxy();
         $tagBuilder->removeAttribute($joinPoint->getMethodArgument('attributeName'));
     } else {
         $joinPoint->getAdviceChain()->proceed($joinPoint);
     }
 }

 /**
  * Check if department of logged in User match with department property of page node and hide this node if true
  *
  * @param \TYPO3\Flow\AOP\JoinPointInterface $joinPoint
  * @Flow\After("method(TYPO3\Neos\EventLog\Integrations\TYPO3CRIntegrationService->afterNodePublishing(NodeInterface $node, $propertyName, $oldValue, $newValue))")
  * @return boolean
  */
 public function departmentNameChanged($joinPoint)
 {
     if ($joinPoint->getMethodArgument('node')->hasProperty("departmentName")) {
         // flush node caches after department change
         foreach ($joinPoint->getMethodArgument('node')->getChildNodes() as $childnode) {
             $childnode->getContext()->getFirstLevelNodeCache()->flush();
         }
         $joinPoint->getMethodArgument('node')->getContext()->getFirstLevelNodeCache()->flush();
     }
 }

 /**
  * @Flow\Around("method(TYPO3\TYPO3CR\Domain\Model\Workspace->replaceNodeData())")
  * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point
  * @return string The result of the target method if it has not been intercepted
  */
 public function replaceNodeData(JoinPointInterface $joinPoint)
 {
     /** @var Node $node */
     $node = $joinPoint->getMethodArgument('node');
     if ($node->isRemoved()) {
         // If the node is supposed to be removed, we do not need to do anything as the node will be gone anyways afterwards
         return $joinPoint->getAdviceChain()->proceed($joinPoint);
     }
     /** @var NodeData $targetNodeData */
     $targetNodeData = $joinPoint->getMethodArgument('targetNodeData');
     $commentsForToBePublishedNode = $this->extractComments($node);
     $commentsInTargetWorkspace = $this->extractComments($targetNodeData);
     // Call original Method
     $result = $joinPoint->getAdviceChain()->proceed($joinPoint);
     if (count($commentsForToBePublishedNode) == 0 && count($commentsInTargetWorkspace) == 0) {
         return $result;
     }
     // After publishing the node, we update the published node with the merged comments. We cannot do this
     // before publishing, as otherwise the NodeData which is underneath the to-be-published Node will be "dirty"
     // and marked as "removed" at the same time, leading to a CR crash. This also is a CR bug which only occurs in
     // very rare occasions.
     $mergedComments = $this->mergeComments($commentsForToBePublishedNode, $commentsInTargetWorkspace);
     $this->writeComments($node, $mergedComments);
     return $result;
 }

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

 /**
  * Add the current node and all parent identifiers to be used for cache entry tagging
  *
  * @Flow\Before("method(TYPO3\Flow\Mvc\Routing\RouterCachingService->extractUuids())")
  * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point
  * @return void
  */
 public function addCurrentNodeIdentifier(JoinPointInterface $joinPoint)
 {
     $values = $joinPoint->getMethodArgument('values');
     if (!isset($values['node']) || strpos($values['node'], '@') === false) {
         return;
     }
     // Build context explicitly without authorization checks because the security context isn't available yet
     // anyway and any Entity Privilege targeted on Workspace would fail at this point:
     $this->securityContext->withoutAuthorizationChecks(function () use($joinPoint, $values) {
         $contextPathPieces = NodePaths::explodeContextPath($values['node']);
         $context = $this->contextFactory->create(['workspaceName' => $contextPathPieces['workspaceName'], 'dimensions' => $contextPathPieces['dimensions'], 'invisibleContentShown' => true]);
         $node = $context->getNode($contextPathPieces['nodePath']);
         if (!$node instanceof NodeInterface) {
             return;
         }
         $values['node-identifier'] = $node->getIdentifier();
         $node = $node->getParent();
         $values['node-parent-identifier'] = array();
         while ($node !== null) {
             $values['node-parent-identifier'][] = $node->getIdentifier();
             $node = $node->getParent();
         }
         $joinPoint->setMethodArgument('values', $values);
     });
 }

 /**
  * Advice for a disabled content cache (e.g. because an exception was handled)
  *
  * @Flow\AfterReturning("method(TYPO3\TypoScript\Core\Cache\RuntimeContentCache->setEnableContentCache())")
  * @param JoinPointInterface $joinPoint
  */
 public function registerDisableContentCache(JoinPointInterface $joinPoint)
 {
     $enableContentCache = $joinPoint->getMethodArgument('enableContentCache');
     if ($enableContentCache !== TRUE) {
         $this->evaluatedUncached = TRUE;
     }
 }

 /**
  * @Flow\Around("method(TYPO3\Neos\Routing\FrontendNodeRoutePartHandler->convertRequestPathToNode())")
  *
  * @param \TYPO3\FLOW\AOP\JoinPointInterface $joinPoint the join point
  *
  * @return mixed
  */
 public function aroundConvertRequestPathToNodeAspect($joinPoint)
 {
     if ($this->nodeNotFoundService->isEnabled()) {
         /** @var NodeInterface $node */
         $requestPath = $joinPoint->getMethodArgument('requestPath');
         try {
             return $joinPoint->getAdviceChain()->proceed($joinPoint);
         } catch (InvalidRequestPathException $e) {
             $defaultUriSegment = $this->nodeNotFoundService->getDefaultUriSegment();
             $requestPath = $defaultUriSegment . $this->nodeNotFoundService->get404NodeUriForDimensionUriSegment($defaultUriSegment);
             $joinPoint->setMethodArgument("requestPath", $requestPath);
             return $joinPoint->getAdviceChain()->proceed($joinPoint);
         } catch (NoSuchDimensionValueException $e) {
             $defaultUriSegment = $this->nodeNotFoundService->getDefaultUriSegment();
             $requestPath = $defaultUriSegment . $this->nodeNotFoundService->get404NodeUriForDimensionUriSegment($defaultUriSegment);
             $joinPoint->setMethodArgument("requestPath", $requestPath);
             return $joinPoint->getAdviceChain()->proceed($joinPoint);
         } catch (NoSuchNodeException $e) {
             $dimensionUriSegment = strstr($requestPath, "/", true);
             if (count($this->contentDimensionPresetSource->getAllPresets()) > 0) {
                 $requestPath = $dimensionUriSegment . "/" . $this->nodeNotFoundService->get404NodeUriForDimensionUriSegment($dimensionUriSegment);
             } else {
                 $requestPath = $this->nodeNotFoundService->get404NodeUriForDimensionUriSegment('');
             }
             $joinPoint->setMethodArgument("requestPath", $requestPath);
             return $joinPoint->getAdviceChain()->proceed($joinPoint);
         }
     } else {
         // execute the original code
         return $joinPoint->getAdviceChain()->proceed($joinPoint);
     }
 }

 /**
  * Check if nodetype is in allowed sites (apply node context by filtering out not allowed node types)
  *
  * @param \TYPO3\Flow\AOP\JoinPointInterface $joinPoint
  * @Flow\Around("method(TYPO3\TYPO3CR\Domain\Factory\NodeFactory->filterNodeByContext(.*))")
  * @return \TYPO3\TYPO3CR\Domain\Model\NodeInterface|NULL
  */
 public function filterNodeByAllowedSites($joinPoint)
 {
     if ($this->isNodeTypeInAllowedSite($joinPoint->getMethodArgument('node')->getNodeType()) == FALSE) {
         return null;
     }
     $result = $joinPoint->getAdviceChain()->proceed($joinPoint);
     return $result;
 }

 /**
  * Logs calls of destroy()
  *
  * @Flow\Before("within(TYPO3\Flow\Session\SessionInterface) && method(.*->destroy())")
  * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current joinpoint
  * @return mixed The result of the target method if it has not been intercepted
  */
 public function logDestroy(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint)
 {
     $session = $joinPoint->getProxy();
     if ($session->isStarted()) {
         $reason = $joinPoint->isMethodArgument('reason') ? $joinPoint->getMethodArgument('reason') : 'no reason given';
         $this->systemLogger->log(sprintf('%s: Destroyed session with id %s: %s', $this->getClassName($joinPoint), $joinPoint->getProxy()->getId(), $reason), LOG_INFO);
     }
 }

 /**
  * @Flow\Around("within(TYPO3\Flow\Property\TypeConverter\MediaTypeConverterInterface) && method(.*->convertMediaType())")
  * @param JoinPointInterface $joinPoint The current joinpoint
  * @return mixed
  */
 public function rewriteJsonApiOrgMediaTypeToJson(JoinPointInterface $joinPoint)
 {
     $mediaType = $joinPoint->getMethodArgument('mediaType');
     if (strpos($mediaType, 'application/vnd.api+json') !== false) {
         $joinPoint->setMethodArgument('mediaType', 'application/json');
     }
     return $joinPoint->getAdviceChain()->proceed($joinPoint);
 }

 /**
  * Advice for a disabled content cache (e.g. because an exception was handled)
  *
  * @Flow\AfterReturning("method(TYPO3\TypoScript\Core\Cache\RuntimeContentCache->setEnableContentCache())")
  * @param JoinPointInterface $joinPoint
  */
 public function registerDisableContentCache(JoinPointInterface $joinPoint)
 {
     $enableContentCache = $joinPoint->getMethodArgument('enableContentCache');
     if ($enableContentCache !== TRUE) {
         $this->logger->log('Varnish cache disabled due content cache being disabled (e.g. because an exception was handled)', LOG_DEBUG);
         $this->evaluatedUncached = TRUE;
     }
 }

 /**
  * Makes sure that XML content (such as the RSS feed) is not wrapped with divs.
  *
  * @param JoinPointInterface $joinPoint
  * @return string
  * @Flow\Around("method(TYPO3\Neos\Service\ContentElementWrappingService->wrapContentObject())")
  */
 public function preventContentElementWraps(JoinPointInterface $joinPoint)
 {
     $content = $joinPoint->getMethodArgument('content');
     if (substr($content, 0, 5) === '<?xml') {
         return $content;
     }
     return $joinPoint->getAdviceChain()->proceed($joinPoint);
 }

 /**
  * Convert the object to its context path, if we deal with TYPO3CR nodes.
  *
  * @Flow\Around("method(TYPO3\Flow\Persistence\AbstractPersistenceManager->convertObjectToIdentityArray())")
  * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint the joinpoint
  * @return string|array the context path to be used for routing
  */
 public function convertNodeToContextPathForRouting(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint)
 {
     $objectArgument = $joinPoint->getMethodArgument('object');
     if ($objectArgument instanceof NodeInterface) {
         return $objectArgument->getContextPath();
     } else {
         return $joinPoint->getAdviceChain()->proceed($joinPoint);
     }
 }

 /**
  * @Flow\Around("method(TYPO3\Neos\Controller\Frontend\NodeController->handleShortcutNode())")
  * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point
  * @return void
  */
 public function dontResolveShortcutsInFrontend(JoinPointInterface $joinPoint)
 {
     $node = $joinPoint->getMethodArgument('node');
     if ($node instanceof NodeInterface) {
         if (in_array($node->getProperty('targetMode'), $this->legitShortcutTargets)) {
             $joinPoint->getAdviceChain()->proceed($joinPoint);
         }
     }
 }