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

Open in your IDE?
  1. <?php
  3. /*
  4. * This file is part of the Symfony package.
  5. *
  6. * (c) Fabien Potencier <[email protected]>
  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. * @internal This method is public to be usable as callback. It should not
  90. * be used in user code.
  91. */
  92. public function getQueryBuilderPartsForCachingHash(object $queryBuilder): ?array
  93. {
  94. return null;
  95. }
  97. public function __construct(ManagerRegistry $registry)
  98. {
  99. $this->registry = $registry;
  100. }
  102. public function buildForm(FormBuilderInterface $builder, array $options)
  103. {
  104. if ($options['multiple'] && interface_exists(Collection::class)) {
  105. $builder
  106. ->addEventSubscriber(new MergeDoctrineCollectionListener())
  107. ->addViewTransformer(new CollectionToArrayTransformer(), true)
  108. ;
  109. }
  110. }
  112. public function configureOptions(OptionsResolver $resolver)
  113. {
  114. $choiceLoader = function (Options $options) {
  115. // Unless the choices are given explicitly, load them on demand
  116. if (null === $options['choices']) {
  117. // If there is no QueryBuilder we can safely cache
  118. $vary = [$options['em'], $options['class']];
  120. // also if concrete Type can return important QueryBuilder parts to generate
  121. // hash key we go for it as well, otherwise fallback on the instance
  122. if ($options['query_builder']) {
  123. $vary[] = $this->getQueryBuilderPartsForCachingHash($options['query_builder']) ?? $options['query_builder'];
  124. }
  126. return ChoiceList::loader($this, new DoctrineChoiceLoader(
  127. $options['em'],
  128. $options['class'],
  129. $options['id_reader'],
  130. $this->getCachedEntityLoader(
  131. $options['em'],
  132. $options['query_builder'] ?? $options['em']->getRepository($options['class'])->createQueryBuilder('e'),
  133. $options['class'],
  134. $vary
  135. )
  136. ), $vary);
  137. }
  139. return null;
  140. };
  142. $choiceName = function (Options $options) {
  143. // If the object has a single-column, numeric ID, use that ID as
  144. // field name. We can only use numeric IDs as names, as we cannot
  145. // guarantee that a non-numeric ID contains a valid form name
  146. if ($options['id_reader'] instanceof IdReader && $options['id_reader']->isIntId()) {
  147. return ChoiceList::fieldName($this, [__CLASS__, 'createChoiceName']);
  148. }
  150. // Otherwise, an incrementing integer is used as name automatically
  151. return null;
  152. };
  154. // The choices are always indexed by ID (see "choices" normalizer
  155. // and DoctrineChoiceLoader), unless the ID is composite. Then they
  156. // are indexed by an incrementing integer.
  157. // Use the ID/incrementing integer as choice value.
  158. $choiceValue = function (Options $options) {
  159. // If the entity has a single-column ID, use that ID as value
  160. if ($options['id_reader'] instanceof IdReader && $options['id_reader']->isSingleId()) {
  161. return ChoiceList::value($this, [$options['id_reader'], 'getIdValue'], $options['id_reader']);
  162. }
  164. // Otherwise, an incrementing integer is used as value automatically
  165. return null;
  166. };
  168. $emNormalizer = function (Options $options, $em) {
  169. if (null !== $em) {
  170. if ($em instanceof ObjectManager) {
  171. return $em;
  172. }
  174. return $this->registry->getManager($em);
  175. }
  177. $em = $this->registry->getManagerForClass($options['class']);
  179. if (null === $em) {
  180. throw new RuntimeException(sprintf('Class "%s" seems not to be a managed Doctrine entity. Did you forget to map it?', $options['class']));
  181. }
  183. return $em;
  184. };
  186. // Invoke the query builder closure so that we can cache choice lists
  187. // for equal query builders
  188. $queryBuilderNormalizer = function (Options $options, $queryBuilder) {
  189. if (\is_callable($queryBuilder)) {
  190. $queryBuilder = $queryBuilder($options['em']->getRepository($options['class']));
  191. }
  193. return $queryBuilder;
  194. };
  196. // Set the "id_reader" option via the normalizer. This option is not
  197. // supposed to be set by the user.
  198. $idReaderNormalizer = function (Options $options) {
  199. // The ID reader is a utility that is needed to read the object IDs
  200. // when generating the field values. The callback generating the
  201. // field values has no access to the object manager or the class
  202. // of the field, so we store that information in the reader.
  203. // The reader is cached so that two choice lists for the same class
  204. // (and hence with the same reader) can successfully be cached.
  205. return $this->getCachedIdReader($options['em'], $options['class']);
  206. };
  208. $resolver->setDefaults([
  209. 'em' => null,
  210. 'query_builder' => null,
  211. 'choices' => null,
  212. 'choice_loader' => $choiceLoader,
  213. 'choice_label' => ChoiceList::label($this, [__CLASS__, 'createChoiceLabel']),
  214. 'choice_name' => $choiceName,
  215. 'choice_value' => $choiceValue,
  216. 'id_reader' => null, // internal
  217. 'choice_translation_domain' => false,
  218. ]);
  220. $resolver->setRequired(['class']);
  222. $resolver->setNormalizer('em', $emNormalizer);
  223. $resolver->setNormalizer('query_builder', $queryBuilderNormalizer);
  224. $resolver->setNormalizer('id_reader', $idReaderNormalizer);
  226. $resolver->setAllowedTypes('em', ['null', 'string', ObjectManager::class]);
  227. }
  229. /**
  230. * Return the default loader object.
  231. *
  232. * @return EntityLoaderInterface
  233. */
  234. abstract public function getLoader(ObjectManager $manager, object $queryBuilder, string $class);
  236. /**
  237. * @return string
  238. */
  239. public function getParent()
  240. {
  241. return ChoiceType::class;
  242. }
  244. public function reset()
  245. {
  246. $this->idReaders = [];
  247. $this->entityLoaders = [];
  248. }
  250. private function getCachedIdReader(ObjectManager $manager, string $class): ?IdReader
  251. {
  252. $hash = CachingFactoryDecorator::generateHash([$manager, $class]);
  254. if (isset($this->idReaders[$hash])) {
  255. return $this->idReaders[$hash];
  256. }
  258. $idReader = new IdReader($manager, $manager->getClassMetadata($class));
  260. // don't cache the instance for composite ids that cannot be optimized
  261. return $this->idReaders[$hash] = $idReader->isSingleId() ? $idReader : null;
  262. }
  264. private function getCachedEntityLoader(ObjectManager $manager, object $queryBuilder, string $class, array $vary): EntityLoaderInterface
  265. {
  266. $hash = CachingFactoryDecorator::generateHash($vary);
  268. return $this->entityLoaders[$hash] ?? ($this->entityLoaders[$hash] = $this->getLoader($manager, $queryBuilder, $class));
  269. }
  270. }