PHP ConfigManager::getConfigFieldModel方法代码示例

 /**
  * {@inheritdoc}
  */
 public function isApplicableField($className, $fieldName)
 {
     $fieldModel = $this->configManager->getConfigFieldModel($className, $fieldName);
     if (!$fieldModel) {
         // this serializer works with non configurable entities as well
         return true;
     }
     if ($fieldModel->getMode() === ConfigModelManager::MODE_HIDDEN) {
         // exclude hidden fields
         return false;
     }
     $extendConfigProvider = $this->configManager->getProvider('extend');
     $extendConfig = $extendConfigProvider->getConfig($className, $fieldName);
     if (!$this->allowExtendedFields && $extendConfig->is('is_extend')) {
         // exclude extended fields if it is requested
         return false;
     }
     if ($extendConfig->is('is_deleted') || $extendConfig->is('state', ExtendScope::STATE_NEW)) {
         // exclude deleted and not created yet fields
         return false;
     }
     if ($extendConfig->has('target_entity') && $extendConfigProvider->getConfig($extendConfig->get('target_entity'))->is('is_deleted')) {
         // exclude associations with deleted custom entities
         return false;
     }
     return true;
 }

 /**
  * @param FormEvent $event
  */
 public function preSetData(FormEvent $event)
 {
     $form = $event->getForm()->getRoot();
     $data = $form->getData();
     if (null === $data || isset($data['extend']['set_options'])) {
         return;
     }
     /** @var FieldConfigId $fieldConfigId */
     $fieldConfigId = $event->getForm()->getConfig()->getOption('config_id');
     $configModel = $this->configManager->getConfigFieldModel($fieldConfigId->getClassName(), $fieldConfigId->getFieldName());
     $data['extend']['set_options'] = $this->configManager->getEntityManager()->getRepository(OptionSet::ENTITY_NAME)->findBy(['field' => $configModel->getId()], ['priority' => 'ASC']);
     $form->setData($data);
 }

 public function testGetConfigFieldModel()
 {
     $model = $this->createFieldConfigModel($this->createEntityConfigModel(self::ENTITY_CLASS), 'id', 'int');
     $this->modelManager->expects($this->once())->method('findFieldModel')->with(self::ENTITY_CLASS, 'id')->willReturn($model);
     $result = $this->configManager->getConfigFieldModel(self::ENTITY_CLASS, 'id');
     $this->assertSame($model, $result);
 }

 /**
  * @param string $className
  * @param string $fieldName
  * @param string $fieldType
  */
 protected function changeFieldType($className, $fieldName, $fieldType)
 {
     if ($this->configManager->getConfigFieldModel($className, $fieldName)->getType() !== $fieldType) {
         $this->logger->notice(sprintf('Update a type of field "%s" to "%s". Entity: %s.', $fieldName, $fieldType, $className));
         $this->configManager->changeFieldType($className, $fieldName, $fieldType);
     }
 }

 /**
  * @param ConfigInterface $sourceEntityConfig The 'extend' config of the source entity
  * @param string          $targetEntityName
  * @param string          $relationName
  * @param string          $targetFieldName    A field 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
  *
  * @return string The relation key
  */
 public function addManyToOneRelation(ConfigInterface $sourceEntityConfig, $targetEntityName, $relationName, $targetFieldName, $options = [], $fieldType = RelationType::MANY_TO_ONE)
 {
     $sourceEntityName = $sourceEntityConfig->getId()->getClassName();
     $relationKey = ExtendHelper::buildRelationKey($sourceEntityName, $relationName, RelationType::MANY_TO_ONE, $targetEntityName);
     // add a relation field config
     if (!$this->configManager->hasConfigFieldModel($sourceEntityName, $relationName)) {
         $this->configManager->createConfigFieldModel($sourceEntityName, $relationName, $fieldType);
         $options['extend']['state'] = ExtendScope::STATE_NEW;
     } else {
         $configFieldModel = $this->configManager->getConfigFieldModel($sourceEntityName, $relationName);
         if ($configFieldModel->getType() !== $fieldType) {
             $this->configManager->changeFieldType($sourceEntityName, $relationName, $fieldType);
         }
     }
     $options['extend']['is_extend'] = true;
     $options['extend']['relation_key'] = $relationKey;
     $options['extend']['target_entity'] = $targetEntityName;
     $options['extend']['target_field'] = $targetFieldName;
     $this->updateFieldConfigs($sourceEntityName, $relationName, $options);
     // add relation to config
     $relations = $sourceEntityConfig->get('relation', false, []);
     if (!isset($relations[$relationKey])) {
         $fieldId = new FieldConfigId('extend', $sourceEntityName, $relationName, RelationType::MANY_TO_ONE);
         $relations[$relationKey] = ['assign' => false, 'field_id' => $fieldId, 'owner' => true, 'target_entity' => $targetEntityName, 'target_field_id' => false];
         if (isset($options['extend']['cascade'])) {
             $relations[$relationKey]['cascade'] = $options['extend']['cascade'];
         }
         $sourceEntityConfig->set('relation', $relations);
         $extendConfigProvider = $this->configManager->getProvider('extend');
         $extendConfigProvider->persist($sourceEntityConfig);
     }
     return $relationKey;
 }

 /**
  * @param string $className
  * @param string $fieldName
  * @param string $mode      Can be the value of one of ConfigModel::MODE_* constants
  *
  * @return bool TRUE if the mode was changed; otherwise, FALSE
  */
 protected function changeFieldMode($className, $fieldName, $mode)
 {
     if ($this->configManager->getConfigFieldModel($className, $fieldName)->getMode() !== $mode) {
         $this->logger->info(sprintf('Update a mode of field "%s" to "%s". Entity: %s.', $fieldName, $mode, $className));
         return $this->configManager->changeFieldMode($className, $fieldName, $mode);
     }
     return false;
 }

 /**
  * @param FormEvent $event
  * @return array
  */
 protected function prepareEvent(FormEvent $event)
 {
     $formData = $event->getForm()->getRoot()->getData();
     if (!$formData) {
         return;
     }
     $entityId = $formData->getId();
     $fieldConfigId = $event->getForm()->getConfig()->getOption('config_id');
     $extendConfig = $this->configManager->getConfig($fieldConfigId);
     $model = $this->configManager->getConfigFieldModel($fieldConfigId->getClassName(), $fieldConfigId->getFieldName());
     return [$entityId, $model, $extendConfig];
 }

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

 /**
  * Returns a list of all choices for an option set
  *
  * @param string $entityClassName
  * @param string $entityFieldName
  * @return array
  */
 protected function getChoices($entityClassName, $entityFieldName)
 {
     $configFieldModel = $this->configManager->getConfigFieldModel($entityClassName, $entityFieldName);
     $options = $configFieldModel->getOptions()->toArray();
     uasort($options, function ($a, $b) {
         if ($a->getPriority() === $b->getPriority()) {
             return 0;
         }
         return $a->getPriority() < $b->getPriority() ? -1 : 1;
     });
     $result = [];
     foreach ($options as $option) {
         $result[$option->getId()] = $option->getLabel();
     }
     return $result;
 }

 /**
  * @param string $entityClass
  * @param string $fieldName
  */
 protected function hideRelationField($entityClass, $fieldName)
 {
     $fieldModel = $this->configManager->getConfigFieldModel($entityClass, $fieldName);
     $fieldModel->setType(ConfigModelManager::MODE_HIDDEN);
 }