vendor/coreshop/resource-bundle/DependencyInjection/Driver/AbstractDriver.php line 101

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * CoreShop
  7.  *
  8.  * This source file is available under two different licenses:
  9.  *  - GNU General Public License version 3 (GPLv3)
  10.  *  - CoreShop Commercial License (CCL)
  11.  * Full copyright and license information is available in
  12.  * LICENSE.md which is distributed with this source code.
  13.  *
  14.  * @copyright  Copyright (c) CoreShop GmbH (https://www.coreshop.org)
  15.  * @license    https://www.coreshop.org/license     GPLv3 and CCL
  16.  *
  17.  */
  19. namespace CoreShop\Bundle\ResourceBundle\DependencyInjection\Driver;
  21. use CoreShop\Bundle\ResourceBundle\Controller\EventDispatcherInterface;
  22. use CoreShop\Bundle\ResourceBundle\Controller\ResourceFormFactoryInterface;
  23. use CoreShop\Bundle\ResourceBundle\Controller\ViewHandlerInterface;
  24. use CoreShop\Bundle\ResourceBundle\Form\Helper\ErrorSerializer;
  25. use CoreShop\Component\Resource\Factory\Factory;
  26. use CoreShop\Component\Resource\Factory\TranslatableFactoryInterface;
  27. use CoreShop\Component\Resource\Metadata\Metadata;
  28. use CoreShop\Component\Resource\Metadata\MetadataInterface;
  29. use CoreShop\Component\Resource\Metadata\RegistryInterface;
  30. use Symfony\Component\DependencyInjection\ContainerBuilder;
  31. use Symfony\Component\DependencyInjection\Definition;
  32. use Symfony\Component\DependencyInjection\Reference;
  34. abstract class AbstractDriver implements DriverInterface
  35. {
  36.     public function load(ContainerBuilder $container, MetadataInterface $metadata): void
  37.     {
  38.         $this->setClassesParameters($container, $metadata);
  40.         if ($metadata->hasClass('admin_controller')) {
  41.             $this->addController($container, $metadata);
  42.         }
  44.         $this->addManager($container, $metadata);
  45.         $this->addRepository($container, $metadata);
  47.         if ($metadata->hasClass('factory')) {
  48.             $this->addFactory($container, $metadata);
  49.         }
  50.     }
  52.     protected function setClassesParameters(ContainerBuilder $container, MetadataInterface $metadata): void
  53.     {
  54.         if ($metadata->hasClass('model')) {
  55.             $container->setParameter(sprintf('%s.model.%s.class', $metadata->getApplicationName(), $metadata->getName()), $metadata->getClass('model'));
  56.         }
  57.         if ($metadata->hasClass('interface')) {
  58.             $container->setParameter(sprintf('%s.interface.%s', $metadata->getApplicationName(), $metadata->getName()), $metadata->getClass('interface'));
  59.         }
  60.         if ($metadata->hasClass('admin_controller')) {
  61.             $container->setParameter(sprintf('%s.admin_controller.%s.class', $metadata->getApplicationName(), $metadata->getName()), $metadata->getClass('admin_controller'));
  62.         }
  63.         if ($metadata->hasClass('factory')) {
  64.             $container->setParameter(sprintf('%s.factory.%s.class', $metadata->getApplicationName(), $metadata->getName()), $metadata->getClass('factory'));
  65.         }
  66.         if ($metadata->hasClass('repository')) {
  67.             $container->setParameter(sprintf('%s.repository.%s.class', $metadata->getApplicationName(), $metadata->getName()), $metadata->getClass('repository'));
  68.         }
  69.     }
  71.     protected function addController(ContainerBuilder $container, MetadataInterface $metadata): void
  72.     {
  73.         $definition = new Definition($metadata->getClass('admin_controller'));
  74.         $definition
  75.             ->setPublic(true)
  76.             ->setArguments([
  77.                 $this->getMetadataDefinition($metadata),
  78.                 new Reference($metadata->getServiceId('repository')),
  79.                 new Reference($metadata->getServiceId('factory')),
  80.                 new Reference($metadata->getServiceId('manager')),
  81.                 new Reference(ViewHandlerInterface::class),
  82.                 new Reference(EventDispatcherInterface::class),
  83.                 new Reference(ResourceFormFactoryInterface::class),
  84.                 new Reference(ErrorSerializer::class),
  85.             ])
  86.             ->addMethodCall('setContainer', [new Reference('service_container')])
  87.         ;
  89.         $container->setDefinition($metadata->getServiceId('admin_controller'), $definition);
  90.     }
  92.     protected function addFactory(ContainerBuilder $container, MetadataInterface $metadata): void
  93.     {
  94.         $factoryClass = $metadata->getClass('factory');
  95.         $modelClass = $metadata->getClass('model');
  97.         $definition = new Definition($factoryClass);
  98.         $definition->setPublic(true);
  100.         $definitionArgs = [$modelClass];
  101.         if (in_array(TranslatableFactoryInterface::class, class_implements($factoryClass))) {
  102.             $decoratedDefinition = new Definition(Factory::class);
  103.             $decoratedDefinition->setArguments($definitionArgs);
  105.             $definitionArgs = [$decoratedDefinition, new Reference('coreshop.translation_locale_provider')];
  106.         }
  108.         $definition->setArguments($definitionArgs);
  110.         $container->setDefinition($metadata->getServiceId('factory'), $definition);
  112.         if (method_exists($container, 'registerAliasForArgument')) {
  113.             foreach (class_implements($factoryClass) as $typehintClass) {
  114.                 $container->registerAliasForArgument(
  115.                     $metadata->getServiceId('factory'),
  116.                     $typehintClass,
  117.                     $metadata->getHumanizedName() . ' factory',
  118.                 );
  119.             }
  120.         }
  121.     }
  123.     protected function getMetadataDefinition(MetadataInterface $metadata): Definition
  124.     {
  125.         $definition = new Definition(Metadata::class);
  126.         $definition
  127.             ->setFactory([new Reference(RegistryInterface::class), 'get'])
  128.             ->setArguments([$metadata->getAlias()])
  129.         ;
  131.         return $definition;
  132.     }
  134.     abstract protected function addManager(ContainerBuilder $container, MetadataInterface $metadata): void;
  136.     abstract protected function addRepository(ContainerBuilder $container, MetadataInterface $metadata): void;
  137. }