AbstractPlugin.php

Go to the documentation of this file.

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

/*
 * 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 Doctrine\DBAL\Driver\Statement;
use TYPO3\CMS\Core\Database\Connection;
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Database\DatabaseConnection;
use TYPO3\CMS\Core\Database\Query\QueryHelper;
use TYPO3\CMS\Core\Database\Query\Restriction\FrontendRestrictionContainer;
use TYPO3\CMS\Core\Localization\Locales;
use TYPO3\CMS\Core\Localization\LocalizationFactory;
use TYPO3\CMS\Core\Service\MarkerBasedTemplateService;
use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;
use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;

class AbstractPlugin
{
    public $cObj;

    public $prefixId;

    public $scriptRelPath;

    public $extKey;

    public $piVars = [
        'pointer' => '',
        // Used as a pointer for lists
        'mode' => '',
        // List mode
        'sword' => '',
        // Search word
        'sort' => ''
    ];

    public $internal = ['res_count' => 0, 'results_at_a_time' => 20, 'maxPages' => 10, 'currentRow' => [], 'currentTable' => ''];

    public $LOCAL_LANG = [];

    protected $LOCAL_LANG_UNSET = [];

    public $LOCAL_LANG_loaded = false;

    public $LLkey = 'default';

    public $altLLkey = '';

    public $LLtestPrefix = '';

    public $LLtestPrefixAlt = '';

    public $pi_isOnlyFields = 'mode,pointer';

    public $pi_alwaysPrev = 0;

    public $pi_lowerThan = 5;

    public $pi_moreParams = '';

    public $pi_listFields = '*';

    public $pi_autoCacheFields = [];

    public $pi_autoCacheEn = false;

    public $pi_USER_INT_obj = false;

    public $pi_checkCHash = false;

    public $conf = [];

    public $pi_EPtemp_cObj;

    public $pi_tmpPageId = 0;

    protected $frontendController;

    protected $databaseConnection;

    protected $templateService;

    public function __construct(DatabaseConnection $databaseConnection = null, TypoScriptFrontendController $frontendController = null)
    {
        $this->databaseConnection = $databaseConnection ?: $GLOBALS['TYPO3_DB'];
        $this->frontendController = $frontendController ?: $GLOBALS['TSFE'];
        $this->templateService = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
        // Setting piVars:
        if ($this->prefixId) {
            $this->piVars = GeneralUtility::_GPmerged($this->prefixId);
            // cHash mode check
            // IMPORTANT FOR CACHED PLUGINS (USER cObject): As soon as you generate cached plugin output which
            // depends on parameters (eg. seeing the details of a news item) you MUST check if a cHash value is set.
            // Background: The function call will check if a cHash parameter was sent with the URL because only if
            // it was the page may be cached. If no cHash was found the function will simply disable caching to
            // avoid unpredictable caching behaviour. In any case your plugin can generate the expected output and
            // the only risk is that the content may not be cached. A missing cHash value is considered a mistake
            // in the URL resulting from either URL manipulation, "realurl" "grayzones" etc. The problem is rare
            // (more frequent with "realurl") but when it occurs it is very puzzling!
            if ($this->pi_checkCHash && !empty($this->piVars)) {
                $this->frontendController->reqCHash();
            }
        }
        if (!empty($this->frontendController->config['config']['language'])) {
            $this->LLkey = $this->frontendController->config['config']['language'];
            if (empty($this->frontendController->config['config']['language_alt'])) {
                $locales = GeneralUtility::makeInstance(Locales::class);
                if (in_array($this->LLkey, $locales->getLocales())) {
                    $this->altLLkey = '';
                    foreach ($locales->getLocaleDependencies($this->LLkey) as $language) {
                        $this->altLLkey .= $language . ',';
                    }
                    $this->altLLkey = rtrim($this->altLLkey, ',');
                }
            } else {
                $this->altLLkey = $this->frontendController->config['config']['language_alt'];
            }
        }
    }

    protected function applyStdWrapRecursive(array $conf, $level = 0)
    {
        foreach ($conf as $key => $confNextLevel) {
            if (strpos($key, '.') !== false) {
                $key = substr($key, 0, -1);

                // descend into all non-stdWrap-subelements first
                foreach ($confNextLevel as $subKey => $subConfNextLevel) {
                    if (is_array($subConfNextLevel) && strpos($subKey, '.') !== false && $subKey !== 'stdWrap.') {
                        $conf[$key . '.'] = $this->applyStdWrapRecursive($confNextLevel, $level + 1);
                    }
                }

                // now for stdWrap
                foreach ($confNextLevel as $subKey => $subConfNextLevel) {
                    if (is_array($subConfNextLevel) && $subKey === 'stdWrap.') {
                        $conf[$key] = $this->cObj->stdWrap($conf[$key], $conf[$key . '.']['stdWrap.']);
                        unset($conf[$key . '.']['stdWrap.']);
                        if (empty($conf[$key . '.'])) {
                            unset($conf[$key . '.']);
                        }
                    }
                }
            }
        }
        return $conf;
    }

    public function pi_setPiVarDefaults()
    {
        if (isset($this->conf['_DEFAULT_PI_VARS.']) && is_array($this->conf['_DEFAULT_PI_VARS.'])) {
            $this->conf['_DEFAULT_PI_VARS.'] = $this->applyStdWrapRecursive($this->conf['_DEFAULT_PI_VARS.']);
            $tmp = $this->conf['_DEFAULT_PI_VARS.'];
            ArrayUtility::mergeRecursiveWithOverrule($tmp, is_array($this->piVars) ? $this->piVars : []);
            $this->piVars = $tmp;
        }
    }

    /***************************
     *
     * Link functions
     *
     **************************/
    public function pi_getPageLink($id, $target = '', $urlParameters = [])
    {
        return $this->cObj->getTypoLink_URL($id, $urlParameters, $target);
    }

    public function pi_linkToPage($str, $id, $target = '', $urlParameters = [])
    {
        return $this->cObj->getTypoLink($str, $id, $urlParameters, $target);
    }

    public function pi_linkTP($str, $urlParameters = [], $cache = false, $altPageId = 0)
    {
        $conf = [];
        $conf['useCacheHash'] = $this->pi_USER_INT_obj ? 0 : $cache;
        $conf['no_cache'] = $this->pi_USER_INT_obj ? 0 : !$cache;
        $conf['parameter'] = $altPageId ? $altPageId : ($this->pi_tmpPageId ? $this->pi_tmpPageId : $this->frontendController->id);
        $conf['additionalParams'] = $this->conf['parent.']['addParams'] . GeneralUtility::implodeArrayForUrl('', $urlParameters, '', true) . $this->pi_moreParams;
        return $this->cObj->typoLink($str, $conf);
    }

    public function pi_linkTP_keepPIvars($str, $overrulePIvars = [], $cache = false, $clearAnyway = false, $altPageId = 0)
    {
        if (is_array($this->piVars) && is_array($overrulePIvars) && !$clearAnyway) {
            $piVars = $this->piVars;
            unset($piVars['DATA']);
            ArrayUtility::mergeRecursiveWithOverrule($piVars, $overrulePIvars);
            $overrulePIvars = $piVars;
            if ($this->pi_autoCacheEn) {
                $cache = $this->pi_autoCache($overrulePIvars);
            }
        }
        return $this->pi_linkTP($str, [$this->prefixId => $overrulePIvars], $cache, $altPageId);
    }

    public function pi_linkTP_keepPIvars_url($overrulePIvars = [], $cache = false, $clearAnyway = false, $altPageId = 0)
    {
        $this->pi_linkTP_keepPIvars('|', $overrulePIvars, $cache, $clearAnyway, $altPageId);
        return $this->cObj->lastTypoLinkUrl;
    }

    public function pi_list_linkSingle($str, $uid, $cache = false, $mergeArr = [], $urlOnly = false, $altPageId = 0)
    {
        if ($this->prefixId) {
            if ($cache) {
                $overrulePIvars = $uid ? ['showUid' => $uid] : [];
                $overrulePIvars = array_merge($overrulePIvars, (array)$mergeArr);
                $str = $this->pi_linkTP($str, [$this->prefixId => $overrulePIvars], $cache, $altPageId);
            } else {
                $overrulePIvars = ['showUid' => $uid ?: ''];
                $overrulePIvars = array_merge($overrulePIvars, (array)$mergeArr);
                $str = $this->pi_linkTP_keepPIvars($str, $overrulePIvars, $cache, 0, $altPageId);
            }
            // If urlOnly flag, return only URL as it has recently be generated.
            if ($urlOnly) {
                $str = $this->cObj->lastTypoLinkUrl;
            }
        }
        return $str;
    }

    public function pi_openAtagHrefInJSwindow($str, $winName = '', $winParams = 'width=670,height=500,status=0,menubar=0,scrollbars=1,resizable=1')
    {
        if (preg_match('/(.*)(<a[^>]*>)(.*)/i', $str, $match)) {
            $aTagContent = GeneralUtility::get_tag_attributes($match[2]);
            $onClick = 'vHWin=window.open('
                . GeneralUtility::quoteJSvalue($this->frontendController->baseUrlWrap($aTagContent['href'])) . ','
                . GeneralUtility::quoteJSvalue($winName ?: md5($aTagContent['href'])) . ','
                . GeneralUtility::quoteJSvalue($winParams) . ');vHWin.focus();return false;';
            $match[2] = '<a href="#" onclick="' . htmlspecialchars($onClick) . '">';
            $str = $match[1] . $match[2] . $match[3];
        }
        return $str;
    }

    /***************************
     *
     * Functions for listing, browsing, searching etc.
     *
     **************************/
    public function pi_list_browseresults($showResultCount = 1, $tableParams = '', $wrapArr = [], $pointerName = 'pointer', $hscText = true, $forceOutput = false)
    {
        if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS'][self::class]['pi_list_browseresults'])
            && is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS'][self::class]['pi_list_browseresults'])
        ) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS'][self::class]['pi_list_browseresults'] as $classRef) {
                $hookObj = GeneralUtility::makeInstance($classRef);
                if (method_exists($hookObj, 'pi_list_browseresults')) {
                    $pageBrowser = $hookObj->pi_list_browseresults($showResultCount, $tableParams, $wrapArr, $pointerName, $hscText, $forceOutput, $this);
                    if (is_string($pageBrowser) && trim($pageBrowser) !== '') {
                        return $pageBrowser;
                    }
                }
            }
        }
        // example $wrapArr-array how it could be traversed from an extension
        /* $wrapArr = array(
        'browseBoxWrap' => '<div class="browseBoxWrap">|</div>',
        'showResultsWrap' => '<div class="showResultsWrap">|</div>',
        'browseLinksWrap' => '<div class="browseLinksWrap">|</div>',
        'showResultsNumbersWrap' => '<span class="showResultsNumbersWrap">|</span>',
        'disabledLinkWrap' => '<span class="disabledLinkWrap">|</span>',
        'inactiveLinkWrap' => '<span class="inactiveLinkWrap">|</span>',
        'activeLinkWrap' => '<span class="activeLinkWrap">|</span>'
        );*/
        // Initializing variables:
        $pointer = (int)$this->piVars[$pointerName];
        $count = (int)$this->internal['res_count'];
        $results_at_a_time = MathUtility::forceIntegerInRange($this->internal['results_at_a_time'], 1, 1000);
        $totalPages = ceil($count / $results_at_a_time);
        $maxPages = MathUtility::forceIntegerInRange($this->internal['maxPages'], 1, 100);
        $pi_isOnlyFields = $this->pi_isOnlyFields($this->pi_isOnlyFields);
        if (!$forceOutput && $count <= $results_at_a_time) {
            return '';
        }
        // $showResultCount determines how the results of the pagerowser will be shown.
        // If set to 0: only the result-browser will be shown
        //           1: (default) the text "Displaying results..." and the result-browser will be shown.
        //           2: only the text "Displaying results..." will be shown
        $showResultCount = (int)$showResultCount;
        // If this is set, two links named "<< First" and "LAST >>" will be shown and point to the very first or last page.
        $showFirstLast = !empty($this->internal['showFirstLast']);
        // If this has a value the "previous" button is always visible (will be forced if "showFirstLast" is set)
        $alwaysPrev = $showFirstLast ? 1 : $this->pi_alwaysPrev;
        if (isset($this->internal['pagefloat'])) {
            if (strtoupper($this->internal['pagefloat']) === 'CENTER') {
                $pagefloat = ceil(($maxPages - 1) / 2);
            } else {
                // pagefloat set as integer. 0 = left, value >= $this->internal['maxPages'] = right
                $pagefloat = MathUtility::forceIntegerInRange($this->internal['pagefloat'], -1, $maxPages - 1);
            }
        } else {
            // pagefloat disabled
            $pagefloat = -1;
        }
        // Default values for "traditional" wrapping with a table. Can be overwritten by vars from $wrapArr
        $wrapper['disabledLinkWrap'] = '<td class="nowrap"><p>|</p></td>';
        $wrapper['inactiveLinkWrap'] = '<td class="nowrap"><p>|</p></td>';
        $wrapper['activeLinkWrap'] = '<td' . $this->pi_classParam('browsebox-SCell') . ' class="nowrap"><p>|</p></td>';
        $wrapper['browseLinksWrap'] = rtrim('<table ' . $tableParams) . '><tr>|</tr></table>';
        $wrapper['showResultsWrap'] = '<p>|</p>';
        $wrapper['browseBoxWrap'] = '
        <!--
            List browsing box:
        -->
        <div ' . $this->pi_classParam('browsebox') . '>
            |
        </div>';
        // Now overwrite all entries in $wrapper which are also in $wrapArr
        $wrapper = array_merge($wrapper, $wrapArr);
        // Show pagebrowser
        if ($showResultCount != 2) {
            if ($pagefloat > -1) {
                $lastPage = min($totalPages, max($pointer + 1 + $pagefloat, $maxPages));
                $firstPage = max(0, $lastPage - $maxPages);
            } else {
                $firstPage = 0;
                $lastPage = MathUtility::forceIntegerInRange($totalPages, 1, $maxPages);
            }
            $links = [];
            // Make browse-table/links:
            // Link to first page
            if ($showFirstLast) {
                if ($pointer > 0) {
                    $label = $this->pi_getLL('pi_list_browseresults_first', '<< First');
                    $links[] = $this->cObj->wrap($this->pi_linkTP_keepPIvars($hscText ? htmlspecialchars($label) : $label, [$pointerName => null], $pi_isOnlyFields), $wrapper['inactiveLinkWrap']);
                } else {
                    $label = $this->pi_getLL('pi_list_browseresults_first', '<< First');
                    $links[] = $this->cObj->wrap($hscText ? htmlspecialchars($label) : $label, $wrapper['disabledLinkWrap']);
                }
            }
            // Link to previous page
            if ($alwaysPrev >= 0) {
                if ($pointer > 0) {
                    $label = $this->pi_getLL('pi_list_browseresults_prev', '< Previous');
                    $links[] = $this->cObj->wrap($this->pi_linkTP_keepPIvars($hscText ? htmlspecialchars($label) : $label, [$pointerName => ($pointer - 1) ?: ''], $pi_isOnlyFields), $wrapper['inactiveLinkWrap']);
                } elseif ($alwaysPrev) {
                    $label = $this->pi_getLL('pi_list_browseresults_prev', '< Previous');
                    $links[] = $this->cObj->wrap($hscText ? htmlspecialchars($label) : $label, $wrapper['disabledLinkWrap']);
                }
            }
            // Links to pages
            for ($a = $firstPage; $a < $lastPage; $a++) {
                if ($this->internal['showRange']) {
                    $pageText = ($a * $results_at_a_time + 1) . '-' . min($count, ($a + 1) * $results_at_a_time);
                } else {
                    $label = $this->pi_getLL('pi_list_browseresults_page', 'Page');
                    $pageText = trim(($hscText ? htmlspecialchars($label) : $label) . ' ' . ($a + 1));
                }
                // Current page
                if ($pointer == $a) {
                    if ($this->internal['dontLinkActivePage']) {
                        $links[] = $this->cObj->wrap($pageText, $wrapper['activeLinkWrap']);
                    } else {
                        $links[] = $this->cObj->wrap($this->pi_linkTP_keepPIvars($pageText, [$pointerName => $a ?: ''], $pi_isOnlyFields), $wrapper['activeLinkWrap']);
                    }
                } else {
                    $links[] = $this->cObj->wrap($this->pi_linkTP_keepPIvars($pageText, [$pointerName => $a ?: ''], $pi_isOnlyFields), $wrapper['inactiveLinkWrap']);
                }
            }
            if ($pointer < $totalPages - 1 || $showFirstLast) {
                // Link to next page
                if ($pointer >= $totalPages - 1) {
                    $label = $this->pi_getLL('pi_list_browseresults_next', 'Next >');
                    $links[] = $this->cObj->wrap($hscText ? htmlspecialchars($label) : $label, $wrapper['disabledLinkWrap']);
                } else {
                    $label = $this->pi_getLL('pi_list_browseresults_next', 'Next >');
                    $links[] = $this->cObj->wrap($this->pi_linkTP_keepPIvars($hscText ? htmlspecialchars($label) : $label, [$pointerName => $pointer + 1], $pi_isOnlyFields), $wrapper['inactiveLinkWrap']);
                }
            }
            // Link to last page
            if ($showFirstLast) {
                if ($pointer < $totalPages - 1) {
                    $label = $this->pi_getLL('pi_list_browseresults_last', 'Last >>');
                    $links[] = $this->cObj->wrap($this->pi_linkTP_keepPIvars($hscText ? htmlspecialchars($label) : $label, [$pointerName => $totalPages - 1], $pi_isOnlyFields), $wrapper['inactiveLinkWrap']);
                } else {
                    $label = $this->pi_getLL('pi_list_browseresults_last', 'Last >>');
                    $links[] = $this->cObj->wrap($hscText ? htmlspecialchars($label) : $label, $wrapper['disabledLinkWrap']);
                }
            }
            $theLinks = $this->cObj->wrap(implode(LF, $links), $wrapper['browseLinksWrap']);
        } else {
            $theLinks = '';
        }
        $pR1 = $pointer * $results_at_a_time + 1;
        $pR2 = $pointer * $results_at_a_time + $results_at_a_time;
        if ($showResultCount) {
            if ($wrapper['showResultsNumbersWrap']) {
                // This will render the resultcount in a more flexible way using markers (new in TYPO3 3.8.0).
                // The formatting string is expected to hold template markers (see function header). Example: 'Displaying results ###FROM### to ###TO### out of ###OUT_OF###'
                $markerArray['###FROM###'] = $this->cObj->wrap($this->internal['res_count'] > 0 ? $pR1 : 0, $wrapper['showResultsNumbersWrap']);
                $markerArray['###TO###'] = $this->cObj->wrap(min($this->internal['res_count'], $pR2), $wrapper['showResultsNumbersWrap']);
                $markerArray['###OUT_OF###'] = $this->cObj->wrap($this->internal['res_count'], $wrapper['showResultsNumbersWrap']);
                $markerArray['###FROM_TO###'] = $this->cObj->wrap(($this->internal['res_count'] > 0 ? $pR1 : 0) . ' ' . $this->pi_getLL('pi_list_browseresults_to', 'to') . ' ' . min($this->internal['res_count'], $pR2), $wrapper['showResultsNumbersWrap']);
                $markerArray['###CURRENT_PAGE###'] = $this->cObj->wrap($pointer + 1, $wrapper['showResultsNumbersWrap']);
                $markerArray['###TOTAL_PAGES###'] = $this->cObj->wrap($totalPages, $wrapper['showResultsNumbersWrap']);
                // Substitute markers
                $resultCountMsg = $this->templateService->substituteMarkerArray($this->pi_getLL('pi_list_browseresults_displays', 'Displaying results ###FROM### to ###TO### out of ###OUT_OF###'), $markerArray);
            } else {
                // Render the resultcount in the "traditional" way using sprintf
                $resultCountMsg = sprintf(str_replace('###SPAN_BEGIN###', '<span' . $this->pi_classParam('browsebox-strong') . '>', $this->pi_getLL('pi_list_browseresults_displays', 'Displaying results ###SPAN_BEGIN###%s to %s</span> out of ###SPAN_BEGIN###%s</span>')), $count > 0 ? $pR1 : 0, min($count, $pR2), $count);
            }
            $resultCountMsg = $this->cObj->wrap($resultCountMsg, $wrapper['showResultsWrap']);
        } else {
            $resultCountMsg = '';
        }
        $sTables = $this->cObj->wrap($resultCountMsg . $theLinks, $wrapper['browseBoxWrap']);
        return $sTables;
    }

    public function pi_list_modeSelector($items = [], $tableParams = '')
    {
        $cells = [];
        foreach ($items as $k => $v) {
            $cells[] = '
                    <td' . ($this->piVars['mode'] == $k ? $this->pi_classParam('modeSelector-SCell') : '') . '><p>' . $this->pi_linkTP_keepPIvars(htmlspecialchars($v), ['mode' => $k], $this->pi_isOnlyFields($this->pi_isOnlyFields)) . '</p></td>';
        }
        $sTables = '

        <!--
            Mode selector (menu for list):
        -->
        <div' . $this->pi_classParam('modeSelector') . '>
            <' . rtrim('table ' . $tableParams) . '>
                <tr>
                    ' . implode('', $cells) . '
                </tr>
            </table>
        </div>';
        return $sTables;
    }

    public function pi_list_makelist($statement, $tableParams = '')
    {
        // Make list table header:
        $tRows = [];
        $this->internal['currentRow'] = '';
        $tRows[] = $this->pi_list_header();
        // Make list table rows
        $c = 0;
        while ($this->internal['currentRow'] = $statement->fetch()) {
            $tRows[] = $this->pi_list_row($c);
            $c++;
        }
        $out = '

        <!--
            Record list:
        -->
        <div' . $this->pi_classParam('listrow') . '>
            <' . rtrim('table ' . $tableParams) . '>
                ' . implode('', $tRows) . '
            </table>
        </div>';
        return $out;
    }

    public function pi_list_row($c)
    {
        // Dummy
        return '<tr' . ($c % 2 ? $this->pi_classParam('listrow-odd') : '') . '><td><p>[dummy row]</p></td></tr>';
    }

    public function pi_list_header()
    {
        return '<tr' . $this->pi_classParam('listrow-header') . '><td><p>[dummy header row]</p></td></tr>';
    }

    /***************************
     *
     * Stylesheet, CSS
     *
     **************************/
    public function pi_getClassName($class)
    {
        return str_replace('_', '-', $this->prefixId) . ($this->prefixId ? '-' : '') . $class;
    }

    public function pi_classParam($class, $addClasses = '')
    {
        $output = '';
        $classNames = GeneralUtility::trimExplode(',', $class);
        foreach ($classNames as $className) {
            $output .= ' ' . $this->pi_getClassName($className);
        }
        $additionalClassNames = GeneralUtility::trimExplode(',', $addClasses);
        foreach ($additionalClassNames as $additionalClassName) {
            $output .= ' ' . $additionalClassName;
        }
        return ' class="' . trim($output) . '"';
    }

    public function pi_wrapInBaseClass($str)
    {
        $content = '<div class="' . str_replace('_', '-', $this->prefixId) . '">
        ' . $str . '
    </div>
    ';
        if (!$this->frontendController->config['config']['disablePrefixComment']) {
            $content = '


    <!--

        BEGIN: Content of extension "' . $this->extKey . '", plugin "' . $this->prefixId . '"

    -->
    ' . $content . '
    <!-- END: Content of extension "' . $this->extKey . '", plugin "' . $this->prefixId . '" -->

    ';
        }
        return $content;
    }

    /***************************
     *
     * Frontend editing: Edit panel, edit icons
     *
     **************************/
    public function pi_getEditPanel($row = [], $tablename = '', $label = '', $conf = [])
    {
        $panel = '';
        if (!$row || !$tablename) {
            $row = $this->internal['currentRow'];
            $tablename = $this->internal['currentTable'];
        }
        if ($this->frontendController->beUserLogin) {
            // Create local cObj if not set:
            if (!is_object($this->pi_EPtemp_cObj)) {
                $this->pi_EPtemp_cObj = GeneralUtility::makeInstance(ContentObjectRenderer::class);
                $this->pi_EPtemp_cObj->setParent($this->cObj->data, $this->cObj->currentRecord);
            }
            // Initialize the cObj object with current row
            $this->pi_EPtemp_cObj->start($row, $tablename);
            // Setting TypoScript values in the $conf array. See documentation in TSref for the EDITPANEL cObject.
            $conf['allow'] = 'edit,new,delete,move,hide';
            $panel = $this->pi_EPtemp_cObj->cObjGetSingle('EDITPANEL', $conf, 'editpanel');
        }
        if ($panel) {
            if ($label) {
                return '<!-- BEGIN: EDIT PANEL --><table border="0" cellpadding="0" cellspacing="0" width="100%"><tr><td valign="top">' . $label . '</td><td valign="top" align="right">' . $panel . '</td></tr></table><!-- END: EDIT PANEL -->';
            }
            return '<!-- BEGIN: EDIT PANEL -->' . $panel . '<!-- END: EDIT PANEL -->';
        }
        return $label;
    }

    public function pi_getEditIcon($content, $fields, $title = '', $row = [], $tablename = '', $oConf = [])
    {
        if ($this->frontendController->beUserLogin) {
            if (!$row || !$tablename) {
                $row = $this->internal['currentRow'];
                $tablename = $this->internal['currentTable'];
            }
            $conf = array_merge([
                'beforeLastTag' => 1,
                'iconTitle' => $title
            ], $oConf);
            $content = $this->cObj->editIcons($content, $tablename . ':' . $fields, $conf, $tablename . ':' . $row['uid'], $row, '&viewUrl=' . rawurlencode(GeneralUtility::getIndpEnv('REQUEST_URI')));
        }
        return $content;
    }

    /***************************
     *
     * Localization, locallang functions
     *
     **************************/
    public function pi_getLL($key, $alternativeLabel = '', $hsc = false)
    {
        $word = null;
        if (!empty($this->LOCAL_LANG[$this->LLkey][$key][0]['target'])
            || isset($this->LOCAL_LANG_UNSET[$this->LLkey][$key])
        ) {
            $word = $this->LOCAL_LANG[$this->LLkey][$key][0]['target'];
        } elseif ($this->altLLkey) {
            $alternativeLanguageKeys = GeneralUtility::trimExplode(',', $this->altLLkey, true);
            $alternativeLanguageKeys = array_reverse($alternativeLanguageKeys);
            foreach ($alternativeLanguageKeys as $languageKey) {
                if (!empty($this->LOCAL_LANG[$languageKey][$key][0]['target'])
                    || isset($this->LOCAL_LANG_UNSET[$languageKey][$key])
                ) {
                    // Alternative language translation for key exists
                    $word = $this->LOCAL_LANG[$languageKey][$key][0]['target'];
                    break;
                }
            }
        }
        if ($word === null) {
            if (!empty($this->LOCAL_LANG['default'][$key][0]['target'])
                || isset($this->LOCAL_LANG_UNSET['default'][$key])
            ) {
                // Get default translation (without charset conversion, english)
                $word = $this->LOCAL_LANG['default'][$key][0]['target'];
            } else {
                // Return alternative string or empty
                $word = isset($this->LLtestPrefixAlt) ? $this->LLtestPrefixAlt . $alternativeLabel : $alternativeLabel;
            }
        }
        $output = isset($this->LLtestPrefix) ? $this->LLtestPrefix . $word : $word;
        if ($hsc) {
            GeneralUtility::deprecationLog(
                'Calling pi_getLL() with argument \'hsc\' has been deprecated.'
            );
            $output = htmlspecialchars($output);
        }
        return $output;
    }

    public function pi_loadLL($languageFilePath = '')
    {
        if ($this->LOCAL_LANG_loaded) {
            return;
        }

        if ($languageFilePath === '' && $this->scriptRelPath) {
            $languageFilePath = 'EXT:' . $this->extKey . '/' . dirname($this->scriptRelPath) . '/locallang.xlf';
        }
        if ($languageFilePath !== '') {
            $languageFactory = GeneralUtility::makeInstance(LocalizationFactory::class);
            // Read the strings in the required charset (since TYPO3 4.2)
            $this->LOCAL_LANG = $languageFactory->getParsedData($languageFilePath, $this->LLkey, 'utf-8');
            $alternativeLanguageKeys = GeneralUtility::trimExplode(',', $this->altLLkey, true);
            foreach ($alternativeLanguageKeys as $languageKey) {
                $tempLL = $languageFactory->getParsedData($languageFilePath, $languageKey);
                if ($this->LLkey !== 'default' && isset($tempLL[$languageKey])) {
                    $this->LOCAL_LANG[$languageKey] = $tempLL[$languageKey];
                }
            }
            // Overlaying labels from TypoScript (including fictitious language keys for non-system languages!):
            if (isset($this->conf['_LOCAL_LANG.'])) {
                // Clear the "unset memory"
                $this->LOCAL_LANG_UNSET = [];
                foreach ($this->conf['_LOCAL_LANG.'] as $languageKey => $languageArray) {
                    // Remove the dot after the language key
                    $languageKey = substr($languageKey, 0, -1);
                    // Don't process label if the language is not loaded
                    if (is_array($languageArray) && isset($this->LOCAL_LANG[$languageKey])) {
                        foreach ($languageArray as $labelKey => $labelValue) {
                            if (!is_array($labelValue)) {
                                $this->LOCAL_LANG[$languageKey][$labelKey][0]['target'] = $labelValue;
                                if ($labelValue === '') {
                                    $this->LOCAL_LANG_UNSET[$languageKey][$labelKey] = '';
                                }
                            }
                        }
                    }
                }
            }
        }
        $this->LOCAL_LANG_loaded = true;
    }

    /***************************
     *
     * Database, queries
     *
     **************************/
    public function pi_exec_query($table, $count = false, $addWhere = '', $mm_cat = '', $groupBy = '', $orderBy = '', $query = '')
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);
        $queryBuilder->from($table);

        // Begin Query:
        if (!$query) {
            // This adds WHERE-clauses that ensures deleted, hidden, starttime/endtime/access records are NOT
            // selected, if they should not! Almost ALWAYS add this to your queries!
            $queryBuilder->setRestrictions(GeneralUtility::makeInstance(FrontendRestrictionContainer::class));

            // Fetches the list of PIDs to select from.
            // TypoScript property .pidList is a comma list of pids. If blank, current page id is used.
            // TypoScript property .recursive is an int+ which determines how many levels down from the pids in the pid-list subpages should be included in the select.
            $pidList = GeneralUtility::intExplode(',', $this->pi_getPidList($this->conf['pidList'], $this->conf['recursive']), true);
            if (is_array($mm_cat)) {
                $queryBuilder->from($mm_cat['table'])
                    ->from($mm_cat['mmtable'])
                    ->where(
                        $queryBuilder->expr()->eq($table . '.uid', $queryBuilder->quoteIdentifier($mm_cat['mmtable'] . '.uid_local')),
                        $queryBuilder->expr()->eq($mm_cat['table'] . '.uid', $queryBuilder->quoteIdentifier($mm_cat['mmtable'] . '.uid_foreign')),
                        $queryBuilder->expr()->in(
                            $table . '.pid',
                            $queryBuilder->createNamedParameter($pidList, Connection::PARAM_INT_ARRAY)
                        )
                    );
                if (strcmp($mm_cat['catUidList'], '')) {
                    $queryBuilder->andWhere(
                        $queryBuilder->expr()->in(
                            $mm_cat['table'] . '.uid',
                            $queryBuilder->createNamedParameter(
                                GeneralUtility::intExplode(',', $mm_cat['catUidList'], true),
                                Connection::PARAM_INT_ARRAY
                            )
                        )
                    );
                }
            } else {
                $queryBuilder->where(
                    $queryBuilder->expr()->in(
                        'pid',
                        $queryBuilder->createNamedParameter($pidList, Connection::PARAM_INT_ARRAY)
                    )
                );
            }
        } else {
            // Restrictions need to be handled by the $query parameter!
            $queryBuilder->getRestrictions()->removeAll();

            // Split the "FROM ... WHERE" string so we get the WHERE part and TABLE names separated...:
            list($tableListFragment, $whereFragment) = preg_split('/WHERE/i', trim($query), 2);
            foreach (QueryHelper::parseTableList($tableListFragment) as $tableNameAndAlias) {
                list($tableName, $tableAlias) = $tableNameAndAlias;
                $queryBuilder->from($tableName, $tableAlias);
            }
            $queryBuilder->where(QueryHelper::stripLogicalOperatorPrefix($whereFragment));
        }

        // Add '$addWhere'
        if ($addWhere) {
            $queryBuilder->andWhere(QueryHelper::stripLogicalOperatorPrefix($addWhere));
        }
        // Search word:
        if ($this->piVars['sword'] && $this->internal['searchFieldList']) {
            $queryBuilder->andWhere(
                QueryHelper::stripLogicalOperatorPrefix(
                    $this->cObj->searchWhere($this->piVars['sword'], $this->internal['searchFieldList'], $table)
                )
            );
        }

        if ($count) {
            $queryBuilder->count('*');
        } else {
            // Add 'SELECT'
            $fields = $this->pi_prependFieldsWithTable($table, $this->pi_listFields);
            $queryBuilder->select(...GeneralUtility::trimExplode(',', $fields, true));

            // Order by data:
            if (!$orderBy && $this->internal['orderBy']) {
                if (GeneralUtility::inList($this->internal['orderByList'], $this->internal['orderBy'])) {
                    $sorting = $this->internal['descFlag'] ? ' DESC' : 'ASC';
                    $queryBuilder->orderBy($table . '.' . $this->internal['orderBy'], $sorting);
                }
            } elseif ($orderBy) {
                foreach (QueryHelper::parseOrderBy($orderBy) as $fieldNameAndSorting) {
                    list($fieldName, $sorting) = $fieldNameAndSorting;
                    $queryBuilder->addOrderBy($fieldName, $sorting);
                }
            }

            // Limit data:
            $pointer = (int)$this->piVars['pointer'];
            $results_at_a_time = MathUtility::forceIntegerInRange($this->internal['results_at_a_time'], 1, 1000);
            $queryBuilder->setFirstResult($pointer * $results_at_a_time)
                ->setMaxResults($results_at_a_time);

            // Grouping
            if (!empty($groupBy)) {
                $queryBuilder->groupBy(...QueryHelper::parseGroupBy($groupBy));
            }
        }

        return $queryBuilder->execute();
    }

    public function pi_getRecord($table, $uid, $checkPage = false)
    {
        return $this->frontendController->sys_page->checkRecord($table, $uid, $checkPage);
    }

    public function pi_getPidList($pid_list, $recursive = 0)
    {
        if (!strcmp($pid_list, '')) {
            $pid_list = $this->frontendController->id;
        }
        $recursive = MathUtility::forceIntegerInRange($recursive, 0);
        $pid_list_arr = array_unique(GeneralUtility::trimExplode(',', $pid_list, true));
        $pid_list = [];
        foreach ($pid_list_arr as $val) {
            $val = MathUtility::forceIntegerInRange($val, 0);
            if ($val) {
                $_list = $this->cObj->getTreeList(-1 * $val, $recursive);
                if ($_list) {
                    $pid_list[] = $_list;
                }
            }
        }
        return implode(',', $pid_list);
    }

    public function pi_prependFieldsWithTable($table, $fieldList)
    {
        $list = GeneralUtility::trimExplode(',', $fieldList, true);
        $return = [];
        foreach ($list as $listItem) {
            $return[] = $table . '.' . $listItem;
        }
        return implode(',', $return);
    }

    public function pi_getCategoryTableContents($table, $pid, $whereClause = '', $groupBy = '', $orderBy = '', $limit = '')
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);
        $queryBuilder->setRestrictions(GeneralUtility::makeInstance(FrontendRestrictionContainer::class));
        $queryBuilder->select('*')
            ->from($table)
            ->where(
                $queryBuilder->expr()->eq(
                    'pid',
                    $queryBuilder->createNamedParameter($pid, \PDO::PARAM_INT)
                ),
                QueryHelper::stripLogicalOperatorPrefix($whereClause)
            );

        if (!empty($orderBy)) {
            foreach (QueryHelper::parseOrderBy($orderBy) as $fieldNameAndSorting) {
                list($fieldName, $sorting) = $fieldNameAndSorting;
                $queryBuilder->addOrderBy($fieldName, $sorting);
            }
        }

        if (!empty($groupBy)) {
            $queryBuilder->groupBy(...QueryHelper::parseGroupBy($groupBy));
        }

        if (!empty($limit)) {
            $limitValues = GeneralUtility::intExplode(',', $limit, true);
            if (count($limitValues) === 1) {
                $queryBuilder->setMaxResults($limitValues[0]);
            } else {
                $queryBuilder->setFirstResult($limitValues[0])
                    ->setMaxResults($limitValues[1]);
            }
        }

        $result = $queryBuilder->execute();
        $outArr = [];
        while ($row = $result->fetch()) {
            $outArr[$row['uid']] = $row;
        }
        return $outArr;
    }

    /***************************
     *
     * Various
     *
     **************************/
    public function pi_isOnlyFields($fList, $lowerThan = -1)
    {
        $lowerThan = $lowerThan == -1 ? $this->pi_lowerThan : $lowerThan;
        $fList = GeneralUtility::trimExplode(',', $fList, true);
        $tempPiVars = $this->piVars;
        foreach ($fList as $k) {
            if (!MathUtility::canBeInterpretedAsInteger($tempPiVars[$k]) || $tempPiVars[$k] < $lowerThan) {
                unset($tempPiVars[$k]);
            }
        }
        if (empty($tempPiVars)) {
            //@TODO: How do we deal with this? return TRUE would be the right thing to do here but that might be breaking
            return 1;
        }
        return null;
    }

    public function pi_autoCache($inArray)
    {
        if (is_array($inArray)) {
            foreach ($inArray as $fN => $fV) {
                if (!strcmp($inArray[$fN], '')) {
                    unset($inArray[$fN]);
                } elseif (is_array($this->pi_autoCacheFields[$fN])) {
                    if (is_array($this->pi_autoCacheFields[$fN]['range']) && (int)$inArray[$fN] >= (int)$this->pi_autoCacheFields[$fN]['range'][0] && (int)$inArray[$fN] <= (int)$this->pi_autoCacheFields[$fN]['range'][1]) {
                        unset($inArray[$fN]);
                    }
                    if (is_array($this->pi_autoCacheFields[$fN]['list']) && in_array($inArray[$fN], $this->pi_autoCacheFields[$fN]['list'])) {
                        unset($inArray[$fN]);
                    }
                }
            }
        }
        if (empty($inArray)) {
            //@TODO: How do we deal with this? return TRUE would be the right thing to do here but that might be breaking
            return 1;
        }
        return null;
    }

    public function pi_RTEcssText($str)
    {
        $parseFunc = $this->frontendController->tmpl->setup['lib.']['parseFunc_RTE.'];
        if (is_array($parseFunc)) {
            $str = $this->cObj->parseFunc($str, $parseFunc);
        }
        return $str;
    }

    /*******************************
     *
     * FlexForms related functions
     *
     *******************************/
    public function pi_initPIflexForm($field = 'pi_flexform')
    {
        // Converting flexform data into array:
        if (!is_array($this->cObj->data[$field]) && $this->cObj->data[$field]) {
            $this->cObj->data[$field] = GeneralUtility::xml2array($this->cObj->data[$field]);
            if (!is_array($this->cObj->data[$field])) {
                $this->cObj->data[$field] = [];
            }
        }
    }

    public function pi_getFFvalue($T3FlexForm_array, $fieldName, $sheet = 'sDEF', $lang = 'lDEF', $value = 'vDEF')
    {
        $sheetArray = is_array($T3FlexForm_array) ? $T3FlexForm_array['data'][$sheet][$lang] : '';
        if (is_array($sheetArray)) {
            return $this->pi_getFFvalueFromSheetArray($sheetArray, explode('/', $fieldName), $value);
        }
        return null;
    }

    public function pi_getFFvalueFromSheetArray($sheetArray, $fieldNameArr, $value)
    {
        $tempArr = $sheetArray;
        foreach ($fieldNameArr as $k => $v) {
            if (MathUtility::canBeInterpretedAsInteger($v)) {
                if (is_array($tempArr)) {
                    $c = 0;
                    foreach ($tempArr as $values) {
                        if ($c == $v) {
                            $tempArr = $values;
                            break;
                        }
                        $c++;
                    }
                }
            } else {
                $tempArr = $tempArr[$v];
            }
        }
        return $tempArr[$value];
    }
}