/**
* Gets a table name for many-to-many relation
*
* @param string $activityTableName Activity entity table name. It is owning side of the association.
* @param string $targetTableName Target entity table name.
*
* @return string
*/
public function getAssociationTableName($activityTableName, $targetTableName)
{
$sourceClassName = $this->extendExtension->getEntityClassByTableName($activityTableName);
$targetClassName = $this->extendExtension->getEntityClassByTableName($targetTableName);
$associationName = ExtendHelper::buildAssociationName($targetClassName, ActivityScope::ASSOCIATION_KIND);
return $this->nameGenerator->generateManyToManyJoinTableName($sourceClassName, $associationName, $targetClassName);
}
/**
* {@inheritdoc}
*/
public function setDefaultOptions(OptionsResolverInterface $resolver)
{
$resolver->setDefaults(array('constraints' => [new Assert\NotBlank()]));
$constraintsNormalizer = function (Options $options, $constraints) {
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $options['config_id'];
if (!$this->typeHelper->hasEnumCode($fieldConfigId->getClassName(), $fieldConfigId->getFieldName())) {
// validations of new enum
$constraints[] = new Assert\Length(['max' => $this->nameGenerator->getMaxEnumCodeSize()]);
$constraints[] = new Assert\Regex(['pattern' => '/^[\\w- ]*$/', 'message' => self::INVALID_NAME_MESSAGE]);
$callback = function ($value, ExecutionContext $context) {
if (!empty($value)) {
$code = ExtendHelper::buildEnumCode($value, false);
if (empty($code)) {
$context->addViolation(self::INVALID_NAME_MESSAGE, ['{{ value }}' => $value]);
}
}
};
$constraints[] = new Assert\Callback([$callback]);
$constraints[] = new UniqueEnumName(['entityClassName' => $fieldConfigId->getClassName(), 'fieldName' => $fieldConfigId->getFieldName()]);
} else {
// validations of existing enum
$constraints[] = new Assert\Length(['max' => 255]);
}
return $constraints;
};
$resolver->setNormalizers(['constraints' => $constraintsNormalizer, 'disabled' => function (Options $options, $value) {
return $this->isReadOnly($options) ? true : $value;
}, 'validation_groups' => function (Options $options, $value) {
return $options['disabled'] ? false : $value;
}]);
}
/**
* @param LoggerInterface $logger
* @param bool $dryRun
*/
protected function runActivityLists(LoggerInterface $logger, $dryRun = false)
{
// @todo: this workaround should be removed in BAP-9156
$this->configManager->clear();
$targetEntities = $this->provider->getTargetEntityClasses(false);
$toSchema = clone $this->schema;
$hasSchemaChanges = false;
foreach ($targetEntities as $targetEntity) {
$associationName = ExtendHelper::buildAssociationName($targetEntity, ActivityListEntityConfigDumperExtension::ASSOCIATION_KIND);
$relationTableName = $this->nameGenerator->generateManyToManyJoinTableName(ActivityListEntityConfigDumperExtension::ENTITY_CLASS, $associationName, $targetEntity);
if (!$toSchema->hasTable($relationTableName)) {
$hasSchemaChanges = true;
$this->activityListExtension->addActivityListAssociation($toSchema, $this->metadataHelper->getTableNameByEntityClass($targetEntity));
}
}
if ($hasSchemaChanges) {
$comparator = new Comparator();
$platform = $this->connection->getDatabasePlatform();
$schemaDiff = $comparator->compare($this->schema, $toSchema);
$queries = $schemaDiff->toSql($platform);
foreach ($queries as $query) {
$this->logQuery($logger, $query);
if (!$dryRun) {
$this->connection->executeQuery($query);
}
}
}
}
/**
* {@inheritdoc}
*/
public function up(Schema $schema, QueryBag $queries)
{
$relationTableName = $this->nameGenerator->generateManyToManyJoinTableName('Oro\\Bundle\\EmailBundle\\Entity\\Email', ExtendHelper::buildAssociationName('OroCRM\\Bundle\\SalesBundle\\Entity\\B2bCustomer', ActivityScope::ASSOCIATION_KIND), 'OroCRM\\Bundle\\SalesBundle\\Entity\\B2bCustomer');
if (!$schema->hasTable($relationTableName)) {
$this->activityExtension->addActivityAssociation($schema, 'oro_email', 'orocrm_sales_b2bcustomer');
}
}
/**
* {@inheritdoc}
*/
public function build(ClassMetadataBuilder $metadataBuilder, ConfigInterface $extendConfig)
{
$className = $extendConfig->getId()->getClassName();
$indices = $extendConfig->get('index');
// TODO: need to be changed to fieldName => columnName
// TODO: should be done in scope https://magecore.atlassian.net/browse/BAP-3940
foreach ($indices as $columnName => $enabled) {
$fieldConfig = $this->extendConfigProvider->getConfig($className, $columnName);
if ($enabled && !$fieldConfig->is('state', ExtendScope::STATE_NEW)) {
$indexName = $this->nameGenerator->generateIndexNameForExtendFieldVisibleInGrid($className, $columnName);
$metadataBuilder->addIndex([$columnName], $indexName);
}
}
}
/**
* @param string $className
* @param array $originalFieldNames
* @return array
*/
protected function getReverseRelationTypes($className, array &$originalFieldNames)
{
$extendProvider = $this->configManager->getProvider('extend');
$entityConfig = $extendProvider->getConfig($className);
$entityProvider = $this->configManager->getProvider('entity');
$result = [];
if ($entityConfig->is('relation')) {
$relations = $entityConfig->get('relation');
foreach ($relations as $relationKey => $relation) {
if (!$this->isAvailableRelation($extendProvider, $relation, $relationKey)) {
continue;
}
/** @var FieldConfigId $fieldId */
$fieldId = $relation['field_id'];
/** @var FieldConfigId $targetFieldId */
$targetFieldId = $relation['target_field_id'];
$entityLabel = $entityProvider->getConfig($targetFieldId->getClassName())->get('label');
$fieldLabel = $entityProvider->getConfigById($targetFieldId)->get('label');
$fieldName = $fieldId ? $fieldId->getFieldName() : '';
$maxFieldNameLength = $this->nameGenerator->getMaxCustomEntityFieldNameSize();
if (strlen($fieldName) > $maxFieldNameLength) {
$cutFieldName = substr($fieldName, 0, $maxFieldNameLength);
$originalFieldNames[$cutFieldName] = $fieldName;
$fieldName = $cutFieldName;
}
$key = $relationKey . '||' . $fieldName;
$result[$key] = $this->translator->trans(self::TYPE_LABEL_PREFIX . 'inverse_relation', ['%entity_name%' => $this->translator->trans($entityLabel), '%field_name%' => $this->translator->trans($fieldLabel)]);
}
}
return $result;
}
/**
* @param Schema $schema
* @param QueryBag $queries
* @param string $tableName
* @param string $columnName
* @param array $options
*/
protected function processColumn(Schema $schema, QueryBag $queries, $tableName, $columnName, $options)
{
$className = $this->entityMetadataHelper->getEntityClassByTableName($tableName);
$table = $schema->getTable($tableName);
if (!isset($options[ExtendOptionsManager::NEW_NAME_OPTION])) {
if (isset($options[ExtendOptionsManager::TYPE_OPTION])) {
$columnType = $options[ExtendOptionsManager::TYPE_OPTION];
if (!in_array($columnType, ['oneToMane', 'manyToMany', 'manyToOne', 'optionSet'])) {
$indexName = $this->nameGenerator->generateIndexNameForExtendFieldVisibleInGrid($className, $columnName);
$enabled = !isset($options['datagrid']['is_visible']) || $options['datagrid']['is_visible'];
if ($enabled && !$table->hasIndex($indexName)) {
$table->addIndex([$columnName], $indexName);
} elseif (!$enabled && $table->hasIndex($indexName)) {
$table->dropIndex($indexName);
}
}
}
} else {
// in case of renaming column name we should rename existing index
$newColumnName = $options[ExtendOptionsManager::NEW_NAME_OPTION];
$indexName = $this->nameGenerator->generateIndexNameForExtendFieldVisibleInGrid($className, $columnName);
if ($table->hasIndex($indexName)) {
$table->dropIndex($indexName);
$newIndexName = $this->nameGenerator->generateIndexNameForExtendFieldVisibleInGrid($className, $newColumnName);
$this->renameExtension->addIndex($schema, $queries, $tableName, [$newColumnName], $newIndexName);
}
}
}
/**
* @param Table $table
* @param string $associationName
* @param Table $targetTable
*/
protected function addDefaultRelation(Table $table, $associationName, Table $targetTable)
{
$defaultRelationColumnName = $this->nameGenerator->generateRelationDefaultColumnName($associationName);
$targetPrimaryKeyColumnName = $this->getPrimaryKeyColumnName($targetTable);
$targetPrimaryKeyColumn = $targetTable->getColumn($targetPrimaryKeyColumnName);
$this->addRelationColumn($table, $defaultRelationColumnName, $targetPrimaryKeyColumn, ['notnull' => false]);
$table->addIndex([$defaultRelationColumnName]);
$table->addForeignKeyConstraint($targetTable, [$defaultRelationColumnName], [$targetPrimaryKeyColumnName], ['onDelete' => 'SET NULL']);
}
/**
* @param Schema $schema
* @param QueryBag $queries
* @param string $tableName
* @param string $columnName
* @param array $options
* @param string $className
* @param Table $table
*/
protected function renameIndex(Schema $schema, QueryBag $queries, $tableName, $columnName, $options, $className, $table)
{
$newColumnName = $options[ExtendOptionsManager::NEW_NAME_OPTION];
$indexName = $this->nameGenerator->generateIndexNameForExtendFieldVisibleInGrid($className, $columnName);
if ($table->hasIndex($indexName)) {
$table->dropIndex($indexName);
$newIndexName = $this->nameGenerator->generateIndexNameForExtendFieldVisibleInGrid($className, $newColumnName);
$this->renameExtension->addIndex($schema, $queries, $tableName, [$newColumnName], $newIndexName);
}
}
/**
* @param FieldConfigId $fieldId
*
* @return string
*/
protected function getManyToOneColumnName(FieldConfigId $fieldId)
{
$columnName = null;
if ($this->configManager->hasConfig($fieldId->getClassName(), $fieldId->getFieldName())) {
$columnName = $this->getFieldConfig($fieldId)->get('column_name');
}
if (!$columnName) {
$columnName = $this->nameGenerator->generateRelationColumnName($fieldId->getFieldName());
}
return $columnName;
}
public function testNewEnumNameValidators()
{
$configId = new FieldConfigId('enum', 'Test\\Entity', 'testField', 'enum');
$this->typeHelper->expects($this->any())->method('hasEnumCode')->with($configId->getClassName(), $configId->getFieldName())->will($this->returnValue(false));
$resolver = $this->getOptionsResolver();
$this->type->setDefaultOptions($resolver);
$resolvedOptions = $resolver->resolve(['config_id' => $configId]);
$this->assertCount(5, $resolvedOptions['constraints']);
$this->assertInstanceOf('Symfony\\Component\\Validator\\Constraints\\NotBlank', $resolvedOptions['constraints'][0]);
$this->assertInstanceOf('Symfony\\Component\\Validator\\Constraints\\Length', $resolvedOptions['constraints'][1]);
$this->assertEquals($this->nameGenerator->getMaxEnumCodeSize(), $resolvedOptions['constraints'][1]->max);
$this->assertInstanceOf('Symfony\\Component\\Validator\\Constraints\\Regex', $resolvedOptions['constraints'][2]);
$this->assertEquals('/^[\\w- ]*$/', $resolvedOptions['constraints'][2]->pattern);
$this->assertEquals(EnumNameType::INVALID_NAME_MESSAGE, $resolvedOptions['constraints'][2]->message);
$this->assertInstanceOf('Symfony\\Component\\Validator\\Constraints\\Callback', $resolvedOptions['constraints'][3]);
$context = $this->getMockBuilder('Symfony\\Component\\Validator\\ExecutionContext')->disableOriginalConstructor()->getMock();
$context->expects($this->once())->method('addViolation')->with(EnumNameType::INVALID_NAME_MESSAGE);
call_user_func($resolvedOptions['constraints'][3]->methods[0], '!@#$', $context);
$this->assertInstanceOf('Oro\\Bundle\\EntityExtendBundle\\Validator\\Constraints\\UniqueEnumName', $resolvedOptions['constraints'][4]);
$this->assertEquals($configId->getClassName(), $resolvedOptions['constraints'][4]->entityClassName);
$this->assertEquals($configId->getFieldName(), $resolvedOptions['constraints'][4]->fieldName);
}
public function testPostUpdateForDeletedMultiEnumField()
{
$entityConfig = new Config(new EntityConfigId('extend', 'Extend\\EnumValue1'));
$entityConfig->set('owner', ExtendScope::OWNER_CUSTOM);
$entityConfig->set('is_extend', true);
$entityConfig->set('schema', ['doctrine' => ['Extend\\EnumValue1' => ['fields' => [ExtendHelper::getMultiEnumSnapshotFieldName('field2') => ['column' => 'field2']]]]]);
$fieldConfig = new Config(new FieldConfigId('extend', 'Extend\\EnumValue1', 'field1', 'multiEnum'));
$fieldConfig->set('is_deleted', true);
$entityConfigs = [$entityConfig];
$fieldConfigs = [$fieldConfig];
$extendConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock();
$this->configManager->expects($this->once())->method('getProvider')->with('extend')->will($this->returnValue($extendConfigProvider));
$extendConfigProvider->expects($this->at(0))->method('getConfigs')->with(null, true)->will($this->returnValue($entityConfigs));
$extendConfigProvider->expects($this->at(1))->method('getConfigs')->with($entityConfig->getId()->getClassName())->will($this->returnValue($fieldConfigs));
$this->configManager->expects($this->once())->method('persist')->with($this->identicalTo($entityConfig));
$this->extension->postUpdate();
$this->assertEquals(['doctrine' => ['Extend\\EnumValue1' => ['fields' => [ExtendHelper::getMultiEnumSnapshotFieldName('field1') => ['column' => $this->nameGenerator->generateMultiEnumSnapshotColumnName('field1'), 'type' => 'string', 'nullable' => true, 'length' => ExtendHelper::MAX_ENUM_SNAPSHOT_LENGTH], ExtendHelper::getMultiEnumSnapshotFieldName('field2') => ['column' => 'field2']]]], 'property' => [ExtendHelper::getMultiEnumSnapshotFieldName('field1') => ['private' => true]]], $entityConfig->get('schema'));
}
/**
* Adds many-to-one relation
*
* @param Schema $schema
* @param Table|string $table A Table object or table name
* @param string $associationName A relation name
* @param Table|string $targetTable A Table object or table name
* @param string $targetColumnName A column name is used to show related entity
* @param array $options
* @param string $fieldType The field type. By default the field type is manyToOne,
* but you can specify another type if it is based on manyToOne.
* In this case this type should be registered
* in entity_extend.yml under underlying_types section
*/
public function addManyToOneRelation(Schema $schema, $table, $associationName, $targetTable, $targetColumnName, array $options = [], $fieldType = RelationType::MANY_TO_ONE)
{
$this->ensureExtendFieldSet($options);
$selfTableName = $this->getTableName($table);
$selfTable = $this->getTable($table, $schema);
$selfColumnName = $this->nameGenerator->generateManyToOneRelationColumnName($associationName);
$targetTableName = $this->getTableName($targetTable);
$targetTable = $this->getTable($targetTable, $schema);
$targetPrimaryKeyColumnName = $this->getPrimaryKeyColumnName($targetTable);
$targetPrimaryKeyColumn = $targetTable->getColumn($targetPrimaryKeyColumnName);
$this->checkColumnsExist($targetTable, [$targetColumnName]);
$this->addRelationColumn($selfTable, $selfColumnName, $targetPrimaryKeyColumn, ['notnull' => false]);
$selfTable->addIndex([$selfColumnName]);
$selfTable->addForeignKeyConstraint($targetTable, [$selfColumnName], [$targetPrimaryKeyColumnName], ['onDelete' => 'SET NULL']);
$options[ExtendOptionsManager::TARGET_OPTION] = ['table_name' => $targetTableName, 'column' => $targetColumnName];
$options[ExtendOptionsManager::TYPE_OPTION] = $fieldType;
$this->extendOptionsManager->setColumnOptions($selfTableName, $associationName, $options);
}
/**
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*/
public function testBuildManyToManyWithDefaultRelation()
{
$entityClass = 'Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass';
$fieldName = 'srcField';
$fieldType = RelationType::MANY_TO_MANY;
$fieldId = new FieldConfigId('extend', $entityClass, $fieldName, $fieldType);
$fieldConfig = new Config($fieldId, []);
$targetEntityClass = 'Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass2';
$targetFieldName = 'targetField';
$targetFieldType = RelationType::MANY_TO_MANY;
$targetFieldId = new FieldConfigId('extend', $targetEntityClass, $targetFieldName, $targetFieldType);
$this->configManager->expects($this->once())->method('getFieldConfig')->with('extend', $entityClass, $fieldName)->willReturn($fieldConfig);
$metadataBuilder = new ClassMetadataBuilder(new ClassMetadataInfo($entityClass));
$relationKey = ExtendHelper::buildRelationKey($entityClass, $fieldName, RelationType::MANY_TO_ONE, $targetEntityClass);
$extendConfig = $this->getEntityConfig($entityClass, ['relation' => [$relationKey => ['field_id' => $fieldId, 'owner' => true, 'target_entity' => $targetEntityClass, 'target_field_id' => $targetFieldId]], 'schema' => ['relation' => [$fieldName => []]]]);
$this->builder->build($metadataBuilder, $extendConfig);
$result = $metadataBuilder->getClassMetadata()->getAssociationMapping($fieldName);
$this->assertEquals(['sourceEntity' => $entityClass, 'targetEntity' => $targetEntityClass, 'fieldName' => $fieldName, 'type' => ClassMetadataInfo::MANY_TO_MANY, 'isOwningSide' => true, 'mappedBy' => null, 'inversedBy' => $targetFieldName, 'cascade' => [], 'joinTable' => ['name' => $this->nameGenerator->generateManyToManyJoinTableName($entityClass, $fieldName, $targetEntityClass), 'joinColumns' => [['name' => 'testclass_id', 'referencedColumnName' => 'id', 'onDelete' => 'CASCADE']], 'inverseJoinColumns' => [['name' => 'testclass2_id', 'referencedColumnName' => 'id', 'onDelete' => 'CASCADE']]], 'joinTableColumns' => ['testclass_id', 'testclass2_id'], 'relationToSourceKeyColumns' => ['testclass_id' => 'id'], 'relationToTargetKeyColumns' => ['testclass2_id' => 'id'], 'fetch' => ClassMetadataInfo::FETCH_LAZY, 'isOnDeleteCascade' => true, 'isCascadeRemove' => false, 'isCascadePersist' => false, 'isCascadeRefresh' => false, 'isCascadeMerge' => false, 'isCascadeDetach' => false, 'orphanRemoval' => false], $result);
$defaultRelationFieldName = ExtendConfigDumper::DEFAULT_PREFIX . $fieldName;
$this->assertEquals(['sourceEntity' => $entityClass, 'targetEntity' => $targetEntityClass, 'fieldName' => $defaultRelationFieldName, 'type' => ClassMetadataInfo::MANY_TO_ONE, 'isOwningSide' => true, 'mappedBy' => null, 'inversedBy' => null, 'cascade' => [], 'joinColumns' => [['name' => $defaultRelationFieldName . '_id', 'referencedColumnName' => 'id', 'nullable' => true, 'unique' => false, 'onDelete' => 'SET NULL', 'columnDefinition' => null]], 'joinColumnFieldNames' => [$defaultRelationFieldName . '_id' => $defaultRelationFieldName . '_id'], 'sourceToTargetKeyColumns' => [$defaultRelationFieldName . '_id' => 'id'], 'targetToSourceKeyColumns' => ['id' => $defaultRelationFieldName . '_id'], 'fetch' => ClassMetadataInfo::FETCH_LAZY, 'isCascadeRemove' => false, 'isCascadePersist' => false, 'isCascadeRefresh' => false, 'isCascadeMerge' => false, 'isCascadeDetach' => false, 'orphanRemoval' => false], $metadataBuilder->getClassMetadata()->getAssociationMapping($defaultRelationFieldName));
}
/**
* @param string $sourceTableName
* @param string $targetTableName
* @param string $ownerColumnName
* @param QueryBag $queries
*/
public function assignActivities($sourceTableName, $targetTableName, $ownerColumnName, QueryBag $queries)
{
// prepare select email_id:contact_id sql
$fromAndRecipients = '
SELECT DISTINCT email_id, owner_id FROM (
SELECT e.id as email_id, ea.{owner} as owner_id
FROM oro_email_address ea
INNER JOIN oro_email e ON e.from_email_address_id = ea.id
WHERE ea.{owner} IS NOT NULL
UNION
SELECT er.email_id as email_id, ea.{owner} as owner_id
FROM oro_email_address ea
INNER JOIN oro_email_recipient er ON er.email_address_id = ea.id
WHERE ea.{owner} IS NOT NULL
) as subq';
$sourceClassName = $this->extendExtension->getEntityClassByTableName($sourceTableName);
$targetClassName = $this->extendExtension->getEntityClassByTableName($targetTableName);
$fromAndRecipients = str_replace('{owner}', $ownerColumnName, $fromAndRecipients);
$associationName = ExtendHelper::buildAssociationName($targetClassName, ActivityScope::ASSOCIATION_KIND);
$tableName = $this->nameGenerator->generateManyToManyJoinTableName($sourceClassName, $associationName, $targetClassName);
$queries->addQuery(sprintf("INSERT INTO %s %s", $tableName, $fromAndRecipients));
}
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 $enumValueClassName The full class name of an entity is used to store enum values
* @param string $enumCode The unique identifier of an enum
* @param bool $isMultiple Indicates whether several options can be selected for this enum
* or it supports only one selected option
* @param bool|null $isPublic Indicates whether this enum can be used by any entity or
* it is designed to use in one entity only
* NULL means unspecified. In this case this attribute will not be
* changed for existing enum entity and will be set to FALSE
* for new enum entity
*/
protected function createEnumValueConfigEntityModel($enumValueClassName, $enumCode, $isMultiple, $isPublic)
{
if ($this->configManager->hasConfigEntityModel($enumValueClassName)) {
if (null !== $isPublic) {
$this->relationBuilder->updateEntityConfigs($enumValueClassName, ['enum' => ['public' => $isPublic]]);
}
return;
}
if (null === $isPublic) {
$isPublic = false;
}
// create entity
$this->configManager->createConfigEntityModel($enumValueClassName, ConfigModelManager::MODE_HIDDEN);
$this->relationBuilder->updateEntityConfigs($enumValueClassName, ['entity' => ['label' => ExtendHelper::getEnumTranslationKey('label', $enumCode), 'plural_label' => ExtendHelper::getEnumTranslationKey('plural_label', $enumCode), 'description' => ExtendHelper::getEnumTranslationKey('description', $enumCode)], 'extend' => ['owner' => ExtendScope::OWNER_SYSTEM, 'is_extend' => true, 'table' => $this->nameGenerator->generateEnumTableName($enumCode, true), 'inherit' => ExtendHelper::BASE_ENUM_VALUE_CLASS], 'enum' => ['code' => $enumCode, 'public' => $isPublic, 'multiple' => $isMultiple]]);
// create fields
$this->configManager->createConfigFieldModel($enumValueClassName, 'id', 'string');
$this->relationBuilder->updateFieldConfigs($enumValueClassName, 'id', ['entity' => ['label' => ExtendHelper::getEnumTranslationKey('label', $enumCode, 'id'), 'description' => ExtendHelper::getEnumTranslationKey('description', $enumCode, 'id')], 'importexport' => ['identity' => true]]);
$this->configManager->createConfigFieldModel($enumValueClassName, 'name', 'string');
$this->relationBuilder->updateFieldConfigs($enumValueClassName, 'name', ['entity' => ['label' => ExtendHelper::getEnumTranslationKey('label', $enumCode, 'name'), 'description' => ExtendHelper::getEnumTranslationKey('description', $enumCode, 'name')], 'datagrid' => ['is_visible' => false]]);
$this->configManager->createConfigFieldModel($enumValueClassName, 'priority', 'integer');
$this->relationBuilder->updateFieldConfigs($enumValueClassName, 'priority', ['entity' => ['label' => ExtendHelper::getEnumTranslationKey('label', $enumCode, 'priority'), 'description' => ExtendHelper::getEnumTranslationKey('description', $enumCode, 'priority')], 'datagrid' => ['is_visible' => false]]);
$this->configManager->createConfigFieldModel($enumValueClassName, 'default', 'boolean');
$this->relationBuilder->updateFieldConfigs($enumValueClassName, 'default', ['entity' => ['label' => ExtendHelper::getEnumTranslationKey('label', $enumCode, 'default'), 'description' => ExtendHelper::getEnumTranslationKey('description', $enumCode, 'default')], 'datagrid' => ['is_visible' => false]]);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage The enum code length must be less or equal 21 characters. Code: test_56789012345678901
*/
public function testGenerateEnumTableNameWithTooLongEnumCode()
{
$this->nameGenerator->generateEnumTableName('test_56789012345678901');
}
/**
* @param ClassMetadataBuilder $metadataBuilder
* @param FieldConfigId $fieldId
* @param string $targetEntity
*/
protected function buildDefaultRelation(ClassMetadataBuilder $metadataBuilder, FieldConfigId $fieldId, $targetEntity)
{
$builder = $metadataBuilder->createOneToOne(ExtendConfigDumper::DEFAULT_PREFIX . $fieldId->getFieldName(), $targetEntity);
$builder->addJoinColumn($this->nameGenerator->generateRelationDefaultColumnName($fieldId->getFieldName()), 'id', true, false, 'SET NULL');
$builder->build();
}
/**
* @SuppressWarnings(PHPMD.NPathComplexity)
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*
* @param ConfigInterface $extendConfig
* @param array|null $aliases
* @param array|null $skippedOrigins
*/
protected function checkSchema(ConfigInterface $extendConfig, $aliases, array $skippedOrigins = null)
{
$extendProvider = $this->em->getExtendConfigProvider();
$className = $extendConfig->getId()->getClassName();
$doctrine = [];
$entityName = $className;
if (ExtendHelper::isCustomEntity($className)) {
$type = 'Custom';
$tableName = $extendConfig->get('table');
if (!$tableName) {
$tableName = $this->nameGenerator->generateCustomEntityTableName($className);
}
$doctrine[$entityName] = ['type' => 'entity', 'table' => $tableName];
// add 'id' field only for Custom entity without inheritance
if (!$extendConfig->has('inherit')) {
$doctrine[$entityName]['fields'] = ['id' => ['type' => 'integer', 'id' => true, 'generator' => ['strategy' => 'AUTO']]];
}
} else {
$type = 'Extend';
$entityName = $extendConfig->get('extend_class');
$doctrine[$entityName] = ['type' => 'mappedSuperclass', 'fields' => []];
}
$schema = $extendConfig->get('schema');
$properties = [];
$relationProperties = $schema ? $schema['relation'] : [];
$defaultProperties = [];
$addRemoveMethods = [];
$fieldConfigs = $extendProvider->filter($this->createOriginFilterCallback($skippedOrigins), $className, true);
foreach ($fieldConfigs as $fieldConfig) {
$this->checkFields($entityName, $fieldConfig, $relationProperties, $defaultProperties, $properties, $doctrine);
$extendProvider->persist($fieldConfig);
}
$relations = $extendConfig->get('relation', false, []);
foreach ($relations as &$relation) {
if (!$relation['field_id']) {
continue;
}
$relation['assign'] = true;
if ($relation['field_id']->getFieldType() !== RelationType::MANY_TO_ONE) {
$fieldName = $relation['field_id']->getFieldName();
$addRemoveMethods[$fieldName]['self'] = $fieldName;
if ($relation['target_field_id']) {
$addRemoveMethods[$fieldName]['target'] = $relation['target_field_id']->getFieldName();
$addRemoveMethods[$fieldName]['is_target_addremove'] = $relation['field_id']->getFieldType() === RelationType::MANY_TO_MANY;
}
}
$this->updateRelationValues($relation['target_entity'], $relation['field_id']);
}
$extendConfig->set('relation', $relations);
$schema = ['class' => $className, 'entity' => $entityName, 'type' => $type, 'property' => $properties, 'relation' => $relationProperties, 'default' => $defaultProperties, 'addremove' => $addRemoveMethods, 'doctrine' => $doctrine];
if ($type == 'Extend') {
$parentClassName = get_parent_class($className);
if ($parentClassName == $entityName) {
$parentClassName = $aliases[$entityName];
}
$schema['parent'] = $parentClassName;
$schema['inherit'] = get_parent_class($parentClassName);
} elseif ($extendConfig->has('inherit')) {
$schema['inherit'] = $extendConfig->get('inherit');
}
$extendConfig->set('schema', $schema);
$extendProvider->persist($extendConfig);
}
/**
* Gets an association column name for note relation
*
* @param string $targetTableName Target entity table name.
*
* @return string
*/
public function getAssociationColumnName($targetTableName)
{
$associationName = ExtendHelper::buildAssociationName($this->extendExtension->getEntityClassByTableName($targetTableName));
return $this->nameGenerator->generateManyToOneRelationColumnName($associationName);
}
/**
* @SuppressWarnings(PHPMD.NPathComplexity)
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*
* @param ConfigInterface $extendConfig
* @param ConfigProvider $configProvider
* @param array|null $aliases
* @param callable|null $filter function (ConfigInterface $config) : bool
*/
protected function checkSchema(ConfigInterface $extendConfig, ConfigProvider $configProvider, $aliases, $filter = null)
{
$className = $extendConfig->getId()->getClassName();
$doctrine = [];
$entityName = $className;
if (ExtendHelper::isCustomEntity($className)) {
$type = 'Custom';
$tableName = $extendConfig->get('table');
if (!$tableName) {
$tableName = $this->nameGenerator->generateCustomEntityTableName($className);
}
$doctrine[$entityName] = ['type' => 'entity', 'table' => $tableName];
// add 'id' field only for Custom entity without inheritance
if (!$extendConfig->has('inherit')) {
$doctrine[$entityName]['fields'] = ['id' => ['type' => 'integer', 'id' => true, 'generator' => ['strategy' => 'AUTO']]];
}
} else {
$type = 'Extend';
$entityName = $extendConfig->get('extend_class');
$doctrine[$entityName] = ['type' => 'mappedSuperclass', 'fields' => []];
}
$schema = $extendConfig->get('schema', false, []);
$properties = isset($schema['property']) && null !== $filter ? $schema['property'] : [];
$relationProperties = isset($schema['relation']) && null !== $filter ? $schema['relation'] : [];
$defaultProperties = isset($schema['default']) && null !== $filter ? $schema['default'] : [];
$addRemoveMethods = isset($schema['addremove']) && null !== $filter ? $schema['addremove'] : [];
$fieldConfigs = null === $filter ? $configProvider->getConfigs($className, true) : $configProvider->filter($filter, $className, true);
foreach ($fieldConfigs as $fieldConfig) {
$this->updateFieldState($fieldConfig);
$this->checkFieldSchema($entityName, $fieldConfig, $relationProperties, $defaultProperties, $properties, $doctrine);
}
$relations = $extendConfig->get('relation', false, []);
foreach ($relations as $relation) {
/** @var FieldConfigId $fieldId */
$fieldId = $relation['field_id'];
if (!$fieldId) {
continue;
}
$fieldName = $fieldId->getFieldName();
$isDeleted = $configProvider->hasConfig($fieldId->getClassName(), $fieldName) ? $configProvider->getConfig($fieldId->getClassName(), $fieldName)->is('is_deleted') : false;
if (!isset($relationProperties[$fieldName])) {
$relationProperties[$fieldName] = [];
if ($isDeleted) {
$relationProperties[$fieldName]['private'] = true;
}
}
if (!$isDeleted && $fieldId->getFieldType() !== RelationType::MANY_TO_ONE) {
$addRemoveMethods[$fieldName]['self'] = $fieldName;
/** @var FieldConfigId $targetFieldId */
$targetFieldId = $relation['target_field_id'];
if ($targetFieldId) {
$fieldType = $fieldId->getFieldType();
$addRemoveMethods[$fieldName]['target'] = $targetFieldId->getFieldName();
$addRemoveMethods[$fieldName]['is_target_addremove'] = $fieldType === RelationType::MANY_TO_MANY;
}
}
}
$schema = ['class' => $className, 'entity' => $entityName, 'type' => $type, 'property' => $properties, 'relation' => $relationProperties, 'default' => $defaultProperties, 'addremove' => $addRemoveMethods, 'doctrine' => $doctrine];
if ($type === 'Extend') {
$parentClassName = get_parent_class($className);
if ($parentClassName === $entityName) {
$parentClassName = $aliases[$entityName];
}
$schema['parent'] = $parentClassName;
$schema['inherit'] = get_parent_class($parentClassName);
} elseif ($extendConfig->has('inherit')) {
$schema['inherit'] = $extendConfig->get('inherit');
}
$extendConfig->set('schema', $schema);
$this->configManager->persist($extendConfig);
}
/**
* Gets an activity list table name for many-to-many relation
*
* @param string $targetTableName Target entity table name.
*
* @return string
*/
protected function getAssociationActivityListTableName($targetTableName)
{
$targetClassName = $this->extendExtension->getEntityClassByTableName($targetTableName);
$associationName = ExtendHelper::buildAssociationName($targetClassName, ActivityListEntityConfigDumperExtension::ASSOCIATION_KIND);
return $this->nameGenerator->generateManyToManyJoinTableName(ActivityListEntityConfigDumperExtension::ENTITY_CLASS, $associationName, $targetClassName);
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder->add('className', 'text', ['label' => 'oro.entity_extend.form.name.label', 'block' => 'general', 'subblock' => 'second', 'constraints' => [new Assert\Length(['min' => 5, 'max' => $this->nameGenerator->getMaxCustomEntityNameSize()])]]);
}
