/**
* Process field
*
* @param array $mapConfig
* @param ConfigInterface $searchConfig
* @param FieldConfigId $fieldId
* @param string $className
*/
protected function processFields(&$mapConfig, ConfigInterface $searchConfig, FieldConfigId $fieldId, $className)
{
$extendConfigProvider = $this->configManager->getProvider('extend');
$fieldName = $fieldId->getFieldName();
if ($searchConfig->is('searchable')) {
$fieldType = $this->transformCustomType($fieldId->getFieldType());
if (in_array($fieldType, [Indexer::RELATION_ONE_TO_ONE, Indexer::RELATION_MANY_TO_ONE])) {
$config = $extendConfigProvider->getConfig($className, $fieldName);
$targetEntity = $config->get('target_entity');
$targetField = $config->get('target_field');
$targetType = $this->transformCustomType($this->configManager->getId('extend', $targetEntity, $targetField)->getFieldType());
$field = ['name' => $fieldName, 'relation_type' => $fieldType, 'relation_fields' => [['name' => $targetField, 'target_type' => $targetType, 'target_fields' => [strtolower($fieldName . '_' . $targetField)]]]];
} elseif (in_array($fieldType, [Indexer::RELATION_MANY_TO_MANY, Indexer::RELATION_ONE_TO_MANY])) {
$config = $extendConfigProvider->getConfig($className, $fieldName);
$targetEntity = $config->get('target_entity');
$targetFields = array_unique(array_merge($config->get('target_grid'), $config->get('target_title'), $config->get('target_detailed')));
$fields = [];
foreach ($targetFields as $targetField) {
$targetType = $this->transformCustomType($this->configManager->getId('extend', $targetEntity, $targetField)->getFieldType());
$fields[] = ['name' => $targetField, 'target_type' => $targetType, 'target_fields' => [strtolower($fieldName . '_' . $targetField)]];
}
$field = ['name' => $fieldName, 'relation_type' => $fieldType, 'relation_fields' => $fields];
} else {
$field = ['name' => $fieldName, 'target_type' => $fieldType, 'target_fields' => [strtolower($fieldName)]];
}
$mapConfig[$className][self::FIELDS_PATH][] = $field;
}
}
/**
* @param FieldConfigId $selfFieldId
* @param string $targetEntity
* @return string
*/
public static function generateManyToManyJoinTableName(FieldConfigId $selfFieldId, $targetEntity)
{
$selfClassArray = explode('\\', $selfFieldId->getClassName());
$selfClassName = array_pop($selfClassArray);
$targetClassArray = explode('\\', $targetEntity);
$targetClassName = array_pop($targetClassArray);
return strtolower('oro_extend_' . $selfClassName . '_' . $targetClassName . '_' . $selfFieldId->getFieldName());
}
public function testSetState()
{
$fieldId = FieldConfigId::__set_state(['className' => 'Test\\Class', 'scope' => 'testScope', 'fieldName' => 'testField', 'fieldType' => 'string']);
$this->assertEquals('Test\\Class', $fieldId->getClassName());
$this->assertEquals('testScope', $fieldId->getScope());
$this->assertEquals('testField', $fieldId->getFieldName());
$this->assertEquals('string', $fieldId->getFieldType());
}
public function testGetConfig()
{
$this->assertEquals('Test\\Class', $this->fieldId->getClassName());
$this->assertEquals('testScope', $this->fieldId->getScope());
$this->assertEquals('testField', $this->fieldId->getFieldName());
$this->assertEquals('string', $this->fieldId->getFieldType());
$this->assertEquals('field_testScope_Test-Class_testField', $this->fieldId->toString());
$this->fieldId->setFieldType('integer');
$this->assertEquals('integer', $this->fieldId->getFieldType());
}
/**
* Guess formatters for given fieldConfigId
* Returns array with data:
* - formatters: array with supported formatters for given field
* - default_formatter: default formatter for given field
*
* @param FieldConfigId $configId
*
* @return array|null
*/
public function guessFormatters(FieldConfigId $configId)
{
$fieldType = $configId->getFieldType();
$formatters = [];
$defaultFormatter = null;
$found = false;
foreach ($this->formatters as $formatterName => $formatter) {
$isSupport = in_array($fieldType, $formatter->getSupportedTypes());
if ($isSupport) {
$found = true;
$formatters[] = $formatterName;
if ($formatter->isDefaultFormatter()) {
$defaultFormatter = $formatterName;
}
}
}
if ($found) {
return ['formatters' => $formatters, 'default_formatter' => $defaultFormatter];
}
return null;
}
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);
}
/**
* @param ConfigInterface $fieldConfig
* @param string $relationKey
*/
protected function createTargetRelation(ConfigInterface $fieldConfig, $relationKey)
{
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $fieldConfig->getId();
$selfFieldId = new FieldConfigId('extend', $fieldConfigId->getClassName(), $fieldConfigId->getFieldName(), $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType()));
$targetEntityClass = $fieldConfig->get('target_entity');
$selfConfig = $this->extendConfigProvider->getConfig($selfFieldId->getClassName());
$selfRelations = $selfConfig->get('relation');
$selfRelationConfig =& $selfRelations[$relationKey];
$selfRelationConfig['field_id'] = $selfFieldId;
$targetConfig = $this->extendConfigProvider->getConfig($targetEntityClass);
$targetRelations = $targetConfig->get('relation');
$targetRelationConfig =& $targetRelations[$relationKey];
$targetRelationConfig['target_field_id'] = $selfFieldId;
$selfConfig->set('relation', $selfRelations);
$targetConfig->set('relation', $targetRelations);
$this->extendConfigProvider->persist($targetConfig);
}
/**
* @param FieldConfigId $fieldConfigId
*
* @return string
*/
protected function getRelationKey(FieldConfigId $fieldConfigId)
{
return ExtendHelper::buildRelationKey($fieldConfigId->getClassName(), $fieldConfigId->getFieldName(), 'manyToOne', 'Oro\\Bundle\\AttachmentBundle\\Entity\\File');
}
/**
* @param string $scope
* @param FieldConfigId $fieldId
*
* @return ConfigInterface
*/
protected function getFieldConfig($scope, FieldConfigId $fieldId)
{
return $this->configManager->getProvider($scope)->getConfig($fieldId->getClassName(), $fieldId->getFieldName());
}
/**
* @SuppressWarnings(PHPMD.NPathComplexity)
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*
* @param array $config
*/
protected function prepare($config)
{
$metadata = [];
$fieldConfigs = [];
foreach ($config as $entityClassName => $entityData) {
$entityMetadata = $this->getMockBuilder('Doctrine\\ORM\\Mapping\\ClassMetadata')->disableOriginalConstructor()->getMock();
$entityMetadata->expects($this->any())->method('getName')->will($this->returnValue($entityClassName));
$metadata[$entityClassName] = $entityMetadata;
$fieldNames = [];
$fieldTypes = [];
$fieldIdentifiers = [];
$configs = [];
foreach ($entityData['fields'] as $fieldName => $fieldData) {
$fieldNames[] = $fieldName;
$fieldTypes[] = [$fieldName, $fieldData['type']];
$fieldIdentifiers[] = [$fieldName, isset($fieldData['identifier']) ? $fieldData['identifier'] : false];
$configId = new FieldConfigId('extend', $entityClassName, $fieldName, $fieldData['type']);
$configs[] = new Config($configId);
}
$fieldConfigs[$entityClassName] = $configs;
$entityMetadata->expects($this->any())->method('getFieldNames')->will($this->returnValue($fieldNames));
$entityMetadata->expects($this->any())->method('hasField')->willReturnCallback(function ($name) use($fieldNames) {
return in_array($name, $fieldNames, true);
});
$entityMetadata->expects($this->any())->method('isIdentifier')->will($this->returnValueMap($fieldIdentifiers));
$relNames = [];
$mappings = [];
if (isset($entityData['relations'])) {
$relTargetClasses = [];
foreach ($entityData['relations'] as $relName => $relData) {
$type = $relData['type'];
$relTargetClass = $relData['target_class'];
if ($type === 'ref-one') {
$mappings[$relName] = $relData;
}
$fieldTypes[] = [$relName, $type];
$relNames[] = $relName;
$relTargetClasses[] = [$relName, $relTargetClass];
}
$entityMetadata->expects($this->any())->method('getAssociationTargetClass')->will($this->returnValueMap($relTargetClasses));
$entityMetadata->expects($this->any())->method('getAssociationMappedByTargetField')->will($this->returnValue('id'));
}
$entityMetadata->expects($this->any())->method('getAssociationNames')->will($this->returnValue($relNames));
$entityMetadata->expects($this->any())->method('hasAssociation')->willReturnCallback(function ($name) use($relNames) {
return in_array($name, $relNames, true);
});
if (isset($entityData['unidirectional_relations'])) {
foreach ($entityData['unidirectional_relations'] as $relName => $relData) {
$fieldTypes[] = [$relName, $relData['type']];
$relData['fieldName'] = $relName;
$relData['isOwningSide'] = true;
$relData['inversedBy'] = null;
$relData['sourceEntity'] = $entityClassName;
unset($relData['config']);
$mappings[$relName] = $relData;
}
$entityMetadata->expects($this->any())->method('getAssociationMappings')->will($this->returnValue($mappings));
}
$entityMetadata->expects($this->any())->method('isSingleValuedAssociation')->will($this->returnCallback(function ($field) use($mappings) {
return !empty($mappings[$field]);
}));
$entityMetadata->expects($this->any())->method('getTypeOfField')->will($this->returnValueMap($fieldTypes));
}
$em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$metadataFactory = $this->getMock('Doctrine\\ORM\\Mapping\\ClassMetadataFactory');
$em->expects($this->any())->method('getMetadataFactory')->will($this->returnValue($metadataFactory));
$metadataFactory->expects($this->any())->method('getMetadataFor')->will($this->returnCallback(function ($entityClassName) use(&$metadata) {
return $metadata[$entityClassName];
}));
$this->doctrine->expects($this->any())->method('getManagerForClass')->with($this->isType('string'))->will($this->returnValue($em));
$this->extendConfigProvider->expects($this->any())->method('getConfigs')->will($this->returnCallback(function ($className) use($fieldConfigs) {
return $fieldConfigs[$className];
}));
$this->entityConfigProvider->expects($this->any())->method('hasConfig')->will($this->returnCallback(function ($className, $fieldName) use(&$config) {
if (isset($config[$className])) {
if ($fieldName === null) {
return true;
}
if (isset($config[$className]['fields'][$fieldName]['config'])) {
return true;
}
if (isset($config[$className]['relations'][$fieldName]['config'])) {
return true;
}
if (isset($config[$className]['unidirectional_relations'][$fieldName]['config'])) {
return true;
}
}
return false;
}));
$this->entityConfigProvider->expects($this->any())->method('getConfig')->will($this->returnCallback(function ($className, $fieldName) use(&$config) {
if (isset($config[$className])) {
if ($fieldName === null) {
return $this->getEntityConfig($className, $config[$className]['config']);
}
if (isset($config[$className]['fields'][$fieldName]['config'])) {
return $this->getEntityFieldConfig($className, $fieldName, $config[$className]['fields'][$fieldName]['type'], $config[$className]['fields'][$fieldName]['config']);
}
if (isset($config[$className]['relations'][$fieldName]['config'])) {
return $this->getEntityFieldConfig($className, $fieldName, $config[$className]['relations'][$fieldName]['type'], $config[$className]['relations'][$fieldName]['config']);
}
if (isset($config[$className]['unidirectional_relations'][$fieldName]['config'])) {
return $this->getEntityFieldConfig($className, $fieldName, $config[$className]['unidirectional_relations'][$fieldName]['type'], $config[$className]['unidirectional_relations'][$fieldName]['config']);
}
}
return null;
}));
$this->extendConfigProvider->expects($this->any())->method('hasConfig')->will($this->returnCallback(function ($className, $fieldName) use(&$config) {
if (isset($config[$className])) {
if ($fieldName === null) {
return true;
}
if (isset($config[$className]['fields'][$fieldName]['config'])) {
return true;
}
if (isset($config[$className]['relations'][$fieldName]['config'])) {
return true;
}
if (isset($config[$className]['unidirectional_relations'][$fieldName]['config'])) {
return true;
}
}
return false;
}));
$this->extendConfigProvider->expects($this->any())->method('getConfig')->will($this->returnCallback(function ($className, $fieldName) use(&$config) {
if (isset($config[$className])) {
if ($fieldName === null) {
return $this->getExtendEntityConfig($className, $config[$className]['config']);
}
if (isset($config[$className]['fields'][$fieldName]['config'])) {
return $this->getExtendFieldConfig($className, $fieldName, $config[$className]['fields'][$fieldName]['type'], $config[$className]['fields'][$fieldName]['config']);
}
if (isset($config[$className]['relations'][$fieldName]['config'])) {
return $this->getExtendFieldConfig($className, $fieldName, $config[$className]['relations'][$fieldName]['type'], $config[$className]['relations'][$fieldName]['config']);
}
if (isset($config[$className]['unidirectional_relations'][$fieldName]['config'])) {
return $this->getExtendFieldConfig($className, $fieldName, $config[$className]['unidirectional_relations'][$fieldName]['type'], $config[$className]['unidirectional_relations'][$fieldName]['config']);
}
}
return null;
}));
$this->extendConfigProvider->expects($this->any())->method('getConfigById')->will($this->returnCallback(function (EntityConfigId $configId) use(&$config) {
$className = $configId->getClassname();
if (isset($config[$className])) {
return $this->getExtendEntityConfig($className, $config[$className]['config']);
}
return null;
}));
$this->extendConfigProvider->expects($this->any())->method('getId')->will($this->returnCallback(function ($className, $fieldName) use(&$config) {
if (isset($config[$className])) {
if (isset($config[$className]['fields'][$fieldName]['config'])) {
return new FieldConfigId('extend', $className, $fieldName, $config[$className]['fields'][$fieldName]['type']);
}
if (isset($config[$className]['relations'][$fieldName]['config'])) {
return new FieldConfigId('extend', $className, $fieldName, $config[$className]['relations'][$fieldName]['type']);
}
if (isset($config[$className]['unidirectional_relations'][$fieldName]['config'])) {
return new FieldConfigId('extend', $className, $fieldName, $config[$className]['unidirectional_relations'][$fieldName]['type']);
}
}
return null;
}));
}
protected function renameExtendField(Schema $schema, QueryBag $queries, Table $table, FieldConfigId $fieldConfigId, ConfigManager $configManager, EntityMetadataHelper $entityMetadataHelper)
{
switch ($fieldConfigId->getFieldType()) {
case RelationType::MANY_TO_ONE:
$this->renameManyToOneExtendField($schema, $queries, $table, $fieldConfigId->getFieldName());
break;
case RelationType::ONE_TO_MANY:
$config = $configManager->getConfig($fieldConfigId);
$targetEntityClassName = $config->get('target_entity');
$this->renameOneToManyExtendField($schema, $queries, $table, $fieldConfigId->getFieldName(), $targetEntityClassName, $entityMetadataHelper);
break;
case RelationType::MANY_TO_MANY:
break;
default:
$oldColumnName = 'field_' . $fieldConfigId->getFieldName();
if ($table->hasColumn($oldColumnName)) {
$this->renameExtension->renameColumn($schema, $queries, $table, $oldColumnName, $fieldConfigId->getFieldName());
}
break;
}
}
/**
* @param ConfigInterface $fieldConfig
*/
protected function createSelfRelation(ConfigInterface $fieldConfig)
{
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $fieldConfig->getId();
$targetEntityClass = $fieldConfig->get('target_entity');
$selfFieldId = $selfFieldId = new FieldConfigId('extend', $fieldConfigId->getClassName(), $fieldConfigId->getFieldName(), $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType()));
$targetFieldId = false;
$owner = true;
$targetOwner = false;
if (in_array($selfFieldId->getFieldType(), RelationType::$toManyRelations, true)) {
$classNameArray = explode('\\', $selfFieldId->getClassName());
$relationFieldName = strtolower(array_pop($classNameArray)) . '_' . $selfFieldId->getFieldName();
if ($selfFieldId->getFieldType() === RelationType::ONE_TO_MANY) {
$owner = false;
$targetOwner = true;
}
$targetFieldId = new FieldConfigId('extend', $targetEntityClass, $relationFieldName, ExtendHelper::getReverseRelationType($selfFieldId->getFieldType()));
}
$relationKey = ExtendHelper::buildRelationKey($selfFieldId->getClassName(), $selfFieldId->getFieldName(), $selfFieldId->getFieldType(), $targetEntityClass);
$selfConfig = $this->extendConfigProvider->getConfig($selfFieldId->getClassName());
$selfRelationConfig = ['field_id' => $selfFieldId, 'owner' => $owner, 'target_entity' => $targetEntityClass, 'target_field_id' => $targetFieldId];
if ($fieldConfig->has('cascade')) {
$selfRelationConfig['cascade'] = $fieldConfig->get('cascade');
}
$selfRelations = $selfConfig->get('relation', false, []);
$selfRelations[$relationKey] = $selfRelationConfig;
$selfConfig->set('relation', $selfRelations);
$this->configManager->persist($selfConfig);
$targetConfig = $this->extendConfigProvider->getConfig($targetEntityClass);
$targetRelationConfig = ['field_id' => $targetFieldId, 'owner' => $targetOwner, 'target_entity' => $selfFieldId->getClassName(), 'target_field_id' => $selfFieldId];
$targetRelations = $targetConfig->get('relation', false, []);
$targetRelations[$relationKey] = $targetRelationConfig;
$targetConfig->set('relation', $targetRelations);
$this->configManager->persist($targetConfig);
$fieldConfig->set('relation_key', $relationKey);
$this->configManager->persist($fieldConfig);
}
public function setDefaultOptions(OptionsResolverInterface $resolver)
{
$resolver->setDefaults(array('attr' => array('class' => 'extend-rel-target-name'), 'label' => 'Target entity', 'empty_value' => $this->targetEntity ? false : 'Please choice target entity...', 'read_only' => (bool) $this->targetEntity, 'choices' => $this->getEntityChoiceList($this->configId->getClassName(), $this->configId->getFieldType())));
}
/**
* @param string $code
* @param $label
* @param FieldConfigId $fieldConfig
*
* @return array
*/
protected function createFieldArrayDefinition($code, $label, FieldConfigId $fieldConfig)
{
return [$code => ['type' => 'field', 'label' => $label, 'field_name' => $code, 'filter_type' => $this->filterMap[$fieldConfig->getFieldType()], 'required' => false, 'sortable' => true, 'filterable' => true, 'show_filter' => true]];
}
/**
* @param object $entity
* @param FieldConfigId $fieldConfig
* @return OptionSetRelation[]
*/
protected function getValueForOptionSet($entity, FieldConfigId $fieldConfig)
{
/** @var $optionSetRepository OptionSetRelationRepository */
$optionSetRepository = $this->configManager->getEntityManager()->getRepository(OptionSetRelation::ENTITY_NAME);
$model = $this->configManager->getConfigFieldModel($fieldConfig->getClassName(), $fieldConfig->getFieldName());
$value = $optionSetRepository->findByFieldId($model->getId(), $entity->getId());
array_walk($value, function (OptionSetRelation &$item) {
$item = array('title' => $item->getOption()->getLabel());
});
$value['values'] = $value;
return $value;
}
public function setDefaultOptions(OptionsResolverInterface $resolver)
{
$resolver->setDefaults(array('attr' => array('class' => 'extend-rel-target-name'), 'label' => 'oro.entity_extend.form.target_entity', 'empty_value' => $this->targetEntity ? null : '', 'read_only' => (bool) $this->targetEntity, 'choices' => $this->getEntityChoiceList($this->configId->getClassName(), $this->configId->getFieldType()), 'choice_attr' => function ($choice) {
return $this->getChoiceAttributes($choice);
}, 'configs' => array('allowClear' => true, 'placeholder' => 'oro.entity.form.choose_entity', 'result_template_twig' => 'OroEntityBundle:Choice:entity/result.html.twig', 'selection_template_twig' => 'OroEntityBundle:Choice:entity/selection.html.twig')));
}
public function testDeleteFieldConfig()
{
$configId = new FieldConfigId(self::SCOPE, self::ENTITY_CLASS, self::FIELD_NAME, self::FIELD_TYPE);
$cacheKey = self::ENTITY_CLASS . '.' . self::FIELD_NAME;
$this->cache->expects($this->at(0))->method('delete')->with(ConfigCache::FIELD_NAMES_KEY . self::ENTITY_CLASS)->willReturn(true);
$this->cache->expects($this->at(1))->method('delete')->with($cacheKey)->willReturn(true);
$this->assertTrue($this->configCache->deleteFieldConfig($configId->getClassName(), $configId->getFieldName()));
}
/**
* @param array $options
* @param ConfigInterface $extendConfig
* @param FieldConfigId $fieldConfigId
*
* @return array
*/
protected function addConstraintsToOptions(array $options, ConfigInterface $extendConfig, FieldConfigId $fieldConfigId)
{
switch ($fieldConfigId->getFieldType()) {
case 'decimal':
$options['constraints'] = [new Decimal(['precision' => $extendConfig->get('precision'), 'scale' => $extendConfig->get('scale')])];
break;
case 'string':
$length = $extendConfig->get('length') ?: 255;
$options['constraints'] = [new Length(['max' => $length])];
break;
}
return $options;
}
/**
* @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();
}
/**
* @param FieldConfigId $fieldId
*
* @return ConfigInterface
*/
protected function getFieldConfig(FieldConfigId $fieldId)
{
return $this->configManager->getFieldConfig('extend', $fieldId->getClassName(), $fieldId->getFieldName());
}
public function testClearFieldCache()
{
$configId = new FieldConfigId('entity', self::ENTITY_CLASS, 'field');
$this->configCache->expects($this->once())->method('deleteFieldConfig')->with($configId->getClassName(), $configId->getFieldName());
$this->configManager->clearCache($configId);
}
/**
* Changes a type of a field
*
* @param string $className
* @param string $fieldName
* @param string $newFieldName
* @return bool TRUE if the name was changed; otherwise, FALSE
*/
public function changeFieldName($className, $fieldName, $newFieldName)
{
$result = $this->modelManager->changeFieldName($className, $fieldName, $newFieldName);
if ($result) {
$this->eventDispatcher->dispatch(Events::RENAME_FIELD, new RenameFieldEvent($className, $fieldName, $newFieldName, $this));
foreach ($this->getProviders() as $provider) {
/** @var FieldConfigId $newConfigId */
$newConfigId = $this->getId($provider->getScope(), $className, $newFieldName);
$newConfigKey = $this->buildConfigKey($newConfigId);
$configId = new FieldConfigId($newConfigId->getScope(), $newConfigId->getClassName(), $fieldName, $newConfigId->getFieldType());
$cachedConfig = $this->cache->getFieldConfig($configId->getScope(), $configId->getClassName(), $configId->getFieldName(), true);
if ($cachedConfig) {
$this->cache->saveConfig($this->changeConfigFieldName($cachedConfig, $newFieldName), true);
$this->cache->deleteFieldConfig($configId->getClassName(), $configId->getFieldName(), true);
}
$configKey = $this->buildConfigKey($configId);
if (isset($this->persistConfigs[$configKey])) {
$this->persistConfigs[$newConfigKey] = $this->changeConfigFieldName($this->persistConfigs[$configKey], $newFieldName);
unset($this->persistConfigs[$configKey]);
}
if (isset($this->originalConfigs[$configKey])) {
$this->originalConfigs[$newConfigKey] = $this->changeConfigFieldName($this->originalConfigs[$configKey], $newFieldName);
unset($this->originalConfigs[$configKey]);
}
if (isset($this->configChangeSets[$configKey])) {
$this->configChangeSets[$newConfigKey] = $this->configChangeSets[$configKey];
unset($this->configChangeSets[$configKey]);
}
}
}
return $result;
}
