vendor/kreait/firebase-bundle/src/DependencyInjection/FirebaseExtension.php line 91

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Kreait\Firebase\Symfony\Bundle\DependencyInjection;
  7. use Kreait\Firebase;
  8. use Kreait\Firebase\Symfony\Bundle\DependencyInjection\Factory\ProjectFactory;
  9. use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
  10. use Symfony\Component\Config\FileLocator;
  11. use Symfony\Component\DependencyInjection\ContainerBuilder;
  12. use Symfony\Component\DependencyInjection\Extension\Extension;
  13. use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
  14. use Symfony\Component\DependencyInjection\Reference;
  16. class FirebaseExtension extends Extension
  17. {
  18.     public function load(array $configs, ContainerBuilder $container): void
  19.     {
  20.         $configuration = $this->getConfiguration($configs, $container);
  21.         $config = $this->processConfiguration($configuration, $configs);
  23.         $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
  24.         $loader->load('firebase.xml');
  26.         $projectConfigurations = $config['projects'] ?? [];
  27.         $projectConfigurationsCount = \count($projectConfigurations);
  29.         $this->assertThatOnlyOneDefaultProjectExists($projectConfigurations);
  31.         foreach ($projectConfigurations as $projectName => $projectConfiguration) {
  32.             if (1 === $projectConfigurationsCount) {
  33.                 $projectConfiguration['default'] = $projectConfiguration['default'] ?? true;
  34.             }
  36.             $this->processProjectConfiguration($projectName, $projectConfiguration, $container);
  37.         }
  38.     }
  40.     private function processProjectConfiguration(string $name, array $config, ContainerBuilder $container): void
  41.     {
  42.         $this->registerService($name.'.database', $config, Firebase\Database::class, Firebase\Contract\Database::class, $container, 'createDatabase');
  43.         $this->registerService($name.'.auth', $config, Firebase\Auth::class, Firebase\Contract\Auth::class, $container, 'createAuth');
  44.         $this->registerService($name.'.storage', $config, Firebase\Storage::class, Firebase\Contract\Storage::class, $container, 'createStorage');
  45.         $this->registerService($name.'.remote_config', $config, Firebase\RemoteConfig::class, Firebase\Contract\RemoteConfig::class, $container, 'createRemoteConfig');
  46.         $this->registerService($name.'.messaging', $config, Firebase\Messaging::class, Firebase\Contract\Messaging::class, $container, 'createMessaging');
  47.         $this->registerService($name.'.firestore', $config, Firebase\Firestore::class, Firebase\Contract\Firestore::class, $container, 'createFirestore');
  48.         $this->registerService($name.'.dynamic_links', $config, Firebase\DynamicLinks::class, Firebase\Contract\DynamicLinks::class, $container, 'createDynamicLinksService');
  49.     }
  51.     public function getAlias(): string
  52.     {
  53.         return 'kreait_firebase';
  54.     }
  56.     public function getConfiguration(array $config, ContainerBuilder $container): Configuration
  57.     {
  58.         return new Configuration($this->getAlias());
  59.     }
  61.     private function registerService(string $name, array $config, string $class, string $contract, ContainerBuilder $container, string $method = 'create'): void
  62.     {
  63.         $projectServiceId = \sprintf('%s.%s', $this->getAlias(), $name);
  64.         $isPublic = $config['public'];
  66.         $factory = $container->getDefinition(ProjectFactory::class);
  68.         if ($config['verifier_cache'] ?? null) {
  69.             $factory->addMethodCall('setVerifierCache', [new Reference($config['verifier_cache'])]);
  70.         }
  72.         if ($config['auth_token_cache'] ?? null) {
  73.             $factory->addMethodCall('setAuthTokenCache', [new Reference($config['auth_token_cache'])]);
  74.         }
  76.         if ($config['http_request_logger'] ?? null) {
  77.             $factory->addMethodCall('setHttpRequestLogger', [new Reference($config['http_request_logger'])]);
  78.         }
  80.         if ($config['http_request_debug_logger'] ?? null) {
  81.             $factory->addMethodCall('setHttpRequestDebugLogger', [new Reference($config['http_request_debug_logger'])]);
  82.         }
  84.         $container->register($projectServiceId, $contract)
  85.             ->setFactory([$factory, $method])
  86.             ->addArgument($config)
  87.             ->setPublic($isPublic);
  89.         if ($config['default'] ?? false) {
  90.             $container->setAlias($contract, $projectServiceId)->setPublic($isPublic);
  91.             $container->setAlias($class, $projectServiceId)->setPublic($isPublic)->setDeprecated();
  92.         }
  93.     }
  95.     private function assertThatOnlyOneDefaultProjectExists(array $projectConfigurations): void
  96.     {
  97.         $count = 0;
  99.         foreach ($projectConfigurations as $projectConfiguration) {
  100.             if ($projectConfiguration['default'] ?? false) {
  101.                 ++$count;
  102.             }
  104.             if ($count > 1) {
  105.                 throw new InvalidConfigurationException('Only one project can be set as default.');
  106.             }
  107.         }
  108.     }
  109. }