/** * {@inheritdoc} */ public function getEntityAlias($entityClass) { if ($this->configManager->hasConfig($entityClass)) { // check for enums $enumCode = $this->configManager->getProvider('enum')->getConfig($entityClass)->get('code'); if ($enumCode) { $entityAlias = $this->getEntityAliasFromConfig($entityClass); if (null !== $entityAlias) { return $entityAlias; } return $this->createEntityAlias(str_replace('_', '', $enumCode)); } // check for dictionaries $groups = $this->configManager->getProvider('grouping')->getConfig($entityClass)->get('groups'); if (!empty($groups) && in_array(GroupingScope::GROUP_DICTIONARY, $groups, true)) { // delegate aliases generation to default provider return null; } // exclude hidden entities if ($this->configManager->isHiddenModel($entityClass)) { return false; } // check for custom entities if (ExtendHelper::isCustomEntity($entityClass)) { $entityAlias = $this->getEntityAliasFromConfig($entityClass); if (null !== $entityAlias) { return $entityAlias; } return $this->createEntityAlias('Extend' . ExtendHelper::getShortClassName($entityClass)); } } return null; }
/** * @param EntityConfigEvent $event */ public function updateEntity(EntityConfigEvent $event) { $className = $event->getClassName(); $parentClassName = get_parent_class($className); if (!$parentClassName) { return; } if (ExtendHelper::isExtendEntityProxy($parentClassName)) { // When application is installed parent class will be replaced (via class_alias) $extendClass = $parentClassName; } else { // During install parent class is not replaced (via class_alias) $shortClassName = ExtendHelper::getShortClassName($className); if (ExtendHelper::getShortClassName($parentClassName) !== 'Extend' . $shortClassName) { return; } $extendClass = ExtendHelper::getExtendEntityProxyClassName($parentClassName); } $configManager = $event->getConfigManager(); $config = $configManager->getProvider('extend')->getConfig($className); $hasChanges = false; if (!$config->is('is_extend')) { $config->set('is_extend', true); $hasChanges = true; } if (!$config->is('extend_class', $extendClass)) { $config->set('extend_class', $extendClass); $hasChanges = true; } if ($hasChanges) { $configManager->persist($config); } }
/** * @dataProvider setDefaultOptionsProvider */ public function testSetDefaultOptions($enumCode, $class, $nullValue, $values, $fieldOptions, $expectedOptions) { $enumValueClassName = $class !== null ? $class : ExtendHelper::buildEnumValueClassName($enumCode); if ($enumValueClassName) { // AbstractEnumType require class to be instance of AbstractEnumValue // This may be achieved with Stub. Stub namespace does not reflect Stub path. // So we have to load it manually $fileName = ExtendHelper::getShortClassName($enumValueClassName) . '.php'; require_once realpath(__DIR__ . DIRECTORY_SEPARATOR . 'Stub' . DIRECTORY_SEPARATOR . $fileName); $this->provider->expects($this->once())->method('getEnumChoices')->with($enumValueClassName)->will($this->returnValue($values)); } $this->translator->expects($this->any())->method('trans')->with('oro.entity_extend.datagrid.enum.filter.empty')->will($this->returnValue('None')); $resolver = $this->getOptionsResolver(); $this->type->setDefaultOptions($resolver); $options = []; if ($enumCode !== null) { $options['enum_code'] = $enumCode; } if ($class !== null) { $options['class'] = $class; } if ($nullValue !== null) { $options['null_value'] = $nullValue; } if ($fieldOptions !== null) { $options['field_options'] = $fieldOptions; } $resolvedOptions = $resolver->resolve($options); $this->assertEquals($expectedOptions, $resolvedOptions); }
/** * @param EntityConfigEvent $event */ public function updateEntityConfig(EntityConfigEvent $event) { $parentClassName = get_parent_class($event->getClassName()); if (!$parentClassName) { return; } $shortClassName = ExtendHelper::getShortClassName($event->getClassName()); if (ExtendHelper::getShortClassName($parentClassName) !== 'Extend' . $shortClassName) { return; } $config = $event->getConfigManager()->getProvider('extend')->getConfig($event->getClassName()); $hasChanges = false; if (!$config->is('is_extend')) { $config->set('is_extend', true); $hasChanges = true; } $extendClass = ExtendHelper::getExtendEntityProxyClassName($parentClassName); if (!$config->is('extend_class', $extendClass)) { $config->set('extend_class', $extendClass); $hasChanges = true; } if ($hasChanges) { $event->getConfigManager()->persist($config); } }
/** * Generate php and yml files for schema * * @param array $schema */ public function generateSchemaFiles(array $schema) { // generate PHP code $class = PhpClass::create($schema['entity']); foreach ($this->getExtensions() as $extension) { if ($extension->supports($schema)) { $extension->generate($schema, $class); } } $className = ExtendHelper::getShortClassName($schema['entity']); // write PHP class to the file $strategy = new DefaultGeneratorStrategy(); file_put_contents($this->entityCacheDir . DIRECTORY_SEPARATOR . $className . '.php', "<?php\n\n" . $strategy->generate($class)); // write doctrine metadata in separate yaml file file_put_contents($this->entityCacheDir . DIRECTORY_SEPARATOR . $className . '.orm.yml', Yaml::dump($schema['doctrine'], 5)); }
/** * {@inheritdoc} */ public function getWidgets($object) { $result = []; $entityClass = ClassUtils::getClass($object); $entityId = $this->entityIdAccessor->getIdentifier($object); $items = $this->activityManager->getActivityAssociations($entityClass); foreach ($items as $item) { if (empty($item['acl']) || $this->securityFacade->isGranted($item['acl'])) { $url = $this->entityRoutingHelper->generateUrl($item['route'], $entityClass, $entityId); $alias = sprintf('%s_%s_%s', strtolower(ExtendHelper::getShortClassName($item['className'])), dechex(crc32($item['className'])), $item['associationName']); $widget = ['widgetType' => 'block', 'alias' => $alias, 'label' => $this->translator->trans($item['label']), 'url' => $url]; if (isset($item['priority'])) { $widget['priority'] = $item['priority']; } $result[] = $widget; } } return $result; }
/** * {@inheritdoc} */ protected function hasAssociationConfigs(ClassMetadata $metadata, $associationName) { if ($this->isExtendField($metadata->name, $associationName)) { return false; } // check for default field of oneToMany or manyToMany relation if (strpos($associationName, ExtendConfigDumper::DEFAULT_PREFIX) === 0) { $guessedName = substr($associationName, strlen(ExtendConfigDumper::DEFAULT_PREFIX)); if (!empty($guessedName) && $this->isExtendField($metadata->name, $guessedName)) { return false; } } // check for inverse side field of oneToMany relation $targetClass = $metadata->getAssociationTargetClass($associationName); $prefix = strtolower(ExtendHelper::getShortClassName($targetClass)) . '_'; if (strpos($associationName, $prefix) === 0) { $guessedName = substr($associationName, strlen($prefix)); if (!empty($guessedName) && $this->isExtendField($targetClass, $guessedName)) { return false; } } return parent::hasAssociationConfigs($metadata, $associationName); }
protected function doTestSetDefaultOptions(AbstractEnumType $type, OptionsResolver $resolver, $enumCode, $multiple = false, $expanded = false, array $options = []) { $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode); // AbstractEnumType require class to be instance of AbstractEnumValue // This may be achieved with Stub. Stub namespace does not reflect Stub path. So we have to load it manually $fileName = ExtendHelper::getShortClassName($enumValueClassName) . '.php'; require_once realpath(__DIR__ . DIRECTORY_SEPARATOR . 'Stub' . DIRECTORY_SEPARATOR . $fileName); $enumConfig = new Config(new EntityConfigId('enum', $enumValueClassName)); $enumConfig->set('multiple', $multiple); $enumConfigProvider = $this->getConfigProviderMock(); $this->configManager->expects($this->once())->method('getProvider')->with('enum')->will($this->returnValue($enumConfigProvider)); $enumConfigProvider->expects($this->once())->method('getConfig')->with($enumValueClassName)->will($this->returnValue($enumConfig)); $type->setDefaultOptions($resolver); $resolvedOptions = $resolver->resolve(array_merge($options, ['enum_code' => $enumCode, 'expanded' => $expanded])); $this->assertEquals($multiple, $resolvedOptions['multiple']); $this->assertEquals($expanded, $resolvedOptions['expanded']); $this->assertEquals($enumCode, $resolvedOptions['enum_code']); $this->assertEquals($enumValueClassName, $resolvedOptions['class']); $this->assertEquals('name', $resolvedOptions['property']); $this->assertNotNull($resolvedOptions['query_builder']); unset($resolvedOptions['multiple'], $resolvedOptions['expanded'], $resolvedOptions['enum_code'], $resolvedOptions['class'], $resolvedOptions['property'], $resolvedOptions['query_builder']); return $resolvedOptions; }
/** * Returns a string that can be used as a field name to the relation to the given entity. * * To prevent name collisions this method adds a hash built based on the full class name * and the kind of the association to the end. * * @param string $targetEntityClassName The association target class name * @param string $associationKind The kind of the association * For example 'activity', 'sponsorship' etc * NULL for unclassified (default) association * * @return string */ public static function buildAssociationName($targetEntityClassName, $associationKind = null) { $hash = strtolower(dechex(crc32(empty($associationKind) ? $targetEntityClassName : $associationKind . $targetEntityClassName))); return sprintf('%s_%s', Inflector::tableize(ExtendHelper::getShortClassName($targetEntityClassName)), $hash); }
/** * @param string $entityClassName * @param string $fieldName * @param string[] $existingEnumTables * * @return string */ protected function buildEnumCode($entityClassName, $fieldName, $existingEnumTables) { $nameGenerator = $this->extendExtension->getNameGenerator(); $enumCode = ExtendHelper::generateEnumCode($entityClassName, $fieldName, $nameGenerator->getMaxEnumCodeSize()); // check if an enum with that code is already exist and generate new code if so while (in_array($nameGenerator->generateEnumTableName($enumCode), $existingEnumTables, true)) { $enumCode = sprintf('enum_%s_%s', dechex(crc32(ExtendHelper::getShortClassName($entityClassName))), dechex(crc32(microtime()))); } return $enumCode; }
protected function renameOneToManyExtendField(Schema $schema, QueryBag $queries, Table $table, $associationName, $targetEntityClassName, EntityMetadataHelper $entityMetadataHelper) { $entityClassName = $entityMetadataHelper->getEntityClassByTableName($table->getName()); $targetTableName = $entityMetadataHelper->getTableNameByEntityClass($targetEntityClassName); if ($schema->hasTable($targetTableName)) { $targetTable = $schema->getTable($targetTableName); $oldTargetColumnName = sprintf('field_%s_%s_id', strtolower(ExtendHelper::getShortClassName($entityClassName)), $associationName); if ($targetTable->hasColumn($oldTargetColumnName)) { $newTargetColumnName = $this->nameGenerator->generateOneToManyRelationColumnName($entityClassName, $associationName); $oldIndexName = $this->nameGenerator->generateIndexName($targetTableName, [$oldTargetColumnName], false, true); if ($targetTable->hasIndex($oldIndexName)) { $targetTable->dropIndex($oldIndexName); } $oldForeignKeyName = $this->nameGenerator->generateForeignKeyConstraintName($targetTableName, [$oldTargetColumnName], true); if ($targetTable->hasForeignKey($oldForeignKeyName)) { $targetTable->removeForeignKey($oldForeignKeyName); } $this->renameExtension->renameColumn($schema, $queries, $targetTable, $oldTargetColumnName, $newTargetColumnName); $this->renameExtension->addIndex($schema, $queries, $targetTable->getName(), [$newTargetColumnName]); $this->renameExtension->addForeignKeyConstraint($schema, $queries, $targetTable->getName(), $table->getName(), [$newTargetColumnName], $table->getPrimaryKeyColumns(), ['onDelete' => 'SET NULL']); } } }
/** * @param string $entityClassName * @param string $fieldName * @return string */ public function generateIndexNameForExtendFieldVisibleInGrid($entityClassName, $fieldName) { $entityClassName = ExtendHelper::getShortClassName($entityClassName); // remove ending underscore (_) char $prefix = substr(self::CUSTOM_INDEX_PREFIX, 0, -1); return $this->generateIdentifierName($entityClassName, [$fieldName], $prefix, false); }
/** * @dataProvider getShortClassNameProvider */ public function testGetShortClassName($className, $expected) { $this->assertEquals($expected, ExtendHelper::getShortClassName($className)); }