/**
* Create an action request from stored route match values and dispatch to that
*
* @param ComponentContext $componentContext
* @return void
*/
public function handle(ComponentContext $componentContext)
{
$httpRequest = $componentContext->getHttpRequest();
/** @var $actionRequest ActionRequest */
$actionRequest = $this->objectManager->get(ActionRequest::class, $httpRequest);
$this->securityContext->setRequest($actionRequest);
$routingMatchResults = $componentContext->getParameter(Routing\RoutingComponent::class, 'matchResults');
$actionRequest->setArguments($this->mergeArguments($httpRequest, $routingMatchResults));
$this->setDefaultControllerAndActionNameIfNoneSpecified($actionRequest);
$componentContext->setParameter(self::class, 'actionRequest', $actionRequest);
$this->dispatcher->dispatch($actionRequest, $componentContext->getHttpResponse());
}
/**
* @test
*/
public function handleDispatchesTheRequest()
{
$this->mockHttpRequest->expects($this->any())->method('getArguments')->will($this->returnValue([]));
$this->mockPropertyMapper->expects($this->any())->method('convert')->with('', 'array', $this->mockPropertyMappingConfiguration)->will($this->returnValue([]));
$this->mockDispatcher->expects($this->once())->method('dispatch')->with($this->mockActionRequest, $this->mockHttpResponse);
$this->dispatchComponent->handle($this->mockComponentContext);
}
/**
* Returns the rendered content of this plugin
*
* @return string The rendered content as a string
*/
public function evaluate()
{
$currentContext = $this->tsRuntime->getCurrentContext();
$this->node = $currentContext['node'];
$this->documentNode = $currentContext['documentNode'];
/** @var $parentResponse Response */
$parentResponse = $this->tsRuntime->getControllerContext()->getResponse();
$pluginResponse = new Response($parentResponse);
$this->dispatcher->dispatch($this->buildPluginRequest(), $pluginResponse);
foreach ($pluginResponse->getHeaders()->getAll() as $key => $value) {
$parentResponse->getHeaders()->set($key, $value, true);
}
return $pluginResponse->getContent();
}
/**
* @test
*/
public function handleDispatchesActionRequestIfWidgetContextIsPresent()
{
$mockWidgetId = 'SomeWidgetId';
$mockControllerObjectName = 'SomeControllerObjectName';
$this->mockHttpRequest->expects($this->at(0))->method('hasArgument')->with('__widgetId')->will($this->returnValue(true));
$this->mockHttpRequest->expects($this->atLeastOnce())->method('getArgument')->with('__widgetId')->will($this->returnValue($mockWidgetId));
$mockWidgetContext = $this->getMockBuilder(\Neos\FluidAdaptor\Core\Widget\WidgetContext::class)->getMock();
$mockWidgetContext->expects($this->atLeastOnce())->method('getControllerObjectName')->will($this->returnValue($mockControllerObjectName));
$this->mockAjaxWidgetContextHolder->expects($this->atLeastOnce())->method('get')->with($mockWidgetId)->will($this->returnValue($mockWidgetContext));
$mockActionRequest = $this->getMockBuilder(\Neos\Flow\Mvc\ActionRequest::class)->disableOriginalConstructor()->getMock();
$this->mockObjectManager->expects($this->atLeastOnce())->method('get')->with(\Neos\Flow\Mvc\ActionRequest::class)->will($this->returnValue($mockActionRequest));
$this->mockDispatcher->expects($this->once())->method('dispatch')->with($mockActionRequest, $this->mockHttpResponse);
$this->ajaxWidgetComponent->handle($this->mockComponentContext);
}
/**
* @param array $module
* @return mixed
* @throws DisabledModuleException
*/
public function indexAction(array $module)
{
$moduleRequest = new ActionRequest($this->request);
$moduleRequest->setArgumentNamespace('moduleArguments');
$moduleRequest->setControllerObjectName($module['controller']);
$moduleRequest->setControllerActionName($module['action']);
if (isset($module['format'])) {
$moduleRequest->setFormat($module['format']);
}
if ($this->request->hasArgument($moduleRequest->getArgumentNamespace()) === true && is_array($this->request->getArgument($moduleRequest->getArgumentNamespace()))) {
$moduleRequest->setArguments($this->request->getArgument($moduleRequest->getArgumentNamespace()));
}
foreach ($this->request->getPluginArguments() as $argumentNamespace => $argument) {
$moduleRequest->setArgument('--' . $argumentNamespace, $argument);
}
$modules = explode('/', $module['module']);
$moduleConfiguration = Arrays::getValueByPath($this->settings['modules'], implode('.submodules.', $modules));
$moduleConfiguration['path'] = $module['module'];
if (!$this->menuHelper->isModuleEnabled($moduleConfiguration['path'])) {
throw new DisabledModuleException(sprintf('The module "%s" is disabled. You can enable it with the "enabled" flag in Settings.yaml.', $module['module']), 1437148922);
}
$moduleBreadcrumb = array();
$path = array();
foreach ($modules as $moduleIdentifier) {
array_push($path, $moduleIdentifier);
$config = Arrays::getValueByPath($this->settings['modules'], implode('.submodules.', $path));
$moduleBreadcrumb[implode('/', $path)] = $config;
}
$moduleRequest->setArgument('__moduleConfiguration', $moduleConfiguration);
$moduleResponse = new Response($this->response);
$this->dispatcher->dispatch($moduleRequest, $moduleResponse);
if ($moduleResponse->hasHeader('Location')) {
$this->redirectToUri($moduleResponse->getHeader('Location'), 0, $moduleResponse->getStatusCode());
} elseif ($moduleRequest->getFormat() !== 'html') {
$mediaType = MediaTypes::getMediaTypeFromFilename('file.' . $moduleRequest->getFormat());
if ($mediaType !== 'application/octet-stream') {
$this->controllerContext->getResponse()->setHeader('Content-Type', $mediaType);
}
return $moduleResponse->getContent();
} else {
$user = $this->partyService->getAssignedPartyOfAccount($this->securityContext->getAccount());
$sites = $this->menuHelper->buildSiteList($this->controllerContext);
$this->view->assignMultiple(array('moduleClass' => implode('-', $modules), 'moduleContents' => $moduleResponse->getContent(), 'title' => $moduleRequest->hasArgument('title') ? $moduleRequest->getArgument('title') : $moduleConfiguration['label'], 'rootModule' => array_shift($modules), 'submodule' => array_shift($modules), 'moduleConfiguration' => $moduleConfiguration, 'moduleBreadcrumb' => $moduleBreadcrumb, 'user' => $user, 'modules' => $this->menuHelper->buildModuleList($this->controllerContext), 'sites' => $sites));
}
}
/**
* Handles a command line request.
*
* While booting, the Object Manager is not yet available for retrieving the CommandExceptionHandler.
* For this purpose, possible occurring exceptions at this stage are caught manually and treated the
* same way the CommandExceptionHandler treats exceptions on itself anyways.
*
* @return void
*/
public function handleRequest()
{
$runLevel = $this->bootstrap->isCompiletimeCommand(isset($_SERVER['argv'][1]) ? $_SERVER['argv'][1] : '') ? Bootstrap::RUNLEVEL_COMPILETIME : Bootstrap::RUNLEVEL_RUNTIME;
$this->boot($runLevel);
$commandLine = isset($_SERVER['argv']) ? $_SERVER['argv'] : [];
$this->request = $this->objectManager->get(RequestBuilder::class)->build(array_slice($commandLine, 1));
$this->response = new Response();
$this->exitIfCompiletimeCommandWasNotCalledCorrectly($runLevel);
if ($runLevel === Bootstrap::RUNLEVEL_RUNTIME) {
/** @var Context $securityContext */
$securityContext = $this->objectManager->get(Context::class);
$securityContext->withoutAuthorizationChecks(function () {
$this->dispatcher->dispatch($this->request, $this->response);
});
} else {
$this->dispatcher->dispatch($this->request, $this->response);
}
$this->response->send();
$this->shutdown($runLevel);
}
/**
* @test
* @expectedException \Neos\Flow\Security\Exception\AccessDeniedException
*/
public function dispatchRethrowsAccessDeniedException()
{
$this->mockActionRequest->expects($this->any())->method('isDispatched')->will($this->returnValue(true));
$this->mockFirewall->expects($this->once())->method('blockIllegalRequests')->will($this->throwException(new AccessDeniedException()));
$this->dispatcher->dispatch($this->mockActionRequest, $this->mockHttpResponse);
}
/**
* Run the interactive Shell
*
* The shell command runs Flow's interactive shell. This shell allows for
* entering commands like through the regular command line interface but
* additionally supports autocompletion and a user-based command history.
*
* @return void
*/
public function shellCommand()
{
if (!function_exists('readline_read_history')) {
$this->outputLine('Interactive Shell is not available on this system!');
$this->quit(1);
}
$subProcess = false;
$pipes = [];
$historyPathAndFilename = getenv('HOME') . '/.flow_' . md5(FLOW_PATH_ROOT);
readline_read_history($historyPathAndFilename);
readline_completion_function([$this, 'autocomplete']);
echo "Flow Interactive Shell\n\n";
while (true) {
$commandLine = readline('Flow > ');
if ($commandLine == '') {
echo "\n";
break;
}
readline_add_history($commandLine);
readline_write_history($historyPathAndFilename);
$request = $this->requestBuilder->build($commandLine);
$response = new Response();
$command = $request->getCommand();
if ($request === false || $command->getCommandIdentifier() === false) {
echo "Bad command\n";
continue;
}
if ($this->bootstrap->isCompiletimeCommand($command->getCommandIdentifier())) {
$this->dispatcher->dispatch($request, $response);
$response->send();
if (is_resource($subProcess)) {
$this->quitSubProcess($subProcess, $pipes);
}
} else {
if (is_resource($subProcess)) {
$subProcessStatus = proc_get_status($subProcess);
if ($subProcessStatus['running'] === false) {
proc_close($subProcess);
}
}
if (!is_resource($subProcess)) {
list($subProcess, $pipes) = $this->launchSubProcess();
if ($subProcess === false || !is_array($pipes)) {
echo "Failed launching the shell sub process for executing the runtime command.\n";
continue;
}
$this->echoSubProcessResponse($pipes);
}
fwrite($pipes[0], $commandLine . "\n");
fflush($pipes[0]);
$this->echoSubProcessResponse($pipes);
if ($command->isFlushingCaches()) {
$this->quitSubProcess($subProcess, $pipes);
}
}
}
if (is_resource($subProcess)) {
$this->quitSubProcess($subProcess, $pipes);
}
echo "Bye!\n";
}
