/**
* Sends the given HTTP request
*
* @param \TYPO3\FLOW3\Http\Request $request
* @return \TYPO3\FLOW3\Http\Response
* @throws \TYPO3\FLOW3\Http\Exception
* @api
*/
public function sendRequest(Request $request)
{
$requestHandler = $this->bootstrap->getActiveRequestHandler();
if (!$requestHandler instanceof \TYPO3\FLOW3\Tests\FunctionalTestRequestHandler) {
throw new \TYPO3\FLOW3\Http\Exception('The browser\'s internal request engine has only been designed for use within functional tests.', 1335523749);
}
$response = new Response();
$requestHandler->setHttpRequest($request);
$requestHandler->setHttpResponse($response);
try {
$actionRequest = $this->router->route($request);
$this->securityContext->clearContext();
$this->securityContext->injectRequest($actionRequest);
$this->dispatcher->dispatch($actionRequest, $response);
} catch (\Exception $exception) {
$pathPosition = strpos($exception->getFile(), 'Packages/');
$filePathAndName = $pathPosition !== FALSE ? substr($exception->getFile(), $pathPosition) : $exception->getFile();
$exceptionCodeNumber = $exception->getCode() > 0 ? '#' . $exception->getCode() . ': ' : '';
$content = PHP_EOL . 'Uncaught Exception in FLOW3 ' . $exceptionCodeNumber . $exception->getMessage() . PHP_EOL;
$content .= 'thrown in file ' . $filePathAndName . PHP_EOL;
$content .= 'in line ' . $exception->getLine() . PHP_EOL . PHP_EOL;
$content .= \TYPO3\FLOW3\Error\Debugger::getBacktraceCode($exception->getTrace(), FALSE, TRUE) . PHP_EOL;
$response->setStatus(500);
$response->setContent($content);
$response->setHeader('X-FLOW3-ExceptionCode', $exceptionCodeNumber);
$response->setHeader('X-FLOW3-ExceptionMessage', $exception->getMessage());
}
return $response;
}
/**
* This is the default Policy voter, it votes for the access privilege for the given resource
*
* @param \TYPO3\FLOW3\Security\Context $securityContext The current securit context
* @param string $resource The resource to vote for
* @return integer One of: VOTE_GRANT, VOTE_ABSTAIN, VOTE_DENY
*/
public function voteForResource(\TYPO3\FLOW3\Security\Context $securityContext, $resource)
{
$accessGrants = 0;
$accessDenies = 0;
foreach ($securityContext->getRoles() as $role) {
try {
$privilege = $this->policyService->getPrivilegeForResource($role, $resource);
} catch (\TYPO3\FLOW3\Security\Exception\NoEntryInPolicyException $e) {
return self::VOTE_ABSTAIN;
}
if ($privilege === NULL) {
continue;
}
if ($privilege === \TYPO3\FLOW3\Security\Policy\PolicyService::PRIVILEGE_GRANT) {
$accessGrants++;
} elseif ($privilege === \TYPO3\FLOW3\Security\Policy\PolicyService::PRIVILEGE_DENY) {
$accessDenies++;
}
}
if ($accessDenies > 0) {
return self::VOTE_DENY;
}
if ($accessGrants > 0) {
return self::VOTE_GRANT;
}
return self::VOTE_ABSTAIN;
}
/**
* Returns the specified node
*
* @param string $term
* @param integer $requestIndex
* @return void
* @ExtDirect
* @todo Improve this WIP search implementation
*/
public function searchAction($term, $requestIndex)
{
$contentContext = new \TYPO3\TYPO3\Domain\Service\ContentContext($this->securityContext->getParty()->getPreferences()->get('context.workspace'));
$this->nodeRepository->setContext($contentContext);
$searchContentGroups = array();
$searchContentTypes = array();
foreach (array('TYPO3.Phoenix.ContentTypes:Page', 'TYPO3.Phoenix.ContentTypes:ContentObject') as $contentType) {
$searchContentGroups[$contentType] = $this->contentTypeManager->getContentType($contentType)->getConfiguration();
array_push($searchContentTypes, $contentType);
$subContentTypes = $this->contentTypeManager->getSubContentTypes($contentType);
if (count($subContentTypes) > 0) {
$searchContentGroups[$contentType]['subContentTypes'] = $subContentTypes;
$searchContentTypes = array_merge($searchContentTypes, array_keys($subContentTypes));
}
}
$staticWebBaseUri = $this->resourcePublisher->getStaticResourcesWebBaseUri() . 'Packages/TYPO3.TYPO3/';
$groups = array();
foreach ($this->nodeSearchService->findByProperties($term, $searchContentTypes) as $result) {
$contentType = $result->getContentType();
if (array_key_exists($contentType->getName(), $searchContentGroups)) {
$type = $contentType->getName();
} else {
foreach ($searchContentGroups as $searchContentGroup => $searchContentGroupConfiguration) {
if (isset($searchContentGroupConfiguration['subContentTypes']) && array_key_exists($contentType->getName(), $searchContentGroupConfiguration['subContentTypes'])) {
$type = $searchContentGroup;
break;
}
}
}
if (!array_key_exists($type, $groups)) {
$groups[$type] = array('type' => $contentType->getName(), 'label' => $searchContentGroups[$type]['search'], 'items' => array());
}
foreach ($contentType->getProperties() as $property => $configuration) {
if ($property[0] !== '_') {
$labelProperty = $property;
break;
}
}
$this->uriBuilder->reset();
if ($result->getContentType()->isOfType('TYPO3.Phoenix.ContentTypes:Page')) {
$pageNode = $result;
} else {
$pageNode = $this->findNextParentFolderNode($result);
$this->uriBuilder->setSection('c' . $result->getIdentifier());
}
$searchResult = array('type' => $contentType->getName(), 'label' => substr(trim(strip_tags($result->getProperty($labelProperty))), 0, 50), 'action' => $this->uriBuilder->uriFor('show', array('node' => $pageNode), 'Frontend\\Node', 'TYPO3.TYPO3'), 'path' => $result->getPath());
$contentTypeConfiguration = $contentType->getConfiguration();
if (isset($contentTypeConfiguration['darkIcon'])) {
$searchResult['icon'] = $staticWebBaseUri . $contentTypeConfiguration['darkIcon'];
}
array_push($groups[$type]['items'], $searchResult);
}
$data = array('requestIndex' => $requestIndex, 'actions' => array(array('label' => 'Clear all cache', 'command' => 'clear:cache:all'), array('label' => 'Clear page cache', 'command' => 'clear:cache:pages')), 'results' => array_values($groups));
$this->view->assign('value', array('data' => $data, 'success' => TRUE));
}
/**
* @param string $workspaceName
* @return void
* @todo Pagination
* @todo Tree filtering + level limit
* @todo Search field
* @todo Difference mechanism
*/
public function indexAction($workspaceName = NULL)
{
if (is_null($workspaceName)) {
$workspaceName = $this->securityContext->getParty()->getPreferences()->get('context.workspace');
}
$contentContext = new \TYPO3\TYPO3\Domain\Service\ContentContext($workspaceName);
$contentContext->setInvisibleContentShown(TRUE);
$contentContext->setRemovedContentShown(TRUE);
$contentContext->setInaccessibleContentShown(TRUE);
$this->nodeRepository->setContext($contentContext);
$sites = array();
foreach ($this->workspacesService->getUnpublishedNodes($workspaceName) as $node) {
if (!$node->getContentType()->isOfType('TYPO3.Phoenix.ContentTypes:Section')) {
$pathParts = explode('/', $node->getPath());
if (count($pathParts) > 2) {
$siteNodeName = $pathParts[2];
$folder = $this->findFolderNode($node);
$folderPath = implode('/', array_slice(explode('/', $folder->getPath()), 3));
$relativePath = str_replace(sprintf('/sites/%s/%s', $siteNodeName, $folderPath), '', $node->getPath());
if (!isset($sites[$siteNodeName]['siteNode'])) {
$sites[$siteNodeName]['siteNode'] = $this->siteRepository->findOneByNodeName($siteNodeName);
}
$sites[$siteNodeName]['folders'][$folderPath]['folderNode'] = $folder;
$change = array('node' => $node);
if ($node->getContentType()->isOfType('TYPO3.Phoenix.ContentTypes:AbstractNode')) {
$change['configuration'] = $node->getContentType()->getConfiguration();
}
$sites[$siteNodeName]['folders'][$folderPath]['changes'][$relativePath] = $change;
}
}
}
$liveWorkspace = $this->workspacesService->getWorkspace('live');
ksort($sites);
foreach ($sites as $siteKey => $site) {
foreach ($site['folders'] as $folderKey => $folder) {
foreach ($folder['changes'] as $changeKey => $change) {
$liveNode = $this->nodeRepository->findOneByIdentifier($change['node']->getIdentifier(), $liveWorkspace);
$sites[$siteKey]['folders'][$folderKey]['changes'][$changeKey]['isNew'] = is_null($liveNode);
$sites[$siteKey]['folders'][$folderKey]['changes'][$changeKey]['isMoved'] = $liveNode && $change['node']->getPath() !== $liveNode->getPath();
}
}
ksort($sites[$siteKey]['folders']);
}
$workspaces = array();
foreach ($this->workspacesService->getWorkspaces() as $workspace) {
array_push($workspaces, array('workspaceNode' => $workspace, 'unpublishedNodesCount' => $this->workspacesService->getUnpublishedNodesCount($workspace->getName())));
}
$this->view->assignMultiple(array('workspaceName' => $workspaceName, 'workspaces' => $workspaces, 'sites' => $sites));
}
public function redirectToLogin()
{
$entryPointFound = FALSE;
foreach ($this->securityContext->getAuthenticationTokens() as $token) {
if (!is_object($token)) {
continue;
}
$entryPoint = $token->getAuthenticationEntryPoint();
if ($entryPoint !== NULL && $entryPoint->canForward($this->request)) {
$entryPointFound = TRUE;
if ($entryPoint instanceof \TYPO3\FLOW3\Security\Authentication\EntryPoint\WebRedirect) {
$options = $entryPoint->getOptions();
$options['uri'] = $options['uri'] . "?_redirect=" . urlencode($this->request->getRequestUri());
$entryPoint->setOptions($options);
$this->securityLogger->log('Redirecting to authentication entry point with URI ' . (isset($options['uri']) ? $options['uri'] : '- undefined -'), LOG_INFO);
} else {
$this->securityLogger->log('Starting authentication with entry point of type ' . get_class($entryPoint), LOG_INFO);
}
$rootRequest = $this->request;
if ($this->request instanceof \TYPO3\FLOW3\MVC\Web\SubRequest) {
$rootRequest = $this->request->getRootRequest();
}
$this->securityContext->setInterceptedRequest($rootRequest);
$entryPoint->startAuthentication($rootRequest, $this->response);
throw new \TYPO3\FLOW3\MVC\Exception\StopActionException();
}
}
if ($entryPointFound === FALSE) {
$this->securityLogger->log('No authentication entry point found for active tokens, therefore cannot authenticate or redirect to authentication automatically.', LOG_NOTICE);
throw new \TYPO3\FLOW3\Security\Exception\AuthenticationRequiredException('No authentication entry point found for active tokens, therefore cannot authenticate or redirect to authentication automatically.', 1317309673);
}
}
/**
* Logout all active authentication tokens
*
* @return void
*/
public function logout()
{
if ($this->isAuthenticated() !== TRUE) {
return;
}
foreach ($this->securityContext->getAuthenticationTokens() as $token) {
$token->setAuthenticationStatus(\TYPO3\FLOW3\Security\Authentication\TokenInterface::NO_CREDENTIALS_GIVEN);
}
$this->emitLoggedOut();
}
/**
* @param \TYPO3\FLOW3\Security\Account $account
* @return void
* @todo Security
*/
public function deleteAction(\TYPO3\FLOW3\Security\Account $account)
{
if ($this->securityContext->getAccount() === $account) {
$this->addFlashMessage('You can not remove current logged in user');
$this->redirect('index');
}
$this->accountRepository->remove($account);
$this->addFlashMessage('The user has been deleted.');
$this->redirect('index');
}
/**
* Default action of the backend controller.
*
* @return void
* @FLOW3\SkipCsrfProtection
*/
public function indexAction()
{
$workspaceName = $this->securityContext->getParty()->getPreferences()->get('context.workspace');
// Hack: Create the workspace if it does not exist yet.
$contentContext = new \TYPO3\TYPO3\Domain\Service\ContentContext($workspaceName);
$contentContext->getWorkspace();
if (isset($_COOKIE['TYPO3_lastVisitedUri'])) {
$redirectUri = $_COOKIE['TYPO3_lastVisitedUri'];
$appendHtml = !strpos($redirectUri, '.html') ? FALSE : TRUE;
if (!strpos($redirectUri, '@')) {
$redirectUri = str_replace('.html', '', $redirectUri);
} else {
$redirectUri = substr($redirectUri, 0, strpos($redirectUri, '@'));
}
$redirectUri .= '@' . $workspaceName . ($appendHtml === TRUE ? '.html' : '');
$this->redirectToUri($redirectUri);
} else {
$this->redirectToUri('/@' . $workspaceName . '.html');
}
}
/**
* Adds a CSRF token as argument in the URI builder
*
* @FLOW3\Before("setting(TYPO3.FLOW3.security.enable) && method(TYPO3\FLOW3\Mvc\Routing\UriBuilder->build())")
* @param \TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint The current join point
* @return void
*/
public function addCsrfTokenToUri(\TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint)
{
$uriBuilder = $joinPoint->getProxy();
$arguments = $joinPoint->getMethodArgument('arguments');
$packageKey = isset($arguments['@package']) ? $arguments['@package'] : '';
$subpackageKey = isset($arguments['@subpackage']) ? $arguments['@subpackage'] : '';
$controllerName = isset($arguments['@controller']) ? $arguments['@controller'] : 'Standard';
$actionName = (isset($arguments['@action']) ? $arguments['@action'] : 'index') . 'Action';
$possibleObjectName = '@package\\@subpackage\\Controller\\@controllerController';
$possibleObjectName = str_replace('@package', str_replace('.', '\\', $packageKey), $possibleObjectName);
$possibleObjectName = str_replace('@subpackage', $subpackageKey, $possibleObjectName);
$possibleObjectName = str_replace('@controller', $controllerName, $possibleObjectName);
$possibleObjectName = str_replace('\\\\', '\\', $possibleObjectName);
$lowercaseObjectName = strtolower($possibleObjectName);
$className = $this->objectManager->getClassNameByObjectName($this->objectManager->getCaseSensitiveObjectName($lowercaseObjectName));
if ($this->policyService->hasPolicyEntryForMethod($className, $actionName) && !$this->reflectionService->isMethodAnnotatedWith($className, $actionName, 'TYPO3\\FLOW3\\Annotations\\SkipCsrfProtection')) {
$internalArguments = $uriBuilder->getArguments();
$internalArguments['__csrfToken'] = $this->securityContext->getCsrfProtectionToken();
$uriBuilder->setArguments($internalArguments);
}
}
/**
* Default action of this controller.
*
* @return void
*/
public function indexAction()
{
if ($this->exception !== NULL) {
$this->view->assign('errorMessage', $this->exception->getMessage());
}
$httpRequest = $this->request->getHttpRequest();
$uriPath = $httpRequest->getUri()->getPath();
$uriPathWithoutFormat = substr($uriPath, 0, strrpos($uriPath, '.'));
preg_match(\TYPO3\TYPO3CR\Domain\Model\NodeInterface::MATCH_PATTERN_CONTEXTPATH, $uriPathWithoutFormat, $matches);
if (isset($matches['WorkspaceName'])) {
$uri = $httpRequest->getBaseUri() . '@' . $matches['WorkspaceName'];
} elseif ($this->securityContext->getParty() instanceof \TYPO3\TYPO3\Domain\Model\User) {
$uri = $httpRequest->getBaseUri() . '@' . $this->securityContext->getParty()->getPreferences()->get('context.workspace');
} else {
$uri = $httpRequest->getBaseUri();
}
$this->view->assign('pageTitle', '404 Not Found');
$this->view->assign('errorTitle', 'Page Not Found');
$this->view->assign('errorDescription', 'Sorry, we could not find any page at this URL.<br />Please visit the <a href="' . $uri . '">homepage</a> to get back on the path.');
$this->response->setStatus(404);
}
/**
* Matches a \TYPO3\FLOW3\Mvc\RequestInterface against the configured CSRF pattern rules and searches for invalid
* csrf tokens.
*
* @param \TYPO3\FLOW3\Mvc\RequestInterface $request The request that should be matched
* @return boolean TRUE if the pattern matched, FALSE otherwise
* @throws \TYPO3\FLOW3\Security\Exception\AuthenticationRequiredException
*/
public function matchRequest(\TYPO3\FLOW3\Mvc\RequestInterface $request)
{
if ($this->authenticationManager->isAuthenticated() === FALSE) {
return FALSE;
}
$controllerClassName = $this->objectManager->getClassNameByObjectName($request->getControllerObjectName());
$actionName = $request->getControllerActionName() . 'Action';
if ($this->policyService->hasPolicyEntryForMethod($controllerClassName, $actionName) && !$this->reflectionService->isMethodTaggedWith($controllerClassName, $actionName, 'skipcsrfprotection')) {
$internalArguments = $request->getInternalArguments();
if (!isset($internalArguments['__csrfToken'])) {
return TRUE;
}
$csrfToken = $internalArguments['__csrfToken'];
if (!$this->securityContext->hasCsrfProtectionTokens()) {
throw new \TYPO3\FLOW3\Security\Exception\AuthenticationRequiredException('No tokens in security context, possible session timeout', 1317309673);
}
if ($this->securityContext->isCsrfProtectionTokenValid($csrfToken) === FALSE) {
return TRUE;
}
}
return FALSE;
}
/**
* Decide if wireframe mode should be enabled.
*
* @param \TYPO3\TYPO3CR\Domain\Model\NodeInterface $node
* @return boolean
*/
protected function isWireframeModeEnabled(\TYPO3\TYPO3CR\Domain\Model\NodeInterface $node)
{
if ($this->securityContext->getParty() !== NULL) {
try {
$this->accessDecisionManager->decideOnResource('TYPO3_TYPO3_Backend_BackendController');
if (!$this->view->canRenderWithNodeAndPath($node, $this->view->getTypoScriptPath())) {
return TRUE;
}
return $this->securityContext->getParty()->getPreferences()->get('contentEditing.wireframeMode') ? TRUE : FALSE;
} catch (\Exception $e) {
}
}
return FALSE;
}
/**
* Calls the authentication manager to authenticate all active tokens
* and redirects to the original intercepted request on success if there
* is one stored in the security context. If no intercepted request is
* found, the function simply returns.
*
* If authentication fails, the result of calling the defined
* $errorMethodName is returned.
*
* @return string
*/
public function authenticateAction()
{
$authenticated = FALSE;
try {
$this->authenticationManager->authenticate();
$authenticated = TRUE;
} catch (\TYPO3\FLOW3\Security\Exception\AuthenticationRequiredException $exception) {
}
if ($authenticated) {
$storedRequest = $this->securityContext->getInterceptedRequest();
if ($storedRequest !== NULL) {
$mainRequest = $storedRequest->getMainRequest();
$packageKey = $mainRequest->getControllerPackageKey();
$subpackageKey = $mainRequest->getControllerSubpackageKey();
if ($subpackageKey !== NULL) {
$packageKey .= '\\' . $subpackageKey;
}
$this->redirect($mainRequest->getControllerActionName(), $mainRequest->getControllerName(), $packageKey, $mainRequest->getArguments());
}
} else {
return call_user_func(array($this, $this->errorMethodName));
}
}
/**
* Advices the dispatch method so that illegal action requests are blocked before
* invoking any controller.
*
* The "request" referred to within this method is an ActionRequest or some other
* dispatchable request implementing RequestInterface. Note that we don't deal
* with HTTP requests here.
*
* @FLOW3\Around("setting(TYPO3.FLOW3.security.enable) && method(TYPO3\FLOW3\Mvc\Dispatcher->dispatch())")
* @param \TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint The current joinpoint
* @return mixed Result of the advice chain
* @throws \TYPO3\FLOW3\Security\Exception\AccessDeniedException
* @throws \TYPO3\FLOW3\Security\Exception\AuthenticationRequiredException
*/
public function blockIllegalRequestsAndForwardToAuthenticationEntryPoints(\TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint)
{
$request = $joinPoint->getMethodArgument('request');
if (!$request instanceof ActionRequest) {
return $joinPoint->getAdviceChain()->proceed($joinPoint);
}
try {
$this->firewall->blockIllegalRequests($request);
return $joinPoint->getAdviceChain()->proceed($joinPoint);
} catch (\TYPO3\FLOW3\Security\Exception\AuthenticationRequiredException $exception) {
$response = $joinPoint->getMethodArgument('response');
$entryPointFound = FALSE;
foreach ($this->securityContext->getAuthenticationTokens() as $token) {
$entryPoint = $token->getAuthenticationEntryPoint();
if ($entryPoint !== NULL) {
$entryPointFound = TRUE;
if ($entryPoint instanceof \TYPO3\FLOW3\Security\Authentication\EntryPoint\WebRedirect) {
$options = $entryPoint->getOptions();
$this->securityLogger->log('Redirecting to authentication entry point with URI ' . (isset($options['uri']) ? $options['uri'] : '- undefined -'), LOG_INFO);
} else {
$this->securityLogger->log('Starting authentication with entry point of type ' . get_class($entryPoint), LOG_INFO);
}
$this->securityContext->setInterceptedRequest($request->getMainRequest());
$entryPoint->startAuthentication($request->getHttpRequest(), $response);
}
}
if ($entryPointFound === FALSE) {
$this->securityLogger->log('No authentication entry point found for active tokens, therefore cannot authenticate or redirect to authentication automatically.', LOG_NOTICE);
throw $exception;
}
} catch (\TYPO3\FLOW3\Security\Exception\AccessDeniedException $exception) {
$this->securityLogger->log('Access denied', LOG_WARNING);
$response = $joinPoint->getMethodArgument('response');
$response->setStatus(403);
$response->setContent('<h1>403 Forbidden</h1><p>' . $exception->getMessage());
}
}
/**
* Handles a HTTP request
*
* @return void
*/
public function handleRequest()
{
// Create the request very early so the Resource Management has a chance to grab it:
$this->request = Request::createFromEnvironment();
$this->response = new Response();
$this->boot();
$this->resolveDependencies();
$this->request->injectSettings($this->settings);
$this->router->setRoutesConfiguration($this->routesConfiguration);
$actionRequest = $this->router->route($this->request);
$this->securityContext->injectRequest($actionRequest);
$this->dispatcher->dispatch($actionRequest, $this->response);
$this->response->makeStandardsCompliant($this->request);
$this->response->send();
$this->bootstrap->shutdown('Runtime');
$this->exit->__invoke();
}
/**
* Checks, if the current policy allows the retrieval of the object fetched by getObjectDataByIdentifier()
*
* @FLOW3\Around("within(TYPO3\FLOW3\Persistence\PersistenceManagerInterface) && method(.*->getObjectByIdentifier()) && setting(TYPO3.FLOW3.security.enable)")
* @param \TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint The current joinpoint
* @return array The object data of the original object, or NULL if access is not permitted
*/
public function checkAccessAfterFetchingAnObjectByIdentifier(\TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint)
{
$result = $joinPoint->getAdviceChain()->proceed($joinPoint);
if ($this->securityContext->isInitialized() === FALSE) {
return $result;
}
$authenticatedRoles = $this->securityContext->getRoles();
if ($result instanceof \Doctrine\ORM\Proxy\Proxy) {
$entityType = get_parent_class($result);
} else {
$entityType = get_class($result);
}
if ($this->policyService->hasPolicyEntryForEntityType($entityType, $authenticatedRoles)) {
if ($this->policyService->isGeneralAccessForEntityTypeGranted($entityType, $authenticatedRoles) === FALSE) {
return NULL;
}
$policyConstraintsDefinition = $this->policyService->getResourcesConstraintsForEntityTypeAndRoles($entityType, $authenticatedRoles);
if ($this->checkConstraintDefinitionsOnResultObject($policyConstraintsDefinition, $result) === FALSE) {
return NULL;
}
}
return $result;
}
/**
* Returns the publish path and filename to be used to publish the specified persistent resource
*
* @FLOW3\Around("method(TYPO3\FLOW3\Resource\Publishing\FileSystemPublishingTarget->buildPersistentResourcePublishPathAndFilename()) && setting(TYPO3.FLOW3.security.enable)")
* @param \TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint The current join point
* @return mixed Result of the target method
*/
public function rewritePersistentResourcePublishPathAndFilenameForPrivateResources(\TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint)
{
$resource = $joinPoint->getMethodArgument('resource');
$configuration = $resource->getPublishingConfiguration();
$returnFilename = $joinPoint->getMethodArgument('returnFilename');
if ($configuration === NULL || $configuration instanceof \TYPO3\FLOW3\Security\Authorization\Resource\SecurityPublishingConfiguration === FALSE) {
return $joinPoint->getAdviceChain()->proceed($joinPoint);
}
$publishingPath = FALSE;
$allowedRoles = $configuration->getAllowedRoles();
if (count(array_intersect($allowedRoles, $this->securityContext->getRoles())) > 0) {
$publishingPath = \TYPO3\FLOW3\Utility\Files::concatenatePaths(array($joinPoint->getProxy()->getResourcesPublishingPath(), 'Persistent/', $this->session->getID())) . '/';
$filename = $resource->getResourcePointer()->getHash() . '.' . $resource->getFileExtension();
\TYPO3\FLOW3\Utility\Files::createDirectoryRecursively($publishingPath);
$this->accessRestrictionPublisher->publishAccessRestrictionsForPath($publishingPath);
if ($this->settings['resource']['publishing']['fileSystem']['mirrorMode'] === 'link') {
foreach ($allowedRoles as $role) {
$roleDirectory = \TYPO3\FLOW3\Utility\Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'PrivateResourcePublishing/', $role));
\TYPO3\FLOW3\Utility\Files::createDirectoryRecursively($roleDirectory);
if (file_exists($publishingPath . $role)) {
if (\TYPO3\FLOW3\Utility\Files::is_link(\TYPO3\FLOW3\Utility\Files::concatenatePaths(array($publishingPath, $role))) && realpath(\TYPO3\FLOW3\Utility\Files::concatenatePaths(array($publishingPath, $role))) === $roleDirectory) {
continue;
}
unlink($publishingPath . $role);
symlink($roleDirectory, \TYPO3\FLOW3\Utility\Files::concatenatePaths(array($publishingPath, $role)));
} else {
symlink($roleDirectory, \TYPO3\FLOW3\Utility\Files::concatenatePaths(array($publishingPath, $role)));
}
}
$publishingPath = \TYPO3\FLOW3\Utility\Files::concatenatePaths(array($publishingPath, $allowedRoles[0])) . '/';
}
if ($returnFilename === TRUE) {
$publishingPath = \TYPO3\FLOW3\Utility\Files::concatenatePaths(array($publishingPath, $filename));
}
}
return $publishingPath;
}
/**
* Prepares the environment for and conducts an account authentication
*
* @param \TYPO3\FLOW3\Security\Account $account
* @return void
* @api
*/
protected function authenticateAccount(\TYPO3\FLOW3\Security\Account $account)
{
$this->testingProvider->setAuthenticationStatus(\TYPO3\FLOW3\Security\Authentication\TokenInterface::AUTHENTICATION_SUCCESSFUL);
$this->testingProvider->setAccount($account);
$this->securityContext->clearContext();
$requestHandler = self::$bootstrap->getActiveRequestHandler();
$request = $requestHandler->getHttpRequest();
$actionRequest = $request->createActionRequest();
$this->securityContext->injectRequest($actionRequest);
$this->authenticationManager->authenticate();
}
/**
* Get a user preference.
*
* @param string $preferencePath The preference key / path
* @return void
* @ExtDirect
*/
public function getPreferenceAction($preferencePath)
{
$value = $this->securityContext->getParty()->getPreferences()->get($preferencePath);
$this->view->setConfiguration(array('value' => array('data' => array('_descendAll' => array()))));
$this->view->assign('value', array('data' => $value, 'success' => TRUE));
}
/**
*
* @param \TYPO3\FLOW3\Mvc\View\ViewInterface $view
* @return void
*/
protected function initializeView(\TYPO3\FLOW3\Mvc\View\ViewInterface $view)
{
parent::initializeView($view);
$account = $this->securityContext->getAccount();
$view->assign('account', $account);
}
/**
* @return void
*/
public function indexAction()
{
$this->view->assign('account', $this->securityContext->getAccount());
}
