/**
* {@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));
}
