/** * 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()])]]); }