vendor/mvo/contao-group-widget/src/Group/Registry.php line 44

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * @author  Moritz Vondano
  7.  * @license MIT
  8.  */
  10. namespace Mvo\ContaoGroupWidget\Group;
  12. use Doctrine\DBAL\Connection;
  13. use Mvo\ContaoGroupWidget\Storage\NullStorage;
  14. use Mvo\ContaoGroupWidget\Storage\StorageFactoryInterface;
  15. use Mvo\ContaoGroupWidget\Storage\StorageInterface;
  16. use Symfony\Component\HttpFoundation\RequestStack;
  17. use Terminal42\DcMultilingualBundle\Driver;
  18. use Twig\Environment;
  20. /**
  21.  * Group factory methods.
  22.  *
  23.  * @final
  24.  */
  25. class Registry
  26. {
  27.     private Environment $twig;
  28.     private RequestStack $requestStack;
  29.     private Connection $connection;
  31.     /**
  32.      * @var array<string, StorageFactoryInterface>
  33.      */
  34.     private array $storageFactories = [];
  36.     /**
  37.      * @var array<string, array<string,Group>>
  38.      */
  39.     private array $groupCache = [];
  41.     /**
  42.      * @internal
  43.      */
  44.     public function __construct(Environment $twig, RequestStack $requestStack, Connection $connection, \IteratorAggregate $storageFactories)
  45.     {
  46.         $this->twig = $twig;
  47.         $this->requestStack = $requestStack;
  48.         $this->connection = $connection;
  50.         /** @var StorageFactoryInterface $factory */
  51.         foreach ($storageFactories->getIterator() as $factory) {
  52.             $this->storageFactories[$factory::getName()] = $factory;
  53.         }
  54.     }
  56.     /**
  57.      * Creates and returns a group. The same instance will be returned if
  58.      * called with identical arguments.
  59.      */
  60.     public function getGroup(string $table, int $rowId, string $name): Group
  61.     {
  62.         if (null !== ($group = $this->groupCache[$cacheKey = $this->getCacheKey($table, $rowId)][$name] ?? null)) {
  63.             return $group;
  64.         }
  66.         if (null === $group = $this->handleDcMultilingual($table, $rowId, $name)) {
  67.             $group = $this->createGroup($table, $rowId, $name);
  68.         }
  70.         return $this->groupCache[$cacheKey][$name] = $group;
  71.     }
  73.     public function getInitializedGroups(string $table, int $rowId): array
  74.     {
  75.         return array_values($this->groupCache[$this->getCacheKey($table, $rowId)] ?? []);
  76.     }
  78.     /**
  79.      * @return array<string>
  80.      */
  81.     public function getGroupFields(string $table): array
  82.     {
  83.         return array_keys(
  84.             array_filter(
  85.                 array_filter($GLOBALS['TL_DCA'][$table]['fields'] ?? []),
  86.                 static fn (array $definition): bool => 'group' === ($definition['inputType'] ?? null)
  87.             )
  88.         );
  89.     }
  91.     private function createGroup(string $table, int $rowId, string $name, StorageInterface $storage = null): Group
  92.     {
  93.         $group = new Group($this->twig, $table, $rowId, $name);
  94.         $group->setStorage($storage ?? $this->createStorage($table, $name, $group));
  96.         return $group;
  97.     }
  99.     private function createStorage(string $table, $name, Group $group): StorageInterface
  100.     {
  101.         $storageType = $GLOBALS['TL_DCA'][$table]['fields'][$name]['storage'] ?? 'serialized';
  103.         $storageFactory = $this->storageFactories[$storageType] ?? null;
  105.         if (null === $storageFactory) {
  106.             throw new \InvalidArgumentException("Invalid definition for group '$name': Unknown storage type '$storageType'.");
  107.         }
  109.         return $storageFactory->create($group);
  110.     }
  112.     private function getCacheKey(string $table, int $rowId): string
  113.     {
  114.         return $table."\x0".$rowId;
  115.     }
  117.     /**
  118.      * DC Multilingual stores translations in their own rows. In order to be
  119.      * compatible, we need to adjust the target $rowId in case a translated
  120.      * version was selected.
  121.      */
  122.     private function handleDcMultilingual(string $table, int $rowId, string $name): ?Group
  123.     {
  124.         if (($GLOBALS['TL_DCA'][$table]['config']['dataContainer'] ?? '') !== Driver::class) {
  125.             return null;
  126.         }
  128.         $language = $this->requestStack
  129.             ->getSession()
  130.             ->getBag('contao_backend')
  131.             ->get("dc_multilingual:$table:$rowId")
  132.         ;
  134.         if (null === $language) {
  135.             return null;
  136.         }
  138.         $pidColumn = $dca['config']['langPid'] ?? 'langPid';
  139.         $languageColumn = $dca['config']['langColumnName'] ?? 'language';
  141.         $result = $this->connection->fetchOne(
  142.             sprintf(
  143.                 'SELECT id FROM %s WHERE %s=? AND %s=?',
  144.                 $this->connection->quoteIdentifier($table),
  145.                 $this->connection->quoteIdentifier($pidColumn),
  146.                 $this->connection->quoteIdentifier($languageColumn),
  147.             ),
  148.             [$rowId, $language]
  149.         );
  151.         if ($result) {
  152.             return $this->createGroup($table, (int) $result, $name);
  153.         }
  155.         // In case we do not have a record yet, we create a group with an empty
  156.         // dummy storage that does not persist anything - otherwise the parent
  157.         // entries would show up. As soon as the record gets saved/the page is
  158.         // reloaded, we do have a record and the real storage kicks in
  159.         // persisting the posted values.
  160.         return $this->createGroup($table, $rowId, $name, new NullStorage());
  161.     }
  162. }