vendor/symfony/doctrine-bridge/Form/Type/DoctrineType.php line 135

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Bridge\Doctrine\Form\Type;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\Persistence\ManagerRegistry;
  16. use Doctrine\Persistence\ObjectManager;
  17. use Symfony\Bridge\Doctrine\Form\ChoiceList\DoctrineChoiceLoader;
  18. use Symfony\Bridge\Doctrine\Form\ChoiceList\EntityLoaderInterface;
  19. use Symfony\Bridge\Doctrine\Form\ChoiceList\IdReader;
  20. use Symfony\Bridge\Doctrine\Form\DataTransformer\CollectionToArrayTransformer;
  21. use Symfony\Bridge\Doctrine\Form\EventListener\MergeDoctrineCollectionListener;
  22. use Symfony\Component\Form\AbstractType;
  23. use Symfony\Component\Form\ChoiceList\ChoiceList;
  24. use Symfony\Component\Form\ChoiceList\Factory\CachingFactoryDecorator;
  25. use Symfony\Component\Form\Exception\RuntimeException;
  26. use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
  27. use Symfony\Component\Form\FormBuilderInterface;
  28. use Symfony\Component\OptionsResolver\Options;
  29. use Symfony\Component\OptionsResolver\OptionsResolver;
  30. use Symfony\Contracts\Service\ResetInterface;
  32. abstract class DoctrineType extends AbstractType implements ResetInterface
  33. {
  34.     /**
  35.      * @var ManagerRegistry
  36.      */
  37.     protected $registry;
  39.     /**
  40.      * @var IdReader[]
  41.      */
  42.     private $idReaders = [];
  44.     /**
  45.      * @var EntityLoaderInterface[]
  46.      */
  47.     private $entityLoaders = [];
  49.     /**
  50.      * Creates the label for a choice.
  51.      *
  52.      * For backwards compatibility, objects are cast to strings by default.
  53.      *
  54.      * @internal This method is public to be usable as callback. It should not
  55.      *           be used in user code.
  56.      */
  57.     public static function createChoiceLabel(object $choice): string
  58.     {
  59.         return (string) $choice;
  60.     }
  62.     /**
  63.      * Creates the field name for a choice.
  64.      *
  65.      * This method is used to generate field names if the underlying object has
  66.      * a single-column integer ID. In that case, the value of the field is
  67.      * the ID of the object. That ID is also used as field name.
  68.      *
  69.      * @param int|string $key   The choice key
  70.      * @param string     $value The choice value. Corresponds to the object's
  71.      *                          ID here.
  72.      *
  73.      * @internal This method is public to be usable as callback. It should not
  74.      *           be used in user code.
  75.      */
  76.     public static function createChoiceName(object $choice, $key, string $value): string
  77.     {
  78.         return str_replace('-', '_', $value);
  79.     }
  81.     /**
  82.      * Gets important parts from QueryBuilder that will allow to cache its results.
  83.      * For instance in ORM two query builders with an equal SQL string and
  84.      * equal parameters are considered to be equal.
  85.      *
  86.      * @param object $queryBuilder A query builder, type declaration is not present here as there
  87.      *                             is no common base class for the different implementations
  88.      *
  89.      * @return array|null Array with important QueryBuilder parts or null if
  90.      *                    they can't be determined
  91.      *
  92.      * @internal This method is public to be usable as callback. It should not
  93.      *           be used in user code.
  94.      */
  95.     public function getQueryBuilderPartsForCachingHash(object $queryBuilder): ?array
  96.     {
  97.         return null;
  98.     }
  100.     public function __construct(ManagerRegistry $registry)
  101.     {
  102.         $this->registry = $registry;
  103.     }
  105.     public function buildForm(FormBuilderInterface $builder, array $options)
  106.     {
  107.         if ($options['multiple'] && interface_exists(Collection::class)) {
  108.             $builder
  109.                 ->addEventSubscriber(new MergeDoctrineCollectionListener())
  110.                 ->addViewTransformer(new CollectionToArrayTransformer(), true)
  111.             ;
  112.         }
  113.     }
  115.     public function configureOptions(OptionsResolver $resolver)
  116.     {
  117.         $choiceLoader = function (Options $options) {
  118.             // Unless the choices are given explicitly, load them on demand
  119.             if (null === $options['choices']) {
  120.                 // If there is no QueryBuilder we can safely cache
  121.                 $vary = [$options['em'], $options['class']];
  123.                 // also if concrete Type can return important QueryBuilder parts to generate
  124.                 // hash key we go for it as well, otherwise fallback on the instance
  125.                 if ($options['query_builder']) {
  126.                     $vary[] = $this->getQueryBuilderPartsForCachingHash($options['query_builder']) ?? $options['query_builder'];
  127.                 }
  129.                 return ChoiceList::loader($this, new DoctrineChoiceLoader(
  130.                     $options['em'],
  131.                     $options['class'],
  132.                     $options['id_reader'],
  133.                     $this->getCachedEntityLoader(
  134.                         $options['em'],
  135.                         $options['query_builder'] ?? $options['em']->getRepository($options['class'])->createQueryBuilder('e'),
  136.                         $options['class'],
  137.                         $vary
  138.                     )
  139.                 ), $vary);
  140.             }
  142.             return null;
  143.         };
  145.         $choiceName = function (Options $options) {
  146.             // If the object has a single-column, numeric ID, use that ID as
  147.             // field name. We can only use numeric IDs as names, as we cannot
  148.             // guarantee that a non-numeric ID contains a valid form name
  149.             if ($options['id_reader'] instanceof IdReader && $options['id_reader']->isIntId()) {
  150.                 return ChoiceList::fieldName($this, [__CLASS__, 'createChoiceName']);
  151.             }
  153.             // Otherwise, an incrementing integer is used as name automatically
  154.             return null;
  155.         };
  157.         // The choices are always indexed by ID (see "choices" normalizer
  158.         // and DoctrineChoiceLoader), unless the ID is composite. Then they
  159.         // are indexed by an incrementing integer.
  160.         // Use the ID/incrementing integer as choice value.
  161.         $choiceValue = function (Options $options) {
  162.             // If the entity has a single-column ID, use that ID as value
  163.             if ($options['id_reader'] instanceof IdReader && $options['id_reader']->isSingleId()) {
  164.                 return ChoiceList::value($this, [$options['id_reader'], 'getIdValue'], $options['id_reader']);
  165.             }
  167.             // Otherwise, an incrementing integer is used as value automatically
  168.             return null;
  169.         };
  171.         $emNormalizer = function (Options $options, $em) {
  172.             if (null !== $em) {
  173.                 if ($em instanceof ObjectManager) {
  174.                     return $em;
  175.                 }
  177.                 return $this->registry->getManager($em);
  178.             }
  180.             $em = $this->registry->getManagerForClass($options['class']);
  182.             if (null === $em) {
  183.                 throw new RuntimeException(sprintf('Class "%s" seems not to be a managed Doctrine entity. Did you forget to map it?', $options['class']));
  184.             }
  186.             return $em;
  187.         };
  189.         // Invoke the query builder closure so that we can cache choice lists
  190.         // for equal query builders
  191.         $queryBuilderNormalizer = function (Options $options, $queryBuilder) {
  192.             if (\is_callable($queryBuilder)) {
  193.                 $queryBuilder = $queryBuilder($options['em']->getRepository($options['class']));
  194.             }
  196.             return $queryBuilder;
  197.         };
  199.         // Set the "id_reader" option via the normalizer. This option is not
  200.         // supposed to be set by the user.
  201.         $idReaderNormalizer = function (Options $options) {
  202.             // The ID reader is a utility that is needed to read the object IDs
  203.             // when generating the field values. The callback generating the
  204.             // field values has no access to the object manager or the class
  205.             // of the field, so we store that information in the reader.
  206.             // The reader is cached so that two choice lists for the same class
  207.             // (and hence with the same reader) can successfully be cached.
  208.             return $this->getCachedIdReader($options['em'], $options['class']);
  209.         };
  211.         $resolver->setDefaults([
  212.             'em' => null,
  213.             'query_builder' => null,
  214.             'choices' => null,
  215.             'choice_loader' => $choiceLoader,
  216.             'choice_label' => ChoiceList::label($this, [__CLASS__, 'createChoiceLabel']),
  217.             'choice_name' => $choiceName,
  218.             'choice_value' => $choiceValue,
  219.             'id_reader' => null, // internal
  220.             'choice_translation_domain' => false,
  221.         ]);
  223.         $resolver->setRequired(['class']);
  225.         $resolver->setNormalizer('em', $emNormalizer);
  226.         $resolver->setNormalizer('query_builder', $queryBuilderNormalizer);
  227.         $resolver->setNormalizer('id_reader', $idReaderNormalizer);
  229.         $resolver->setAllowedTypes('em', ['null', 'string', ObjectManager::class]);
  230.     }
  232.     /**
  233.      * Return the default loader object.
  234.      *
  235.      * @return EntityLoaderInterface
  236.      */
  237.     abstract public function getLoader(ObjectManager $manager, object $queryBuilder, string $class);
  239.     /**
  240.      * @return string
  241.      */
  242.     public function getParent()
  243.     {
  244.         return ChoiceType::class;
  245.     }
  247.     public function reset()
  248.     {
  249.         $this->idReaders = [];
  250.         $this->entityLoaders = [];
  251.     }
  253.     private function getCachedIdReader(ObjectManager $manager, string $class): ?IdReader
  254.     {
  255.         $hash = CachingFactoryDecorator::generateHash([$manager, $class]);
  257.         if (isset($this->idReaders[$hash])) {
  258.             return $this->idReaders[$hash];
  259.         }
  261.         $idReader = new IdReader($manager, $manager->getClassMetadata($class));
  263.         // don't cache the instance for composite ids that cannot be optimized
  264.         return $this->idReaders[$hash] = $idReader->isSingleId() ? $idReader : null;
  265.     }
  267.     private function getCachedEntityLoader(ObjectManager $manager, object $queryBuilder, string $class, array $vary): EntityLoaderInterface
  268.     {
  269.         $hash = CachingFactoryDecorator::generateHash($vary);
  271.         return $this->entityLoaders[$hash] ?? ($this->entityLoaders[$hash] = $this->getLoader($manager, $queryBuilder, $class));
  272.     }
  273. }