protected function dispatch(Request $request) { $method = $request->getMethod(); if (!is_string($method)) { throw new ApiException(405, 'Unsupported HTTP method; must be a string, received ' . (is_object($method) ? get_class($method) : gettype($method))); } $method = strtoupper($method); /** @var Resource $resource */ $resource = $this->getResource(); if ('GET' === $method) { if ($id = $request->getAttribute(static::PK)) { $result = $resource->fetch($id, $request->getQueryParams()); } else { $result = $resource->fetchAll($request->getQueryParams()); } } elseif ('POST' === $method) { $result = $resource->create($request->getParsedBody()); } elseif ('PUT' === $method) { $result = $resource->update($request->getAttribute(static::PK), $request->getParsedBody()); } elseif ('PATCH' === $method) { $result = $resource->patch($request->getAttribute(static::PK), $request->getParsedBody()); } elseif ('DELETE' === $method) { $result = $resource->delete($request->getAttribute(static::PK)); } else { throw new ApiException(405, 'The ' . $method . ' method has not been defined'); } return $result; }
public function __invoke(Request $request) { /** Check for token on header */ if (isset($this->options['header'])) { if ($request->hasHeader($this->options['header'])) { $header = $request->getHeader($this->options['header'])[0]; if (preg_match($this->options['regex'], $header, $matches)) { return $matches[1]; } } } /** If nothing on header, try query parameters */ if (isset($this->options['parameter'])) { if (!empty($request->getQueryParams()[$this->options['parameter']])) { return $request->getQueryParams()[$this->options['parameter']]; } } /** If nothing on parameters, try cookies */ if (isset($this->options['cookie'])) { $cookie_params = $request->getCookieParams(); if (!empty($cookie_params[$this->options["cookie"]])) { return $cookie_params[$this->options["cookie"]]; } } /** If nothing until now, check argument as last try */ if (isset($this->options['argument'])) { if ($route = $request->getAttribute('route')) { $argument = $route->getArgument($this->options['argument']); if (!empty($argument)) { return $argument; } } } throw new TokenNotFoundException('Token not found'); }
/** * Renders/Echoes the ajax output * * @param ServerRequestInterface $request * @param ResponseInterface $response * @return ResponseInterface|NULL * @throws \InvalidArgumentException */ public function processRequest(ServerRequestInterface $request, ResponseInterface $response) { $action = isset($request->getParsedBody()['action']) ? $request->getParsedBody()['action'] : (isset($request->getQueryParams()['action']) ? $request->getQueryParams()['action'] : ''); if (!in_array($action, array('route', 'getAPI'), true)) { return null; } $this->routeAction($action); return $this->ajaxObject->render(); }
/** * Convert a PSR-7 ServerRequest to a Zend\Http server-side request. * * @param ServerRequestInterface $psr7Request * @param bool $shallow Whether or not to convert without body/file * parameters; defaults to false, meaning a fully populated request * is returned. * @return Zend\Request */ public static function toZend(ServerRequestInterface $psr7Request, $shallow = false) { if ($shallow) { return new Zend\Request($psr7Request->getMethod(), $psr7Request->getUri(), $psr7Request->getHeaders(), $psr7Request->getCookieParams(), $psr7Request->getQueryParams(), [], [], $psr7Request->getServerParams()); } $zendRequest = new Zend\Request($psr7Request->getMethod(), $psr7Request->getUri(), $psr7Request->getHeaders(), $psr7Request->getCookieParams(), $psr7Request->getQueryParams(), $psr7Request->getParsedBody() ?: [], self::convertUploadedFiles($psr7Request->getUploadedFiles()), $psr7Request->getServerParams()); $zendRequest->setContent($psr7Request->getBody()); return $zendRequest; }
public function __invoke(Request $req, Response $res, callable $next) : Response { if (isset($req->getQueryParams()['redirect'])) { $redirect = $this->session->getSegment('redirect'); $redirect->set('auth', $req->getQueryParams()['redirect']); } $auth = new Opauth($this->config); return $res; }
/** * {@inheritdoc} */ public function getData() { $headers = []; foreach ($this->request->getHeaders() as $name => $values) { $headers[$name] = implode(', ', $values); } $data = ['SERVER' => $this->request->getServerParams(), 'QUERY' => $this->request->getQueryParams(), 'COOKIES' => $this->request->getCookieParams(), 'HEADERS' => $headers, 'ATTRIBUTES' => $this->request->getAttributes()]; return $data; }
/** * Processes all AJAX calls and returns a JSON for the data * * @param ServerRequestInterface $request * @param ResponseInterface $response * @return ResponseInterface */ public function processAjaxRequest(ServerRequestInterface $request, ResponseInterface $response) { // do the regular / main logic, depending on the action parameter $action = isset($request->getParsedBody()['action']) ? $request->getParsedBody()['action'] : $request->getQueryParams()['action']; $key = isset($request->getParsedBody()['key']) ? $request->getParsedBody()['fileName'] : $request->getQueryParams()['key']; $value = isset($request->getParsedBody()['value']) ? $request->getParsedBody()['value'] : $request->getQueryParams()['value']; $content = $this->process($action, $key, $value); $response->getBody()->write(json_encode($content)); return $response; }
/** * @param ServerRequestInterface $request * @param ResponseInterface $response * @param callable|null $next * @return HtmlResponse */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next = null) { $templateName = $this->defaultTemplateName; $layoutName = $this->defaultLayoutName; if (isset($request->getQueryParams()['t'])) { $templateName = $request->getQueryParams()['t']; } if (isset($request->getQueryParams()['l'])) { $layoutName = $request->getQueryParams()['l']; } return new HtmlResponse($this->template->render('proto::' . $templateName, ['layout' => 'proto-layout::' . $layoutName])); }
/** * Checks if the request token is valid. This is checked to see if the route is really * created by the same instance. Should be called for all routes in the backend except * for the ones that don't require a login. * * @param \Psr\Http\Message\ServerRequestInterface $request * @return bool * @see \TYPO3\CMS\Backend\Routing\UriBuilder where the token is generated. */ protected function isValidRequest($request) { $route = $request->getAttribute('route'); if ($route->getOption('access') === 'public') { return true; } elseif ($route->getOption('ajax')) { $token = (string) (isset($request->getParsedBody()['ajaxToken']) ? $request->getParsedBody()['ajaxToken'] : $request->getQueryParams()['ajaxToken']); return $this->getFormProtection()->validateToken($token, 'ajaxCall', $route->getOption('_identifier')); } else { $token = (string) (isset($request->getParsedBody()['token']) ? $request->getParsedBody()['token'] : $request->getQueryParams()['token']); return $this->getFormProtection()->validateToken($token, 'route', $route->getOption('_identifier')); } }
/** * Set up the application and shut it down afterwards * * @param callable $execute * @return void */ public function run(callable $execute = null) { $this->request = \TYPO3\CMS\Core\Http\ServerRequestFactory::fromGlobals(); // see below when this option is set and Bootstrap::defineTypo3RequestTypes() for more details if (TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_AJAX) { $this->request = $this->request->withAttribute('isAjaxRequest', true); } elseif (isset($this->request->getQueryParams()['M'])) { $this->request = $this->request->withAttribute('isModuleRequest', true); } $this->bootstrap->handleRequest($this->request); if ($execute !== null) { call_user_func($execute); } $this->bootstrap->shutdown(); }
/** * Handles an install tool request * Execute 'tool' or 'step' controller depending on install[controller] GET/POST parameter * * @param ServerRequestInterface $request * @return void */ public function handleRequest(ServerRequestInterface $request) { $getPost = !empty($request->getQueryParams()['install']) ? $request->getQueryParams()['install'] : $request->getParsedBody()['install']; switch ($getPost['controller']) { case 'tool': $controllerClassName = \TYPO3\CMS\Install\Controller\ToolController::class; break; case 'ajax': $controllerClassName = \TYPO3\CMS\Install\Controller\AjaxController::class; break; default: $controllerClassName = \TYPO3\CMS\Install\Controller\StepController::class; } GeneralUtility::makeInstance($controllerClassName)->execute(); }
/** * Sets the TYPO3 Backend context to a certain workspace, * called by the Backend toolbar menu * * @param ServerRequestInterface $request * @param ResponseInterface $response * @return ResponseInterface */ public function switchWorkspaceAction(ServerRequestInterface $request, ResponseInterface $response) { $parsedBody = $request->getParsedBody(); $queryParams = $request->getQueryParams(); $workspaceId = (int) (isset($parsedBody['workspaceId']) ? $parsedBody['workspaceId'] : $queryParams['workspaceId']); $pageId = (int) (isset($parsedBody['pageId']) ? $parsedBody['pageId'] : $queryParams['pageId']); $finalPageUid = 0; $originalPageId = $pageId; $this->getBackendUser()->setWorkspace($workspaceId); while ($pageId) { $page = BackendUtility::getRecordWSOL('pages', $pageId, '*', ' AND pages.t3ver_wsid IN (0, ' . $workspaceId . ')'); if ($page) { if ($this->getBackendUser()->doesUserHaveAccess($page, 1)) { break; } } else { $page = BackendUtility::getRecord('pages', $pageId); } $pageId = $page['pid']; } if (isset($page['uid'])) { $finalPageUid = (int) $page['uid']; } $ajaxResponse = ['title' => \TYPO3\CMS\Workspaces\Service\WorkspaceService::getWorkspaceTitle($workspaceId), 'workspaceId' => $workspaceId, 'pageId' => $finalPageUid && $originalPageId == $finalPageUid ? null : $finalPageUid]; $response->getBody()->write(json_encode($ajaxResponse)); return $response; }
protected function delete(ServerRequestInterface $request) { $this->assertAdmin($request->getAttribute('actor')); $name = array_get($request->getQueryParams(), 'name'); $this->extensions->disable($name); $this->extensions->uninstall($name); }
/** * {@inheritdoc} */ protected function data(ServerRequestInterface $request, Document $document) { $id = array_get($request->getQueryParams(), 'id'); $actor = $request->getAttribute('actor'); $file = array_get($request->getUploadedFiles(), 'avatar'); return $this->bus->dispatch(new UploadAvatar($id, $file, $actor)); }
/** * @param Request $request * @return \Psr\Http\Message\ResponseInterface|RedirectResponse */ public function handle(Request $request) { $redirectUri = (string) $request->getAttribute('originalUri', $request->getUri())->withQuery(''); $server = new Twitter(['identifier' => $this->settings->get('flarum-auth-twitter.api_key'), 'secret' => $this->settings->get('flarum-auth-twitter.api_secret'), 'callback_uri' => $redirectUri]); $session = $request->getAttribute('session'); $queryParams = $request->getQueryParams(); $oAuthToken = array_get($queryParams, 'oauth_token'); $oAuthVerifier = array_get($queryParams, 'oauth_verifier'); if (!$oAuthToken || !$oAuthVerifier) { $temporaryCredentials = $server->getTemporaryCredentials(); $session->set('temporary_credentials', serialize($temporaryCredentials)); $session->save(); // Second part of OAuth 1.0 authentication is to redirect the // resource owner to the login screen on the server. $server->authorize($temporaryCredentials); exit; } // Retrieve the temporary credentials we saved before $temporaryCredentials = unserialize($session->get('temporary_credentials')); // We will now retrieve token credentials from the server $tokenCredentials = $server->getTokenCredentials($temporaryCredentials, $oAuthToken, $oAuthVerifier); $user = $server->getUserDetails($tokenCredentials); $identification = ['twitter_id' => $user->uid]; $suggestions = ['username' => $user->nickname, 'avatarUrl' => str_replace('_normal', '', $user->imageUrl)]; return $this->authResponse->make($request, $identification, $suggestions); }
/** * {@inheritdoc} */ protected function delete(ServerRequestInterface $request) { $id = array_get($request->getQueryParams(), 'id'); $actor = $request->getAttribute('actor'); $input = $request->getParsedBody(); $this->bus->dispatch(new DeleteDiscussion($id, $actor, $input)); }
/** * {@inheritdoc} */ protected function data(ServerRequestInterface $request, Document $document) { $actor = $request->getAttribute('actor'); $discussionId = array_get($request->getQueryParams(), 'id'); $data = array_get($request->getParsedBody(), 'data', []); $discussion = $this->bus->dispatch(new EditDiscussion($discussionId, $actor, $data)); // TODO: Refactor the ReadDiscussion (state) command into EditDiscussion? // That's what extensions will do anyway. if ($readNumber = array_get($data, 'attributes.readNumber')) { $state = $this->bus->dispatch(new ReadDiscussion($discussionId, $actor, $readNumber)); $discussion = $state->discussion; } if ($posts = $discussion->getModifiedPosts()) { $discussionPosts = $discussion->postsVisibleTo($actor)->orderBy('time')->lists('id')->all(); foreach ($discussionPosts as &$id) { foreach ($posts as $post) { if ($id == $post->id) { $id = $post; $post->discussion = $post->discussion_id; $post->user = $post->user_id; } } } $discussion->setRelation('posts', $discussionPosts); $this->include = array_merge($this->include, ['posts', 'posts.discussion', 'posts.user']); } return $discussion; }
/** * Generates a cache key based on a unique request. * * @todo determine parts required for unique request * @param ServerRequestInterface $request * @return string */ private function generateKey(ServerRequestInterface $request) { $params = $request->getQueryParams(); ksort($params); $parts = [$request->getMethod(), $request->getUri()->getPath(), serialize($params)]; return sha1(implode(':', $parts)); }
public function __construct(Request $request, Response $response) { $this->request = $request; $this->response = $response; $this->getInput = $request->getQueryParams(); $this->postInput = $request->getParsedBody(); }
/** * Init function, setting the input vars in the global space. * * @return void * @throws \InvalidArgumentException * @throws \TYPO3\CMS\Core\Resource\Exception\FileDoesNotExistException */ public function initialize() { $fileUid = isset($this->request->getQueryParams()['file']) ? $this->request->getQueryParams()['file'] : null; $parametersArray = isset($this->request->getQueryParams()['parameters']) ? $this->request->getQueryParams()['parameters'] : null; // If no file-param or parameters are given, we must exit if (!$fileUid || !isset($parametersArray) || !is_array($parametersArray)) { throw new \InvalidArgumentException('No valid fileUid given'); } // rebuild the parameter array and check if the HMAC is correct $parametersEncoded = implode('', $parametersArray); /* For backwards compatibility the HMAC is transported within the md5 param */ $hmacParameter = isset($this->request->getQueryParams()['md5']) ? $this->request->getQueryParams()['md5'] : null; $hmac = GeneralUtility::hmac(implode('|', array($fileUid, $parametersEncoded))); if ($hmac !== $hmacParameter) { throw new \InvalidArgumentException('hash does not match'); } // decode the parameters Array $parameters = unserialize(base64_decode($parametersEncoded)); foreach ($parameters as $parameterName => $parameterValue) { $this->{$parameterName} = $parameterValue; } if (MathUtility::canBeInterpretedAsInteger($fileUid)) { $this->file = ResourceFactory::getInstance()->getFileObject((int) $fileUid); } else { $this->file = ResourceFactory::getInstance()->retrieveFileOrFolderObject($fileUid); } $this->frame = isset($this->request->getQueryParams()['frame']) ? $this->request->getQueryParams()['frame'] : null; }
public function __invoke(Request $req, Response $res, callable $next) : Response { $middleware = $this->middleware; $id = $req->getAttribute('id', false); if (!empty($req->getQueryParams()['amp'])) { $id .= '-amp'; } // Caching is disabled, or no identifier present; invoke the middleware. if (!$this->enabled || !$id) { return $middleware($req, $res, $next); } $result = $this->fetchFromCache($id, $res); // Hit cache; resturn response. if ($result instanceof Response) { return $result; } // Invoke middleware $result = $middleware($req, $res, $next); // Result is not a response; cannot cache; error condition. if (!$result instanceof Response) { return $next($req, $res, $result); } // Result represents an error response; cannot cache. if (300 <= $result->getStatusCode()) { return $result; } // Cache result $this->cache($id, $result); return $result; }
/** * {@inheritDoc} * @throws OAuth2Exception */ public function createAuthorizationResponse(ServerRequestInterface $request, Client $client, TokenOwnerInterface $owner = null) { $queryParams = $request->getQueryParams(); // We must validate some parameters first $responseType = $queryParams['response_type'] ?? null; if ($responseType !== self::GRANT_RESPONSE_TYPE) { throw OAuth2Exception::invalidRequest(sprintf('The desired grant type must be "code", but "%s" was given', $responseType)); } // We try to fetch the redirect URI from query param as per spec, and if none found, we just use // the first redirect URI defined in the client $redirectUri = $queryParams['redirect_uri'] ?? $client->getRedirectUris()[0]; // If the redirect URI cannot be found in the list, we throw an error as we don't want the user // to be redirected to an unauthorized URL if (!$client->hasRedirectUri($redirectUri)) { throw OAuth2Exception::invalidRequest('Redirect URI does not match the registered one'); } // Scope and state allow to perform additional validation $scope = $queryParams['scope'] ?? null; $state = $queryParams['state'] ?? null; $authorizationCode = new AuthorizationCode(); $authorizationCode->setRedirectUri($redirectUri); $this->populateToken($authorizationCode, $client, $owner, $scope); $authorizationCode = $this->authorizationCodeService->createToken($authorizationCode); $uri = http_build_query(array_filter(['code' => $authorizationCode->getToken(), 'state' => $state])); return new Response\RedirectResponse($redirectUri . '?' . $uri); }
/** * Process add media request * * @param ServerRequestInterface $request * @param ResponseInterface $response * @return ResponseInterface */ public function mainAction(ServerRequestInterface $request, ResponseInterface $response) { $files = $request->getParsedBody()['file']; $newMedia = []; if (isset($files['newMedia'])) { $newMedia = (array) $files['newMedia']; } foreach ($newMedia as $media) { if (!empty($media['url']) && !empty($media['target'])) { $allowed = !empty($media['allowed']) ? GeneralUtility::trimExplode(',', $media['allowed']) : []; $file = $this->addMediaFromUrl($media['url'], $media['target'], $allowed); if ($file !== null) { $flashMessage = GeneralUtility::makeInstance(FlashMessage::class, $file->getName(), $this->getLanguageService()->sL('LLL:EXT:lang/locallang_core.xlf:online_media.new_media.added'), FlashMessage::OK, true); } else { $flashMessage = GeneralUtility::makeInstance(FlashMessage::class, $this->getLanguageService()->sL('LLL:EXT:lang/locallang_core.xlf:online_media.error.invalid_url'), $this->getLanguageService()->sL('LLL:EXT:lang/locallang_core.xlf:online_media.error.new_media.failed'), FlashMessage::ERROR, true); } $this->addFlashMessage($flashMessage); } } $redirect = isset($request->getParsedBody()['redirect']) ? $request->getParsedBody()['redirect'] : $request->getQueryParams()['redirect']; $redirect = GeneralUtility::sanitizeLocalUrl($redirect); if ($redirect) { $response = $response->withHeader('Location', GeneralUtility::locationHeaderUrl($redirect))->withStatus(303); } return $response; }
public function __construct(ServerRequestInterface $request) { $this->body = $request->getParsedBody(); foreach ($request->getQueryParams() as $param => $value) { switch ($param) { case 'sort': $parts = explode(',', $value); foreach ($parts as $part) { preg_match_all('/^(\\-)?([\\w]+)$/', $part, $matches); if (empty($matches[0])) { throw new \Exception('Invalid sort format.', 1); } $name = $matches[2][0]; $order = $matches[1][0]; $this->sort[$name] = $order; } break; case 'pageSize': case 'pageNumber': $this->{$param} = $value; break; default: $this->userFilters[$param] = $value; } } }
/** * Handles any backend request * * @param ServerRequestInterface $request * @return NULL|ResponseInterface */ public function handleRequest(ServerRequestInterface $request) { // enable dispatching via Request/Response logic only for typo3/index.php // This fallback will be removed in TYPO3 CMS 8, as only index.php will be allowed $path = substr($request->getUri()->getPath(), strlen(GeneralUtility::getIndpEnv('TYPO3_SITE_PATH'))); $routingEnabled = $path === TYPO3_mainDir . 'index.php' || $path === TYPO3_mainDir; $proceedIfNoUserIsLoggedIn = false; if ($routingEnabled) { $pathToRoute = (string) $request->getQueryParams()['route']; // Allow the login page to be displayed if routing is not used and on index.php if (empty($pathToRoute)) { $pathToRoute = '/login'; } $request = $request->withAttribute('routePath', $pathToRoute); // Evaluate the constant for skipping the BE user check for the bootstrap // should be handled differently in the future by checking the Bootstrap directly if ($pathToRoute === '/login') { $proceedIfNoUserIsLoggedIn = true; } } $this->boot($proceedIfNoUserIsLoggedIn); // Check if the router has the available route and dispatch. if ($routingEnabled) { return $this->dispatch($request); } // No route found, so the system proceeds in called entrypoint as fallback. return null; }
/** * Executes the modules configured via Extbase * * @param string $moduleName * @return Response A PSR-7 response object * @throws \RuntimeException */ protected function dispatchModule($moduleName) { $moduleConfiguration = $this->getModuleConfiguration($moduleName); // Check permissions and exit if the user has no permission for entry $this->backendUserAuthentication->modAccess($moduleConfiguration, true); $id = isset($this->request->getQueryParams()['id']) ? $this->request->getQueryParams()['id'] : $this->request->getParsedBody()['id']; if ($id && MathUtility::canBeInterpretedAsInteger($id)) { // Check page access $permClause = $this->backendUserAuthentication->getPagePermsClause(true); $access = is_array(BackendUtility::readPageAccess((int) $id, $permClause)); if (!$access) { throw new \RuntimeException('You don\'t have access to this page', 1289917924); } } /** @var Response $response */ $response = GeneralUtility::makeInstance(Response::class); // Use Core Dispatching if (isset($moduleConfiguration['routeTarget'])) { $dispatcher = GeneralUtility::makeInstance(Dispatcher::class); $this->request = $this->request->withAttribute('target', $moduleConfiguration['routeTarget']); $response = $dispatcher->dispatch($this->request, $response); } else { // extbase module $configuration = array('extensionName' => $moduleConfiguration['extensionName'], 'pluginName' => $moduleName); if (isset($moduleConfiguration['vendorName'])) { $configuration['vendorName'] = $moduleConfiguration['vendorName']; } // Run Extbase $bootstrap = GeneralUtility::makeInstance(\TYPO3\CMS\Extbase\Core\Bootstrap::class); $content = $bootstrap->run('', $configuration); $response->getBody()->write($content); } return $response; }
/** * Get the string contents of the view. * * @return string */ public function render() { $view = app('view')->file(__DIR__ . '/../../../views/app.blade.php'); $forum = $this->getForumDocument(); $data = $this->getDataFromDocument($forum); if ($this->actor->exists) { $user = $this->getUserDocument(); $data = array_merge($data, $this->getDataFromDocument($user)); } $view->app = ['preload' => ['data' => $data, 'session' => $this->getSession(), 'document' => $this->document]] + $this->variables; $view->bootstrappers = $this->bootstrappers; $noJs = array_get($this->request->getQueryParams(), 'nojs'); $view->title = ($this->title ? $this->title . ' - ' : '') . $forum->data->attributes->title; $view->forum = $forum->data; $view->layout = app('view')->file($this->layout, ['forum' => $forum->data, 'content' => app('view')->file(__DIR__ . '/../../../views/content.blade.php', ['content' => $this->content, 'noJs' => $noJs, 'forum' => $forum->data])]); $view->noJs = $noJs; $view->styles = [$this->assets->getCssFile()]; $view->scripts = [$this->assets->getJsFile()]; if ($this->localeJs) { $view->scripts[] = $this->localeJs->getFile(); } $view->head = implode("\n", $this->headStrings); $view->foot = implode("\n", $this->footStrings); return $view->render(); }
protected function getSourceParams(ServerRequestInterface $request) { $request_method = $request->getServerParams()['REQUEST_METHOD']; switch (strtolower($request_method)) { case 'options': case 'head': case 'get': return array_merge($request->getParsedBody(), $request->getQueryParams()); case 'post': case 'put': case 'delete': return array_merge($request->getQueryParams(), $request->getParsedBody()); default: return []; } }
/** * {@inheritdoc} */ protected function data(ServerRequestInterface $request, Document $document) { $id = array_get($request->getQueryParams(), 'id'); $actor = $request->getAttribute('actor'); $data = array_get($request->getParsedBody(), 'data'); return $this->bus->dispatch(new EditLink($id, $actor, $data)); }
/** * Processes all AJAX calls and sends back a JSON object * * @param ServerRequestInterface $request * @param ResponseInterface $response * @return ResponseInterface */ public function liveSearchAction(ServerRequestInterface $request, ResponseInterface $response) { $queryString = $request->getQueryParams()['q']; $liveSearch = GeneralUtility::makeInstance(LiveSearch::class); $queryParser = GeneralUtility::makeInstance(QueryParser::class); $searchResults = array(); $liveSearch->setQueryString($queryString); // Jump & edit - find page and retrieve an edit link (this is only for pages if ($queryParser->isValidPageJump($queryString)) { $searchResults[] = array_merge($liveSearch->findPage($queryString), ['type' => 'pageJump']); $commandQuery = $queryParser->getCommandForPageJump($queryString); if ($commandQuery) { $queryString = $commandQuery; } } // Search through the database and find records who match to the given search string $resultArray = $liveSearch->find($queryString); foreach ($resultArray as $resultFromTable) { foreach ($resultFromTable as $item) { $searchResults[] = $item; } } $response->getBody()->write(json_encode($searchResults)); return $response; }