SuggestWizardDefaultReceiver.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Backend\Form\Wizard;
 
/*
 * 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!
 */
 
use ‪TYPO3\CMS\Backend\Tree\View\PageTreeView;
use ‪TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\QueryBuilder;
use ‪TYPO3\CMS\Core\Database\Query\QueryHelper;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\BackendWorkspaceRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;
use ‪TYPO3\CMS\Core\Imaging\Icon;
use ‪TYPO3\CMS\Core\Imaging\IconFactory;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Type\Bitmask\Permission;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
 
class ‪SuggestWizardDefaultReceiver
{
    protected ‪$table = '';
 
    protected ‪$mmForeignTable = '';
 
    protected ‪$config = [];
 
    protected ‪$allowedPages = [];
 
    protected ‪$maxItems = 10;
 
    protected ‪$params = [];
 
    protected ‪$iconFactory;
 
    protected ‪$queryBuilder;
 
    public function ‪__construct(‪$table, ‪$config)
    {
        $this->iconFactory = GeneralUtility::makeInstance(IconFactory::class);
        $this->queryBuilder = $this->‪getQueryBuilderForTable(‪$table);
        $this->queryBuilder->getRestrictions()
            ->removeAll()
            ->add(GeneralUtility::makeInstance(DeletedRestriction::class))
            // if table is versionized, only get the records from the Live Workspace
            // the overlay itself of WS-records is done below
            ->add(GeneralUtility::makeInstance(BackendWorkspaceRestriction::class, 0));
        $this->table = ‪$table;
        $this->config = ‪$config;
        // get a list of all the pages that should be looked on
        if (isset(‪$config['pidList'])) {
            $pageIds = GeneralUtility::intExplode(',', ‪$config['pidList'], true);
            $depth = (int)(‪$config['pidDepth'] ?? 0);
            $availablePageIds = [];
            foreach ($pageIds as $pageId) {
                $availablePageIds[] = $this->‪getAvailablePageIds($pageId, $depth);
            }
            $this->allowedPages = array_unique(array_merge($this->allowedPages, ...$availablePageIds));
        }
        if (isset(‪$config['maxItemsInResultList'])) {
            $this->maxItems = ‪$config['maxItemsInResultList'];
        }
        ‪$GLOBALS['BE_USER']->initializeWebmountsForElementBrowser();
        if ($this->table === 'pages') {
            $this->queryBuilder->andWhere(
                ‪QueryHelper::stripLogicalOperatorPrefix(‪$GLOBALS['BE_USER']->getPagePermsClause(‪Permission::PAGE_SHOW)),
                $this->queryBuilder->expr()->eq('sys_language_uid', 0)
            );
        }
        if (isset(‪$config['addWhere'])) {
            $this->queryBuilder->andWhere(
                ‪QueryHelper::stripLogicalOperatorPrefix(‪$config['addWhere'])
            );
        }
    }
 
    public function ‪queryTable(&‪$params, $recursionCounter = 0)
    {
        $maxQueryResults = 50;
        $rows = [];
        $this->params = &‪$params;
        $start = $recursionCounter * $maxQueryResults;
        $this->‪prepareSelectStatement();
        $this->‪prepareOrderByStatement();
        $result = $this->queryBuilder->select('*')
            ->from($this->table)
            ->setFirstResult($start)
            ->setMaxResults($maxQueryResults)
            ->execute();
        $allRowsCount = $this->queryBuilder
            ->count('uid')
            ->resetQueryPart('orderBy')
            ->execute()
            ->fetchColumn(0);
        if ($allRowsCount) {
            while ($row = $result->fetch()) {
                // check if we already have collected the maximum number of records
                if (count($rows) > $this->maxItems) {
                    break;
                }
                $this->‪manipulateRecord($row);
                $this->‪makeWorkspaceOverlay($row);
                // check if the user has access to the record
                if (!$this->‪checkRecordAccess($row, $row['uid'])) {
                    continue;
                }
                $spriteIcon = $this->iconFactory->getIconForRecord($this->table, $row, ‪Icon::SIZE_SMALL)->render();
                $uid = $row['t3ver_oid'] > 0 ? $row['t3ver_oid'] : $row['uid'];
                $path = $this->‪getRecordPath($row, $uid);
                if (mb_strlen($path, 'utf-8') > 30) {
                    $croppedPath = '<abbr title="' . htmlspecialchars($path) . '">' .
                        htmlspecialchars(
                            mb_substr($path, 0, 10, 'utf-8')
                                . '...'
                                . mb_substr($path, -20, null, 'utf-8')
                        ) .
                        '</abbr>';
                } else {
                    $croppedPath = htmlspecialchars($path);
                }
                $label = $this->‪getLabel($row);
                $entry = [
                    'text' => '<span class="suggest-label">' . $label . '</span><span class="suggest-uid">[' . $uid . ']</span><br />
                                <span class="suggest-path">' . $croppedPath . '</span>',
                    'table' => $this->mmForeignTable ? $this->mmForeignTable : ‪$this->table,
                    'label' => strip_tags($label),
                    'path' => $path,
                    'uid' => $uid,
                    'style' => '',
                    'class' => $this->config['cssClass'] ?? '',
                    'sprite' => $spriteIcon
                ];
                $rows[$this->table . '_' . $uid] = $this->‪renderRecord($row, $entry);
            }
 
            // if there are less records than we need, call this function again to get more records
            if (count($rows) < $this->maxItems && $allRowsCount >= $maxQueryResults && $recursionCounter < $this->maxItems) {
                $tmp = ‪self::queryTable(‪$params, ++$recursionCounter);
                $rows = array_merge($tmp, $rows);
            }
        }
        return $rows;
    }
 
    protected function ‪prepareSelectStatement()
    {
        $expressionBuilder = $this->queryBuilder->expr();
        $searchString = $this->params['value'];
        if ($searchString !== '') {
            $splitStrings = $this->‪splitSearchString($searchString);
            $constraints = [];
            foreach ($splitStrings as $splitString) {
                $constraints[] = $this->‪buildConstraintBlock($splitString);
            }
            foreach ($constraints as $constraint) {
                $this->queryBuilder->andWhere($expressionBuilder->andX($constraint));
            }
        }
        if (!empty($this->allowedPages)) {
            $pidList = array_map('intval', $this->allowedPages);
            if (!empty($pidList)) {
                $this->queryBuilder->andWhere(
                    $expressionBuilder->in('pid', $pidList)
                );
            }
        }
        // add an additional search condition comment
        if (isset($this->config['searchCondition']) && $this->config['searchCondition'] !== '') {
            $this->queryBuilder->andWhere(‪QueryHelper::stripLogicalOperatorPrefix($this->config['searchCondition']));
        }
    }
 
    protected function ‪buildConstraintBlock(string $searchString)
    {
        $expressionBuilder = $this->queryBuilder->expr();
        $selectParts = $expressionBuilder->orX();
        if (‪MathUtility::canBeInterpretedAsInteger($searchString) && (int)$searchString > 0) {
            $selectParts->add($expressionBuilder->eq('uid', (int)$searchString));
        }
        $searchWholePhrase = !isset($this->config['searchWholePhrase']) || $this->config['searchWholePhrase'];
        $likeCondition = ($searchWholePhrase ? '%' : '') . $this->queryBuilder->escapeLikeWildcards($searchString) . '%';
        // Search in all fields given by label or label_alt
        $selectFieldsList = (‪$GLOBALS['TCA'][‪$this->table]['ctrl']['label'] ?? '') . ',' . (‪$GLOBALS['TCA'][$this->table]['ctrl']['label_alt'] ?? '') . ',' . $this->config['additionalSearchFields'];
        $selectFields = GeneralUtility::trimExplode(',', $selectFieldsList, true);
        $selectFields = array_unique($selectFields);
        foreach ($selectFields as $field) {
            $selectParts->add($expressionBuilder->like($field, $this->queryBuilder->createPositionalParameter($likeCondition)));
        }
 
        return $selectParts;
    }
 
    protected function ‪splitSearchString(string $searchString): array
    {
        return str_getcsv($searchString, ' ');
    }
 
    protected function ‪getAvailablePageIds(int $id, int $depth = 0): array
    {
        if ($depth === 0) {
            return [$id];
        }
        $tree = GeneralUtility::makeInstance(PageTreeView::class);
        $tree->init();
        $tree->getTree($id, $depth);
        $tree->makeHTML = 0;
        $tree->fieldArray = ['uid'];
        $tree->ids[] = $id;
        return $tree->ids;
    }
 
    protected function ‪prepareOrderByStatement()
    {
        if (empty($this->config['orderBy'])) {
            $this->queryBuilder->addOrderBy(‪$GLOBALS['TCA'][$this->table]['ctrl']['label']);
        } else {
            foreach (‪QueryHelper::parseOrderBy($this->config['orderBy']) as $orderPair) {
                list($fieldName, $order) = $orderPair;
                $this->queryBuilder->addOrderBy($fieldName, $order);
            }
        }
    }
 
    protected function ‪manipulateRecord(&$row)
    {
    }
 
    protected function ‪checkRecordAccess($row, $uid)
    {
        $retValue = true;
        ‪$table = $this->mmForeignTable ?: ‪$this->table;
        if (‪$table === 'pages') {
            if (!‪BackendUtility::readPageAccess($uid, ‪$GLOBALS['BE_USER']->getPagePermsClause(‪Permission::PAGE_SHOW))) {
                $retValue = false;
            }
        } elseif (isset(‪$GLOBALS['TCA'][‪$table]['ctrl']['is_static']) && (bool)‪$GLOBALS['TCA'][‪$table]['ctrl']['is_static']) {
            $retValue = true;
        } else {
            if (!is_array(‪BackendUtility::readPageAccess($row['pid'], ‪$GLOBALS['BE_USER']->getPagePermsClause(‪Permission::PAGE_SHOW)))) {
                $retValue = false;
            }
        }
        return $retValue;
    }
 
    protected function ‪makeWorkspaceOverlay(&$row)
    {
        // Check for workspace-versions
        if (‪$GLOBALS['BE_USER']->workspace != 0 && ‪$GLOBALS['TCA'][$this->table]['ctrl']['versioningWS'] == true) {
            ‪BackendUtility::workspaceOL($this->mmForeignTable ? $this->mmForeignTable : $this->table, $row);
        }
    }
 
    protected function ‪getRecordPath(&$row, $uid)
    {
        $titleLimit = max($this->config['maxPathTitleLength'], 0);
        if (($this->mmForeignTable ? $this->mmForeignTable : $this->table) === 'pages') {
            $path = ‪BackendUtility::getRecordPath($uid, '', $titleLimit);
            // For pages we only want the first (n-1) parts of the path,
            // because the n-th part is the page itself
            $path = substr($path, 0, strrpos($path, '/', -2)) . '/';
        } else {
            $path = ‪BackendUtility::getRecordPath($row['pid'], '', $titleLimit);
        }
        return $path;
    }
 
    protected function ‪getLabel($row)
    {
        return ‪BackendUtility::getRecordTitle($this->mmForeignTable ? $this->mmForeignTable : $this->table, $row, true);
    }
 
    protected function ‪renderRecord($row, $entry)
    {
        // Call renderlet if available (normal pages etc. usually don't have one)
        if ($this->config['renderFunc'] != '') {
            ‪$params = [
                'table' => ‪$this->table,
                'uid' => $row['uid'],
                'row' => $row,
                'entry' => &$entry
            ];
            GeneralUtility::callUserFunction($this->config['renderFunc'], ‪$params, $this);
        }
        return $entry;
    }
 
    protected function ‪getLanguageService()
    {
        return ‪$GLOBALS['LANG'];
    }
 
    protected function ‪getQueryBuilderForTable(‪$table)
    {
        return GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(‪$table);
    }
}