9.5/_soft_reference_index_8php_source.html

<?php

namespace ‪TYPO3\CMS\Core\Database;


/*

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

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

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

use ‪TYPO3\CMS\Core\Html\HtmlParser;

use ‪TYPO3\CMS\Core\LinkHandling\Exception\UnknownLinkHandlerException;

use ‪TYPO3\CMS\Core\LinkHandling\LinkService;

use ‪TYPO3\CMS\Core\Resource\File;

use ‪TYPO3\CMS\Core\Resource\FileInterface;

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

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

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

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

use ‪TYPO3\CMS\Frontend\Service\TypoLinkCodecService;


class ‪SoftReferenceIndex

{

    public ‪$tokenID_basePrefix = '';


    public function ‪findRef($table, $field, $uid, $content, $spKey, $spParams, $structurePath = '')

    {

        $retVal = false;

        $this->tokenID_basePrefix = $table . ':' . $uid . ':' . $field . ':' . $structurePath . ':' . $spKey;

        switch ($spKey) {

            case 'notify':

                // Simple notification

                $resultArray = [

                    'elements' => [

                        [

                            'matchString' => $content

                        ]

                    ]

                ];

                $retVal = $resultArray;

                break;

            case 'substitute':

                $tokenID = $this->‪makeTokenID();

                $resultArray = [

                    'content' => '{softref:' . $tokenID . '}',

                    'elements' => [

                        [

                            'matchString' => $content,

                            'subst' => [

                                'type' => 'string',

                                'tokenID' => $tokenID,

                                'tokenValue' => $content

                            ]

                        ]

                    ]

                ];

                $retVal = $resultArray;

                break;

            case 'images':

                $retVal = $this->‪findRef_images($content);

                break;

            case 'typolink':

                $retVal = $this->‪findRef_typolink($content, $spParams);

                break;

            case 'typolink_tag':

                $retVal = $this->‪findRef_typolink_tag($content);

                break;

            case 'ext_fileref':

                $retVal = $this->‪findRef_extension_fileref($content);

                break;

            case 'email':

                $retVal = $this->‪findRef_email($content, $spParams);

                break;

            case 'url':

                $retVal = $this->‪findRef_url($content, $spParams);

                break;

            default:

                $retVal = false;

        }

        return $retVal;

    }


    public function ‪findRef_images($content)

    {

        // Start HTML parser and split content by image tag:

        $htmlParser = GeneralUtility::makeInstance(\‪TYPO3\CMS\Core\Html\HtmlParser::class);

        $splitContent = $htmlParser->splitTags('img', $content);

        $elements = [];

        // Traverse splitted parts:

        foreach ($splitContent as $k => $v) {

            if ($k % 2) {

                // Get file reference:

                $attribs = $htmlParser->get_tag_attributes($v);

                $srcRef = htmlspecialchars_decode($attribs[0]['src']);

                $pI = pathinfo($srcRef);

                // If it looks like a local image, continue. Otherwise ignore it.

                $absPath = GeneralUtility::getFileAbsFileName(‪Environment::getPublicPath() . '/' . $srcRef);

                if (!$pI['scheme'] && !$pI['query'] && $absPath && $srcRef !== 'clear.gif') {

                    // @deprecated since TYPO3 v9, will be removed in TYPO3 v10.0. Deprecation logged by TcaMigration class.

                    // Initialize the element entry with info text here:

                    $tokenID = $this->‪makeTokenID($k);

                    $elements[$k] = [];

                    $elements[$k]['matchString'] = $v;

                    // If the image seems to be an RTE image, then proceed to set up substitution token:

                    if (GeneralUtility::isFirstPartOfStr($srcRef, 'uploads/') && preg_match('/^RTEmagicC_/', ‪PathUtility::basename($srcRef))) {

                        // Token and substitute value:

                        // Make sure the value we work on is found and will get substituted in the content (Very important that the src-value is not DeHSC'ed)

                        if (strstr($splitContent[$k], $attribs[0]['src'])) {

                            // Substitute value with token (this is not be an exact method if the value is in there twice, but we assume it will not)

                            $splitContent[$k] = str_replace($attribs[0]['src'], '{softref:' . $tokenID . '}', $splitContent[$k]);

                            $elements[$k]['subst'] = [

                                'type' => 'file',

                                'relFileName' => $srcRef,

                                'tokenID' => $tokenID,

                                'tokenValue' => $attribs[0]['src']

                            ];

                            // Finally, notice if the file does not exist.

                            if (!@is_file($absPath)) {

                                $elements[$k]['error'] = 'File does not exist!';

                            }

                        } else {

                            $elements[$k]['error'] = 'Could not substitute image source with token!';

                        }

                    }

                }

            }

        }

        // Return result:

        if (!empty($elements)) {

            $resultArray = [

                'content' => implode('', $splitContent),

                'elements' => $elements

            ];

            return $resultArray;

        }

    }


    public function ‪findRef_typolink($content, $spParams)

    {

        // First, split the input string by a comma if the "linkList" parameter is set.

        // An example: the link field for images in content elements of type "textpic" or "image". This field CAN be configured to define a link per image, separated by comma.

        if (is_array($spParams) && in_array('linkList', $spParams)) {

            // Preserving whitespace on purpose.

            $linkElement = explode(',', $content);

        } else {

            // If only one element, just set in this array to make it easy below.

            $linkElement = [$content];

        }

        // Traverse the links now:

        $elements = [];

        foreach ($linkElement as $k => $typolinkValue) {

            $tLP = $this->‪getTypoLinkParts($typolinkValue);

            $linkElement[$k] = $this->‪setTypoLinkPartsElement($tLP, $elements, $typolinkValue, $k);

        }

        // Return output:

        if (!empty($elements)) {

            $resultArray = [

                'content' => implode(',', $linkElement),

                'elements' => $elements

            ];

            return $resultArray;

        }

    }


    public function ‪findRef_typolink_tag($content)

    {

        // Parse string for special TYPO3 <link> tag:

        $htmlParser = GeneralUtility::makeInstance(HtmlParser::class);

        $linkService = GeneralUtility::makeInstance(LinkService::class);

        $linkTags = $htmlParser->splitTags('a', $content);

        // Traverse result:

        $elements = [];

        foreach ($linkTags as $key => $foundValue) {

            if ($key % 2) {

                if (preg_match('/href="([^"]+)"/', $foundValue, $matches)) {

                    try {

                        $linkDetails = $linkService->resolve($matches[1]);

                        if ($linkDetails['type'] === ‪LinkService::TYPE_FILE && preg_match('/file\?uid=(\d+)/', $matches[1], $fileIdMatch)) {

                            $token = $this->‪makeTokenID($key);

                            $elements[$key]['matchString'] = $linkTags[$key];

                            $linkTags[$key] = str_replace($matches[1], '{softref:' . $token . '}', $linkTags[$key]);

                            $elements[$key]['subst'] = [

                                'type' => 'db',

                                'recordRef' => 'sys_file:' . $fileIdMatch[1],

                                'tokenID' => $token,

                                'tokenValue' => 'file:' . ($linkDetails['file'] instanceof ‪File ? $linkDetails['file']->‪getUid() : $fileIdMatch[1])

                            ];

                        } elseif ($linkDetails['type'] === ‪LinkService::TYPE_PAGE && preg_match('/page\?uid=(\d+)#?(\d+)?/', $matches[1], $pageAndAnchorMatches)) {

                            $token = $this->‪makeTokenID($key);

                            $content = '{softref:' . $token . '}';

                            $elements[$key]['matchString'] = $linkTags[$key];

                            $elements[$key]['subst'] = [

                                'type' => 'db',

                                'recordRef' => 'pages:' . $linkDetails['pageuid'],

                                'tokenID' => $token,

                                'tokenValue' => $linkDetails['pageuid']

                            ];

                            if (isset($pageAndAnchorMatches[2]) && $pageAndAnchorMatches[2] !== '') {

                                // Anchor is assumed to point to a content elements:

                                if (‪MathUtility::canBeInterpretedAsInteger($pageAndAnchorMatches[2])) {

                                    // Initialize a new entry because we have a new relation:

                                    $newTokenID = $this->‪makeTokenID('setTypoLinkPartsElement:anchor:' . $key);

                                    $elements[$newTokenID . ':' . $key] = [];

                                    $elements[$newTokenID . ':' . $key]['matchString'] = 'Anchor Content Element: ' . $pageAndAnchorMatches[2];

                                    $content .= '#{softref:' . $newTokenID . '}';

                                    $elements[$newTokenID . ':' . $key]['subst'] = [

                                        'type' => 'db',

                                        'recordRef' => 'tt_content:' . $pageAndAnchorMatches[2],

                                        'tokenID' => $newTokenID,

                                        'tokenValue' => $pageAndAnchorMatches[2]

                                    ];

                                } else {

                                    // Anchor is a hardcoded string

                                    $content .= '#' . $pageAndAnchorMatches[2];

                                }

                            }

                            $linkTags[$key] = str_replace($matches[1], $content, $linkTags[$key]);

                        } elseif ($linkDetails['type'] === ‪LinkService::TYPE_URL) {

                            $token = $this->‪makeTokenID($key);

                            $elements[$key]['matchString'] = $linkTags[$key];

                            $linkTags[$key] = str_replace($matches[1], '{softref:' . $token . '}', $linkTags[$key]);

                            $elements[$key]['subst'] = [

                                'type' => 'external',

                                'tokenID' => $token,

                                'tokenValue' => $linkDetails['url']

                            ];

                        } elseif ($linkDetails['type'] === ‪LinkService::TYPE_EMAIL) {

                            $token = $this->‪makeTokenID($key);

                            $elements[$key]['matchString'] = $linkTags[$key];

                            $linkTags[$key] = str_replace($matches[1], '{softref:' . $token . '}', $linkTags[$key]);

                            $elements[$key]['subst'] = [

                                'type' => 'string',

                                'tokenID' => $token,

                                'tokenValue' => $linkDetails['email']

                            ];

                        }

                    } catch (\‪Exception $e) {

                        // skip invalid links

                    }

                }

            }

        }

        // Return output:

        if (!empty($elements)) {

            $resultArray = [

                'content' => implode('', $linkTags),

                'elements' => $elements

            ];

            return $resultArray;

        }

    }


    public function ‪findRef_email($content, $spParams)

    {

        // Email:

        $parts = preg_split('/([^[:alnum:]]+)([A-Za-z0-9\\._-]+[@][A-Za-z0-9\\._-]+[\\.].[A-Za-z0-9]+)/', ' ' . $content . ' ', 10000, PREG_SPLIT_DELIM_CAPTURE);

        foreach ($parts as $idx => $value) {

            if ($idx % 3 == 2) {

                $tokenID = $this->‪makeTokenID($idx);

                $elements[$idx] = [];

                $elements[$idx]['matchString'] = $value;

                if (is_array($spParams) && in_array('subst', $spParams)) {

                    $parts[$idx] = '{softref:' . $tokenID . '}';

                    $elements[$idx]['subst'] = [

                        'type' => 'string',

                        'tokenID' => $tokenID,

                        'tokenValue' => $value

                    ];

                }

            }

        }

        // Return output:

        if (!empty($elements)) {

            $resultArray = [

                'content' => substr(implode('', $parts), 1, -1),

                'elements' => $elements

            ];

            return $resultArray;

        }

    }


    public function ‪findRef_url($content, $spParams)

    {

        // URLs

        $parts = preg_split('/([^[:alnum:]"\']+)((https?|ftp):\\/\\/[^[:space:]"\'<>]*)([[:space:]])/', ' ' . $content . ' ', 10000, PREG_SPLIT_DELIM_CAPTURE);

        foreach ($parts as $idx => $value) {

            if ($idx % 5 == 3) {

                unset($parts[$idx]);

            }

            if ($idx % 5 == 2) {

                $tokenID = $this->‪makeTokenID($idx);

                $elements[$idx] = [];

                $elements[$idx]['matchString'] = $value;

                if (is_array($spParams) && in_array('subst', $spParams)) {

                    $parts[$idx] = '{softref:' . $tokenID . '}';

                    $elements[$idx]['subst'] = [

                        'type' => 'string',

                        'tokenID' => $tokenID,

                        'tokenValue' => $value

                    ];

                }

            }

        }

        // Return output:

        if (!empty($elements)) {

            $resultArray = [

                'content' => substr(implode('', $parts), 1, -1),

                'elements' => $elements

            ];

            return $resultArray;

        }

    }


    public function ‪findRef_extension_fileref($content)

    {

        // Files starting with EXT:

        $parts = preg_split('/([^[:alnum:]"\']+)(EXT:[[:alnum:]_]+\\/[^[:space:]"\',]*)/', ' ' . $content . ' ', 10000, PREG_SPLIT_DELIM_CAPTURE);

        foreach ($parts as $idx => $value) {

            if ($idx % 3 == 2) {

                $this->‪makeTokenID($idx);

                $elements[$idx] = [];

                $elements[$idx]['matchString'] = $value;

            }

        }

        // Return output:

        if (!empty($elements)) {

            $resultArray = [

                'content' => substr(implode('', $parts), 1, -1),

                'elements' => $elements

            ];

            return $resultArray;

        }

    }


    /*************************

     *

     * Helper functions

     *

     *************************/


    public function ‪getTypoLinkParts($typolinkValue)

    {

        $finalTagParts = GeneralUtility::makeInstance(TypoLinkCodecService::class)->decode($typolinkValue);


        $link_param = $finalTagParts['url'];

        // we define various keys below, "url" might be misleading

        unset($finalTagParts['url']);


        if (stripos(rawurldecode(trim($link_param)), 'phar://') === 0) {

            throw new \RuntimeException(

                'phar scheme not allowed as soft reference target',

                1530030672

            );

        }


        $linkService = GeneralUtility::makeInstance(LinkService::class);

        try {

            $linkData = $linkService->resolve($link_param);

            switch ($linkData['type']) {

                case ‪LinkService::TYPE_RECORD:

                    $finalTagParts['table'] = $linkData['identifier'];

                    $finalTagParts['uid'] = $linkData['uid'];

                    break;

                case ‪LinkService::TYPE_PAGE:

                    $linkData['pageuid'] = (int)$linkData['pageuid'];

                    if (isset($linkData['pagetype'])) {

                        $linkData['pagetype'] = (int)$linkData['pagetype'];

                    }

                    if (isset($linkData['fragment'])) {

                        $finalTagParts['anchor'] = $linkData['fragment'];

                    }

                    break;

                case ‪LinkService::TYPE_FILE:

                case ‪LinkService::TYPE_UNKNOWN:

                    if (isset($linkData['file'])) {

                        $finalTagParts['type'] = ‪LinkService::TYPE_FILE;

                        $linkData['file'] = $linkData['file'] instanceof ‪FileInterface ? $linkData['file']->getUid() : $linkData['file'];

                    } else {

                        $pU = parse_url($link_param);

                        parse_str($pU['query'] ?? '', $query);

                        if (isset($query['uid'])) {

                            $finalTagParts['type'] = ‪LinkService::TYPE_FILE;

                            $finalTagParts['file'] = (int)$query['uid'];

                        }

                    }

                    break;

            }

            return array_merge($finalTagParts, $linkData);

        } catch (‪UnknownLinkHandlerException $e) {

            // Cannot handle anything

            return $finalTagParts;

        }

        return $finalTagParts;

    }


    public function ‪setTypoLinkPartsElement($tLP, &$elements, $content, $idx)

    {

        // Initialize, set basic values. In any case a link will be shown

        $tokenID = $this->‪makeTokenID('setTypoLinkPartsElement:' . $idx);

        $elements[$tokenID . ':' . $idx] = [];

        $elements[$tokenID . ':' . $idx]['matchString'] = $content;

        // Based on link type, maybe do more:

        switch ((string)$tLP['type']) {

            case ‪LinkService::TYPE_EMAIL:

                // Mail addresses can be substituted manually:

                $elements[$tokenID . ':' . $idx]['subst'] = [

                    'type' => 'string',

                    'tokenID' => $tokenID,

                    'tokenValue' => $tLP['email']

                ];

                // Output content will be the token instead:

                $content = '{softref:' . $tokenID . '}';

                break;

            case ‪LinkService::TYPE_URL:

                // URLs can be substituted manually

                $elements[$tokenID . ':' . $idx]['subst'] = [

                    'type' => 'external',

                    'tokenID' => $tokenID,

                    'tokenValue' => $tLP['url']

                ];

                // Output content will be the token instead:

                $content = '{softref:' . $tokenID . '}';

                break;

            case ‪LinkService::TYPE_FOLDER:

                // This is a link to a folder...

                unset($elements[$tokenID . ':' . $idx]);

                return $content;

            case ‪LinkService::TYPE_FILE:

                // Process files referenced by their FAL uid

                if (isset($tLP['file'])) {

                    $fileId = $tLP['file'] instanceof ‪FileInterface ? $tLP['file']->getUid() : $tLP['file'];

                    // Token and substitute value

                    $elements[$tokenID . ':' . $idx]['subst'] = [

                        'type' => 'db',

                        'recordRef' => 'sys_file:' . $fileId,

                        'tokenID' => $tokenID,

                        'tokenValue' => 'file:' . $fileId,

                    ];

                    // Output content will be the token instead:

                    $content = '{softref:' . $tokenID . '}';

                } elseif ($tLP['identifier']) {

                    list($linkHandlerKeyword, $linkHandlerValue) = explode(':', trim($tLP['identifier']), 2);

                    if (‪MathUtility::canBeInterpretedAsInteger($linkHandlerValue)) {

                        // Token and substitute value

                        $elements[$tokenID . ':' . $idx]['subst'] = [

                            'type' => 'db',

                            'recordRef' => 'sys_file:' . $linkHandlerValue,

                            'tokenID' => $tokenID,

                            'tokenValue' => $tLP['identifier'],

                        ];

                        // Output content will be the token instead:

                        $content = '{softref:' . $tokenID . '}';

                    } else {

                        // This is a link to a folder...

                        return $content;

                    }

                } else {

                    return $content;

                }

                break;

            case ‪LinkService::TYPE_PAGE:

                // Rebuild page reference typolink part:

                $content = '';

                // Set page id:

                if ($tLP['pageuid']) {

                    $content .= '{softref:' . $tokenID . '}';

                    $elements[$tokenID . ':' . $idx]['subst'] = [

                        'type' => 'db',

                        'recordRef' => 'pages:' . $tLP['pageuid'],

                        'tokenID' => $tokenID,

                        'tokenValue' => !empty($tLP['pagealias']) ? $tLP['pagealias'] : $tLP['pageuid']

                    ];

                }

                // Add type if applicable

                if ((string)($tLP['pagetype'] ?? '') !== '') {

                    $content .= ',' . $tLP['pagetype'];

                }

                // Add anchor if applicable

                if ((string)($tLP['anchor'] ?? '') !== '') {

                    // Anchor is assumed to point to a content elements:

                    if (‪MathUtility::canBeInterpretedAsInteger($tLP['anchor'])) {

                        // Initialize a new entry because we have a new relation:

                        $newTokenID = $this->‪makeTokenID('setTypoLinkPartsElement:anchor:' . $idx);

                        $elements[$newTokenID . ':' . $idx] = [];

                        $elements[$newTokenID . ':' . $idx]['matchString'] = 'Anchor Content Element: ' . $tLP['anchor'];

                        $content .= '#{softref:' . $newTokenID . '}';

                        $elements[$newTokenID . ':' . $idx]['subst'] = [

                            'type' => 'db',

                            'recordRef' => 'tt_content:' . $tLP['anchor'],

                            'tokenID' => $newTokenID,

                            'tokenValue' => $tLP['anchor']

                        ];

                    } else {

                        // Anchor is a hardcoded string

                        $content .= '#' . $tLP['anchor'];

                    }

                }

                break;

            case ‪LinkService::TYPE_RECORD:

                $elements[$tokenID . ':' . $idx]['subst'] = [

                    'type' => 'db',

                    'recordRef' => $tLP['table'] . ':' . $tLP['uid'],

                    'tokenID' => $tokenID,

                    'tokenValue' => $content,

                ];


                $content = '{softref:' . $tokenID . '}';

                break;

            default:

                $linkHandlerFound = false;

                list($linkHandlerFound, $tLP, $content, $newElements) = $this->‪emitSetTypoLinkPartsElement($linkHandlerFound, $tLP, $content, $elements, $idx, $tokenID);

                // We need to merge the array, otherwise we would loose the reference.

                ‪ArrayUtility::mergeRecursiveWithOverrule($elements, $newElements);


                if (!$linkHandlerFound) {

                    $elements[$tokenID . ':' . $idx]['error'] = 'Couldn\'t decide typolink mode.';

                    return $content;

                }

        }

        // Finally, for all entries that was rebuild with tokens, add target, class, title and additionalParams in the end:

        $tLP['url'] = $content;

        $content = GeneralUtility::makeInstance(TypoLinkCodecService::class)->encode($tLP);


        // Return rebuilt typolink value:

        return $content;

    }


    public function ‪getPageIdFromAlias($link_param)

    {

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

        $queryBuilder->getRestrictions()

            ->removeAll()

            ->add(GeneralUtility::makeInstance(DeletedRestriction::class))

            ->add(GeneralUtility::makeInstance(BackendWorkspaceRestriction::class));


        $pageUid = $queryBuilder->select('uid')

            ->from('pages')

            ->where(

                $queryBuilder->expr()->eq('alias', $queryBuilder->createNamedParameter($link_param, \PDO::PARAM_STR))

            )

            ->setMaxResults(1)

            ->execute()

            ->fetchColumn(0);


        return (int)$pageUid;

    }


    public function ‪makeTokenID($index = '')

    {

        return md5($this->tokenID_basePrefix . ':' . $index);

    }


    protected function ‪getSignalSlotDispatcher()

    {

        return GeneralUtility::makeInstance(\‪TYPO3\CMS\‪Extbase\SignalSlot\Dispatcher::class);

    }


    protected function ‪emitSetTypoLinkPartsElement($linkHandlerFound, $tLP, $content, $elements, $idx, $tokenID)

    {

        return $this->‪getSignalSlotDispatcher()->‪dispatch(static::class, 'setTypoLinkPartsElement', [$linkHandlerFound, $tLP, $content, $elements, $idx, $tokenID, $this]);

    }

}