Tells if the specified class is abstract or not
| public isClassAbstract ( string $className ) : boolean | ||
| $className | string | Name of the class to analyze |
| return | boolean | TRUE if the class is abstract, otherwise FALSE |
/**
* 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(\Neos\FluidAdaptor\Core\ViewHelper\AbstractViewHelper::class);
foreach ($allViewHelperClassNames as $viewHelperClassName) {
if ($this->reflectionService->isClassAbstract($viewHelperClassName)) {
continue;
}
if (strncmp($namespace, $viewHelperClassName, strlen($namespace)) === 0) {
$affectedViewHelperClassNames[] = $viewHelperClassName;
}
}
sort($affectedViewHelperClassNames);
return $affectedViewHelperClassNames;
}
/**
* Analyzes the Object Configuration provided by the compiler and builds the necessary PHP code for the proxy classes
* to realize dependency injection.
*
* @return void
*/
public function build()
{
$this->objectConfigurations = $this->objectManager->getObjectConfigurations();
foreach ($this->objectConfigurations as $objectName => $objectConfiguration) {
$className = $objectConfiguration->getClassName();
if ($className === '' || $this->compiler->hasCacheEntryForClass($className) === true) {
continue;
}
if ($objectName !== $className || $this->reflectionService->isClassAbstract($className)) {
continue;
}
$proxyClass = $this->compiler->getProxyClass($className);
if ($proxyClass === false) {
continue;
}
$this->systemLogger->log('Building DI proxy for "' . $className . '".', LOG_DEBUG);
$constructorPreCode = '';
$constructorPostCode = '';
$constructorPreCode .= $this->buildSetInstanceCode($objectConfiguration);
$constructorPreCode .= $this->buildConstructorInjectionCode($objectConfiguration);
$setRelatedEntitiesCode = '';
if (!$this->reflectionService->hasMethod($className, '__sleep')) {
$proxyClass->addTraits(['\\' . ObjectSerializationTrait::class]);
$sleepMethod = $proxyClass->getMethod('__sleep');
$sleepMethod->addPostParentCallCode($this->buildSerializeRelatedEntitiesCode($objectConfiguration));
$setRelatedEntitiesCode = "\n " . '$this->Flow_setRelatedEntities();' . "\n";
}
$wakeupMethod = $proxyClass->getMethod('__wakeup');
$wakeupMethod->addPreParentCallCode($this->buildSetInstanceCode($objectConfiguration));
$wakeupMethod->addPreParentCallCode($setRelatedEntitiesCode);
$wakeupMethod->addPostParentCallCode($this->buildLifecycleInitializationCode($objectConfiguration, ObjectManagerInterface::INITIALIZATIONCAUSE_RECREATED));
$wakeupMethod->addPostParentCallCode($this->buildLifecycleShutdownCode($objectConfiguration));
$injectPropertiesCode = $this->buildPropertyInjectionCode($objectConfiguration);
if ($injectPropertiesCode !== '') {
$proxyClass->addTraits(['\\' . PropertyInjectionTrait::class]);
$proxyClass->getMethod('Flow_Proxy_injectProperties')->addPreParentCallCode($injectPropertiesCode);
$proxyClass->getMethod('Flow_Proxy_injectProperties')->overrideMethodVisibility('private');
$wakeupMethod->addPreParentCallCode(" \$this->Flow_Proxy_injectProperties();\n");
$constructorPostCode .= ' if (\'' . $className . '\' === get_class($this)) {' . "\n";
$constructorPostCode .= ' $this->Flow_Proxy_injectProperties();' . "\n";
$constructorPostCode .= ' }' . "\n";
}
$constructorPostCode .= $this->buildLifecycleInitializationCode($objectConfiguration, ObjectManagerInterface::INITIALIZATIONCAUSE_CREATED);
$constructorPostCode .= $this->buildLifecycleShutdownCode($objectConfiguration);
$constructor = $proxyClass->getConstructor();
$constructor->addPreParentCallCode($constructorPreCode);
$constructor->addPostParentCallCode($constructorPostCode);
if ($this->objectManager->getContext()->isProduction()) {
$this->compileStaticMethods($className, $proxyClass);
}
}
}
/**
* Renders and returns the PHP code for this ProxyClass.
*
* @return string
*/
public function render()
{
$namespace = $this->namespace;
$proxyClassName = $this->originalClassName;
$originalClassName = $this->originalClassName . Compiler::ORIGINAL_CLASSNAME_SUFFIX;
$classModifier = '';
if ($this->reflectionService->isClassAbstract($this->fullOriginalClassName)) {
$classModifier = 'abstract ';
} elseif ($this->reflectionService->isClassFinal($this->fullOriginalClassName)) {
$classModifier = 'final ';
}
$constantsCode = $this->renderConstantsCode();
$propertiesCode = $this->renderPropertiesCode();
$traitsCode = $this->renderTraitsCode();
$methodsCode = isset($this->constructor) ? $this->constructor->render() : '';
foreach ($this->methods as $proxyMethod) {
$methodsCode .= $proxyMethod->render();
}
if ($methodsCode . $constantsCode === '') {
return '';
}
$classCode = ($namespace !== '' ? 'namespace ' . $namespace . ";\n\n" : '') . "use Doctrine\\ORM\\Mapping as ORM;\n" . "use Neos\\Flow\\Annotations as Flow;\n" . "\n" . $this->buildClassDocumentation() . $classModifier . 'class ' . $proxyClassName . ' extends ' . $originalClassName . ' implements ' . implode(', ', array_unique($this->interfaces)) . " {\n\n" . $traitsCode . $constantsCode . $propertiesCode . $methodsCode . '}';
return $classCode;
}
/**
* Lists all public controller actions not covered by the active security policy
*
* @return void
*/
public function showUnprotectedActionsCommand()
{
$methodPrivileges = [];
foreach ($this->policyService->getRoles(true) as $role) {
$methodPrivileges = array_merge($methodPrivileges, $role->getPrivilegesByType(MethodPrivilegeInterface::class));
}
$controllerClassNames = $this->reflectionService->getAllSubClassNamesForClass(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 ORM\MappingException
* @throws \UnexpectedValueException
*/
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 ORM\ClassMetadata $metadata
*/
$class = $metadata->getReflectionClass();
$classSchema = $this->getClassSchema($class->getName());
$classAnnotations = $this->reader->getClassAnnotations($class);
// Evaluate Entity annotation
if (isset($classAnnotations[ORM\MappedSuperclass::class])) {
$mappedSuperclassAnnotation = $classAnnotations[ORM\MappedSuperclass::class];
if ($mappedSuperclassAnnotation->repositoryClass !== null) {
$metadata->setCustomRepositoryClass($mappedSuperclassAnnotation->repositoryClass);
}
$metadata->isMappedSuperclass = true;
} elseif (isset($classAnnotations[Flow\Entity::class]) || isset($classAnnotations[ORM\Entity::class])) {
$entityAnnotation = isset($classAnnotations[Flow\Entity::class]) ? $classAnnotations[Flow\Entity::class] : $classAnnotations[ORM\Entity::class];
if ($entityAnnotation->repositoryClass !== null) {
$metadata->setCustomRepositoryClass($entityAnnotation->repositoryClass);
} elseif ($classSchema->getRepositoryClassName() !== null) {
if ($this->reflectionService->isClassImplementationOf($classSchema->getRepositoryClassName(), \Doctrine\ORM\EntityRepository::class)) {
$metadata->setCustomRepositoryClass($classSchema->getRepositoryClassName());
}
}
if ($entityAnnotation->readOnly) {
$metadata->markReadOnly();
}
} elseif (isset($classAnnotations[Flow\ValueObject::class])) {
$valueObjectAnnotation = $classAnnotations[Flow\ValueObject::class];
if ($valueObjectAnnotation->embedded === true) {
$metadata->isEmbeddedClass = true;
} else {
// also ok... but we make it read-only
$metadata->markReadOnly();
}
} elseif (isset($classAnnotations[ORM\Embeddable::class])) {
$metadata->isEmbeddedClass = true;
} else {
throw ORM\MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
}
// Evaluate Table annotation
$primaryTable = [];
if (isset($classAnnotations[ORM\Table::class])) {
$tableAnnotation = $classAnnotations[ORM\Table::class];
$primaryTable = ['name' => $tableAnnotation->name, 'schema' => $tableAnnotation->schema];
if ($tableAnnotation->indexes !== null) {
foreach ($tableAnnotation->indexes as $indexAnnotation) {
$index = ['columns' => $indexAnnotation->columns];
if (!empty($indexAnnotation->flags)) {
$index['flags'] = $indexAnnotation->flags;
}
if (!empty($indexAnnotation->options)) {
$index['options'] = $indexAnnotation->flags;
}
if (!empty($indexAnnotation->name)) {
$primaryTable['indexes'][$indexAnnotation->name] = $index;
} else {
$primaryTable['indexes'][] = $index;
}
}
}
if ($tableAnnotation->uniqueConstraints !== null) {
foreach ($tableAnnotation->uniqueConstraints as $uniqueConstraint) {
$uniqueConstraint = ['columns' => $uniqueConstraint->columns];
if (!empty($uniqueConstraint->options)) {
$uniqueConstraint['options'] = $uniqueConstraint->options;
}
if (!empty($uniqueConstraint->name)) {
$primaryTable['uniqueConstraints'][$uniqueConstraint->name] = $uniqueConstraint;
} else {
$primaryTable['uniqueConstraints'][] = $uniqueConstraint;
}
}
}
if ($tableAnnotation->options !== null) {
$primaryTable['options'] = $tableAnnotation->options;
}
}
if (!isset($classAnnotations[ORM\Embeddable::class]) && !isset($primaryTable['name'])) {
$className = $classSchema->getClassName();
$primaryTable['name'] = $this->inferTableNameFromClassName($className);
}
// Evaluate @Cache annotation
if (isset($classAnnotations[ORM\Cache::class])) {
$cacheAnnotation = $classAnnotations[ORM\Cache::class];
$cacheMap = array('region' => $cacheAnnotation->region, 'usage' => constant('Doctrine\\ORM\\Mapping\\ClassMetadata::CACHE_USAGE_' . $cacheAnnotation->usage));
$metadata->enableCache($cacheMap);
}
// Evaluate NamedNativeQueries annotation
if (isset($classAnnotations[ORM\NamedNativeQueries::class])) {
$namedNativeQueriesAnnotation = $classAnnotations[ORM\NamedNativeQueries::class];
foreach ($namedNativeQueriesAnnotation->value as $namedNativeQuery) {
$metadata->addNamedNativeQuery(['name' => $namedNativeQuery->name, 'query' => $namedNativeQuery->query, 'resultClass' => $namedNativeQuery->resultClass, 'resultSetMapping' => $namedNativeQuery->resultSetMapping]);
}
}
// Evaluate SqlResultSetMappings annotation
if (isset($classAnnotations[ORM\SqlResultSetMappings::class])) {
$sqlResultSetMappingsAnnotation = $classAnnotations[ORM\SqlResultSetMappings::class];
foreach ($sqlResultSetMappingsAnnotation->value as $resultSetMapping) {
$entities = [];
$columns = [];
foreach ($resultSetMapping->entities as $entityResultAnnotation) {
$entityResult = ['fields' => [], 'entityClass' => $entityResultAnnotation->entityClass, 'discriminatorColumn' => $entityResultAnnotation->discriminatorColumn];
foreach ($entityResultAnnotation->fields as $fieldResultAnnotation) {
$entityResult['fields'][] = ['name' => $fieldResultAnnotation->name, 'column' => $fieldResultAnnotation->column];
}
$entities[] = $entityResult;
}
foreach ($resultSetMapping->columns as $columnResultAnnotation) {
$columns[] = ['name' => $columnResultAnnotation->name];
}
$metadata->addSqlResultSetMapping(['name' => $resultSetMapping->name, 'entities' => $entities, 'columns' => $columns]);
}
}
// Evaluate NamedQueries annotation
if (isset($classAnnotations[ORM\NamedQueries::class])) {
$namedQueriesAnnotation = $classAnnotations[ORM\NamedQueries::class];
if (!is_array($namedQueriesAnnotation->value)) {
throw new \UnexpectedValueException('@ORM\\NamedQueries should contain an array of @ORM\\NamedQuery annotations.');
}
foreach ($namedQueriesAnnotation->value as $namedQuery) {
if (!$namedQuery instanceof ORM\NamedQuery) {
throw new \UnexpectedValueException('@ORM\\NamedQueries should contain an array of @ORM\\NamedQuery annotations.');
}
$metadata->addNamedQuery(['name' => $namedQuery->name, 'query' => $namedQuery->query]);
}
}
// Evaluate InheritanceType annotation
if (isset($classAnnotations[ORM\InheritanceType::class])) {
$inheritanceTypeAnnotation = $classAnnotations[ORM\InheritanceType::class];
$inheritanceType = constant('Doctrine\\ORM\\Mapping\\ClassMetadata::INHERITANCE_TYPE_' . strtoupper($inheritanceTypeAnnotation->value));
if ($inheritanceType !== ORM\ClassMetadata::INHERITANCE_TYPE_NONE) {
// Evaluate DiscriminatorColumn annotation
if (isset($classAnnotations[ORM\DiscriminatorColumn::class])) {
$discriminatorColumnAnnotation = $classAnnotations[ORM\DiscriminatorColumn::class];
$discriminatorColumn = ['name' => $discriminatorColumnAnnotation->name, 'type' => $discriminatorColumnAnnotation->type, 'length' => $discriminatorColumnAnnotation->length, 'columnDefinition' => $discriminatorColumnAnnotation->columnDefinition];
} else {
$discriminatorColumn = ['name' => 'dtype', 'type' => 'string', 'length' => 255];
}
// Evaluate DiscriminatorMap annotation
if (isset($classAnnotations[ORM\DiscriminatorMap::class])) {
$discriminatorMapAnnotation = $classAnnotations[ORM\DiscriminatorMap::class];
$discriminatorMap = $discriminatorMapAnnotation->value;
} else {
$discriminatorMap = [];
$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 !== []) {
$metadata->setDiscriminatorColumn($discriminatorColumn);
$metadata->setDiscriminatorMap($discriminatorMap);
} else {
$inheritanceType = ORM\ClassMetadata::INHERITANCE_TYPE_NONE;
}
}
$metadata->setInheritanceType($inheritanceType);
}
// Evaluate DoctrineChangeTrackingPolicy annotation
if (isset($classAnnotations[ORM\ChangeTrackingPolicy::class])) {
$changeTrackingAnnotation = $classAnnotations[ORM\ChangeTrackingPolicy::class];
$metadata->setChangeTrackingPolicy(constant('Doctrine\\ORM\\Mapping\\ClassMetadata::CHANGETRACKING_' . strtoupper($changeTrackingAnnotation->value)));
} else {
$metadata->setChangeTrackingPolicy(ORM\ClassMetadata::CHANGETRACKING_DEFERRED_EXPLICIT);
}
// Evaluate annotations on properties/fields
try {
$this->evaluatePropertyAnnotations($metadata);
} catch (ORM\MappingException $exception) {
throw new ORM\MappingException(sprintf('Failure while evaluating property annotations for class "%s": %s', $metadata->getName(), $exception->getMessage()), 1382003497, $exception);
}
// build unique index for table
if (!isset($classAnnotations[ORM\Embeddable::class]) && !isset($primaryTable['uniqueConstraints'])) {
$idProperties = array_keys($classSchema->getIdentityProperties());
if (array_diff($idProperties, $metadata->getIdentifierFieldNames()) !== []) {
$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);
}
