Calls all methods starting with with "inject" using autowiring.
| public callInjects ( $service ) : void | ||
| return | void | |
/**
* Creates new presenter instance.
*
* @param string presenter class name
* @return Application\IPresenter
*/
public function createPresenter($class)
{
$callInjects = $this->alwaysCallInjects;
$services = array_keys($this->container->findByTag('nette.presenter'), $class);
if (count($services) > 1) {
throw new Application\InvalidPresenterException("Multiple services of type {$class} found: " . implode(', ', $services) . '.');
} elseif (count($services)) {
$presenter = $this->container->createService($services[0]);
$callInjects = FALSE;
} elseif (count($services = $this->container->findByType($class)) === 1) {
$presenter = $this->container->createService($services[0]);
} else {
$presenter = $this->container->createInstance($class);
$callInjects = TRUE;
}
if (!$presenter instanceof Application\IPresenter) {
throw new UnexpectedValueException("Unable to create create presenter, returned value is not Nette\\Application\\IPresenter type.");
}
if ($callInjects) {
$this->container->callInjects($presenter);
}
if ($presenter instanceof Application\UI\Presenter && $presenter->invalidLinkMode === NULL) {
$presenter->invalidLinkMode = $this->invalidLinkMode;
}
return $presenter;
}
/**
* @return VisualPaginator
*/
public function create()
{
$paginator = new VisualPaginator();
$this->container->callInjects($paginator);
$this->paginatorStack[] = $paginator;
return $paginator;
}
/**
* Create new presenter instance.
* @param string presenter name
* @return IPresenter
*/
public function createPresenter($name)
{
$presenter = $this->container->createInstance($this->getPresenterClass($name));
$this->container->callInjects($presenter);
if ($presenter instanceof UI\Presenter && $presenter->invalidLinkMode === NULL) {
$presenter->invalidLinkMode = $this->container->parameters['debugMode'] ? UI\Presenter::INVALID_LINK_WARNING : UI\Presenter::INVALID_LINK_SILENT;
}
return $presenter;
}
/**
* @param IRepository $repository
* @internal param $IRepository
* @return IMapper
*/
public function createMapper(IRepository $repository)
{
$class = $this->getMapperClass($repository);
/** @var Mappers\Mapper $mapper */
$mapper = new $class($repository);
$this->container->callInjects($mapper);
$mapper->registerEvents($repository->getEvents());
return $mapper;
}
public function execute(File $sql)
{
$version = (int) basename($sql->name, '.php');
$class = "App\\Migrations\\Migration{$version}";
extract($this->getParameters());
include $sql->getPath();
/** @var Migration $migration */
$migration = new $class();
$this->container->callInjects($migration);
$migration->run();
}
/**
* Creates new presenter instance.
* @param string presenter name
* @return IPresenter
*/
public function createPresenter($name)
{
$class = $this->getPresenterClass($name);
if (count($services = $this->container->findByType($class)) === 1) {
$presenter = $this->container->createService($services[0]);
} else {
$presenter = $this->container->createInstance($class);
}
$this->container->callInjects($presenter);
if ($presenter instanceof UI\Presenter && $presenter->invalidLinkMode === NULL) {
$presenter->invalidLinkMode = $this->container->parameters['debugMode'] ? UI\Presenter::INVALID_LINK_WARNING : UI\Presenter::INVALID_LINK_SILENT;
}
return $presenter;
}
protected function doRunCommand(Command $command, InputInterface $input, OutputInterface $output)
{
if ($this->serviceLocator) {
$this->serviceLocator->callInjects($command);
}
return parent::doRunCommand($command, $input, $output);
}
/**
* @return Nette\Application\IPresenter
*/
public function __invoke($class)
{
$services = array_keys($this->container->findByTag('nette.presenter'), $class);
if (count($services) > 1) {
throw new Nette\Application\InvalidPresenterException("Multiple services of type {$class} found: " . implode(', ', $services) . '.');
} elseif (!$services) {
if ($this->touchToRefresh) {
touch($this->touchToRefresh);
}
$presenter = $this->container->createInstance($class);
$this->container->callInjects($presenter);
if ($presenter instanceof Nette\Application\UI\Presenter && $presenter->invalidLinkMode === NULL) {
$presenter->invalidLinkMode = $this->invalidLinkMode;
}
return $presenter;
}
return $this->container->createService($services[0]);
}
public function runTest($name, array $args = [])
{
$this->container->callInjects($this);
$this->setUp();
try {
call_user_func_array([$this, $name], $args);
} catch (\Exception $e) {
// method does not exist
}
try {
$this->tearDown();
} catch (\Exception $tearDownEx) {
throw isset($e) ? $e : $tearDownEx;
}
if (isset($e)) {
throw $e;
}
}
/**
* Creates new presenter instance.
* @param string presenter name
* @return IPresenter
*/
public function createPresenter($name)
{
$class = $this->getPresenterClass($name);
$services = array_keys($this->container->findByTag('nette.presenter'), $class);
if (count($services) > 1) {
throw new InvalidPresenterException("Multiple services of type {$class} found: " . implode(', ', $services) . '.');
} elseif (!$services) {
if ($this->autoRebuild) {
$rc = new \ReflectionClass($this->container);
@unlink($rc->getFileName());
// @ file may not exists
}
$presenter = $this->container->createInstance($class);
$this->container->callInjects($presenter);
if ($presenter instanceof UI\Presenter && $presenter->invalidLinkMode === NULL) {
$presenter->invalidLinkMode = $this->container->parameters['debugMode'] ? UI\Presenter::INVALID_LINK_WARNING : UI\Presenter::INVALID_LINK_SILENT;
}
return $presenter;
}
return $this->container->createService($services[0]);
}
public function injectDependencies(IEntity $entity)
{
$this->container->callInjects($entity);
return $entity;
}
public function __construct(Nette\DI\Container $sl)
{
parent::__construct();
$sl->callInjects($this);
$this->run(new Nette\Application\Request('Front:LinkGenerator', 'GET', array('action' => 'default')));
}
/**
* @return Nette\Application\IResponse
*/
protected function process(Nette\Application\Request $request)
{
// Query output content type -------------------------------------------
// Accept header is comma separated fallback sequence
// @todo sequence should be actually sorted by the degree of specificity
// @todo make support for version options (ie. application/json;version=2)
// see: RESTful Web Services Cookbook page 250
$cTypes = preg_split('/,/', $this->httpRequest->getHeader('Accept'), 0, PREG_SPLIT_NO_EMPTY);
foreach ($cTypes as $cType) {
// We ignore all the options
$cType = preg_replace('/;.*/', '', $cType);
if (strcasecmp($cType, 'text/html') === 0 || strcmp($cType, '*/*') === 0) {
$this->outputContentType = 'text/html';
$this->httpResponse->setContentType('text/html', 'utf-8');
break;
} elseif (strcasecmp($cType, 'application/json') === 0) {
$this->outputContentType = 'application/json';
$this->httpResponse->setContentType('application/json', 'utf-8');
break;
}
}
if ($this->outputContentType === NULL) {
$this->terminateWithError(self::ERROR_INVALID_REQUEST, "Accept header is missing or not satisfiable.", 406);
}
// Process Content-Language header -------------------------------------
// Process Authorization header ----------------------------------------
if (($authHeader = $this->httpRequest->getHeader('Authorization')) !== NULL) {
if (preg_match('/^Bearer\\s([^\\s,;]+)/i', $authHeader, $matches)) {
$tokenHash = $matches[1];
// If connection is not secured return error and invalidate sent token
// just in case
if (!$request->hasFlag(Nette\Application\Request::SECURED) && $this->isInProductionMode()) {
$this->tokenManager->invalidateToken($tokenHash);
$this->terminateWithError(self::ERROR_INVALID_REQUEST, "Secured connection required", 400);
}
if (!$this->attemptLogger->getRemainingAttempts(self::ATTEMPT_IP_TOKEN, $this->httpRequest->getRemoteAddress())) {
$this->terminateWithError(OAuth2ResourceProvider::ERROR_MAXIMUM_ATTEMPTS_EXCEEDED, 'Maximum number of authorization attempts exceeded.', 403);
}
$token = $this->tokenManager->getToken($tokenHash);
if (!$token) {
$this->attemptLogger->logFail(self::ATTEMPT_IP_TOKEN, $this->httpRequest->getRemoteAddress());
$this->httpResponse->addHeader('WWW-Authenticate', 'Bearer realm="' . $this->link() . '"');
$this->terminateWithError(OAuth2ResourceProvider::ERROR_INVALID_GRANT, 'Given authorization token is not valid.', 401);
}
$this->attemptLogger->logSuccess(self::ATTEMPT_IP_TOKEN, $this->httpRequest->getRemoteAddress());
if (isset($token->parameters->userIdentity)) {
$this->user->login(User::AUTHN_METHOD_INVALID, User::AUTHN_SOURCE_ALL, $token->parameters->userIdentity);
}
if (isset($token->parameters->client)) {
$this->client = $token->parameters->client;
}
}
}
// Find request handler ------------------------------------------------
// Gather resource path
$parameters = $request->getParameters();
$resourcePath = isset($parameters[self::PARAM_KEY_PATH]) ? trim($parameters[self::PARAM_KEY_PATH]) : NULL;
if (!$resourcePath) {
$this->terminateWithError(self::ERROR_INVALID_REQUEST, "No resource path given.", 400);
}
// Request router expects leading slash
if ($resourcePath[0] != '/') {
$resourcePath = "/{$resourcePath}";
}
// Request router: find resource handler
try {
/** @var vBuilder\RestApi\Request */
$this->resourceRequest = $handlerRequest = $this->requestRouter->createRequest($this->httpRequest->getMethod(), $resourcePath);
} catch (RequestException $e) {
$this->terminateWithError(self::ERROR_INVALID_REQUEST, $e->getMessage(), $e->getCode() == RequestException::METHOD_NOT_ALLOWED ? 405 : 404);
}
// Request authorization -----------------------------------------------
$handlerMethodAnnotations = $handlerRequest->getMethodReflection()->getAnnotations();
if (!isset($handlerMethodAnnotations['NoAuthorization']) || !$handlerMethodAnnotations['NoAuthorization'][0]) {
if (!$this->client) {
$this->httpResponse->addHeader('WWW-Authenticate', 'Bearer realm="' . $this->link() . '"');
$this->terminateWithError(self::ERROR_UNAUTHORIZED, 'Requested resource requires authorization. Please add Authorization header with correct security token.', 401);
}
}
// Decode POST data ----------------------------------------------------
if ($this->httpRequest->isPost()) {
$cType = $this->httpRequest->getHeader('Content-Type');
if (strcasecmp($cType, 'application/json') === 0) {
try {
$this->postData = Nette\Utils\Json::decode(file_get_contents('php://input'), Nette\Utils\Json::FORCE_ARRAY);
} catch (Nette\Utils\JsonException $e) {
$this->terminateWithError(self::ERROR_INVALID_REQUEST, "Malformed POST data (JSON expected).", 400);
}
} elseif (strcasecmp($cType, 'application/x-www-form-urlencoded') === 0) {
$this->postData = $this->httpRequest->getPost();
} elseif ($cType === NULL) {
$this->terminateWithError(self::ERROR_INVALID_REQUEST, "Missing Content-Type header, which is mandatory for POST requests.", 400);
} else {
$this->terminateWithError(self::ERROR_INVALID_REQUEST, "Request content type of POST data is not supported.", 415);
}
}
// Create resource instance and prepare all dependencies ---------------
$class = $handlerRequest->getResourceClassName();
$resource = new $class();
$resource->presenter = $this;
$this->systemContainer->callInjects($resource);
// Prepare and order invoke parameters ---------------------------------
$mReflection = $handlerRequest->getMethodReflection();
$invokeParams = array();
$requestParams = $handlerRequest->getParameters();
$definedParams = $mReflection->getParameters();
$index = 0;
foreach ($definedParams as $pReflection) {
$index++;
// Parameter not given in URL?
if (!isset($requestParams[$pReflection->getName()])) {
// Default value where available
if ($pReflection->isDefaultValueAvailable()) {
$invokeParams[$pReflection->getName()] = $pReflection->getDefaultValue();
continue;
}
$this->terminateWithError(self::ERROR_INVALID_REQUEST, "Missing #{$index} parameter for resource handler {$class}::" . $mReflection->getName() . '().', 400);
}
$invokeParams[$pReflection->getName()] = $requestParams[$pReflection->getName()];
}
// Perform startup
$resource->startup();
// Invoke handler method on resource instance
$responsePayload = $mReflection->invokeArgs($resource, $invokeParams);
// Automatically set HTTP 204 No Content if necessary
if ($responsePayload === NULL && $this->httpResponse->getCode() == 200) {
$this->httpResponse->setCode(204);
}
return $responsePayload === NULL ? $this->createResponse() : $this->createResponse($responsePayload);
}