801 lines
32 KiB
PHP
801 lines
32 KiB
PHP
<?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\Backend\Controller\Page;
|
|
|
|
use Psr\EventDispatcher\EventDispatcherInterface;
|
|
use Psr\Http\Message\ResponseInterface;
|
|
use Psr\Http\Message\ServerRequestInterface;
|
|
use TYPO3\CMS\Backend\Attribute\AsController;
|
|
use TYPO3\CMS\Backend\Controller\Event\AfterPageTreeItemsPreparedEvent;
|
|
use TYPO3\CMS\Backend\Dto\Tree\Label\Label;
|
|
use TYPO3\CMS\Backend\Dto\Tree\PageTreeItem;
|
|
use TYPO3\CMS\Backend\Dto\Tree\TreeItem;
|
|
use TYPO3\CMS\Backend\Form\FormDataCompiler;
|
|
use TYPO3\CMS\Backend\Form\FormDataGroup\OnTheFly;
|
|
use TYPO3\CMS\Backend\Form\FormDataProvider\DatabaseEffectivePid;
|
|
use TYPO3\CMS\Backend\Form\FormDataProvider\DatabaseParentPageRow;
|
|
use TYPO3\CMS\Backend\Form\FormDataProvider\DatabaseRowInitializeNew;
|
|
use TYPO3\CMS\Backend\Form\FormDataProvider\DatabaseUniqueUidNewRow;
|
|
use TYPO3\CMS\Backend\Form\FormDataProvider\InitializeProcessedTca;
|
|
use TYPO3\CMS\Backend\Form\FormDataProvider\PageTsConfig;
|
|
use TYPO3\CMS\Backend\Form\FormDataProvider\TcaSelectItems;
|
|
use TYPO3\CMS\Backend\Form\FormDataProvider\UserTsConfig;
|
|
use TYPO3\CMS\Backend\Routing\UriBuilder;
|
|
use TYPO3\CMS\Backend\Tree\Repository\PageTreeRepository;
|
|
use TYPO3\CMS\Backend\Utility\BackendUtility;
|
|
use TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
|
|
use TYPO3\CMS\Core\Authentication\JsConfirmation;
|
|
use TYPO3\CMS\Core\Database\ConnectionPool;
|
|
use TYPO3\CMS\Core\Database\Query\Restriction\DocumentTypeExclusionRestriction;
|
|
use TYPO3\CMS\Core\DataHandling\PageDoktypeRegistry;
|
|
use TYPO3\CMS\Core\Exception\SiteNotFoundException;
|
|
use TYPO3\CMS\Core\Http\JsonResponse;
|
|
use TYPO3\CMS\Core\Imaging\IconFactory;
|
|
use TYPO3\CMS\Core\Imaging\IconSize;
|
|
use TYPO3\CMS\Core\Localization\LanguageService;
|
|
use TYPO3\CMS\Core\Site\SiteFinder;
|
|
use TYPO3\CMS\Core\Type\Bitmask\Permission;
|
|
use TYPO3\CMS\Core\Utility\GeneralUtility;
|
|
use TYPO3\CMS\Core\Utility\MathUtility;
|
|
|
|
/**
|
|
* Controller providing data to the page tree
|
|
* @internal This class is a specific Backend controller implementation and is not considered part of the Public TYPO3 API.
|
|
*/
|
|
#[AsController]
|
|
class TreeController
|
|
{
|
|
/**
|
|
* Option to use the nav_title field for outputting in the tree items, set via userTS.
|
|
*/
|
|
protected bool $useNavTitle = false;
|
|
|
|
/**
|
|
* Option to prefix the page ID when outputting the tree items, set via userTS.
|
|
*/
|
|
protected bool $addIdAsPrefix = false;
|
|
|
|
/**
|
|
* Option to prefix the domain name of sys_domains when outputting the tree items, set via userTS.
|
|
*/
|
|
protected bool $addDomainName = false;
|
|
|
|
/**
|
|
* Option to add the rootline path above each mount point, set via userTS.
|
|
*/
|
|
protected bool $showMountPathAboveMounts = false;
|
|
|
|
/**
|
|
* A list of pages not to be shown.
|
|
*/
|
|
protected array $hiddenRecords = [];
|
|
|
|
/**
|
|
* An array of labels for a branch in the tree, set via userTS.
|
|
*/
|
|
protected array $labels = [];
|
|
|
|
/**
|
|
* Number of tree levels which should be returned on the first page tree load
|
|
*/
|
|
protected int $levelsToFetch = 2;
|
|
|
|
/**
|
|
* When set to true all nodes returend by API will be expanded
|
|
*/
|
|
protected bool $expandAllNodes = false;
|
|
|
|
/**
|
|
* Used in the record link picker to limit the page tree only to a specific list
|
|
* of alternative entry points for selecting only from a list of pages
|
|
*/
|
|
protected array $alternativeEntryPoints = [];
|
|
|
|
protected PageTreeRepository $pageTreeRepository;
|
|
|
|
protected bool $userHasAccessToModifyPagesAndToDefaultLanguage = false;
|
|
|
|
public function __construct(
|
|
protected readonly IconFactory $iconFactory,
|
|
protected readonly UriBuilder $uriBuilder,
|
|
protected readonly EventDispatcherInterface $eventDispatcher,
|
|
protected readonly SiteFinder $siteFinder,
|
|
protected readonly PageDoktypeRegistry $pageDoktypeRegistry,
|
|
protected readonly FormDataCompiler $formDataCompiler,
|
|
) {}
|
|
|
|
protected function initializeConfiguration(ServerRequestInterface $request)
|
|
{
|
|
if ($request->getQueryParams()['readOnly'] ?? false) {
|
|
$this->getBackendUser()->initializeWebmountsForElementBrowser();
|
|
}
|
|
if ($request->getQueryParams()['alternativeEntryPoints'] ?? false) {
|
|
$this->alternativeEntryPoints = $request->getQueryParams()['alternativeEntryPoints'];
|
|
$this->alternativeEntryPoints = array_filter($this->alternativeEntryPoints, function (int $pageId): bool {
|
|
return $this->getBackendUser()->isInWebMount($pageId) !== null;
|
|
});
|
|
$this->alternativeEntryPoints = array_map(intval(...), $this->alternativeEntryPoints);
|
|
$this->alternativeEntryPoints = array_unique($this->alternativeEntryPoints);
|
|
}
|
|
$userTsConfig = $this->getBackendUser()->getTSConfig();
|
|
$this->hiddenRecords = GeneralUtility::intExplode(
|
|
',',
|
|
(string)($userTsConfig['options.']['hideRecords.']['pages'] ?? ''),
|
|
true
|
|
);
|
|
$this->labels = $userTsConfig['options.']['pageTree.']['label.'] ?? [];
|
|
$this->addIdAsPrefix = (bool)($userTsConfig['options.']['pageTree.']['showPageIdWithTitle'] ?? false);
|
|
$this->addDomainName = (bool)($userTsConfig['options.']['pageTree.']['showDomainNameWithTitle'] ?? false);
|
|
$this->useNavTitle = (bool)($userTsConfig['options.']['pageTree.']['showNavTitle'] ?? false);
|
|
$this->showMountPathAboveMounts = (bool)($userTsConfig['options.']['pageTree.']['showPathAboveMounts'] ?? false);
|
|
$this->userHasAccessToModifyPagesAndToDefaultLanguage = $this->getBackendUser()->check('tables_modify', 'pages') && $this->getBackendUser()->checkLanguageAccess(0);
|
|
}
|
|
|
|
/**
|
|
* Returns page tree configuration in JSON
|
|
*/
|
|
public function fetchConfigurationAction(ServerRequestInterface $request): ResponseInterface
|
|
{
|
|
$backendUser = $this->getBackendUser();
|
|
$userTsConfig = $backendUser->getTSConfig();
|
|
|
|
// Check if translation search feature is generally available (TSconfig setting)
|
|
$translationSearchAvailable = (bool)($userTsConfig['options.']['pageTree.']['searchInTranslatedPages'] ?? true);
|
|
|
|
// Determine if translation search is enabled by the user preference - otherwise TSconfig setting applies
|
|
$translationSearchEnabled = $translationSearchAvailable
|
|
&& (
|
|
!isset($backendUser->uc['pageTree_searchInTranslatedPages'])
|
|
|| $backendUser->uc['pageTree_searchInTranslatedPages']
|
|
);
|
|
|
|
// Check if frontend URI search feature is generally available (TSconfig setting)
|
|
$frontendUriSearchAvailable = (bool)($userTsConfig['options.']['pageTree.']['searchByFrontendUri'] ?? true);
|
|
|
|
// Determine if frontend URI search is enabled by the user preference - otherwise TSconfig setting applies
|
|
$frontendUriSearchEnabled = $frontendUriSearchAvailable
|
|
&& (
|
|
!isset($backendUser->uc['pageTree_searchByFrontendUri'])
|
|
|| $backendUser->uc['pageTree_searchByFrontendUri']
|
|
);
|
|
|
|
// Build language list from site configuration
|
|
$languages = [];
|
|
$currentLanguageTag = $_COOKIE['pageTreeLang'] ?? '';
|
|
try {
|
|
$siteFinder = GeneralUtility::makeInstance(SiteFinder::class);
|
|
$sites = $siteFinder->getAllSites();
|
|
foreach ($sites as $site) {
|
|
foreach ($site->getAllLanguages() as $lang) {
|
|
$tag = $lang->getLanguageTag();
|
|
$languages[] = [
|
|
'languageTag' => $tag,
|
|
'title' => $lang->getTitle(),
|
|
'flag' => $lang->getFlagIdentifier(),
|
|
];
|
|
}
|
|
break;
|
|
}
|
|
} catch (\Throwable) {}
|
|
|
|
$dataUrlParams = [];
|
|
if ($currentLanguageTag !== '') {
|
|
$dataUrlParams['language'] = $currentLanguageTag;
|
|
}
|
|
|
|
$configuration = [
|
|
'allowDragMove' => $this->isDragMoveAllowed(),
|
|
'doktypes' => $this->getDokTypes($request),
|
|
'displayDeleteConfirmation' => $backendUser->jsConfirmation(JsConfirmation::DELETE),
|
|
'temporaryMountPoint' => $this->getMountPointPath((int)($backendUser->uc['pageTree_temporaryMountPoint'] ?? 0)),
|
|
'showIcons' => true,
|
|
'dataUrl' => (string)$this->uriBuilder->buildUriFromRoute('ajax_page_tree_data', $dataUrlParams),
|
|
'rootlineUrl' => (string)$this->uriBuilder->buildUriFromRoute('ajax_page_tree_rootline'),
|
|
'filterUrl' => (string)$this->uriBuilder->buildUriFromRoute('ajax_page_tree_filter'),
|
|
'setTemporaryMountPointUrl' => (string)$this->uriBuilder->buildUriFromRoute('ajax_page_tree_set_temporary_mount_point'),
|
|
'searchInTranslatedPagesEnabled' => $translationSearchEnabled,
|
|
'searchInTranslatedPagesAvailable' => $translationSearchAvailable,
|
|
'searchByFrontendUriEnabled' => $frontendUriSearchEnabled,
|
|
'searchByFrontendUriAvailable' => $frontendUriSearchAvailable,
|
|
'languages' => $languages,
|
|
'currentLanguage' => $currentLanguageTag,
|
|
];
|
|
|
|
return new JsonResponse($configuration);
|
|
}
|
|
|
|
public function fetchReadOnlyConfigurationAction(ServerRequestInterface $request): ResponseInterface
|
|
{
|
|
$entryPoints = (string)($request->getQueryParams()['alternativeEntryPoints'] ?? '');
|
|
$entryPoints = GeneralUtility::intExplode(',', $entryPoints, true);
|
|
$additionalArguments = [
|
|
'readOnly' => 1,
|
|
];
|
|
if (!empty($entryPoints)) {
|
|
$additionalArguments['alternativeEntryPoints'] = $entryPoints;
|
|
}
|
|
$configuration = [
|
|
'displayDeleteConfirmation' => $this->getBackendUser()->jsConfirmation(JsConfirmation::DELETE),
|
|
'temporaryMountPoint' => $this->getMountPointPath((int)($this->getBackendUser()->uc['pageTree_temporaryMountPoint'] ?? 0)),
|
|
'showIcons' => true,
|
|
'dataUrl' => (string)$this->uriBuilder->buildUriFromRoute('ajax_page_tree_data', $additionalArguments),
|
|
'filterUrl' => (string)$this->uriBuilder->buildUriFromRoute('ajax_page_tree_filter', $additionalArguments),
|
|
'setTemporaryMountPointUrl' => (string)$this->uriBuilder->buildUriFromRoute('ajax_page_tree_set_temporary_mount_point'),
|
|
'nonViewableDoktypes' => $this->pageDoktypeRegistry->getNonViewableDoktypes(),
|
|
];
|
|
return new JsonResponse($configuration);
|
|
}
|
|
|
|
/**
|
|
* Returns the list of doktypes to display in page tree toolbar drag area,
|
|
* automatically determined based on the user's group permissions.
|
|
*/
|
|
protected function getDokTypes(ServerRequestInterface $request): array
|
|
{
|
|
$formDataGroup = GeneralUtility::makeInstance(OnTheFly::class);
|
|
// Skip DatabaseUserPermissionCheck::class to return doktypes even if the user cannot create pages at root level
|
|
$formDataGroup->setProviderList([
|
|
InitializeProcessedTca::class,
|
|
DatabaseParentPageRow::class,
|
|
DatabaseEffectivePid::class,
|
|
UserTsConfig::class,
|
|
PageTsConfig::class,
|
|
DatabaseRowInitializeNew::class,
|
|
DatabaseUniqueUidNewRow::class,
|
|
TcaSelectItems::class,
|
|
]);
|
|
|
|
try {
|
|
$doktypes = $this->formDataCompiler
|
|
->compile(
|
|
[
|
|
'command' => 'new',
|
|
'request' => $request,
|
|
'tableName' => 'pages',
|
|
'vanillaUid' => 0,
|
|
],
|
|
$formDataGroup
|
|
)['processedTca']['columns']['doktype']['config']['items'] ?? [];
|
|
} catch (\Exception) {
|
|
return [];
|
|
}
|
|
|
|
return array_values(
|
|
array_map(
|
|
static fn(array $doktype) => [
|
|
'nodeType' => $doktype['value'],
|
|
'icon' => $doktype['icon'] ?? '',
|
|
'title' => $doktype['label'] ?? '',
|
|
],
|
|
array_filter(
|
|
$doktypes,
|
|
static fn(array $doktype) => ($doktype['value'] ?? '') !== '--div--' && ($doktype['value'] ?? '') !== ''
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns JSON representing page tree
|
|
*/
|
|
public function fetchDataAction(ServerRequestInterface $request): ResponseInterface
|
|
{
|
|
$this->initializeConfiguration($request);
|
|
|
|
$languageParam = $request->getQueryParams()['language'] ?? '';
|
|
$languageTag = ($languageParam !== '' && $languageParam !== '0') ? $languageParam : null;
|
|
|
|
$items = [];
|
|
$parentIdentifier = $request->getQueryParams()['parent'] ?? null;
|
|
if ($parentIdentifier) {
|
|
$parentDepth = (int)($request->getQueryParams()['depth'] ?? 0);
|
|
// Fetching a part of a page tree
|
|
$entryPoints = $this->getAllEntryPointPageTrees((int)$parentIdentifier);
|
|
$mountPid = (int)($request->getQueryParams()['mount'] ?? 0);
|
|
$this->levelsToFetch = $parentDepth + $this->levelsToFetch;
|
|
foreach ($entryPoints as $page) {
|
|
$items[] = $this->pagesToFlatArray($page, $mountPid, $parentDepth);
|
|
}
|
|
} else {
|
|
$entryPoints = $this->getAllEntryPointPageTrees();
|
|
foreach ($entryPoints as $page) {
|
|
$items[] = $this->pagesToFlatArray($page, (int)$page['uid']);
|
|
}
|
|
}
|
|
$items = array_merge(...$items);
|
|
|
|
if ($languageTag !== null) {
|
|
$this->applyTranslationOverlay($items, $languageTag);
|
|
}
|
|
|
|
return new JsonResponse($this->getPostProcessedPageItems($request, $items));
|
|
}
|
|
|
|
private function applyTranslationOverlay(array &$items, string $languageTag): void
|
|
{
|
|
$pageIds = [];
|
|
foreach ($items as $item) {
|
|
$uid = (int)($item['identifier'] ?? 0);
|
|
if ($uid > 0) {
|
|
$pageIds[] = $uid;
|
|
}
|
|
}
|
|
if (empty($pageIds)) {
|
|
return;
|
|
}
|
|
|
|
$queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
|
|
->getQueryBuilderForTable('pages');
|
|
$translations = $queryBuilder
|
|
->select('l10n_parent', 'title', 'nav_title', 'language_tag')
|
|
->from('pages')
|
|
->where(
|
|
$queryBuilder->expr()->in('l10n_parent', $pageIds),
|
|
$queryBuilder->expr()->eq('language_tag', $queryBuilder->createNamedParameter($languageTag))
|
|
)
|
|
->executeQuery()
|
|
->fetchAllAssociative();
|
|
|
|
$translationMap = [];
|
|
foreach ($translations as $trans) {
|
|
$translationMap[(int)$trans['l10n_parent']] = $trans;
|
|
}
|
|
|
|
foreach ($items as &$item) {
|
|
$page = $item['_page'] ?? [];
|
|
$uid = (int)($page['uid'] ?? (int)($item['identifier'] ?? 0));
|
|
$trans = $translationMap[$uid] ?? null;
|
|
if ($trans) {
|
|
$item['name'] = $trans['title'];
|
|
if (!empty($trans['nav_title'])) {
|
|
$item['name'] = $trans['nav_title'];
|
|
$item['nameSourceField'] = 'nav_title';
|
|
}
|
|
$item['_page']['title'] = $trans['title'];
|
|
$item['_page']['nav_title'] = $trans['nav_title'] ?? '';
|
|
$item['_page']['_translatedTitle'] = $trans['title'];
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns JSON representing page rootline
|
|
*/
|
|
public function fetchRootlineAction(ServerRequestInterface $request): ResponseInterface
|
|
{
|
|
$identifier = (string)($request->getQueryParams()['identifier'] ?? '');
|
|
if (!MathUtility::canBeInterpretedAsInteger($identifier)) {
|
|
return new JsonResponse(null, 400);
|
|
}
|
|
$pageId = (int)$identifier;
|
|
|
|
if ($pageId === 0) {
|
|
return new JsonResponse(['rootline' => ['0']]);
|
|
}
|
|
|
|
$rootline = BackendUtility::BEgetRootLine((int)$identifier);
|
|
if ($rootline === []) {
|
|
return new JsonResponse(null, 404);
|
|
}
|
|
|
|
return new JsonResponse([
|
|
'rootline' => array_map(strval(...), array_column(array_reverse($rootline), 'uid')),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Returns JSON representing page tree filtered by keyword
|
|
*/
|
|
public function filterDataAction(ServerRequestInterface $request): ResponseInterface
|
|
{
|
|
$searchQuery = $request->getQueryParams()['q'] ?? '';
|
|
if (trim($searchQuery) === '') {
|
|
return new JsonResponse([]);
|
|
}
|
|
|
|
$this->initializeConfiguration($request);
|
|
$this->expandAllNodes = true;
|
|
|
|
$items = [];
|
|
$entryPoints = $this->getAllEntryPointPageTrees(0, $searchQuery);
|
|
|
|
foreach ($entryPoints as $page) {
|
|
if (!empty($page)) {
|
|
$items[] = $this->pagesToFlatArray($page, (int)$page['uid']);
|
|
}
|
|
}
|
|
$items = array_merge(...$items);
|
|
|
|
return new JsonResponse($this->getPostProcessedPageItems($request, $items));
|
|
}
|
|
|
|
/**
|
|
* Sets a temporary mount point
|
|
*
|
|
* @throws \RuntimeException
|
|
*/
|
|
public function setTemporaryMountPointAction(ServerRequestInterface $request): ResponseInterface
|
|
{
|
|
if (empty($request->getParsedBody()['pid'])) {
|
|
throw new \RuntimeException(
|
|
'Required "pid" parameter is missing.',
|
|
1511792197
|
|
);
|
|
}
|
|
$pid = (int)$request->getParsedBody()['pid'];
|
|
|
|
$this->getBackendUser()->uc['pageTree_temporaryMountPoint'] = $pid;
|
|
$this->getBackendUser()->writeUC();
|
|
$response = [
|
|
'mountPointPath' => $this->getMountPointPath($pid),
|
|
];
|
|
return new JsonResponse($response);
|
|
}
|
|
|
|
/**
|
|
* Converts nested tree structure produced by PageTreeRepository to a flat, one level array
|
|
* and also adds visual representation information to the data.
|
|
*
|
|
* The result is intended to be used as JSON result - dumping data directly to HTML might lead to XSS!
|
|
*
|
|
* @param array $page
|
|
* @param int $entryPoint
|
|
* @param int $depth
|
|
*/
|
|
protected function pagesToFlatArray(array $page, int $entryPoint, int $depth = 0): array
|
|
{
|
|
$backendUser = $this->getBackendUser();
|
|
$pageId = (int)$page['uid'];
|
|
if (in_array($pageId, $this->hiddenRecords, true)) {
|
|
return [];
|
|
}
|
|
|
|
$stopPageTree = !empty($page['php_tree_stop']) && $depth > 0;
|
|
$identifier = $entryPoint . '_' . $pageId;
|
|
|
|
$suffix = '';
|
|
$prefix = '';
|
|
$nameSourceField = 'title';
|
|
$visibleText = $page['title'];
|
|
$tooltip = BackendUtility::titleAttribForPages($page, '', false, $this->useNavTitle);
|
|
if ($pageId !== 0) {
|
|
$icon = $this->iconFactory->getIconForRecord('pages', $page, IconSize::SMALL);
|
|
} else {
|
|
$icon = $this->iconFactory->getIcon('apps-pagetree-root', IconSize::SMALL);
|
|
}
|
|
|
|
if ($this->useNavTitle && trim($page['nav_title'] ?? '') !== '') {
|
|
$nameSourceField = 'nav_title';
|
|
$visibleText = $page['nav_title'];
|
|
}
|
|
if (trim($visibleText) === '') {
|
|
$visibleText = htmlspecialchars('[' . $this->getLanguageService()->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.no_title') . ']');
|
|
}
|
|
|
|
if ($this->addDomainName && ($page['is_siteroot'] ?? false)) {
|
|
$domain = $this->getDomainNameForPage($pageId);
|
|
$suffix = $domain !== '' ? ' [' . $domain . ']' : '';
|
|
}
|
|
|
|
$lockInfo = BackendUtility::isRecordLocked('pages', $pageId);
|
|
if (is_array($lockInfo)) {
|
|
$tooltip .= ' - ' . $lockInfo['msg'];
|
|
}
|
|
if ($this->addIdAsPrefix) {
|
|
$prefix = '[' . $pageId . '] ';
|
|
}
|
|
|
|
$labels = [];
|
|
if (!empty($this->labels[$pageId . '.']) && isset($this->labels[$pageId . '.']['label']) && trim($this->labels[$pageId . '.']['label']) !== '') {
|
|
$labels[] = new Label(
|
|
label: $this->getLanguageService()->sL($this->labels[$pageId . '.']['label']),
|
|
color: (string)($this->labels[$pageId . '.']['color'] ?? '#ff8700'),
|
|
);
|
|
}
|
|
|
|
$editable = false;
|
|
if ($pageId !== 0) {
|
|
$editable = $this->userHasAccessToModifyPagesAndToDefaultLanguage && $backendUser->doesUserHaveAccess($page, Permission::PAGE_EDIT);
|
|
}
|
|
|
|
$items = [];
|
|
$item = [
|
|
// identifier is not only used for pages, therefore it's a string
|
|
'identifier' => (string)$pageId,
|
|
'parentIdentifier' => (string)($page['pid'] ?? ''),
|
|
'recordType' => 'pages',
|
|
'name' => $visibleText,
|
|
'prefix' => !empty($prefix) ? htmlspecialchars($prefix) : '',
|
|
'suffix' => !empty($suffix) ? htmlspecialchars($suffix) : '',
|
|
'tooltip' => $tooltip,
|
|
'depth' => $depth,
|
|
'icon' => $icon->getIdentifier(),
|
|
'overlayIcon' => $icon->getOverlayIcon() ? $icon->getOverlayIcon()->getIdentifier() : '',
|
|
'editable' => $editable,
|
|
'deletable' => $backendUser->doesUserHaveAccess($page, Permission::PAGE_DELETE),
|
|
'labels' => $labels,
|
|
|
|
// _page is only for use in events so they do not need to fetch those
|
|
// records again. The property will be removed from the final payload.
|
|
'_page' => $page,
|
|
// _translationLanguageUids contains the language UIDs for translations that matched (only populated during search)
|
|
'_translationLanguageUids' => $this->pageTreeRepository->getTranslationMatches($pageId),
|
|
'doktype' => (int)($page['doktype'] ?? 0),
|
|
'nameSourceField' => $nameSourceField,
|
|
'mountPoint' => $entryPoint,
|
|
'workspaceId' => !empty($page['t3ver_oid']) ? $page['t3ver_oid'] : $pageId,
|
|
];
|
|
|
|
if (!empty($page['_children']) || $this->pageTreeRepository->hasChildren($pageId)) {
|
|
$item['hasChildren'] = true;
|
|
if ($depth >= $this->levelsToFetch) {
|
|
$page = $this->pageTreeRepository->getTreeLevels($page, 1);
|
|
}
|
|
}
|
|
if (is_array($lockInfo)) {
|
|
$item['locked'] = true;
|
|
}
|
|
if ($stopPageTree) {
|
|
$item['stopPageTree'] = true;
|
|
}
|
|
if ($depth === 0) {
|
|
if ($this->showMountPathAboveMounts) {
|
|
$item['note'] = $this->getMountPointPath($pageId);
|
|
}
|
|
}
|
|
|
|
$items[] = $item;
|
|
if (!$stopPageTree && is_array($page['_children']) && !empty($page['_children']) && ($depth < $this->levelsToFetch || $this->expandAllNodes)) {
|
|
$items[key($items)]['loaded'] = true;
|
|
foreach ($page['_children'] as $child) {
|
|
$items = array_merge($items, $this->pagesToFlatArray($child, $entryPoint, $depth + 1));
|
|
}
|
|
}
|
|
|
|
return $items;
|
|
}
|
|
|
|
protected function initializePageTreeRepository(): PageTreeRepository
|
|
{
|
|
$backendUser = $this->getBackendUser();
|
|
$userTsConfig = $backendUser->getTSConfig();
|
|
$excludedDocumentTypes = GeneralUtility::intExplode(',', (string)($userTsConfig['options.']['pageTree.']['excludeDoktypes'] ?? ''), true);
|
|
|
|
$additionalQueryRestrictions = [];
|
|
if ($excludedDocumentTypes !== []) {
|
|
$additionalQueryRestrictions[] = GeneralUtility::makeInstance(DocumentTypeExclusionRestriction::class, $excludedDocumentTypes);
|
|
}
|
|
|
|
$pageTreeRepository = GeneralUtility::makeInstance(
|
|
PageTreeRepository::class,
|
|
$backendUser->workspace,
|
|
[],
|
|
$additionalQueryRestrictions
|
|
);
|
|
$pageTreeRepository->setAdditionalWhereClause($backendUser->getPagePermsClause(Permission::PAGE_SHOW));
|
|
return $pageTreeRepository;
|
|
}
|
|
|
|
/**
|
|
* Fetches all pages for all tree entry points the user is allowed to see
|
|
*
|
|
* @param string $query The search query can either be a string to be found in the title or the nav_title of a page or the uid of a page.
|
|
*/
|
|
protected function getAllEntryPointPageTrees(int $startPid = 0, string $query = ''): array
|
|
{
|
|
$this->pageTreeRepository ??= $this->initializePageTreeRepository();
|
|
$backendUser = $this->getBackendUser();
|
|
if ($startPid === 0) {
|
|
$startPid = (int)($backendUser->uc['pageTree_temporaryMountPoint'] ?? 0);
|
|
}
|
|
|
|
$entryPointIds = null;
|
|
if ($startPid > 0) {
|
|
$entryPointIds = [$startPid];
|
|
} elseif (!empty($this->alternativeEntryPoints)) {
|
|
$entryPointIds = $this->alternativeEntryPoints;
|
|
}
|
|
|
|
$permClause = $backendUser->getPagePermsClause(Permission::PAGE_SHOW);
|
|
if ($query !== '') {
|
|
$this->levelsToFetch = 999;
|
|
$this->pageTreeRepository->fetchFilteredTree(
|
|
$query,
|
|
$this->getAllowedMountPoints(),
|
|
$permClause
|
|
);
|
|
}
|
|
$rootRecord = [
|
|
'uid' => 0,
|
|
'title' => $GLOBALS['TYPO3_CONF_VARS']['SYS']['sitename'] ?: 'TYPO3',
|
|
];
|
|
$entryPointRecords = [];
|
|
$mountPoints = [];
|
|
if ($entryPointIds === null) {
|
|
//watch out for deleted pages returned as webmount
|
|
$mountPoints = $backendUser->getWebmounts();
|
|
$mountPoints = array_filter($mountPoints, fn(int $id): bool => !in_array($id, $this->hiddenRecords, true));
|
|
|
|
// Switch to multiple-entryPoint-mode if the rootPage is to be mounted.
|
|
// (other mounts would appear duplicated in the pid = 0 tree otherwise)
|
|
if (in_array(0, $mountPoints, true)) {
|
|
$entryPointIds = $mountPoints;
|
|
}
|
|
}
|
|
|
|
if ($entryPointIds === null) {
|
|
if ($query !== '') {
|
|
$rootRecord = $this->pageTreeRepository->getTree(0, null, $mountPoints);
|
|
} else {
|
|
$rootRecord = $this->pageTreeRepository->getTreeLevels($rootRecord, $this->levelsToFetch, $mountPoints);
|
|
}
|
|
|
|
$mountPointOrdering = array_flip($mountPoints);
|
|
if (isset($rootRecord['_children'])) {
|
|
usort($rootRecord['_children'], static function ($a, $b) use ($mountPointOrdering) {
|
|
return ($mountPointOrdering[$a['uid']] ?? 0) <=> ($mountPointOrdering[$b['uid']] ?? 0);
|
|
});
|
|
}
|
|
|
|
$entryPointRecords[] = $rootRecord;
|
|
} else {
|
|
$entryPointIds = array_filter($entryPointIds, fn(int $id): bool => !in_array($id, $this->hiddenRecords, true));
|
|
foreach ($entryPointIds as $k => $entryPointId) {
|
|
if ($entryPointId === 0) {
|
|
$entryPointRecord = $rootRecord;
|
|
} else {
|
|
$entryPointRecord = BackendUtility::getRecordWSOL('pages', $entryPointId, '*', $permClause);
|
|
|
|
if ($entryPointRecord !== null && !$backendUser->isInWebMount($entryPointId)) {
|
|
$entryPointRecord = null;
|
|
}
|
|
if ($entryPointRecord === null) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
$entryPointRecord['uid'] = (int)$entryPointRecord['uid'];
|
|
if ($query === '') {
|
|
$entryPointRecord = $this->pageTreeRepository->getTreeLevels($entryPointRecord, $this->levelsToFetch);
|
|
} else {
|
|
$entryPointRecord = $this->pageTreeRepository->getTree($entryPointRecord['uid'], null, $entryPointIds);
|
|
}
|
|
|
|
if ($entryPointRecord !== []) {
|
|
$entryPointRecords[$k] = $entryPointRecord;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $entryPointRecords;
|
|
}
|
|
|
|
/**
|
|
* Returns the first configured domain name for a page
|
|
*/
|
|
protected function getDomainNameForPage(int $pageId): string
|
|
{
|
|
try {
|
|
$site = $this->siteFinder->getSiteByRootPageId($pageId);
|
|
return (string)$site->getBase();
|
|
} catch (SiteNotFoundException) {
|
|
// No site found
|
|
}
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Returns the mount point path for a temporary mount or the given id
|
|
*/
|
|
protected function getMountPointPath(int $uid): string
|
|
{
|
|
if ($uid <= 0) {
|
|
return '';
|
|
}
|
|
$rootline = array_reverse(BackendUtility::BEgetRootLine($uid));
|
|
array_shift($rootline);
|
|
$path = [];
|
|
foreach ($rootline as $rootlineElement) {
|
|
$record = BackendUtility::getRecordWSOL('pages', $rootlineElement['uid'], 'title, nav_title', '', true, true);
|
|
$text = $record['title'];
|
|
if ($this->useNavTitle && trim($record['nav_title'] ?? '') !== '') {
|
|
$text = $record['nav_title'];
|
|
}
|
|
$path[] = htmlspecialchars($text);
|
|
}
|
|
return '/' . implode('/', $path);
|
|
}
|
|
|
|
/**
|
|
* Check if drag-move in the svg tree is allowed for the user
|
|
*/
|
|
protected function isDragMoveAllowed(): bool
|
|
{
|
|
$backendUser = $this->getBackendUser();
|
|
return $backendUser->isAdmin()
|
|
|| ($backendUser->check('tables_modify', 'pages') && $backendUser->checkLanguageAccess(0));
|
|
}
|
|
|
|
/**
|
|
* Get allowed mountpoints. Returns temporary mountpoint when temporary mountpoint is used.
|
|
*
|
|
* @return int[]
|
|
*/
|
|
protected function getAllowedMountPoints(): array
|
|
{
|
|
$mountPoints = (int)($this->getBackendUser()->uc['pageTree_temporaryMountPoint'] ?? 0);
|
|
if (!$mountPoints) {
|
|
if (!empty($this->alternativeEntryPoints)) {
|
|
return $this->alternativeEntryPoints;
|
|
}
|
|
return $this->getBackendUser()->getWebmounts();
|
|
}
|
|
return [$mountPoints];
|
|
}
|
|
|
|
protected function getPostProcessedPageItems(ServerRequestInterface $request, array $items): array
|
|
{
|
|
return array_map(
|
|
static function (array $item): PageTreeItem {
|
|
return new PageTreeItem(
|
|
// TreeItem
|
|
new TreeItem(
|
|
identifier: $item['identifier'],
|
|
parentIdentifier: (string)($item['parentIdentifier'] ?? ''),
|
|
recordType: (string)($item['recordType'] ?? ''),
|
|
name: (string)($item['name'] ?? ''),
|
|
note: (string)($item['note'] ?? ''),
|
|
prefix: (string)($item['prefix'] ?? ''),
|
|
suffix: (string)($item['suffix'] ?? ''),
|
|
tooltip: (string)($item['tooltip'] ?? ''),
|
|
depth: (int)($item['depth'] ?? 0),
|
|
hasChildren: (bool)($item['hasChildren'] ?? false),
|
|
loaded: (bool)($item['loaded'] ?? false),
|
|
editable: (bool)($item['editable'] ?? false),
|
|
deletable: (bool)($item['deletable'] ?? false),
|
|
icon: (string)($item['icon'] ?? ''),
|
|
overlayIcon: (string)($item['overlayIcon'] ?? ''),
|
|
statusInformation: (array)($item['statusInformation'] ?? []),
|
|
labels: (array)($item['labels'] ?? []),
|
|
),
|
|
// PageTreeItem
|
|
doktype: (int)($item['doktype'] ?? ''),
|
|
nameSourceField: (string)($item['nameSourceField'] ?? ''),
|
|
workspaceId: (int)($item['workspaceId'] ?? 0),
|
|
locked: (bool)($item['locked'] ?? false),
|
|
stopPageTree: (bool)($item['stopPageTree'] ?? false),
|
|
mountPoint: (int)($item['mountPoint'] ?? 0),
|
|
);
|
|
},
|
|
$this->eventDispatcher->dispatch(
|
|
new AfterPageTreeItemsPreparedEvent($request, $items)
|
|
)->getItems()
|
|
);
|
|
}
|
|
|
|
protected function getBackendUser(): BackendUserAuthentication
|
|
{
|
|
return $GLOBALS['BE_USER'];
|
|
}
|
|
|
|
protected function getLanguageService(): ?LanguageService
|
|
{
|
|
return $GLOBALS['LANG'] ?? null;
|
|
}
|
|
}
|