public function readRequest(WikiaRequest $request) { $this->users = $request->getVal('users'); $this->usersData = null; $this->time = $request->getVal('time'); $this->priority = $request->getVal('priority'); }
public function testGetBool() { $testCases = [[[], true, true], [[], false, false], [[], true, 1], [[], false, 0], [[], false, null], [[], false, ""], [[], true, "test"], [['param' => true], true, false], [['param' => false], false, true], [['param' => null], false, false], [['param' => "true"], true, false], [['param' => "false"], false, true], [['param' => "false"], false, false], [['param' => 0], false, true], [['param' => 1], true, false]]; foreach ($testCases as $tc) { $r = new WikiaRequest($tc[0]); $this->assertEquals($tc[1], $r->getBool('param', $tc[2]), 'Expected new WikiaRequest(' . var_export($tc[0], true) . ")->getBool(\"param\", " . var_export($tc[2], true) . ") to be " . var_export($tc[1], true) . "\n"); } }
protected function isTestLocation() { static $result = null; if ($result === null) { $result = stripos($this->request->getScriptUrl(), '/api/test') !== false; } return $result; }
/** * dispatch the request * * @param WikiaApp $app * @param WikiaRequest $request * @throws WikiaException * @throws Exception * @throws WikiaHttpException * @throws WikiaDispatchedException * @return WikiaResponse */ public function dispatch(WikiaApp $app, WikiaRequest $request) { wfProfileIn(__METHOD__); global $wgAutoloadClasses; if (empty($wgAutoloadClasses)) { wfProfileOut(__METHOD__); throw new WikiaException("wgAutoloadClasses is empty, cannot dispatch Request"); } $format = $request->getVal('format', WikiaResponse::FORMAT_HTML); $response = new WikiaResponse($format, $request); $controller = null; $profilename = 'unset'; // Main dispatch is a loop because Controllers can forward to each other // Error condition is also handled via forwarding to the error controller do { // First time through the loop we skip this section // If we got through the dispatch loop and have a nextCall, then call it. // Request and Response are re-used, Response data can be optionally reset if ($controller && $controller->hasNext()) { $nextCall = $controller->getNext(); $request->setVal('controller', $nextCall['controller']); $request->setVal('method', $nextCall['method']); if ($nextCall['reset']) { $response->resetData(); } } $profilename = null; try { // Determine the "base" name for the controller, stripping off Controller/Service/Module $controllerName = $app->getBaseName($request->getVal('controller')); if (empty($controllerName)) { throw new WikiaException("Controller parameter missing or invalid: {$controllerName}"); } // Service classes must be dispatched by full name otherwise we look for a controller. if ($app->isService($request->getVal('controller'))) { $controllerClassName = $app->getServiceClassName($controllerName); } else { $controllerClassName = $app->getControllerClassName($controllerName); } if (empty($wgAutoloadClasses[$controllerClassName])) { throw new ControllerNotFoundException($controllerName); } // Determine the final name for the controller and method based on any routing rules $callNext = $this->applyRouting($app, $response, $controllerClassName, $request->getVal('method', self::DEFAULT_METHOD_NAME)); $controllerClassName = $response->getControllerName(); // might have been changed $controllerName = $app->getBaseName($controllerClassName); // chop off Service/Controller $method = $response->getMethodName(); // might have been changed $profilename = __METHOD__ . " ({$controllerClassName}_{$method})"; wfProfileIn($profilename); $controller = new $controllerClassName(); /* @var $controller WikiaController */ $response->setTemplateEngine($controllerClassName::DEFAULT_TEMPLATE_ENGINE); if ($callNext) { list($nextController, $nextMethod, $resetData) = explode("::", $callNext); $controller->forward($nextController, $nextMethod, $resetData); } // map X to executeX method names for things that used to be modules if (!method_exists($controller, $method)) { $method = ucfirst($method); $hookMethod = $method; // the original module hook naming scheme does not use the "Execute" part // This will throw an exception if the template is missing // Refactor the offending class to not use executeXYZ methods or set format in request params // Warning: this means you can't use the new Dispatcher routing to switch templates in modules if ($format == WikiaResponse::FORMAT_HTML) { try { $response->getView()->setTemplate($controllerName, $method); } catch (WikiaException $e) { throw new MethodNotFoundException("{$controllerClassName}::{$method}"); } } $method = "execute{$method}"; $params = $request->getParams(); // old modules expect params in a different place } else { $hookMethod = $method; $params = array(); } if (!$request->isInternal() && !$controller->allowsExternalRequests() || in_array($method, array('allowsExternalRequests', 'getRequest', 'setRequest', 'getResponse', 'setResponse', 'getApp', 'setApp', 'init')) || !method_exists($controller, $method) || !is_callable(array($controller, $method))) { throw new MethodNotFoundException("{$controllerClassName}::{$method}"); } if (!$request->isInternal()) { $this->testIfUserHasPermissionsOrThrow($app, $controller, $method); } // Initialize the RequestContext object if it is not already set // SpecialPageController context is already set by SpecialPageFactory::execute by the time it gets here if ($controller->getContext() === null) { $controller->setContext(RequestContext::getMain()); } // If a SpecialPageController is dispatching a request to itself, preserve the original request context // TODO: come up with a better fix for this (it's because of the setInstance call in WikiaSpecialPageController) $originalRequest = $controller->getRequest(); $originalResponse = $controller->getResponse(); $controller->setRequest($request); $controller->setResponse($response); $controller->setApp($app); $controller->init(); if (method_exists($controller, 'preventBlockedUsage') && $controller->preventBlockedUsage($controller->getContext()->getUser(), $method)) { $result = false; } elseif (method_exists($controller, 'userAllowedRequirementCheck') && $controller->userAllowedRequirementCheck($controller->getContext()->getUser(), $method)) { $result = false; } else { // Actually call the controller::method! $result = $controller->{$method}($params); } if ($result === false) { // skip template rendering when false returned $controller->skipRendering(); } // Preserve original request (this is for SpecialPageControllers) if ($originalRequest != null) { $controller->setRequest($originalRequest); } if ($originalResponse != null) { $controller->setResponse($originalResponse); } // keep the AfterExecute hooks for now, refactor later using "after" dispatching $app->runHook("{$controllerName}{$hookMethod}AfterExecute", array(&$controller, &$params)); wfProfileOut($profilename); } catch (WikiaHttpException $e) { if ($request->isInternal()) { //if it is internal call rethrow it so we can apply normal handling wfProfileOut(__METHOD__); throw $e; } else { wfProfileOut($profilename); $response->setException($e); $response->setFormat('json'); $response->setCode($e->getCode()); $response->setVal('error', get_class($e)); $details = $e->getDetails(); if (!empty($details)) { $response->setVal('message', $details); } } } catch (Exception $e) { if ($profilename) { wfProfileOut($profilename); } $response->setException($e); Wikia::log(__METHOD__, $e->getMessage()); // if we catch an exception, forward to the WikiaError controller unless we are already dispatching Error if (empty($controllerClassName) || $controllerClassName != 'WikiaErrorController') { $controller = new WikiaErrorController(); $controller->forward('WikiaError', 'error', false); // keep params for error controller $response->getView()->setTemplatePath(null); // response is re-used so skip the original template } } } while ($controller && $controller->hasNext()); if ($request->isInternal() && $response->hasException() && $request->getExceptionMode() !== WikiaRequest::EXCEPTION_MODE_RETURN) { Wikia::logBacktrace(__METHOD__ . '::exception'); wfProfileOut(__METHOD__); switch ($request->getExceptionMode()) { case WikiaRequest::EXCEPTION_MODE_THROW: throw $response->getException(); // case WikiaRequest::EXCEPTION_MODE_WRAP_AND_THROW: // case WikiaRequest::EXCEPTION_MODE_WRAP_AND_THROW: default: throw new WikiaDispatchedException("Internal Throw ({$response->getException()->getMessage()})", $response->getException()); } } wfProfileOut(__METHOD__); return $response; }
/** * Prepares and sends a request to a Controller * * @param string $controllerName The name of the controller, without the 'Controller' or 'Model' suffix * @param string $methodName The name of the Controller method to call * @param array $params An array with the parameters to pass to the specified method * @param boolean $internal whether it's an internal (PHP to PHP) or external request * @param int $exceptionMode exception mode * * @return WikiaResponse a response object with the data produced by the method call */ public function sendRequest($controllerName = null, $methodName = null, $params = array(), $internal = true, $exceptionMode = null) { wfProfileIn(__METHOD__); $values = array(); if (!empty($controllerName)) { $values['controller'] = $controllerName; } if (!empty($methodName)) { $values['method'] = $methodName; } $params = array_merge((array) $params, $values); if (empty($methodName) || empty($controllerName)) { $params = array_merge($params, $_POST, $_GET); } $request = new WikiaRequest($params); $request->setInternal($internal); if ($exceptionMode !== null) { $request->setExceptionMode($exceptionMode); } $out = $this->getDispatcher()->dispatch($this, $request); wfProfileOut(__METHOD__); return $out; }
/** * Logging methods */ private function logResponseException(Exception $e, WikiaRequest $request) { $this->error('FlagsLog Exception', ['exception' => $e, 'prms' => $request->getParams()]); }
/** * dispatch the request * * @param WikiaApp $app * @param WikiaRequest $request * @return WikiaResponse */ public function dispatch(WikiaApp $app, WikiaRequest $request) { $autoloadClasses = $app->wg->AutoloadClasses; if (empty($autoloadClasses)) { throw new WikiaException("wgAutoloadClasses is empty, cannot dispatch Request"); } $format = $request->getVal('format', WikiaResponse::FORMAT_HTML); $response = F::build('WikiaResponse', array('format' => $format, 'request' => $request)); if ($app->wg->EnableSkinTemplateOverride && $app->isSkinInitialized()) { $response->setSkinName($app->wg->User->getSkin()->getSkinName()); } // Main dispatch is a loop because Controllers can forward to each other // Error condition is also handled via dispatching to the error controller do { $request->setDispatched(true); try { $method = $this->getMethodName($request); // Determine the "base" name for the controller, stripping off Controller/Service/Module $controllerName = $app->getBaseName($request->getVal('controller')); // Service classes must be dispatched by full name otherwise we look for a controller. if ($app->isService($request->getVal('controller'))) { $controllerClassName = $app->getServiceClassName($controllerName); } else { $controllerClassName = $app->getControllerClassName($controllerName); } $profilename = __METHOD__ . " ({$controllerName}_{$method})"; if (empty($controllerName)) { throw new WikiaException("Invalid controller name: {$controllerName}"); } if (empty($autoloadClasses[$controllerClassName])) { throw new WikiaException("Controller class does not exist: {$controllerClassName}"); } $app->wf->profileIn($profilename); $response->setControllerName($controllerClassName); $response->setMethodName($method); $controller = F::build($controllerClassName); /* @var $controller WikiaController */ // map X to executeX method names for things that used to be modules if (!method_exists($controller, $method)) { $method = ucfirst($method); // This will throw an exception if the template is missing // Refactor the offending class to not use executeXYZ methods or set format in request params if ($format == WikiaResponse::FORMAT_HTML) { $response->getView()->setTemplate($controllerName, $method); } $method = "execute{$method}"; $params = $request->getParams(); // old modules expect params in a different place } if (!$request->isInternal() && !$controller->allowsExternalRequests() || in_array($method, array('allowsExternalRequests', 'getRequest', 'setRequest', 'getResponse', 'setResponse', 'getApp', 'setApp', 'init')) || !method_exists($controller, $method) || !is_callable(array($controller, $method))) { throw new WikiaException("Could not dispatch {$controllerClassName}::{$method}"); } // Initialize the RequestContext object if it is not already set // SpecialPageController context is already set by SpecialPageFactory::execute by the time it gets here if ($controller->getContext() === null) { $controller->setContext(RequestContext::getMain()); } // If a SpecialPageController is dispatching a request to itself, preserve the original request context // TODO: come up with a better fix for this (it's because of the setInstance call in WikiaSpecialPageController) $originalRequest = $controller->getRequest(); $originalResponse = $controller->getResponse(); $controller->setRequest($request); $controller->setResponse($response); $controller->setApp($app); $controller->init(); // BugId:5125 - keep old hooks naming convention $hookMethod = ucfirst($this->getMethodName($request)); $hookResult = $app->runHook("{$controllerName}{$hookMethod}BeforeExecute", array(&$controller, &$params)); if ($hookResult) { $result = $controller->{$method}($params); if ($result === false) { // skip template rendering when false returned $controller->skipRendering(); } } // Preserve original request (this is for SpecialPageControllers) if ($originalRequest != null) { $controller->setRequest($originalRequest); } if ($originalResponse != null) { $controller->setResponse($originalResponse); } // we ignore the result of the AfterExecute hook $app->runHook("{$controllerName}{$hookMethod}AfterExecute", array(&$controller, &$params)); $app->wf->profileOut($profilename); } catch (Exception $e) { $app->wf->profileOut($profilename); $response->setException($e); Wikia::log(__METHOD__, $e->getMessage()); // if we catch an exception, redirect to the WikiaError controller if ($controllerClassName != 'WikiaErrorController' && $method != 'error') { $response->getView()->setTemplatePath(null); $request->setVal('controller', 'WikiaError'); $request->setVal('method', 'error'); $request->setDispatched(false); } } } while (!$request->isDispatched()); if ($request->isInternal() && $response->hasException()) { Wikia::logBacktrace(__METHOD__ . '::exception'); throw new WikiaDispatchedException("Internal Throw ({$response->getException()->getMessage()})", $response->getException()); } return $response; }