CacheHashCalculator.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Frontend\Page;

/*
 * 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\Utility\GeneralUtility;

class CacheHashCalculator implements \TYPO3\CMS\Core\SingletonInterface
{
    protected $cachedParametersWhiteList = array();

    protected $excludedParameters = array();

    protected $requireCacheHashPresenceParameters = array();

    protected $excludedParametersIfEmpty = array();

    protected $excludeAllEmptyParameters = false;

    public function __construct()
    {
        $this->setConfiguration($GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash']);
    }

    public function calculateCacheHash(array $params)
    {
        return !empty($params) ? md5(serialize($params)) : '';
    }

    public function generateForParameters($queryString)
    {
        $cacheHashParams = $this->getRelevantParameters($queryString);
        return $this->calculateCacheHash($cacheHashParams);
    }

    public function doParametersRequireCacheHash($queryString)
    {
        if (empty($this->requireCacheHashPresenceParameters)) {
            return false;
        }
        $hasRequiredParameter = false;
        $parameterNames = array_keys($this->splitQueryStringToArray($queryString));
        foreach ($parameterNames as $parameterName) {
            if (in_array($parameterName, $this->requireCacheHashPresenceParameters)) {
                $hasRequiredParameter = true;
            }
        }
        return $hasRequiredParameter;
    }

    public function getRelevantParameters($queryString)
    {
        $parameters = $this->splitQueryStringToArray($queryString);
        $relevantParameters = array();
        foreach ($parameters as $parameterName => $parameterValue) {
            if ($this->isAdminPanelParameter($parameterName) || $this->isExcludedParameter($parameterName) || $this->isCoreParameter($parameterName)) {
                continue;
            }
            if ($this->hasCachedParametersWhiteList() && !$this->isInCachedParametersWhiteList($parameterName)) {
                continue;
            }
            if ((is_null($parameterValue) || $parameterValue === '') && !$this->isAllowedWithEmptyValue($parameterName)) {
                continue;
            }
            $relevantParameters[$parameterName] = $parameterValue;
        }
        if (!empty($relevantParameters)) {
            // Finish and sort parameters array by keys:
            $relevantParameters['encryptionKey'] = $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'];
            ksort($relevantParameters);
        }
        return $relevantParameters;
    }

    protected function splitQueryStringToArray($queryString)
    {
        $parameters = array_filter(explode('&', ltrim($queryString, '?')));
        $parameterArray = array();
        foreach ($parameters as $parameter) {
            list($parameterName, $parameterValue) = explode('=', $parameter);
            $parameterArray[rawurldecode($parameterName)] = rawurldecode($parameterValue);
        }
        return $parameterArray;
    }

    protected function isAdminPanelParameter($key)
    {
        return stristr($key, 'TSFE_ADMIN_PANEL') !== false && preg_match('/TSFE_ADMIN_PANEL\\[.*?\\]/', $key);
    }

    protected function isCoreParameter($key)
    {
        return GeneralUtility::inList('id,type,no_cache,cHash,MP,ftu', $key);
    }

    protected function isExcludedParameter($key)
    {
        return in_array($key, $this->excludedParameters);
    }

    protected function isInCachedParametersWhiteList($key)
    {
        return in_array($key, $this->cachedParametersWhiteList);
    }

    protected function hasCachedParametersWhiteList()
    {
        return !empty($this->cachedParametersWhiteList);
    }

    protected function isAllowedWithEmptyValue($key)
    {
        return !($this->excludeAllEmptyParameters || in_array($key, $this->excludedParametersIfEmpty));
    }

    public function setConfiguration($configuration)
    {
        foreach ($configuration as $name => $value) {
            $setterName = 'set' . ucfirst($name);
            if (method_exists($this, $setterName)) {
                $this->{$setterName}($value);
            }
        }
    }

    protected function setCachedParametersWhiteList(array $cachedParametersWhiteList)
    {
        $this->cachedParametersWhiteList = $cachedParametersWhiteList;
    }

    protected function setExcludeAllEmptyParameters($excludeAllEmptyParameters)
    {
        $this->excludeAllEmptyParameters = $excludeAllEmptyParameters;
    }

    protected function setExcludedParameters(array $excludedParameters)
    {
        $this->excludedParameters = $excludedParameters;
    }

    protected function setExcludedParametersIfEmpty(array $excludedParametersIfEmpty)
    {
        $this->excludedParametersIfEmpty = $excludedParametersIfEmpty;
    }

    protected function setRequireCacheHashPresenceParameters(array $requireCacheHashPresenceParameters)
    {
        $this->requireCacheHashPresenceParameters = $requireCacheHashPresenceParameters;
    }
}