/** * Dispatches a signal by calling the registered Slot methods * * @param string $signalClassName Name of the class containing the signal * @param string $signalMethodName Method name of the signal * @param array $signalArguments arguments passed to the signal method * @return void * @throws \F3\FLOW3\SignalSlot\Exception\InvalidSlotException if the slot is not valid * @author Robert Lemke <*****@*****.**> * @api */ public function dispatch($signalClassName, $signalMethodName, array $signalArguments) { if (!isset($this->slots[$signalClassName][$signalMethodName])) { return; } $this->systemLogger->log(sprintf('Dispatching signal %s::%s ...', $signalClassName, $signalMethodName), LOG_DEBUG); foreach ($this->slots[$signalClassName][$signalMethodName] as $slotInformation) { if (isset($slotInformation['object'])) { $object = $slotInformation['object']; } else { if (!$this->objectManager->isObjectRegistered($slotInformation['class'])) { throw new \F3\FLOW3\SignalSlot\Exception\InvalidSlotException('The given class "' . $slotInformation['class'] . '" is not a registered object.', 1245673367); } $object = $this->objectManager->getObject($slotInformation['class']); } $slotArguments = $signalArguments; if ($slotInformation['omitSignalInformation'] !== TRUE) { array_unshift($slotArguments, $signalClassName . '::' . $signalMethodName); } $this->systemLogger->log(sprintf(' to slot %s::%s.', get_class($object), $slotInformation['method']), LOG_DEBUG); if (!method_exists($object, $slotInformation['method'])) { throw new \F3\FLOW3\SignalSlot\Exception\InvalidSlotException('The slot method ' . get_class($object) . '->' . $slotInformation['method'] . '() does not exist.', 1245673368); } call_user_func_array(array($object, $slotInformation['method']), $slotArguments); } }
/** * Create and set a validator conjunction * * @param array $objectNames Object names of the validators * @return \F3\FLOW3\MVC\Controller\Argument Returns $this (used for fluent interface) * @author Andreas Förthner <*****@*****.**> * @api */ public function setNewValidatorConjunction(array $objectNames) { $this->validator = $this->objectFactory->create('F3\\FLOW3\\Validation\\Validator\\ConjunctionValidator'); foreach ($objectNames as $objectName) { if (!$this->objectManager->isObjectRegistered($objectName)) { $objectName = 'F3\\FLOW3\\Validation\\Validator\\' . $objectName; } $this->validator->addValidator($this->objectManager->getObject($objectName)); } return $this; }
/** * Returns an object of an appropriate validator for the given type. If no * validator is available NULL is returned * * @param string $validatorType Either the fully qualified class name of the validator or the short name of a built-in validator * @return string Name of the validator object or FALSE * @author Robert Lemke <*****@*****.**> */ protected function resolveValidatorObjectName($validatorType) { if ($this->objectManager->isObjectRegistered($validatorType)) { return $validatorType; } $possibleClassName = 'F3\\FLOW3\\Validation\\Validator\\' . $this->getValidatorType($validatorType) . 'Validator'; if ($this->objectManager->isObjectRegistered($possibleClassName)) { return $possibleClassName; } return FALSE; }
/** * Creates and sets the configured access decision voters * * @param array $voterClassNames Array of access decision voter class names * @return void * @author Andreas Förthner <*****@*****.**> */ protected function createAccessDecisionVoters(array $voterClassNames) { foreach ($voterClassNames as $voterClassName) { if (!$this->objectManager->isObjectRegistered($voterClassName)) { throw new \F3\FLOW3\Security\Exception\VoterNotFoundException('No voter of type ' . $voterClassName . ' found!', 1222267934); } $voter = $this->objectManager->getObject($voterClassName); if (!$voter instanceof \F3\FLOW3\Security\Authorization\AccessDecisionVoterInterface) { throw new \F3\FLOW3\Security\Exception\VoterNotFoundException('The found voter class did not implement \\F3\\FLOW3\\Security\\Authorization\\AccessDecisionVoterInterface', 1222268008); } $this->accessDecisionVoters[] = $voter; } }
/** * Analyzes the raw request and tries to find a request handler which can handle * it. If none is found, an exception is thrown. * * @return \F3\FLOW3\MVC\RequestHandler A request handler * @throws \F3\FLOW3\MVC\Exception * @author Robert Lemke <*****@*****.**> */ public function resolveRequestHandler() { $availableRequestHandlerClassNames = $this->reflectionService->getAllImplementationClassNamesForInterface('F3\\FLOW3\\MVC\\RequestHandlerInterface'); $suitableRequestHandlers = array(); foreach ($availableRequestHandlerClassNames as $requestHandlerClassName) { if (!$this->objectManager->isObjectRegistered($requestHandlerClassName)) { continue; } $requestHandler = $this->objectManager->getObject($requestHandlerClassName); if ($requestHandler->canHandleRequest()) { $priority = $requestHandler->getPriority(); if (isset($suitableRequestHandlers[$priority])) { throw new \F3\FLOW3\MVC\Exception('More than one request handler with the same priority can handle the request, but only one handler may be active at a time!', 1176475350); } $suitableRequestHandlers[$priority] = $requestHandler; } } if (count($suitableRequestHandlers) === 0) { throw new \F3\FLOW3\MVC\Exception('No suitable request handler found.', 1205414233); } ksort($suitableRequestHandlers); return array_pop($suitableRequestHandlers); }
/** * Creates a fresh instance of the object specified by $objectName. * * This factory method can only create objects of the scope prototype. * Singleton objects must be either injected by some type of Dependency Injection or * if that is not possible, be retrieved by the getObject() method of the * Object Manager * * You must use either Dependency Injection or this factory method for instantiation * of your objects if you need FLOW3's object management capabilities (including * AOP, Security and Persistence). It is absolutely okay and often advisable to * use the "new" operator for instantiation in your automated tests. * * @param string $objectName The name of the object to create * @return object The new object instance * @throws \InvalidArgumentException if the object name starts with a backslash * @throws \F3\FLOW3\Object\Exception\UnknownObjectException if an object with the given name does not exist * @throws \F3\FLOW3\Object\Exception\WrongScopeException if the specified object is not configured as Prototype * @author Robert Lemke <*****@*****.**> * @api */ public function create($objectName) { if ($objectName[0] === '\\') { throw new \InvalidArgumentException('The object name must not start with a backslash, "' . $objectName . '" given.', 1243272770); } if (!$this->objectManager->isObjectRegistered($objectName)) { throw new \F3\FLOW3\Object\Exception\UnknownObjectException('Object "' . $objectName . '" is not registered.', 1166550023); } $objectConfiguration = $this->objectManager->getObjectConfiguration($objectName); if ($objectConfiguration->getScope() != 'prototype') { throw new \F3\FLOW3\Object\Exception\WrongScopeException('Object "' . $objectName . '" is of scope ' . $objectConfiguration->getScope() . ' but only prototype is supported by create()', 1225385285); } $overridingArguments = self::convertArgumentValuesToArgumentObjects(array_slice(func_get_args(), 1)); $object = $this->objectBuilder->createObject($objectName, $objectConfiguration, $overridingArguments); $this->objectManager->registerShutdownObject($object, $objectConfiguration->getLifecycleShutdownMethodName()); return $object; }
/** * Parses the tokens, starting at the current index and replaces the "new" * operator with a call to the object manager if the class to be instantiated * is registered as an object. * * @param array $tokens Tokens to parse * @param integer &$index Token index to start at * @param string &$targetCode Target source code for replacement * @return boolean Returns TRUE if the new operator really has been replaced, otherwise FALSE * @author Robert Lemke <*****@*****.**> */ protected function replaceNewOperator(array $tokens, &$index, &$targetCode) { $index++; $newOperatorHasBeenReplaced = FALSE; $whitespace = ''; while ($tokens[$index][0] === T_WHITESPACE) { $whitespace .= $tokens[$index][1]; $index++; } switch ($tokens[$index][0]) { case T_STRING: $className = $tokens[$index][1]; if ($tokens[$index + 1][0] === '(') { $index++; $constructorArguments = $this->parseConstructorArguments($tokens, $index); if ($this->objectManager->isObjectRegistered($className)) { $targetCode .= '$GLOBALS[\'TYPO3\']->getObjectManager()->getObject' . '(\'' . $className . '\', ' . $constructorArguments . ')' . $whitespace; $newOperatorHasBeenReplaced = TRUE; } else { $targetCode .= 'new' . $whitespace . $className . '(' . $constructorArguments . ')'; } } else { if ($this->objectManager->isObjectRegistered($className)) { $targetCode .= '$GLOBALS[\'TYPO3\']->getObjectManager()->getObject' . '(\'' . $className . '\')' . $whitespace; $newOperatorHasBeenReplaced = TRUE; } else { $targetCode .= 'new' . $whitespace . $className; } } break; case T_VARIABLE: default: $targetCode .= 'new' . $whitespace; $targetCode .= $tokens[$index][1]; } return $newOperatorHasBeenReplaced; }