/**
* Synchronize designs from Flow declarations to CouchDB documents
*
* @return void
* @author Christopher Hlubek <*****@*****.**>
*/
public function synchronizeCommand()
{
$designDocumentClassNames = $this->reflectionService->getAllSubClassNamesForClass('TYPO3\\CouchDB\\DesignDocument');
foreach ($designDocumentClassNames as $objectName) {
if ($this->objectManager->getScope($objectName) === \TYPO3\Flow\Object\Configuration\Configuration::SCOPE_SINGLETON) {
$designDocument = $this->objectManager->get($objectName);
$designDocument->synchronize();
$this->outputLine($objectName . ' synchronized.');
} else {
$this->outputLine($objectName . ' skipped.');
}
}
}
/**
* Get all class names inside this namespace and return them as array.
*
* @param string $namespace
* @return array Array of all class names inside a given namespace.
*/
protected function getClassNamesInNamespace($namespace)
{
$affectedViewHelperClassNames = array();
$allViewHelperClassNames = $this->reflectionService->getAllSubClassNamesForClass('TYPO3\\Fluid\\Core\\ViewHelper\\AbstractViewHelper');
foreach ($allViewHelperClassNames as $viewHelperClassName) {
if ($this->reflectionService->isClassAbstract($viewHelperClassName)) {
continue;
}
if (strncmp($namespace, $viewHelperClassName, strlen($namespace)) === 0) {
$affectedViewHelperClassNames[] = $viewHelperClassName;
}
}
sort($affectedViewHelperClassNames);
return $affectedViewHelperClassNames;
}
/**
* Makes sure that any sub classes of an adviced class also build the advices array on construction.
*
* @param string $className The adviced class name
* @param ClassNameIndex $targetClassNameCandidates target class names for advices
* @param ClassNameIndex $treatedSubClasses Already treated (sub) classes to avoid duplication
* @return ClassNameIndex The new collection of already treated classes
*/
protected function proxySubClassesOfClassToEnsureAdvices($className, ClassNameIndex $targetClassNameCandidates, ClassNameIndex $treatedSubClasses)
{
if ($this->reflectionService->isClassReflected($className) === false) {
return $treatedSubClasses;
}
if (trait_exists($className)) {
return $treatedSubClasses;
}
if (interface_exists($className)) {
return $treatedSubClasses;
}
$subClassNames = $this->reflectionService->getAllSubClassNamesForClass($className);
foreach ($subClassNames as $subClassName) {
if ($treatedSubClasses->hasClassName($subClassName)) {
continue;
}
if ($this->reflectionService->isClassReflected($subClassName) === false || $targetClassNameCandidates->hasClassName($subClassName)) {
continue;
}
$proxyClass = $this->compiler->getProxyClass($subClassName);
if ($proxyClass === false) {
continue;
}
$callBuildMethodsAndAdvicesArrayCode = " if (method_exists(get_parent_class(), 'Flow_Aop_Proxy_buildMethodsAndAdvicesArray') && is_callable('parent::Flow_Aop_Proxy_buildMethodsAndAdvicesArray')) parent::Flow_Aop_Proxy_buildMethodsAndAdvicesArray();\n";
$proxyClass->getConstructor()->addPreParentCallCode($callBuildMethodsAndAdvicesArrayCode);
$proxyClass->getMethod('__wakeup')->addPreParentCallCode($callBuildMethodsAndAdvicesArrayCode);
}
$treatedSubClasses = $treatedSubClasses->union(new ClassNameIndex($subClassNames));
return $treatedSubClasses;
}
/**
* Lists all public controller actions not covered by the active security policy
*
* @return void
*/
public function showUnprotectedActionsCommand()
{
$controllerClassNames = $this->reflectionService->getAllSubClassNamesForClass('TYPO3\\Flow\\Mvc\\Controller\\AbstractController');
$allActionsAreProtected = TRUE;
foreach ($controllerClassNames as $controllerClassName) {
if ($this->reflectionService->isClassAbstract($controllerClassName)) {
continue;
}
$methodNames = get_class_methods($controllerClassName);
$foundUnprotectedAction = FALSE;
foreach ($methodNames as $methodName) {
if (preg_match('/.*Action$/', $methodName) === 0 || $this->reflectionService->isMethodPublic($controllerClassName, $methodName) === FALSE) {
continue;
}
if ($this->policyService->hasPolicyEntryForMethod($controllerClassName, $methodName) === FALSE) {
if ($foundUnprotectedAction === FALSE) {
$this->outputLine(PHP_EOL . '<b>' . $controllerClassName . '</b>');
$foundUnprotectedAction = TRUE;
$allActionsAreProtected = FALSE;
}
$this->outputLine(' ' . $methodName);
}
}
}
if ($allActionsAreProtected === TRUE) {
$this->outputLine('All public controller actions are covered by your security policy. Good job!');
}
}
/**
* @return void
*/
public function initializeObject()
{
$this->imageVariantClassNames = $this->reflectionService->getAllSubClassNamesForClass('TYPO3\\Media\\Domain\\Model\\ImageVariant');
array_unshift($this->imageVariantClassNames, 'TYPO3\\Media\\Domain\\Model\\ImageVariant');
$this->assetClassNames = $this->reflectionService->getAllImplementationClassNamesForInterface('TYPO3\\Media\\Domain\\Model\\AssetInterface');
$this->dateTimeClassNames = $this->reflectionService->getAllSubClassNamesForClass('DateTime');
array_unshift($this->dateTimeClassNames, 'DateTime');
}
/**
* @return void
*/
public function initializeObject()
{
$this->imageVariantClassNames = $this->reflectionService->getAllSubClassNamesForClass(ImageVariant::class);
array_unshift($this->imageVariantClassNames, ImageVariant::class);
$this->assetClassNames = $this->reflectionService->getAllImplementationClassNamesForInterface(AssetInterface::class);
$this->dateTimeClassNames = $this->reflectionService->getAllSubClassNamesForClass('DateTime');
array_unshift($this->dateTimeClassNames, 'DateTime');
}
/**
* Returns an array of all commands
*
* @return array<Command>
* @api
*/
public function getAvailableCommands()
{
if ($this->availableCommands === NULL) {
$this->availableCommands = array();
$commandControllerClassNames = $this->reflectionService->getAllSubClassNamesForClass('TYPO3\\Flow\\Cli\\CommandController');
foreach ($commandControllerClassNames as $className) {
if (!class_exists($className)) {
continue;
}
foreach (get_class_methods($className) as $methodName) {
if (substr($methodName, -7, 7) === 'Command') {
$this->availableCommands[] = new Command($className, substr($methodName, 0, -7));
}
}
}
}
return $this->availableCommands;
}
/**
* @return string
*/
protected function buildClassnameConstraints()
{
$constraints = array('doc.classname=="' . addslashes($this->type) . '"');
$subClassNames = $this->reflectionService->getAllSubClassNamesForClass($this->type);
foreach ($subClassNames as $subClassName) {
if (strpos($subClassName, 'AOPProxy') !== FALSE) {
continue;
}
$constraints[] = 'doc.classname=="' . addslashes($subClassName) . '"';
}
return implode('||', $constraints);
}
/**
* This method is used to optimize the matching process.
*
* @param \TYPO3\Flow\Aop\Builder\ClassNameIndex $classNameIndex
* @return \TYPO3\Flow\Aop\Builder\ClassNameIndex
*/
public function reduceTargetClassNames(\TYPO3\Flow\Aop\Builder\ClassNameIndex $classNameIndex)
{
if (interface_exists($this->interfaceOrClassName)) {
$classNames = $this->reflectionService->getAllImplementationClassNamesForInterface($this->interfaceOrClassName);
} elseif (class_exists($this->interfaceOrClassName)) {
$classNames = $this->reflectionService->getAllSubClassNamesForClass($this->interfaceOrClassName);
$classNames[] = $this->interfaceOrClassName;
} else {
$classNames = array();
}
$filteredIndex = new \TYPO3\Flow\Aop\Builder\ClassNameIndex();
$filteredIndex->setClassNames($classNames);
return $classNameIndex->intersect($filteredIndex);
}
/**
* Makes sure that any sub classes of an adviced class also build the advices array on construction.
*
* @param string $className The adviced class name
* @param ClassNameIndex $targetClassNameCandidates target class names for advices
* @param ClassNameIndex $treatedSubClasses Already treated (sub) classes to avoid duplication
* @return ClassNameIndex The new collection of already treated classes
*/
protected function proxySubClassesOfClassToEnsureAdvices($className, ClassNameIndex $targetClassNameCandidates, ClassNameIndex $treatedSubClasses)
{
if ($this->reflectionService->isClassReflected($className) === false) {
return $treatedSubClasses;
}
if (trait_exists($className)) {
return $treatedSubClasses;
}
if (interface_exists($className)) {
return $treatedSubClasses;
}
$subClassNames = $this->reflectionService->getAllSubClassNamesForClass($className);
foreach ($subClassNames as $subClassName) {
if ($targetClassNameCandidates->hasClassName($subClassName)) {
continue;
}
$treatedSubClasses = $this->addBuildMethodsAndAdvicesCodeToClass($subClassName, $treatedSubClasses);
}
return $treatedSubClasses;
}
/**
* @param array $classesSelector
* @return array
*/
protected function getAffectedClassNames(array $classesSelector)
{
if (isset($classesSelector['parentClassName'])) {
$affectedClassNames = $this->reflectionService->getAllSubClassNamesForClass($classesSelector['parentClassName']);
} elseif (isset($classesSelector['interface'])) {
$affectedClassNames = $this->reflectionService->getAllImplementationClassNamesForInterface($classesSelector['interface']);
} elseif (isset($classesSelector['classesContainingMethodsAnnotatedWith'])) {
$affectedClassNames = $this->reflectionService->getClassesContainingMethodsAnnotatedWith($classesSelector['classesContainingMethodsAnnotatedWith']);
} else {
$affectedClassNames = $this->reflectionService->getAllClassNames();
}
foreach ($affectedClassNames as $index => $className) {
if ($this->reflectionService->isClassAbstract($className) && (!isset($classesSelector['includeAbstractClasses']) || $classesSelector['includeAbstractClasses'] === FALSE)) {
unset($affectedClassNames[$index]);
} elseif (isset($classesSelector['classNamePattern']) && preg_match($classesSelector['classNamePattern'], $className) === 0) {
unset($affectedClassNames[$index]);
}
}
return $affectedClassNames;
}
/**
* Lists all public controller actions not covered by the active security policy
*
* @return void
*/
public function showUnprotectedActionsCommand()
{
$methodPrivileges = array();
foreach ($this->policyService->getRoles(true) as $role) {
$methodPrivileges = array_merge($methodPrivileges, $role->getPrivilegesByType(\TYPO3\Flow\Security\Authorization\Privilege\Method\MethodPrivilegeInterface::class));
}
$controllerClassNames = $this->reflectionService->getAllSubClassNamesForClass(\TYPO3\Flow\Mvc\Controller\AbstractController::class);
$allActionsAreProtected = true;
foreach ($controllerClassNames as $controllerClassName) {
if ($this->reflectionService->isClassAbstract($controllerClassName)) {
continue;
}
$methodNames = get_class_methods($controllerClassName);
$foundUnprotectedAction = false;
foreach ($methodNames as $methodName) {
if (preg_match('/.*Action$/', $methodName) === 0 || $this->reflectionService->isMethodPublic($controllerClassName, $methodName) === false) {
continue;
}
/** @var MethodPrivilegeInterface $methodPrivilege */
foreach ($methodPrivileges as $methodPrivilege) {
if ($methodPrivilege->matchesMethod($controllerClassName, $methodName)) {
continue 2;
}
}
if ($foundUnprotectedAction === false) {
$this->outputLine(PHP_EOL . '<b>' . $controllerClassName . '</b>');
$foundUnprotectedAction = true;
$allActionsAreProtected = false;
}
$this->outputLine(' ' . $methodName);
}
}
if ($allActionsAreProtected === true) {
$this->outputLine('All public controller actions are covered by your security policy. Good job!');
}
}
/**
* Loads the metadata for the specified class into the provided container.
*
* @param string $className
* @param ClassMetadata $metadata
* @return void
* @throws MappingException
* @throws \UnexpectedValueException
* @todo adjust when Doctrine 2.5 is used, see http://www.doctrine-project.org/jira/browse/DDC-93
*/
public function loadMetadataForClass($className, ClassMetadata $metadata)
{
/**
* This is the actual type we have at this point, but we cannot change the
* signature due to inheritance.
*
* @var OrmClassMetadata $metadata
*/
$class = $metadata->getReflectionClass();
$classSchema = $this->getClassSchema($class->getName());
$classAnnotations = $this->reader->getClassAnnotations($class);
// Evaluate Entity annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\MappedSuperclass'])) {
$mappedSuperclassAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\MappedSuperclass'];
if ($mappedSuperclassAnnotation->repositoryClass !== null) {
$metadata->setCustomRepositoryClass($mappedSuperclassAnnotation->repositoryClass);
}
$metadata->isMappedSuperclass = true;
} elseif (isset($classAnnotations[\TYPO3\Flow\Annotations\Entity::class]) || isset($classAnnotations['Doctrine\\ORM\\Mapping\\Entity'])) {
$entityAnnotation = isset($classAnnotations[\TYPO3\Flow\Annotations\Entity::class]) ? $classAnnotations[\TYPO3\Flow\Annotations\Entity::class] : $classAnnotations['Doctrine\\ORM\\Mapping\\Entity'];
if ($entityAnnotation->repositoryClass !== null) {
$metadata->setCustomRepositoryClass($entityAnnotation->repositoryClass);
} elseif ($classSchema->getRepositoryClassName() !== null) {
if ($this->reflectionService->isClassImplementationOf($classSchema->getRepositoryClassName(), 'Doctrine\\ORM\\EntityRepository')) {
$metadata->setCustomRepositoryClass($classSchema->getRepositoryClassName());
}
}
if ($entityAnnotation->readOnly) {
$metadata->markReadOnly();
}
} elseif ($classSchema->getModelType() === ClassSchema::MODELTYPE_VALUEOBJECT) {
// also ok... but we make it read-only
$metadata->markReadOnly();
} else {
throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
}
// Evaluate Table annotation
$primaryTable = array();
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\Table'])) {
$tableAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\Table'];
$primaryTable = array('name' => $tableAnnotation->name, 'schema' => $tableAnnotation->schema);
if ($tableAnnotation->indexes !== null) {
foreach ($tableAnnotation->indexes as $indexAnnotation) {
$index = array('columns' => $indexAnnotation->columns);
if (!empty($indexAnnotation->name)) {
$primaryTable['indexes'][$indexAnnotation->name] = $index;
} else {
$primaryTable['indexes'][] = $index;
}
}
}
if ($tableAnnotation->uniqueConstraints !== null) {
foreach ($tableAnnotation->uniqueConstraints as $uniqueConstraint) {
$uniqueConstraint = array('columns' => $uniqueConstraint->columns);
if (!empty($uniqueConstraint->name)) {
$primaryTable['uniqueConstraints'][$uniqueConstraint->name] = $uniqueConstraint;
} else {
$primaryTable['uniqueConstraints'][] = $uniqueConstraint;
}
}
}
if ($tableAnnotation->options !== null) {
$primaryTable['options'] = $tableAnnotation->options;
}
}
if (!isset($primaryTable['name'])) {
$className = $classSchema->getClassName();
$primaryTable['name'] = $this->inferTableNameFromClassName($className);
}
// Evaluate NamedNativeQueries annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\NamedNativeQueries'])) {
$namedNativeQueriesAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\NamedNativeQueries'];
foreach ($namedNativeQueriesAnnotation->value as $namedNativeQuery) {
$metadata->addNamedNativeQuery(array('name' => $namedNativeQuery->name, 'query' => $namedNativeQuery->query, 'resultClass' => $namedNativeQuery->resultClass, 'resultSetMapping' => $namedNativeQuery->resultSetMapping));
}
}
// Evaluate SqlResultSetMappings annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\SqlResultSetMappings'])) {
$sqlResultSetMappingsAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\SqlResultSetMappings'];
foreach ($sqlResultSetMappingsAnnotation->value as $resultSetMapping) {
$entities = array();
$columns = array();
foreach ($resultSetMapping->entities as $entityResultAnnotation) {
$entityResult = array('fields' => array(), 'entityClass' => $entityResultAnnotation->entityClass, 'discriminatorColumn' => $entityResultAnnotation->discriminatorColumn);
foreach ($entityResultAnnotation->fields as $fieldResultAnnotation) {
$entityResult['fields'][] = array('name' => $fieldResultAnnotation->name, 'column' => $fieldResultAnnotation->column);
}
$entities[] = $entityResult;
}
foreach ($resultSetMapping->columns as $columnResultAnnotation) {
$columns[] = array('name' => $columnResultAnnotation->name);
}
$metadata->addSqlResultSetMapping(array('name' => $resultSetMapping->name, 'entities' => $entities, 'columns' => $columns));
}
}
// Evaluate NamedQueries annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\NamedQueries'])) {
$namedQueriesAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\NamedQueries'];
if (!is_array($namedQueriesAnnotation->value)) {
throw new \UnexpectedValueException('@NamedQueries should contain an array of @NamedQuery annotations.');
}
foreach ($namedQueriesAnnotation->value as $namedQuery) {
if (!$namedQuery instanceof NamedQuery) {
throw new \UnexpectedValueException('@NamedQueries should contain an array of @NamedQuery annotations.');
}
$metadata->addNamedQuery(array('name' => $namedQuery->name, 'query' => $namedQuery->query));
}
}
// Evaluate InheritanceType annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\InheritanceType'])) {
$inheritanceTypeAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\InheritanceType'];
$inheritanceType = constant('Doctrine\\ORM\\Mapping\\ClassMetadata::INHERITANCE_TYPE_' . strtoupper($inheritanceTypeAnnotation->value));
if ($inheritanceType !== OrmClassMetadata::INHERITANCE_TYPE_NONE) {
// Evaluate DiscriminatorColumn annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\DiscriminatorColumn'])) {
$discriminatorColumnAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\DiscriminatorColumn'];
$discriminatorColumn = array('name' => $discriminatorColumnAnnotation->name, 'type' => $discriminatorColumnAnnotation->type, 'length' => $discriminatorColumnAnnotation->length, 'columnDefinition' => $discriminatorColumnAnnotation->columnDefinition);
} else {
$discriminatorColumn = array('name' => 'dtype', 'type' => 'string', 'length' => 255);
}
// Evaluate DiscriminatorMap annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\DiscriminatorMap'])) {
$discriminatorMapAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\DiscriminatorMap'];
$discriminatorMap = $discriminatorMapAnnotation->value;
} else {
$discriminatorMap = array();
$subclassNames = $this->reflectionService->getAllSubClassNamesForClass($className);
if (!$this->reflectionService->isClassAbstract($className)) {
$mappedClassName = strtolower(str_replace('Domain_Model_', '', str_replace('\\', '_', $className)));
$discriminatorMap[$mappedClassName] = $className;
}
foreach ($subclassNames as $subclassName) {
$mappedSubclassName = strtolower(str_replace('Domain_Model_', '', str_replace('\\', '_', $subclassName)));
$discriminatorMap[$mappedSubclassName] = $subclassName;
}
}
if ($discriminatorMap !== array()) {
$metadata->setDiscriminatorColumn($discriminatorColumn);
$metadata->setDiscriminatorMap($discriminatorMap);
} else {
$inheritanceType = OrmClassMetadata::INHERITANCE_TYPE_NONE;
}
}
$metadata->setInheritanceType($inheritanceType);
}
// Evaluate DoctrineChangeTrackingPolicy annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\ChangeTrackingPolicy'])) {
$changeTrackingAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\ChangeTrackingPolicy'];
$metadata->setChangeTrackingPolicy(constant('Doctrine\\ORM\\Mapping\\ClassMetadata::CHANGETRACKING_' . strtoupper($changeTrackingAnnotation->value)));
} else {
$metadata->setChangeTrackingPolicy(OrmClassMetadata::CHANGETRACKING_DEFERRED_EXPLICIT);
}
// Evaluate annotations on properties/fields
try {
$this->evaluatePropertyAnnotations($metadata);
} catch (MappingException $exception) {
throw new MappingException(sprintf('Failure while evaluating property annotations for class "%s": %s', $metadata->getName(), $exception->getMessage()), 1382003497, $exception);
}
// build unique index for table
if (!isset($primaryTable['uniqueConstraints'])) {
$idProperties = array_keys($classSchema->getIdentityProperties());
if (array_diff($idProperties, $metadata->getIdentifierFieldNames()) !== array()) {
$uniqueIndexName = $this->truncateIdentifier('flow_identity_' . $primaryTable['name']);
foreach ($idProperties as $idProperty) {
$primaryTable['uniqueConstraints'][$uniqueIndexName]['columns'][] = isset($metadata->columnNames[$idProperty]) ? $metadata->columnNames[$idProperty] : strtolower($idProperty);
}
}
}
$metadata->setPrimaryTable($primaryTable);
// Evaluate AssociationOverrides annotation
$this->evaluateOverridesAnnotations($classAnnotations, $metadata);
// Evaluate EntityListeners annotation
$this->evaluateEntityListenersAnnotation($class, $metadata, $classAnnotations);
// Evaluate @HasLifecycleCallbacks annotation
$this->evaluateLifeCycleAnnotations($class, $metadata);
}