9.5/_populate_page_slugs_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Install\Updates;


/*

 * 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\Core\Context\Context;

use ‪TYPO3\CMS\Core\Database\ConnectionPool;

use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;

use ‪TYPO3\CMS\Core\DataHandling\Model\RecordStateFactory;

use ‪TYPO3\CMS\Core\DataHandling\SlugHelper;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;


class ‪PopulatePageSlugs implements ‪UpgradeWizardInterface

{

    protected ‪$table = 'pages';


    protected ‪$fieldName = 'slug';


    public function ‪getIdentifier(): string

    {

        return 'pagesSlugs';

    }


    public function ‪getTitle(): string

    {

        return 'Introduce URL parts ("slugs") to all existing pages';

    }


    public function ‪getDescription(): string

    {

        return 'TYPO3 includes native URL handling. Every page record has its own speaking URL path'

            . ' called "slug" which can be edited in TYPO3 Backend. However, it is necessary that all pages have'

            . ' a URL pre-filled. This is done by evaluating the page title / navigation title and all of its rootline.';

    }


    public function ‪updateNecessary(): bool

    {

        $updateNeeded = false;

        // Check if the database table even exists

        if ($this->‪checkIfWizardIsRequired()) {

            $updateNeeded = true;

        }

        return $updateNeeded;

    }


    public function ‪getPrerequisites(): array

    {

        return [

            DatabaseUpdatedPrerequisite::class

        ];

    }


    public function ‪executeUpdate(): bool

    {

        $this->‪populateSlugs();

        return true;

    }


    protected function ‪populateSlugs()

    {

        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->table);

        $queryBuilder = $connection->createQueryBuilder();

        $queryBuilder->getRestrictions()->removeAll()->add(GeneralUtility::makeInstance(DeletedRestriction::class));

        $statement = $queryBuilder

            ->select('*')

            ->from($this->table)

            ->where(

                $queryBuilder->expr()->orX(

                    $queryBuilder->expr()->eq($this->fieldName, $queryBuilder->createNamedParameter('')),

                    $queryBuilder->expr()->isNull($this->fieldName)

                )

            )

            // Ensure that fields with alias are managed first

            ->orderBy('alias', 'desc')

            // Ensure that live workspace records are handled first

            ->addOrderBy('t3ver_wsid', 'asc')

            // Ensure that all pages are run through "per parent page" field, and in the correct sorting values

            ->addOrderBy('pid', 'asc')

            ->addOrderBy('sorting', 'asc')

            ->execute();


        // Check for existing slugs from realurl

        $suggestedSlugs = [];

        if ($this->‪checkIfTableExists('tx_realurl_pathdata')) {

            $suggestedSlugs = $this->‪getSuggestedSlugs('tx_realurl_pathdata');

        } elseif ($this->‪checkIfTableExists('tx_realurl_pathcache')) {

            $suggestedSlugs = $this->‪getSuggestedSlugs('tx_realurl_pathcache', 'cache_id');

        }


        $fieldConfig = ‪$GLOBALS['TCA'][‪$this->table]['columns'][‪$this->fieldName]['config'];

        $fieldConfig['generatorOptions']['fields'] = ['tx_realurl_pathsegment,title'];

        $evalInfo = !empty($fieldConfig['eval']) ? GeneralUtility::trimExplode(',', $fieldConfig['eval'], true) : [];

        $hasToBeUniqueInSite = in_array('uniqueInSite', $evalInfo, true);

        $hasToBeUniqueInPid = in_array('uniqueInPid', $evalInfo, true);

        $slugHelper = GeneralUtility::makeInstance(SlugHelper::class, $this->table, $this->fieldName, $fieldConfig);

        while ($record = $statement->fetch()) {

            $recordId = (int)$record['uid'];

            $pid = (int)$record['pid'];

            $languageId = (int)$record['sys_language_uid'];

            $pageIdInDefaultLanguage = $languageId > 0 ? (int)$record['l10n_parent'] : $recordId;

            $slug = $suggestedSlugs[$pageIdInDefaultLanguage][$languageId] ?? '';


            // see if an alias field was used, then let's build a slug out of that.

            if (!empty($record['alias'])) {

                $slug = $slugHelper->sanitize('/' . $record['alias']);

            }


            if (empty($slug)) {

                if ($pid === -1) {

                    $queryBuilder = $connection->createQueryBuilder();

                    $queryBuilder->getRestrictions()->removeAll()->add(GeneralUtility::makeInstance(DeletedRestriction::class));

                    $liveVersion = $queryBuilder

                        ->select('pid')

                        ->from('pages')

                        ->where(

                            $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($record['t3ver_oid'], \PDO::PARAM_INT))

                        )->execute()->fetch();

                    $pid = (int)$liveVersion['pid'];

                }

                $slug = $slugHelper->generate($record, $pid);

            }


            $state = ‪RecordStateFactory::forName($this->table)

                ->fromArray($record, $pid, $recordId);

            if ($hasToBeUniqueInSite && !$slugHelper->isUniqueInSite($slug, $state)) {

                $slug = $slugHelper->buildSlugForUniqueInSite($slug, $state);

            }

            if ($hasToBeUniqueInPid && !$slugHelper->isUniqueInPid($slug, $state)) {

                $slug = $slugHelper->buildSlugForUniqueInPid($slug, $state);

            }


            $connection->update(

                $this->table,

                [$this->fieldName => $slug],

                ['uid' => $recordId]

            );

        }

    }


    protected function ‪checkIfWizardIsRequired(): bool

    {

        $connectionPool = GeneralUtility::makeInstance(ConnectionPool::class);

        $queryBuilder = $connectionPool->getQueryBuilderForTable($this->table);

        $queryBuilder->getRestrictions()->removeAll()->add(GeneralUtility::makeInstance(DeletedRestriction::class));


        $numberOfEntries = $queryBuilder

            ->count('uid')

            ->from($this->table)

            ->where(

                $queryBuilder->expr()->orX(

                    $queryBuilder->expr()->eq($this->fieldName, $queryBuilder->createNamedParameter('')),

                    $queryBuilder->expr()->isNull($this->fieldName)

                )

            )

            ->execute()

            ->fetchColumn();

        return $numberOfEntries > 0;

    }


    protected function ‪getSuggestedSlugs(string $tableName, string $identityField = 'uid'): array

    {

        $context = GeneralUtility::makeInstance(Context::class);

        $currentTimestamp = $context->getPropertyFromAspect('date', 'timestamp');


        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($tableName);

        $statement = $queryBuilder

            ->select('*')

            ->from($tableName)

            ->where(

                $queryBuilder->expr()->eq('mpvar', $queryBuilder->createNamedParameter('')),

                $queryBuilder->expr()->orX(

                    $queryBuilder->expr()->eq('expire', $queryBuilder->createNamedParameter(0)),

                    $queryBuilder->expr()->gt('expire', $queryBuilder->createNamedParameter($currentTimestamp))

                )

            )

            ->orderBy('expire', 'ASC')

            ->execute();

        $suggestedSlugs = [];

        while ($row = $statement->fetch()) {

            // rawurldecode ensures that non-ASCII arguments are also migrated

            $pagePath = rawurldecode($row['pagepath']);

            if (!isset($suggestedSlugs[(int)$row['page_id']][(int)$row['language_id']])) { // keep only first result

                $suggestedSlugs[(int)$row['page_id']][(int)$row['language_id']] = '/' . trim($pagePath, '/');

            }

        }

        return $suggestedSlugs;

    }


    protected function ‪checkIfTableExists(‪$table)

    {

        $tableExists = GeneralUtility::makeInstance(ConnectionPool::class)

            ->getConnectionForTable(‪$table)

            ->getSchemaManager()

            ->tablesExist([‪$table]);


        return $tableExists;

    }

}