GroupResolver.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Authentication;
 
use Psr\EventDispatcher\EventDispatcherInterface;
use ‪TYPO3\CMS\Core\Authentication\Event\AfterGroupsResolvedEvent;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
class ‪GroupResolver
{
    protected EventDispatcherInterface ‪$eventDispatcher;
    protected string ‪$sourceTable = '';
    protected string ‪$sourceField = 'usergroup';
    protected string ‪$recursiveSourceField = 'subgroup';
 
    public function ‪__construct(EventDispatcherInterface ‪$eventDispatcher)
    {
        $this->eventDispatcher = ‪$eventDispatcher;
    }
 
    public function ‪resolveGroupsForUser(array $userRecord, string ‪$sourceTable): array
    {
        $this->sourceTable = ‪$sourceTable;
        $originalGroupIds = ‪GeneralUtility::intExplode(',', $userRecord[$this->sourceField] ?? '', true);
        $resolvedGroups = $this->‪fetchGroupsRecursive($originalGroupIds);
        $event = $this->eventDispatcher->dispatch(new ‪AfterGroupsResolvedEvent(‪$sourceTable, $resolvedGroups, $originalGroupIds, $userRecord));
        return $event->getGroups();
    }
 
    protected function ‪fetchGroupsRecursive(array $groupIds, array $processedGroupIds = []): array
    {
        if (empty($groupIds)) {
            return [];
        }
        $foundGroups = $this->‪fetchRowsFromDatabase($groupIds);
        $validGroups = [];
        foreach ($groupIds as $groupId) {
            // Database did not find the record
            if (!is_array($foundGroups[$groupId] ?? null)) {
                continue;
            }
            // Record was already processed, continue to avoid adding this group again
            if (in_array($groupId, $processedGroupIds, true)) {
                continue;
            }
            // Add sub groups first
            $subgroupIds = ‪GeneralUtility::intExplode(',', $foundGroups[$groupId][$this->recursiveSourceField] ?? '', true);
            if (!empty($subgroupIds)) {
                $subgroups = $this->‪fetchGroupsRecursive($subgroupIds, array_merge($processedGroupIds, [$groupId]));
                $validGroups = array_merge($validGroups, $subgroups);
            }
            // Add main group after sub groups have been added
            $validGroups[] = $foundGroups[$groupId];
        }
        return $validGroups;
    }
 
    protected function ‪fetchRowsFromDatabase(array $groupIds): array
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->sourceTable);
        $result = $queryBuilder
            ->select('*')
            ->from($this->sourceTable)
            ->where(
                $queryBuilder->expr()->in(
                    'uid',
                    $queryBuilder->createNamedParameter(
                        $groupIds,
                        Connection::PARAM_INT_ARRAY
                    )
                )
            )
            ->executeQuery();
        $groups = [];
        while ($row = $result->fetchAssociative()) {
            $groups[(int)$row['uid']] = $row;
        }
        return $groups;
    }
 
    public function ‪findAllUsersInGroups(array $groupIds, string ‪$sourceTable, string $userSourceTable): array
    {
        $this->sourceTable = ‪$sourceTable;
 
        // Ensure the given groups exist
        $mainGroups = $this->‪fetchRowsFromDatabase($groupIds);
        $groupIds = array_map('intval', array_column($mainGroups, 'uid'));
        if (empty($groupIds)) {
            return [];
        }
        $parentGroupIds = $this->‪fetchParentGroupsRecursive($groupIds, $groupIds);
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($userSourceTable);
        $queryBuilder
            ->select('*')
            ->from($userSourceTable);
 
        $constraints = [];
        foreach ($groupIds as $groupUid) {
            $constraints[] = $queryBuilder->expr()->inSet($this->sourceField, (string)$groupUid);
        }
        foreach ($parentGroupIds as $groupUid) {
            $constraints[] = $queryBuilder->expr()->inSet($this->sourceField, (string)$groupUid);
        }
 
        $users = $queryBuilder
            ->where(
                $queryBuilder->expr()->orX(...$constraints)
            )
            ->executeQuery()
            ->fetchAllAssociative();
        return !empty($users) ? $users : [];
    }
 
    protected function ‪fetchParentGroupsRecursive(array $groupIds, array $processedGroupIds = []): array
    {
        if (empty($groupIds)) {
            return [];
        }
        $parentGroups = $this->‪fetchParentGroupsFromDatabase($groupIds);
        $validParentGroupIds = [];
        foreach ($parentGroups as $parentGroup) {
            $parentGroupId = (int)$parentGroup['uid'];
            // Record was already processed, continue to avoid adding this group again
            if (in_array($parentGroupId, $processedGroupIds, true)) {
                continue;
            }
            $processedGroupIds[] = $parentGroupId;
            $validParentGroupIds[] = $parentGroupId;
        }
 
        $grandParentGroups = $this->‪fetchParentGroupsRecursive($validParentGroupIds, $processedGroupIds);
        return array_merge($validParentGroupIds, $grandParentGroups);
    }
 
    protected function ‪fetchParentGroupsFromDatabase(array $subgroupIds): array
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->sourceTable);
        $queryBuilder
            ->select('*')
            ->from($this->sourceTable);
 
        $constraints = [];
        foreach ($subgroupIds as $subgroupId) {
            $constraints[] = $queryBuilder->expr()->inSet($this->recursiveSourceField, (string)$subgroupId);
        }
 
        $result = $queryBuilder
            ->where(
                $queryBuilder->expr()->orX(...$constraints)
            )
            ->executeQuery();
 
        $groups = [];
        while ($row = $result->fetchAssociative()) {
            $groups[(int)$row['uid']] = $row;
        }
        return $groups;
    }
}