PHP ConfigManager::flush方法代码示例

 /**
  * @param array                $configs
  * @param LoggerInterface|null $logger
  * @param bool                 $dryRun Log modifications without apply them
  * @throws \Exception
  */
 public function processConfigs(array $configs, LoggerInterface $logger = null, $dryRun = false)
 {
     $this->logger = $logger ?: new NullLogger();
     try {
         if (!empty($configs)) {
             $this->appendConfigs = $this->getAndRemoveElement($configs, self::APPEND_CONFIGS, []);
             $renameConfigs = $this->getAndRemoveElement($configs, self::RENAME_CONFIGS, []);
             $this->filterConfigs($configs);
             $hasChanges = false;
             if (!empty($configs)) {
                 foreach ($configs as $className => $entityConfigs) {
                     $this->processEntityConfigs($className, $entityConfigs);
                 }
                 $hasChanges = true;
             }
             if ($this->renameFields($renameConfigs)) {
                 $hasChanges = true;
             }
             if ($hasChanges) {
                 if ($dryRun) {
                     $this->configManager->clear();
                 } else {
                     $this->configManager->flush();
                     $this->configManager->clearCache();
                 }
             }
         }
     } catch (\Exception $ex) {
         $this->logger = null;
         throw $ex;
     }
 }

 /**
  * Load entity configs from annotations to a database
  *
  * @param bool                 $force  Force overwrite config's option values
  * @param callable|null        $filter function (ClassMetadata[] $doctrineAllMetadata)
  * @param LoggerInterface|null $logger
  * @param bool                 $dryRun Log modifications without apply them
  *
  * @throws \Exception
  */
 public function load($force = false, \Closure $filter = null, LoggerInterface $logger = null, $dryRun = false)
 {
     $this->logger = $logger ?: new NullLogger();
     try {
         $entityManagers = $this->entityManagerBag->getEntityManagers();
         foreach ($entityManagers as $em) {
             /** @var ClassMetadata[] $doctrineAllMetadata */
             $doctrineAllMetadata = $em->getMetadataFactory()->getAllMetadata();
             if (null !== $filter) {
                 $doctrineAllMetadata = $filter($doctrineAllMetadata);
             }
             foreach ($doctrineAllMetadata as $metadata) {
                 $this->loadEntityConfigs($metadata, $force);
             }
         }
         if ($dryRun) {
             $this->configManager->clear();
         } else {
             $this->configManager->flush();
             $this->configManager->flushAllCaches();
         }
     } catch (\Exception $ex) {
         $this->logger = null;
         throw $ex;
     }
 }

 public function testFlush()
 {
     $model = new EntityConfigModel(self::ENTITY_CLASS);
     $entityConfigId = new EntityConfigId('entity', self::ENTITY_CLASS);
     $entityConfig = new Config($entityConfigId);
     $entityConfig->set('icon', 'test_icon');
     $entityConfig->set('label', 'test_label');
     $entityPropertyConfig = new PropertyConfigContainer(['entity' => ['items' => ['icon' => [], 'label' => ['options' => ['indexed' => true]]]]]);
     $this->entityConfigProvider->expects($this->once())->method('getPropertyConfig')->will($this->returnValue($entityPropertyConfig));
     $testConfigId = new EntityConfigId('test', self::ENTITY_CLASS);
     $testConfig = new Config($testConfigId);
     $testConfig->set('attr1', 'test_attr1');
     $testPropertyConfig = new PropertyConfigContainer(['entity' => ['items' => ['attr1' => []]]]);
     $this->testConfigProvider->expects($this->once())->method('getPropertyConfig')->will($this->returnValue($testPropertyConfig));
     $this->modelManager->expects($this->once())->method('getEntityModel')->with($entityConfigId->getClassName())->will($this->returnValue($model));
     $em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
     $this->modelManager->expects($this->any())->method('getEntityManager')->will($this->returnValue($em));
     $this->setFlushExpectations($em, [$model]);
     $this->eventDispatcher->expects($this->at(2))->method('dispatch')->with(Events::PRE_FLUSH, new PreFlushConfigEvent(['entity' => $entityConfig, 'test' => $testConfig], $this->configManager));
     $this->configManager->persist($entityConfig);
     $this->configManager->persist($testConfig);
     $this->configManager->flush();
     $this->assertEquals(['icon' => 'test_icon', 'label' => 'test_label'], $model->toArray('entity'));
     $this->assertEquals(['attr1' => 'test_attr1'], $model->toArray('test'));
     $this->assertCount(3, $model->getIndexedValues());
     $this->assertEquals('entity_config', $model->getIndexedValues()[0]->getScope());
     $this->assertEquals('module_name', $model->getIndexedValues()[0]->getCode());
     $this->assertEquals('entity_config', $model->getIndexedValues()[1]->getScope());
     $this->assertEquals('entity_name', $model->getIndexedValues()[1]->getCode());
     $this->assertEquals('entity', $model->getIndexedValues()[2]->getScope());
     $this->assertEquals('label', $model->getIndexedValues()[2]->getCode());
 }

 /**
  * {@inheritdoc}
  */
 public function write(array $items)
 {
     $translations = [];
     foreach ($items as $item) {
         $translations = array_merge($translations, $this->writeItem($item));
     }
     $this->configManager->flush();
     $this->translationHelper->saveTranslations($translations);
 }

 /**
  * {@inheritdoc}
  */
 public function buildForm(FormBuilderInterface $builder, array $options)
 {
     $builder->addEventListener(FormEvents::POST_SUBMIT, function () use($options) {
         /** @var FieldConfigId $fieldConfigId */
         $fieldConfigId = $options['config_id'];
         $entityConfig = $this->configManager->getProvider('extend')->getConfig($fieldConfigId->getClassName());
         if ($entityConfig->is('state', ExtendScope::STATE_ACTIVE) && !$this->hasRelation($entityConfig, $this->getRelationKey($fieldConfigId))) {
             $entityConfig->set('state', ExtendScope::STATE_UPDATE);
             $this->configManager->persist($entityConfig);
             $this->configManager->flush();
         }
     });
 }

 /**
  * @param string $entityClass
  * @throws WorkflowException
  */
 public function generateWorkflowFields($entityClass)
 {
     if ($this->entityConnector->isWorkflowAware($entityClass)) {
         return;
     }
     $extendConfigProvider = $this->configManager->getProvider('extend');
     $entityConfig = $extendConfigProvider->getConfig($entityClass);
     if (!$entityConfig || !$entityConfig->is('is_extend')) {
         throw new WorkflowException(sprintf('Class %s can not be extended', $entityClass));
     }
     $workflowItemClass = 'Oro\\Bundle\\WorkflowBundle\\Entity\\WorkflowItem';
     $workflowStepClass = 'Oro\\Bundle\\WorkflowBundle\\Entity\\WorkflowStep';
     // add fields
     $hasWorkflowItemField = $this->configManager->hasConfig($entityClass, self::PROPERTY_WORKFLOW_ITEM);
     if (!$hasWorkflowItemField) {
         $this->addRelationField($entityClass, self::PROPERTY_WORKFLOW_ITEM, ConfigHelper::getTranslationKey('entity', 'label', $workflowItemClass, 'related_entity'), ConfigHelper::getTranslationKey('entity', 'description', $workflowItemClass, 'related_entity'), $workflowItemClass, 'id');
     }
     $hasWorkflowStepField = $this->configManager->hasConfig($entityClass, self::PROPERTY_WORKFLOW_STEP);
     if (!$hasWorkflowStepField) {
         $this->addRelationField($entityClass, self::PROPERTY_WORKFLOW_STEP, ConfigHelper::getTranslationKey('entity', 'label', $workflowStepClass, 'related_entity'), ConfigHelper::getTranslationKey('entity', 'description', $workflowStepClass, 'related_entity'), $workflowStepClass, 'label');
     }
     // update entity config
     $entityConfig->set('state', ExtendScope::STATE_UPDATE);
     $entityConfig->set('upgradeable', true);
     $this->configManager->persist($entityConfig);
     $this->configManager->flush();
     // update database
     $this->entityProcessor->updateDatabase();
     // make fields hidden
     // TODO: Fields can be hidden only after schema update due to a bug in DoctrineSubscriber
     // TODO: Should be fixed in scope of https://magecore.atlassian.net/browse/BAP-3621
     // TODO: If make fields hidden then these fields will be created only for the first extended entity
     // TODO: Should be fixed in scope of https://magecore.atlassian.net/browse/BAP-3632
     /*
     if (!$hasWorkflowItemField) {
         $this->hideRelationField($entityClass, self::PROPERTY_WORKFLOW_ITEM);
     }
     if (!$hasWorkflowStepField) {
         $this->hideRelationField($entityClass, self::PROPERTY_WORKFLOW_STEP);
     }
     $this->configManager->flush();
     */
 }

 /**
  * Runs command
  *
  * @param  InputInterface  $input
  * @param  OutputInterface $output
  * @throws \InvalidArgumentException
  * @return int|null|void
  */
 public function execute(InputInterface $input, OutputInterface $output)
 {
     $output->writeln($this->getDescription());
     $this->configManager = $this->getContainer()->get('oro_entity_config.config_manager');
     /** @var Kernel $kernel */
     $kernel = $this->getContainer()->get('kernel');
     foreach ($kernel->getBundles() as $bundle) {
         $path = $bundle->getPath() . '/Resources/config/entity_extend.yml';
         if (is_file($path)) {
             $config = Yaml::parse(realpath($path));
             foreach ($config as $className => $entityOptions) {
                 $className = class_exists($className) ? $className : 'Extend\\Entity\\' . $className;
                 $this->parseEntity($className, $entityOptions);
             }
             $this->configManager->flush();
             $output->writeln('Done');
         }
     }
     $this->getContainer()->get('oro_entity_extend.tools.dumper')->clear();
     $this->configManager->clearConfigurableCache();
 }

 /**
  * @param FormEvent $event
  */
 public function postSubmit(FormEvent $event)
 {
     $options = $event->getForm()->getConfig()->getOptions();
     $configModel = $options['config_model'];
     if ($configModel instanceof FieldConfigModel) {
         $className = $configModel->getEntity()->getClassName();
         $fieldName = $configModel->getFieldName();
     } else {
         $fieldName = null;
         $className = $configModel->getClassName();
     }
     $data = $event->getData();
     foreach ($this->configManager->getProviders() as $provider) {
         if (isset($data[$provider->getScope()])) {
             $config = $provider->getConfig($className, $fieldName);
             $config->setValues($data[$provider->getScope()]);
             $this->configManager->persist($config);
         }
     }
     if ($event->getForm()->isValid()) {
         $this->configManager->flush();
     }
 }

 /**
  * @param FormEvent $event
  */
 public function postSubmit(FormEvent $event)
 {
     $form = $event->getForm();
     $configModel = $form->getConfig()->getOption('config_model');
     $data = $event->getData();
     $labelsToBeUpdated = [];
     foreach ($this->configManager->getProviders() as $provider) {
         $scope = $provider->getScope();
         if (isset($data[$scope])) {
             $configId = $this->configManager->getConfigIdByModel($configModel, $scope);
             $config = $provider->getConfigById($configId);
             $translatable = $provider->getPropertyConfig()->getTranslatableValues($configId);
             foreach ($data[$scope] as $code => $value) {
                 if (in_array($code, $translatable, true)) {
                     // check if a label text was changed
                     $labelKey = $config->get($code);
                     if (!$configModel->getId()) {
                         $labelsToBeUpdated[$labelKey] = $value;
                     } elseif ($value != $this->translator->trans($labelKey)) {
                         $labelsToBeUpdated[$labelKey] = $value;
                     }
                     // replace label text with label name in $value variable
                     $value = $config->get($code);
                 }
                 $config->set($code, $value);
             }
             $this->configManager->persist($config);
         }
     }
     if ($form->isValid()) {
         // update changed labels if any
         if (!empty($labelsToBeUpdated)) {
             /** @var EntityManager $translationEm */
             $translationEm = $this->doctrine->getManagerForClass(Translation::ENTITY_NAME);
             /** @var TranslationRepository $translationRepo */
             $translationRepo = $translationEm->getRepository(Translation::ENTITY_NAME);
             $values = [];
             $locale = $this->translator->getLocale();
             foreach ($labelsToBeUpdated as $labelKey => $labelText) {
                 // save into translation table
                 $values[] = $translationRepo->saveValue($labelKey, $labelText, $locale, TranslationRepository::DEFAULT_DOMAIN, Translation::SCOPE_UI);
             }
             // mark translation cache dirty
             $this->dbTranslationMetadataCache->updateTimestamp($locale);
             $translationEm->flush($values);
         }
         $this->configManager->flush();
     }
 }

 /**
  * @param string $enumValueClassName
  * @param bool   $isPublic
  * @param bool   $doFlush
  *
  * @throws \InvalidArgumentException
  */
 public function applyEnumEntityOptions($enumValueClassName, $isPublic, $doFlush = true)
 {
     if (empty($enumValueClassName)) {
         throw new \InvalidArgumentException('$enumValueClassName must not be empty.');
     }
     $enumConfigProvider = $this->configManager->getProvider('enum');
     $enumEntityConfig = $enumConfigProvider->getConfig($enumValueClassName);
     if (!$enumEntityConfig->is('public', $isPublic)) {
         $enumEntityConfig->set('public', $isPublic);
         $this->configManager->persist($enumEntityConfig);
         if ($doFlush) {
             $this->configManager->flush();
         }
     }
 }

 /**
  * Makes sure that extended entity configs are ready to be processing by other config related commands
  */
 public function checkConfig()
 {
     $hasAliases = file_exists(ExtendClassLoadingUtils::getAliasesPath($this->cacheDir));
     if ($hasAliases) {
         return;
     }
     $hasChanges = false;
     $extendConfigs = $this->configManager->getProvider('extend')->getConfigs(null, true);
     foreach ($extendConfigs as $extendConfig) {
         $schema = $extendConfig->get('schema', false, []);
         // make sure that inheritance definition for extended entities is up-to-date
         // this check is required to avoid doctrine mapping exceptions during the platform update
         // in case if a parent class is changed in a new version of a code
         if (isset($schema['type'], $schema['class'], $schema['entity']) && $schema['type'] === 'Extend') {
             $entityClassName = $schema['entity'];
             $parentClassName = get_parent_class($schema['class']);
             if ($parentClassName !== $entityClassName) {
                 $inheritClassName = get_parent_class($parentClassName);
                 $hasSchemaChanges = false;
                 if (!isset($schema['parent']) || $schema['parent'] !== $parentClassName) {
                     $hasSchemaChanges = true;
                     $schema['parent'] = $parentClassName;
                 }
                 if (!isset($schema['inherit']) || $schema['inherit'] !== $inheritClassName) {
                     $hasSchemaChanges = true;
                     $schema['inherit'] = $inheritClassName;
                 }
                 if ($hasSchemaChanges) {
                     $hasChanges = true;
                     $extendConfig->set('schema', $schema);
                     $this->configManager->persist($extendConfig);
                 }
             }
         }
     }
     if ($hasChanges) {
         $this->configManager->flush();
     }
 }

 /**
  * @param ConfigInterface $entityConfig
  */
 protected function persistEntityConfig(ConfigInterface $entityConfig)
 {
     $this->configManager->persist($entityConfig);
     $this->configManager->flush();
 }

 /**
  * Flushes all changes to configuration data that have been queued up to now to the database.
  */
 public function flush()
 {
     $this->configManager->flush();
 }