PHP ConfigProvider::getConfigById方法代码示例

 public function buildForm(FormBuilderInterface $builder, array $options)
 {
     $this->config = $this->configProvider->getConfigById($options['config_id']);
     $this->formFactory = $builder->getFormFactory();
     $builder->add('target_entity', new TargetType($this->configProvider, $options['config_id']), ['constraints' => [new Assert\NotBlank()]]);
     $builder->addEventListener(FormEvents::PRE_SET_DATA, array($this, 'preSubmitData'));
     $builder->addEventListener(FormEvents::PRE_SUBMIT, array($this, 'preSubmitData'));
 }

 /**
  * {@inheritdoc}
  */
 public function beforeValueRender(ValueRenderEvent $event)
 {
     $fieldConfig = $this->configProvider->getConfigById($event->getFieldConfigId());
     $contactInformationType = $fieldConfig->get('contact_information');
     // if some contact information type is defined -- applies proper template for its value
     if (null !== $contactInformationType && isset($this->contactInformationMap[$contactInformationType])) {
         $event->setFieldViewValue(['value' => $event->getFieldValue(), 'entity' => $event->getEntity(), 'template' => $this->contactInformationMap[$contactInformationType]]);
     }
 }

 public function testConfig()
 {
     $this->assertEquals($this->configManager, $this->configProvider->getConfigManager());
     $this->assertEquals(true, $this->configProvider->hasConfig(DemoEntity::ENTITY_NAME));
     $this->assertEquals($this->entityConfig, $this->configProvider->getConfig(DemoEntity::ENTITY_NAME));
     $this->assertEquals('testScope', $this->configProvider->getScope());
     $entityConfigId = new EntityConfigId('testScope', DemoEntity::ENTITY_NAME);
     $fieldConfigId = new FieldConfigId('testScope', DemoEntity::ENTITY_NAME, 'testField', 'string');
     $this->assertEquals($entityConfigId, $this->configProvider->getId(DemoEntity::ENTITY_NAME));
     $this->assertEquals($fieldConfigId, $this->configProvider->getId(DemoEntity::ENTITY_NAME, 'testField', 'string'));
     $entityConfigIdWithOtherScope = new EntityConfigId('otherScope', DemoEntity::ENTITY_NAME);
     $this->assertEquals($this->entityConfig, $this->configProvider->getConfigById($entityConfigIdWithOtherScope));
 }

 /**
  * @param Collection        $collection
  * @param ConfigIdInterface $fieldConfig
  *
  * @return array
  */
 protected function getValueForCollection(Collection $collection, ConfigIdInterface $fieldConfig)
 {
     $extendConfig = $this->extendProvider->getConfigById($fieldConfig);
     $titleFieldName = $extendConfig->get('target_title');
     $value = $this->getEntityRouteOptions($extendConfig->get('target_entity'));
     $values = [];
     $priorities = [];
     /** @var object $item */
     foreach ($collection as $item) {
         $value['route_params']['id'] = $item->getId();
         $title = [];
         foreach ($titleFieldName as $fieldName) {
             $title[] = $this->propertyAccessor->getValue($item, $fieldName);
         }
         $values[] = ['id' => $item->getId(), 'link' => $value['route'] ? $this->router->generate($value['route'], $value['route_params']) : false, 'title' => implode(' ', $title)];
         if ($item instanceof PriorityItem) {
             $priorities[] = $item->getPriority();
         }
     }
     // sort values by priority if needed
     if (!empty($priorities) && count($priorities) === count($values)) {
         array_multisort($priorities, $values);
     }
     $value['values'] = $values;
     return $value;
 }

 /**
  * @param FormEvent $event
  */
 public function preSetData(FormEvent $event)
 {
     $form = $event->getForm();
     $entityClass = $form->getConfig()->getDataClass();
     /** @var FieldConfigId[] $fieldConfigIds */
     $fieldConfigIds = $this->extendConfigProvider->getIds($entityClass);
     foreach ($fieldConfigIds as $fieldConfigId) {
         if ($fieldConfigId->getFieldType() === 'manyToOne') {
             $fieldEntityConfig = $this->entityConfigProvider->getConfigById($fieldConfigId);
             $fieldExtendConfig = $this->extendConfigProvider->getConfigById($fieldConfigId);
             if (!$fieldExtendConfig->is('state', ExtendScope::STATE_ACTIVE)) {
                 continue;
             }
             $form->add($fieldConfigId->getFieldName(), 'entity', ['required' => false, 'class' => $fieldExtendConfig->get('target_entity'), 'property' => $fieldExtendConfig->get('target_field'), 'label' => $fieldEntityConfig->get('label')]);
         }
     }
 }

 /**
  * Check if entity config is new (entity not generated yet) or was deleted
  *
  * @param EntityConfigId $entityConfigId
  *
  * @return bool
  */
 protected function isIgnoredEntity(EntityConfigId $entityConfigId)
 {
     $entityConfig = $this->extendConfigProvider->getConfigById($entityConfigId);
     if ($entityConfig->is('is_deleted') || $entityConfig->in('state', [ExtendScope::STATE_NEW, ExtendScope::STATE_DELETE])) {
         return true;
     }
     return false;
 }

 /**
  * @param ClassMetadataBuilder $metadataBuilder
  * @param FieldConfigId        $fieldId
  * @param string               $targetEntity
  * @param FieldConfigId|null   $targetFieldId
  * @param string[]             $cascade
  */
 protected function buildManyToManyOwningSideRelation(ClassMetadataBuilder $metadataBuilder, FieldConfigId $fieldId, $targetEntity, FieldConfigId $targetFieldId = null, array $cascade = [])
 {
     $builder = $metadataBuilder->createManyToMany($fieldId->getFieldName(), $targetEntity);
     if ($targetFieldId) {
         $builder->inversedBy($targetFieldId->getFieldName());
     }
     $builder->setJoinTable($this->nameGenerator->generateManyToManyJoinTableName($fieldId->getClassName(), $fieldId->getFieldName(), $targetEntity));
     foreach ($cascade as $cascadeType) {
         $builder->{'cascade' . ucfirst($cascadeType)}();
     }
     $builder->build();
     $extendFieldConfig = $this->extendConfigProvider->getConfigById($fieldId);
     if (!$extendFieldConfig->is('without_default')) {
         $this->buildDefaultRelation($metadataBuilder, $fieldId, $targetEntity);
     }
 }

 /**
  * Adds entities to $result
  *
  * @param array $result
  * @param bool  $applyExclusions
  * @param bool  $translate
  */
 protected function addEntities(array &$result, $applyExclusions, $translate)
 {
     // only configurable entities are supported
     $entityConfigs = $this->entityConfigProvider->getConfigs();
     foreach ($entityConfigs as $entityConfig) {
         $entityConfigId = $entityConfig->getId();
         $isStateCorrect = $this->extendConfigProvider->getConfigById($entityConfigId)->in('state', [ExtendScope::STATE_ACTIVE, ExtendScope::STATE_UPDATE]);
         if (false == $isStateCorrect) {
             continue;
         }
         $className = $entityConfigId->getClassName();
         if ($applyExclusions && $this->isIgnoredEntity($className)) {
             continue;
         }
         $this->addEntity($result, $className, $entityConfig->get('label'), $entityConfig->get('plural_label'), $entityConfig->get('icon'), $translate);
     }
 }

 /**
  * Return view link options or simple text
  *
  * @param object          $targetEntity
  * @param ConfigIdInterface $fieldConfigId
  *
  * @throws \Doctrine\ORM\Mapping\MappingException
  * @return array|string
  */
 protected function getValueForSingleRelation($targetEntity, ConfigIdInterface $fieldConfigId)
 {
     $fieldConfig = $this->extendProvider->getConfigById($fieldConfigId);
     $targetFieldName = $fieldConfig->get('target_field');
     $targetClassName = $fieldConfig->get('target_entity');
     if (!class_exists($targetClassName)) {
         return '';
     }
     $title = (string) $this->propertyAccessor->getValue($targetEntity, $targetFieldName);
     /** @var ClassMetadataInfo $targetMetadata */
     $targetMetadata = $this->registry->getManager()->getClassMetadata($targetClassName);
     $id = $this->propertyAccessor->getValue($targetEntity, $targetMetadata->getSingleIdentifierFieldName());
     $routeOptions = $this->getEntityRouteOptions($targetClassName, $id);
     if ($routeOptions['route'] && $this->securityFacade->isGranted('VIEW', $targetEntity)) {
         return ['link' => $this->router->generate($routeOptions['route'], $routeOptions['route_params']), 'title' => $title];
     }
     return $title;
 }

 /**
  * @param ConfigInterface $config
  * @return bool
  */
 public function filterFields(ConfigInterface $config)
 {
     $extendConfig = $this->extendProvider->getConfigById($config->getId());
     /** @var FieldConfigId $fieldConfigId */
     $fieldConfigId = $extendConfig->getId();
     // skip system, new and deleted fields
     if (!$config->is('owner', ExtendScope::OWNER_CUSTOM) || $config->is('state', ExtendScope::STATE_NEW) || $config->is('is_deleted')) {
         return false;
     }
     // skip invisible fields
     if (!$this->viewProvider->getConfigById($config->getId())->is('is_displayable')) {
         return false;
     }
     // skip relations if they are referenced to deleted entity
     $underlyingFieldType = $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType());
     if (in_array($underlyingFieldType, RelationType::$anyToAnyRelations) && $this->extendProvider->getConfig($extendConfig->get('target_entity'))->is('is_deleted', true)) {
         return false;
     }
     return true;
 }

 /**
  * @param ConfigInterface $config
  * @return bool
  */
 public function filterFields(ConfigInterface $config)
 {
     $extendConfig = $this->extendProvider->getConfigById($config->getId());
     /** @var FieldConfigId $fieldConfigId */
     $fieldConfigId = $extendConfig->getId();
     // skip system and not accessible fields
     if (!$config->is('owner', ExtendScope::OWNER_CUSTOM) || !ExtendHelper::isFieldAccessible($config)) {
         return false;
     }
     // skip invisible fields
     if (!$this->viewProvider->getConfigById($config->getId())->is('is_displayable')) {
         return false;
     }
     // skip relations if they are referenced to not accessible entity
     $underlyingFieldType = $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType());
     if (in_array($underlyingFieldType, RelationType::$anyToAnyRelations, true) && !ExtendHelper::isEntityAccessible($this->extendProvider->getConfig($extendConfig->get('target_entity')))) {
         return false;
     }
     return true;
 }

 /**
  * Check if reverse relation can be created
  *
  * @param ConfigProvider $extendProvider
  * @param array          $relation
  * @param string         $relationKey
  *
  * @return bool
  *
  * @SuppressWarnings(PHPMD.CyclomaticComplexity)
  */
 protected function isAvailableRelation(ConfigProvider $extendProvider, array $relation, $relationKey)
 {
     /** @var FieldConfigId|false $fieldId */
     $fieldId = $relation['field_id'];
     /** @var FieldConfigId $targetFieldId */
     $targetFieldId = $relation['target_field_id'];
     if (!$relation['assign'] || !$targetFieldId) {
         if (!$targetFieldId) {
             return false;
         }
         // additional check for revers relation of manyToOne field type
         $targetEntityConfig = $extendProvider->getConfig($targetFieldId->getClassName());
         if (false === (!$relation['assign'] && !$fieldId && $targetFieldId && $targetFieldId->getFieldType() == RelationTypeBase::MANY_TO_ONE && $targetEntityConfig->get('relation') && $targetEntityConfig->get('relation')[$relationKey]['assign'])) {
             return false;
         }
     }
     if ($fieldId && $extendProvider->hasConfigById($fieldId) && $extendProvider->getConfigById($fieldId)->is('state', ExtendScope::STATE_DELETE)) {
         return false;
     }
     if ($targetFieldId && !$extendProvider->hasConfig($targetFieldId->getClassName(), $targetFieldId->getFieldName())) {
         return false;
     }
     return true;
 }

 public function __construct(ConfigProvider $configProvider, $configId)
 {
     $this->configProvider = $configProvider;
     $this->configId = $configId;
     $this->targetEntity = $this->configProvider->getConfigById($this->configId)->get('target_entity');
 }