/**
* Finds an object from the repository by searching for its identity properties.
*
* @param array $identityProperties Property names and values to search for
* @param string $type The object type to look for
* @return mixed Either the object matching the identity or FALSE if no object was found
* @throws \RuntimeException if more than one object was found
* @author Robert Lemke <*****@*****.**>
* @author Karsten Dambekalns <*****@*****.**>
*/
protected function findObjectByIdentityProperties(array $identityProperties, $type)
{
$query = $this->queryFactory->create($type);
$classSchema = $this->reflectionService->getClassSchema($type);
$equals = array();
foreach ($classSchema->getIdentityProperties() as $propertyName => $propertyType) {
if (isset($identityProperties[$propertyName])) {
if ($propertyType === 'string') {
$equals[] = $query->equals($propertyName, $identityProperties[$propertyName], FALSE);
} else {
$equals[] = $query->equals($propertyName, $identityProperties[$propertyName]);
}
}
}
if (count($equals) === 1) {
$constraint = current($equals);
} else {
$constraint = $query->logicalAnd(current($equals), next($equals));
while (($equal = next($equals)) !== FALSE) {
$constraint = $query->logicalAnd($constraint, $equal);
}
}
$objects = $query->matching($constraint)->execute();
if (count($objects) === 1) {
return current($objects);
} elseif (count($objects) === 0) {
return FALSE;
} else {
throw new \RuntimeException('More than one object was returned for the given identity, this is a constraint violation.', 1259612399);
}
}
/**
* Commits new objects and changes to objects in the current persistence
* session into the backend
*
* @return void
* @author Robert Lemke <*****@*****.**>
* @author Karsten Dambekalns <*****@*****.**>
* @api
*/
public function persistAll()
{
$aggregateRootObjects = new \SplObjectStorage();
$deletedEntities = new \SplObjectStorage();
// fetch and inspect objects from all known repositories
$repositoryClassNames = $this->reflectionService->getAllImplementationClassNamesForInterface('F3\\FLOW3\\Persistence\\RepositoryInterface');
foreach ($repositoryClassNames as $repositoryClassName) {
$repository = $this->objectManager->getObject($repositoryClassName);
$aggregateRootObjects->addAll($repository->getAddedObjects());
$deletedEntities->addAll($repository->getRemovedObjects());
}
$aggregateRootObjects->addAll($this->persistenceSession->getReconstitutedObjects());
// hand in only aggregate roots, leaving handling of subobjects to
// the underlying storage layer
$this->backend->setAggregateRootObjects($aggregateRootObjects);
$this->backend->setDeletedEntities($deletedEntities);
$this->backend->commit();
// this needs to unregister more than just those, as at least some of
// the subobjects are supposed to go away as well...
// OTOH those do no harm, changes to the unused ones should not happen,
// so all they do is eat some memory.
foreach ($deletedEntities as $deletedEntity) {
$this->persistenceSession->unregisterReconstitutedObject($deletedEntity);
}
}
/**
* @test
* @author Robert Lemke <*****@*****.**>
* @expectedException \F3\FLOW3\Object\Exception
*/
public function autoWiringThrowsExceptionForUnmatchedDependenciesOfRequiredSetterInjectedDependencies()
{
$this->mockObjectManager->expects($this->once())->method('getObject')->with('stdClass')->will($this->throwException(new \F3\FLOW3\Object\Exception()));
$objectName = 'F3\\FLOW3\\Tests\\Object\\Fixture\\ClassWithUnmatchedRequiredSetterDependency';
$setterParameters = array(array('position' => 0, 'byReference' => FALSE, 'array' => FALSE, 'optional' => FALSE, 'allowsNull' => FALSE, 'class' => 'stdClass'));
$this->mockReflectionService->expects($this->at(1))->method('getMethodParameters')->with($objectName, 'injectRequiredSetterArgument')->will($this->returnValue($setterParameters));
$objectConfiguration = new \F3\FLOW3\Object\Configuration\Configuration($objectName);
$this->objectBuilder->createObject($objectName, $objectConfiguration);
}
/**
* Ext Direct does not provide named arguments by now, so we have
* to map them by reflecting on the action parameters.
*
* @param RequestInterface $dispatchRequest
* @param Transaction $transaction
* @return array The mapped arguments
*/
protected function getArgumentsFromTransaction(\F3\FLOW3\MVC\RequestInterface $dispatchRequest, \F3\ExtJS\ExtDirect\Transaction $transaction)
{
if (!$transaction->getDirectRequest()->isFormPost()) {
$controllerClass = $dispatchRequest->getControllerObjectName();
$parameters = $this->reflectionService->getMethodParameters($controllerClass, $dispatchRequest->getControllerActionName() . 'Action');
return $transaction->mapDataToParameters($parameters);
} else {
// TODO Reuse setArgumentsFromRawRequestData from Web/RequestBuilder
}
}
/**
* 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);
}
/**
* Initializes the backend
*
* @param array $options
* @return void
* @author Karsten Dambekalns <*****@*****.**>
*/
public function initialize(array $options)
{
if (is_array($options) || $options instanceof ArrayAccess) {
foreach ($options as $key => $value) {
$methodName = 'set' . ucfirst($key);
if (method_exists($this, $methodName)) {
$this->{$methodName}($value);
} else {
throw new \InvalidArgumentException('Invalid backend option "' . $key . '" for backend of type "' . get_class($this) . '"', 1259701878);
}
}
}
$this->classSchemata = $this->reflectionService->getClassSchemata();
}
/**
* Check for implementations of F3\FLOW3\Resource\Streams\StreamWrapperInterface and
* register them.
*
* @return void
* @author Karsten Dambekalns <*****@*****.**>
*/
public function initialize()
{
\F3\FLOW3\Resource\Streams\StreamWrapperAdapter::setObjectFactory($this->objectFactory);
$streamWrapperClassNames = $this->reflectionService->getAllImplementationClassNamesForInterface('F3\\FLOW3\\Resource\\Streams\\StreamWrapperInterface');
foreach ($streamWrapperClassNames as $streamWrapperClassName) {
$scheme = $streamWrapperClassName::getScheme();
if (in_array($scheme, stream_get_wrappers())) {
stream_wrapper_unregister($scheme);
}
stream_wrapper_register($scheme, '\\F3\\FLOW3\\Resource\\Streams\\StreamWrapperAdapter');
\F3\FLOW3\Resource\Streams\StreamWrapperAdapter::registerStreamWrapper($scheme, $streamWrapperClassName);
}
// For now this URI is hardcoded, but might be manageable in the future
// if additional persistent resources storages are supported.
$this->persistentResourcesStorageBaseUri = FLOW3_PATH_DATA . 'Persistent/Resources/';
}
/**
* Register an object's clean state, e.g. after it has been reconstituted
* from the FLOW3 persistence layer
*
* The method takes an optional argument $propertyName to mark only the
* specified property as clean. This was used in conjunction with lazy
* loading...
*
* @param \F3\FLOW3\AOP\JoinPointInterface $joinPoint
* @return void
* @before F3\FLOW3\Persistence\Aspect\DirtyMonitoringAspect->needsDirtyCheckingAspect && method(.*->FLOW3_Persistence_memorizeCleanState())
* @author Karsten Dambekalns <*****@*****.**>
*/
public function memorizeCleanState(\F3\FLOW3\AOP\JoinPointInterface $joinPoint)
{
$proxy = $joinPoint->getProxy();
if ($joinPoint->getMethodArgument('propertyName') !== NULL) {
$propertyNames = array($joinPoint->getMethodArgument('propertyName'));
} else {
$propertyNames = array_keys($this->reflectionService->getClassSchema($joinPoint->getClassName())->getProperties());
}
foreach ($propertyNames as $propertyName) {
if (is_object($proxy->FLOW3_AOP_Proxy_getProperty($propertyName))) {
$proxy->FLOW3_Persistence_cleanProperties[$propertyName] = clone $proxy->FLOW3_AOP_Proxy_getProperty($propertyName);
} else {
$proxy->FLOW3_Persistence_cleanProperties[$propertyName] = $proxy->FLOW3_AOP_Proxy_getProperty($propertyName);
}
}
}
/**
* Maps a single record into the object it represents and registers it as
* reconstituted with the session.
*
* @param array $objectData
* @return object
* @author Karsten Dambekalns <*****@*****.**>
*/
public function mapToObject(array $objectData)
{
if ($this->persistenceSession->hasIdentifier($objectData['identifier'])) {
return $this->persistenceSession->getObjectByIdentifier($objectData['identifier']);
} else {
$className = $objectData['classname'];
$classSchema = $this->reflectionService->getClassSchema($className);
$objectConfiguration = $this->objectManager->getObjectConfiguration($className);
$object = $this->objectBuilder->createEmptyObject($className, $objectConfiguration);
$this->persistenceSession->registerObject($object, $objectData['identifier']);
$this->objectBuilder->reinjectDependencies($object, $objectConfiguration);
$this->thawProperties($object, $objectData['identifier'], $objectData, $classSchema);
$object->FLOW3_Persistence_memorizeCleanState();
$this->persistenceSession->registerReconstitutedObject($object);
return $object;
}
}
/**
* Adds the needed valiators to the Arguments:
* - Validators checking the data type from the @param annotation
* - Custom validators specified with @validate.
*
* In case @dontvalidate is NOT set for an argument, the following two
* validators are also added:
* - Model-based validators (@validate annotations in the model)
* - Custom model validator classes
*
* @return void
* @author Sebastian Kurfürst <*****@*****.**>
*/
protected function initializeActionMethodValidators()
{
$parameterValidators = $this->validatorResolver->buildMethodArgumentsValidatorConjunctions(get_class($this), $this->actionMethodName);
$dontValidateAnnotations = array();
$methodTagsValues = $this->reflectionService->getMethodTagsValues(get_class($this), $this->actionMethodName);
if (isset($methodTagsValues['dontvalidate'])) {
$dontValidateAnnotations = $methodTagsValues['dontvalidate'];
}
foreach ($this->arguments as $argument) {
$validator = $parameterValidators[$argument->getName()];
if (array_search('$' . $argument->getName(), $dontValidateAnnotations) === FALSE) {
$baseValidatorConjunction = $this->validatorResolver->getBaseValidatorConjunction($argument->getDataType());
if ($baseValidatorConjunction !== NULL) {
$validator->addValidator($baseValidatorConjunction);
}
}
$argument->setValidator($validator);
}
}
/**
* Runs the the FLOW3 Framework by resolving an appropriate Request Handler and passing control to it.
* If the Framework is not initialized yet, it will be initialized.
*
* @return void
* @author Robert Lemke <*****@*****.**>
* @api
*/
public function run()
{
if (!$this->siteLocked) {
$requestHandlerResolver = $this->objectManager->getObject('F3\\FLOW3\\MVC\\RequestHandlerResolver');
$requestHandler = $requestHandlerResolver->resolveRequestHandler();
$requestHandler->handleRequest();
if ($this->settings['persistence']['enable'] === TRUE) {
$this->objectManager->getObject('F3\\FLOW3\\Persistence\\PersistenceManagerInterface')->persistAll();
}
$this->emitFinishedNormalRun();
$this->systemLogger->log('Shutting down ...', LOG_INFO);
$this->configurationManager->shutdown();
$this->objectManager->shutdown();
$this->reflectionService->shutdown();
$this->objectManager->getObject('F3\\FLOW3\\Object\\SessionRegistry')->writeDataToSession();
$this->objectManager->getObject('F3\\FLOW3\\Session\\SessionInterface')->close();
} else {
header('HTTP/1.1 503 Service Temporarily Unavailable');
readfile('package://FLOW3/Private/Core/LockHoldingStackPage.html');
$this->systemLogger->log('Site is locked, exiting.', LOG_NOTICE);
}
}
/**
* Traverses through all active packages and registers their classes as
* objects at the object manager. Finally the object configuration
* defined by the package is loaded and applied to the registered objects.
*
* @param array $packages The packages whose classes should be registered
* @return void
* @author Robert Lemke <*****@*****.**>
*/
protected function registerAndConfigureAllPackageObjects(array $packages)
{
$objectTypes = array();
$availableClassNames = array();
foreach ($packages as $packageKey => $package) {
foreach (array_keys($package->getClassFiles()) as $className) {
if (!$this->classNameIsBlacklisted($className)) {
$availableClassNames[] = $className;
}
}
}
foreach ($availableClassNames as $className) {
if (substr($className, -9, 9) === 'Interface') {
$objectTypes[] = $className;
if (!isset($this->registeredObjects[$className])) {
$this->registerObjectType($className);
}
} else {
if (!isset($this->registeredObjects[$className])) {
if (!$this->reflectionService->isClassAbstract($className)) {
$this->registerObject($className, $className);
}
}
}
}
foreach (array_keys($packages) as $packageKey) {
$rawObjectConfigurations = $this->configurationManager->getConfiguration(\F3\FLOW3\Configuration\ConfigurationManager::CONFIGURATION_TYPE_OBJECTS, $packageKey);
foreach ($rawObjectConfigurations as $objectName => $rawObjectConfiguration) {
$objectName = str_replace('_', '\\', $objectName);
if (!isset($this->registeredObjects[$objectName])) {
throw new \F3\FLOW3\Object\Exception\InvalidObjectConfigurationException('Tried to configure unknown object "' . $objectName . '" in package "' . $packageKey . '".', 1184926175);
}
if (is_array($rawObjectConfiguration)) {
$existingObjectConfiguration = isset($this->objectConfigurations[$objectName]) ? $this->objectConfigurations[$objectName] : NULL;
$this->objectConfigurations[$objectName] = \F3\FLOW3\Object\Configuration\ConfigurationBuilder::buildFromConfigurationArray($objectName, $rawObjectConfiguration, 'Package ' . $packageKey, $existingObjectConfiguration);
}
}
}
}
/**
* Builds a base validator conjunction for the given data type.
*
* The base validation rules are those which were declared directly in a class (typically
* a model) through some @validate annotations on properties.
*
* Additionally, if a custom validator was defined for the class in question, it will be added
* to the end of the conjunction. A custom validator is found if it follows the naming convention
* "Replace '\Model\' by '\Validator\' and append "Validator".
*
* Example: $dataType is F3\Foo\Domain\Model\Quux, then the Validator will be found if it has the
* name F3\Foo\Domain\Validator\QuuxValidator
*
* @param string $dataType The data type to build the validation conjunction for. Needs to be the fully qualified object name.
* @return F3\FLOW3\Validation\Validator\ConjunctionValidator The validator conjunction or NULL
* @author Robert Lemke <*****@*****.**>
* @author Sebastian Kurfürst <*****@*****.**>
*/
protected function buildBaseValidatorConjunction($dataType)
{
$validatorConjunction = $this->objectManager->getObject('F3\\FLOW3\\Validation\\Validator\\ConjunctionValidator');
// Model based validator
if (class_exists($dataType)) {
$validatorCount = 0;
$objectValidator = $this->createValidator('F3\\FLOW3\\Validation\\Validator\\GenericObjectValidator');
foreach ($this->reflectionService->getClassPropertyNames($dataType) as $classPropertyName) {
$classPropertyTagsValues = $this->reflectionService->getPropertyTagsValues($dataType, $classPropertyName);
if (!isset($classPropertyTagsValues['validate'])) {
continue;
}
foreach ($classPropertyTagsValues['validate'] as $validateValue) {
$parsedAnnotation = $this->parseValidatorAnnotation($validateValue);
foreach ($parsedAnnotation['validators'] as $validatorConfiguration) {
$newValidator = $this->createValidator($validatorConfiguration['validatorName'], $validatorConfiguration['validatorOptions']);
if ($newValidator === NULL) {
throw new \F3\FLOW3\Validation\Exception\NoSuchValidatorException('Invalid validate annotation in ' . $dataType . '::' . $classPropertyName . ': Could not resolve class name for validator "' . $validatorConfiguration['validatorName'] . '".', 1241098027);
}
$objectValidator->addPropertyValidator($classPropertyName, $newValidator);
$validatorCount++;
}
}
}
if ($validatorCount > 0) {
$validatorConjunction->addValidator($objectValidator);
}
}
// Custom validator for the class
$possibleValidatorClassName = str_replace('\\Model\\', '\\Validator\\', $dataType) . 'Validator';
$customValidator = $this->createValidator($possibleValidatorClassName);
if ($customValidator !== NULL) {
$validatorConjunction->addValidator($customValidator);
}
return $validatorConjunction;
}
/**
* Creates and returns an aspect from the annotations found in a class which
* is tagged as an aspect. The object acting as an advice will already be
* fetched (and therefore instantiated if neccessary).
*
* @param string $aspectClassName Name of the class which forms the aspect, contains advices etc.
* @return mixed The aspect container containing one or more advisors or FALSE if no container could be built
* @author Robert Lemke <*****@*****.**>
*/
protected function buildAspectContainer($aspectClassName)
{
if (!$this->reflectionService->isClassReflected($aspectClassName)) {
return FALSE;
}
if (!$this->reflectionService->isClassTaggedWith($aspectClassName, 'aspect')) {
return FALSE;
}
$aspectContainer = new \F3\FLOW3\AOP\AspectContainer($aspectClassName);
foreach ($this->reflectionService->getClassMethodNames($aspectClassName) as $methodName) {
foreach ($this->reflectionService->getMethodTagsValues($aspectClassName, $methodName) as $tagName => $tagValues) {
foreach ($tagValues as $tagValue) {
switch ($tagName) {
case 'around':
$pointcutFilterComposite = $this->pointcutExpressionParser->parse($tagValue);
$advice = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advice\\AroundAdvice', $aspectClassName, $methodName);
$pointcut = $this->objectFactory->create('F3\\FLOW3\\AOP\\Pointcut\\Pointcut', $tagValue, $pointcutFilterComposite, $aspectClassName);
$advisor = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advisor', $advice, $pointcut);
$aspectContainer->addAdvisor($advisor);
break;
case 'before':
$pointcutFilterComposite = $this->pointcutExpressionParser->parse($tagValue);
$advice = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advice\\BeforeAdvice', $aspectClassName, $methodName);
$pointcut = $this->objectFactory->create('F3\\FLOW3\\AOP\\Pointcut\\Pointcut', $tagValue, $pointcutFilterComposite, $aspectClassName);
$advisor = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advisor', $advice, $pointcut);
$aspectContainer->addAdvisor($advisor);
break;
case 'afterreturning':
$pointcutFilterComposite = $this->pointcutExpressionParser->parse($tagValue);
$advice = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advice\\AfterReturningAdvice', $aspectClassName, $methodName);
$pointcut = $this->objectFactory->create('F3\\FLOW3\\AOP\\Pointcut\\Pointcut', $tagValue, $pointcutFilterComposite, $aspectClassName);
$advisor = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advisor', $advice, $pointcut);
$aspectContainer->addAdvisor($advisor);
break;
case 'afterthrowing':
$pointcutFilterComposite = $this->pointcutExpressionParser->parse($tagValue);
$advice = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advice\\AfterThrowingAdvice', $aspectClassName, $methodName);
$pointcut = $this->objectFactory->create('F3\\FLOW3\\AOP\\Pointcut\\Pointcut', $tagValue, $pointcutFilterComposite, $aspectClassName);
$advisor = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advisor', $advice, $pointcut);
$aspectContainer->addAdvisor($advisor);
break;
case 'after':
$pointcutFilterComposite = $this->pointcutExpressionParser->parse($tagValue);
$advice = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advice\\AfterAdvice', $aspectClassName, $methodName);
$pointcut = $this->objectFactory->create('F3\\FLOW3\\AOP\\Pointcut\\Pointcut', $tagValue, $pointcutFilterComposite, $aspectClassName);
$advisor = $this->objectFactory->create('F3\\FLOW3\\AOP\\Advisor', $advice, $pointcut);
$aspectContainer->addAdvisor($advisor);
break;
case 'pointcut':
$pointcutFilterComposite = $this->pointcutExpressionParser->parse($tagValue);
$pointcut = $this->objectFactory->create('F3\\FLOW3\\AOP\\Pointcut\\Pointcut', $tagValue, $pointcutFilterComposite, $aspectClassName, $methodName);
$aspectContainer->addPointcut($pointcut);
break;
}
}
}
}
foreach ($this->reflectionService->getClassPropertyNames($aspectClassName) as $propertyName) {
foreach ($this->reflectionService->getPropertyTagsValues($aspectClassName, $propertyName) as $tagName => $tagValues) {
foreach ($tagValues as $tagValue) {
switch ($tagName) {
case 'introduce':
$splittedTagValue = explode(',', $tagValue);
if (!is_array($splittedTagValue) || count($splittedTagValue) != 2) {
throw new \F3\FLOW3\AOP\Exception('The introduction in class "' . $aspectClassName . '" does not contain the two required parameters.', 1172694761);
}
$pointcutExpression = trim($splittedTagValue[1]);
$pointcutFilterComposite = $this->pointcutExpressionParser->parse($pointcutExpression);
$pointcut = $this->objectFactory->create('F3\\FLOW3\\AOP\\Pointcut\\Pointcut', $pointcutExpression, $pointcutFilterComposite, $aspectClassName);
$interfaceName = trim($splittedTagValue[0]);
$introduction = $this->objectFactory->create('F3\\FLOW3\\AOP\\Introduction', $aspectClassName, $interfaceName, $pointcut);
$aspectContainer->addIntroduction($introduction);
break;
}
}
}
}
if (count($aspectContainer->getAdvisors()) < 1 && count($aspectContainer->getPointcuts()) < 1 && count($aspectContainer->getIntroductions()) < 1) {
throw new \F3\FLOW3\AOP\Exception('The class "' . $aspectClassName . '" is tagged to be an aspect but doesn\'t contain advices nor pointcut or introduction declarations.', 1169124534);
}
return $aspectContainer;
}
/**
* Initializes this object
*
* @return void
* @author Robert Lemke <*****@*****.**>
*/
public function initializeObject()
{
$this->dataTypeClassSchema = $this->reflectionService->getClassSchema($this->dataType);
}
