PHP ExtendHelper::generateEnumCode方法代码示例

 /**
  * {@inheritdoc}
  *
  * @SuppressWarnings(PHPMD.NPathComplexity)
  */
 public function preUpdate()
 {
     $enumConfigProvider = $this->configManager->getProvider('enum');
     $extendConfigProvider = $this->configManager->getProvider('extend');
     $entityConfigs = $extendConfigProvider->getConfigs();
     foreach ($entityConfigs as $entityConfig) {
         if (!$entityConfig->is('is_extend')) {
             continue;
         }
         $fieldConfigs = $extendConfigProvider->getConfigs($entityConfig->getId()->getClassName());
         foreach ($fieldConfigs as $fieldConfig) {
             if (!$fieldConfig->in('state', [ExtendScope::STATE_NEW, ExtendScope::STATE_UPDATE])) {
                 continue;
             }
             /** @var FieldConfigId $fieldConfigId */
             $fieldConfigId = $fieldConfig->getId();
             $fieldType = $fieldConfigId->getFieldType();
             if (!in_array($fieldType, ['enum', 'multiEnum'])) {
                 continue;
             }
             // prepare input parameters
             $fieldOptions = [];
             $enumFieldConfig = $enumConfigProvider->getConfig($fieldConfigId->getClassName(), $fieldConfigId->getFieldName());
             $enumCode = $enumFieldConfig->get('enum_code');
             $enumName = $enumFieldConfig->get('enum_name');
             $isPublic = $enumFieldConfig->get('enum_public');
             if (empty($enumCode) && $isPublic && empty($enumName)) {
                 throw new \LogicException(sprintf('Both "enum_code" and "enum_name" cannot be empty for a public enum. Field: %s::%s.', $fieldConfigId->getClassName(), $fieldConfigId->getFieldName()));
             }
             if (empty($enumCode)) {
                 $enumCode = $enumName !== null ? ExtendHelper::buildEnumCode($enumName) : ExtendHelper::generateEnumCode($fieldConfigId->getClassName(), $fieldConfigId->getFieldName());
                 $fieldOptions['enum']['enum_code'] = $enumCode;
             }
             $isMultiple = $this->fieldTypeHelper->getUnderlyingType($fieldType) === RelationType::MANY_TO_MANY;
             $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode);
             // create an entity is used to store enum values
             $this->createEnumValueConfigEntityModel($enumValueClassName, $enumCode, $isMultiple, $isPublic);
             // create a relation
             if ($isMultiple) {
                 $fieldOptions['extend']['without_default'] = true;
                 $this->relationBuilder->addManyToManyRelation($entityConfig, $enumValueClassName, $fieldConfigId->getFieldName(), ['name'], ['name'], ['name'], $fieldOptions, $fieldType);
             } else {
                 $this->relationBuilder->addManyToOneRelation($entityConfig, $enumValueClassName, $fieldConfigId->getFieldName(), 'name', $fieldOptions, $fieldType);
             }
         }
     }
 }

 /**
  * Post submit event handler
  *
  * @param FormEvent $event
  *
  * @SuppressWarnings(PHPMD.NPathComplexity)
  */
 public function postSubmit(FormEvent $event)
 {
     $form = $event->getForm();
     $configModel = $form->getConfig()->getOption('config_model');
     if (!$configModel instanceof FieldConfigModel) {
         return;
     }
     if (!in_array($configModel->getType(), ['enum', 'multiEnum'])) {
         return;
     }
     if (!$form->isValid()) {
         return;
     }
     $data = $event->getData();
     $enumConfig = $configModel->toArray('enum');
     $enumName = $this->getValue($data['enum'], 'enum_name');
     $enumCode = $this->getValue($enumConfig, 'enum_code');
     if (empty($enumCode)) {
         $enumCode = $enumName !== null ? ExtendHelper::buildEnumCode($enumName) : ExtendHelper::generateEnumCode($configModel->getEntity()->getClassName(), $configModel->getFieldName());
     }
     $locale = $this->translator->getLocale();
     $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode);
     $enumConfigProvider = $this->configManager->getProvider('enum');
     if ($enumConfigProvider->hasConfig($enumValueClassName)) {
         // existing enum
         if ($configModel->getId()) {
             if ($enumName !== null) {
                 $this->enumSynchronizer->applyEnumNameTrans($enumCode, $enumName, $locale);
             }
             $enumOptions = $this->getValue($data['enum'], 'enum_options');
             if ($enumOptions !== null) {
                 $this->enumSynchronizer->applyEnumOptions($enumValueClassName, $enumOptions, $locale);
             }
             $enumPublic = $this->getValue($data['enum'], 'enum_public');
             if ($enumPublic !== null) {
                 $this->enumSynchronizer->applyEnumEntityOptions($enumValueClassName, $enumPublic);
             }
         }
         unset($data['enum']['enum_name']);
         unset($data['enum']['enum_options']);
         unset($data['enum']['enum_public']);
         $event->setData($data);
     } else {
         // new enum
         $this->sortOptions($data['enum']['enum_options']);
         $data['enum']['enum_locale'] = $locale;
         $event->setData($data);
     }
 }

 /**
  * @param string   $entityClassName
  * @param string   $fieldName
  * @param string[] $existingEnumTables
  *
  * @return string
  */
 protected function buildEnumCode($entityClassName, $fieldName, $existingEnumTables)
 {
     $nameGenerator = $this->extendExtension->getNameGenerator();
     $enumCode = ExtendHelper::generateEnumCode($entityClassName, $fieldName, $nameGenerator->getMaxEnumCodeSize());
     // check if an enum with that code is already exist and generate new code if so
     while (in_array($nameGenerator->generateEnumTableName($enumCode), $existingEnumTables, true)) {
         $enumCode = sprintf('enum_%s_%s', dechex(crc32(ExtendHelper::getShortClassName($entityClassName))), dechex(crc32(microtime())));
     }
     return $enumCode;
 }

 /**
  * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
  */
 public function testPreUpdateForNewEnumWithLongEnumCode()
 {
     $entityConfig1 = new Config(new EntityConfigId('extend', 'Test\\EnumValue1'));
     $entityConfig1->set('is_extend', true);
     $fieldConfig1 = new Config(new FieldConfigId('extend', 'Test\\EnumValue1', 'field1', 'enum'));
     $fieldConfig1->set('state', ExtendScope::STATE_NEW);
     $enumFieldConfig1 = new Config(new FieldConfigId('enum', 'Test\\EnumValue1', 'field1', 'enum'));
     $entityConfigs = [$entityConfig1];
     $fieldConfigs = [$fieldConfig1];
     $enumCode1 = ExtendHelper::generateEnumCode('Test\\EnumValue1', 'field1');
     $enumValueClassName1 = ExtendHelper::buildEnumValueClassName($enumCode1);
     $extendConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock();
     $enumConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock();
     $this->configManager->expects($this->any())->method('getProvider')->will($this->returnValueMap([['extend', $extendConfigProvider], ['enum', $enumConfigProvider]]));
     $extendConfigProvider->expects($this->at(0))->method('getConfigs')->will($this->returnValue($entityConfigs));
     $extendConfigProvider->expects($this->at(1))->method('getConfigs')->with($entityConfig1->getId()->getClassName())->will($this->returnValue($fieldConfigs));
     $enumConfigProvider->expects($this->at(0))->method('getConfig')->with($entityConfig1->getId()->getClassName(), 'field1')->will($this->returnValue($enumFieldConfig1));
     $this->configManager->expects($this->once())->method('hasConfigEntityModel')->will($this->returnValueMap([[$enumValueClassName1, false]]));
     $configManagerAt = 3;
     $this->configManager->expects($this->at($configManagerAt++))->method('createConfigEntityModel')->with($enumValueClassName1, ConfigModelManager::MODE_HIDDEN);
     $relationBuilderAt = 0;
     $this->relationBuilder->expects($this->at($relationBuilderAt++))->method('updateEntityConfigs')->with($enumValueClassName1, ['entity' => ['label' => ExtendHelper::getEnumTranslationKey('label', $enumCode1), 'plural_label' => ExtendHelper::getEnumTranslationKey('plural_label', $enumCode1), 'description' => ExtendHelper::getEnumTranslationKey('description', $enumCode1)], 'extend' => ['owner' => ExtendScope::OWNER_SYSTEM, 'is_extend' => true, 'table' => $this->nameGenerator->generateEnumTableName($enumCode1, true), 'inherit' => ExtendHelper::BASE_ENUM_VALUE_CLASS], 'enum' => ['code' => $enumCode1, 'public' => false, 'multiple' => false]]);
     $this->setAddEnumValueEntityFieldsExpectations($enumValueClassName1, $enumCode1, $configManagerAt, $relationBuilderAt);
     $this->relationBuilder->expects($this->at($relationBuilderAt++))->method('addManyToOneRelation')->with($this->identicalTo($entityConfig1), $enumValueClassName1, 'field1', 'name', ['enum' => ['enum_code' => $enumCode1]], 'enum');
     $this->extension->preUpdate();
 }

 /**
  * @expectedException \InvalidArgumentException
  * @expectedExceptionMessage $fieldName must not be empty.
  */
 public function testGenerateEnumCodeForEmptyFieldName()
 {
     ExtendHelper::generateEnumCode('Test\\Entity', '');
 }

 /**
  * @dataProvider enumTypeProvider
  */
 public function testPostSubmitForNewEnumWithoutNameAndPublic($dataType)
 {
     $entityClassName = 'Test\\Entity';
     $fieldName = 'testField';
     $enumCode = ExtendHelper::generateEnumCode($entityClassName, $fieldName);
     $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode);
     $locale = 'fr';
     $entityConfigModel = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Entity\\EntityConfigModel')->disableOriginalConstructor()->getMock();
     $entityConfigModel->expects($this->once())->method('getClassName')->will($this->returnValue($entityClassName));
     $configModel = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Entity\\FieldConfigModel')->disableOriginalConstructor()->getMock();
     $configModel->expects($this->never())->method('getId');
     $configModel->expects($this->once())->method('getType')->will($this->returnValue($dataType));
     $configModel->expects($this->once())->method('getEntity')->will($this->returnValue($entityConfigModel));
     $configModel->expects($this->once())->method('getFieldName')->will($this->returnValue($fieldName));
     $form = $this->getMock('Symfony\\Component\\Form\\Test\\FormInterface');
     $form->expects($this->once())->method('isValid')->will($this->returnValue(true));
     $event = $this->getFormEventMock($configModel, $form);
     $enumOptions = [['id' => 'val1', 'label' => 'Value 1', 'priority' => 1]];
     $submittedData = ['enum' => ['enum_options' => $enumOptions]];
     $expectedData = ['enum' => ['enum_options' => $enumOptions, 'enum_locale' => $locale]];
     $event->expects($this->once())->method('getData')->will($this->returnValue($submittedData));
     $configModel->expects($this->once())->method('toArray')->with('enum')->will($this->returnValue([]));
     $this->translator->expects($this->once())->method('getLocale')->will($this->returnValue($locale));
     $enumConfigProvider = $this->getConfigProviderMock();
     $this->configManager->expects($this->once())->method('getProvider')->with('enum')->will($this->returnValue($enumConfigProvider));
     $enumConfigProvider->expects($this->once())->method('hasConfig')->with($enumValueClassName)->will($this->returnValue(false));
     $event->expects($this->once())->method('setData')->with($expectedData);
     $this->extension->postSubmit($event);
 }