GridDataService.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Workspaces\Service;

use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;

class GridDataService {

    const SIGNAL_GenerateDataArray_BeforeCaching = 'generateDataArray.beforeCaching';
    const SIGNAL_GenerateDataArray_PostProcesss = 'generateDataArray.postProcess';
    const SIGNAL_GetDataArray_PostProcesss = 'getDataArray.postProcess';
    const SIGNAL_SortDataArray_PostProcesss = 'sortDataArray.postProcess';

    const GridColumn_Collection = 'Workspaces_Collection';
    const GridColumn_CollectionLevel = 'Workspaces_CollectionLevel';
    const GridColumn_CollectionParent = 'Workspaces_CollectionParent';
    const GridColumn_CollectionCurrent = 'Workspaces_CollectionCurrent';
    const GridColumn_CollectionChildren = 'Workspaces_CollectionChildren';

    protected $currentWorkspace = NULL;

    protected $dataArray = array();

    protected $sort = '';

    protected $sortDir = '';

    protected $workspacesCache = NULL;

    protected $systemLanguages;

    protected $integrityService;

    public function generateGridListFromVersions($versions, $parameter, $currentWorkspace) {
        // Read the given parameters from grid. If the parameter is not set use default values.
        $filterTxt = isset($parameter->filterTxt) ? $parameter->filterTxt : '';
        $start = isset($parameter->start) ? (int)$parameter->start : 0;
        $limit = isset($parameter->limit) ? (int)$parameter->limit : 30;
        $this->sort = isset($parameter->sort) ? $parameter->sort : 't3ver_oid';
        $this->sortDir = isset($parameter->dir) ? $parameter->dir : 'ASC';
        if (is_int($currentWorkspace)) {
            $this->currentWorkspace = $currentWorkspace;
        } else {
            throw new \InvalidArgumentException('No such workspace defined');
        }
        $data = array();
        $data['data'] = array();
        $this->generateDataArray($versions, $filterTxt);
        $data['total'] = count($this->dataArray);
        $data['data'] = $this->getDataArray($start, $limit);
        return $data;
    }

    protected function generateDataArray(array $versions, $filterTxt) {
        $workspaceAccess = $GLOBALS['BE_USER']->checkWorkspace($GLOBALS['BE_USER']->workspace);
        $swapStage = $workspaceAccess['publish_access'] & 1 ? \TYPO3\CMS\Workspaces\Service\StagesService::STAGE_PUBLISH_ID : 0;
        $swapAccess = $GLOBALS['BE_USER']->workspacePublishAccess($GLOBALS['BE_USER']->workspace) && $GLOBALS['BE_USER']->workspaceSwapAccess();
        $this->initializeWorkspacesCachingFramework();
        // check for dataArray in cache
        if ($this->getDataArrayFromCache($versions, $filterTxt) === FALSE) {
            $stagesObj = GeneralUtility::makeInstance('TYPO3\\CMS\\Workspaces\\Service\\StagesService');
            $defaultGridColumns = array(
                self::GridColumn_Collection => 0,
                self::GridColumn_CollectionLevel => 0,
                self::GridColumn_CollectionParent => '',
                self::GridColumn_CollectionCurrent => '',
                self::GridColumn_CollectionChildren => 0,
            );
            foreach ($versions as $table => $records) {
                $hiddenField = $this->getTcaEnableColumnsFieldName($table, 'disabled');
                $isRecordTypeAllowedToModify = $GLOBALS['BE_USER']->check('tables_modify', $table);

                foreach ($records as $record) {
                    $origRecord = BackendUtility::getRecord($table, $record['t3ver_oid']);
                    $versionRecord = BackendUtility::getRecord($table, $record['uid']);
                    $combinedRecord = \TYPO3\CMS\Workspaces\Domain\Model\CombinedRecord::createFromArrays($table, $origRecord, $versionRecord);
                    $this->getIntegrityService()->checkElement($combinedRecord);

                    if ($hiddenField !== NULL) {
                        $recordState = $this->workspaceState($versionRecord['t3ver_state'], $origRecord[$hiddenField], $versionRecord[$hiddenField]);
                    } else {
                        $recordState = $this->workspaceState($versionRecord['t3ver_state']);
                    }

                    $isDeletedPage = $table == 'pages' && $recordState == 'deleted';
                    $viewUrl = \TYPO3\CMS\Workspaces\Service\WorkspaceService::viewSingleRecord($table, $record['uid'], $origRecord, $versionRecord);
                    $versionArray = array();
                    $versionArray['table'] = $table;
                    $versionArray['id'] = $table . ':' . $record['uid'];
                    $versionArray['uid'] = $record['uid'];
                    $versionArray['workspace'] = $versionRecord['t3ver_id'];
                    $versionArray = array_merge($versionArray, $defaultGridColumns);
                    $versionArray['label_Workspace'] = htmlspecialchars(
                        BackendUtility::getRecordTitle($table, $versionRecord));
                    $versionArray['label_Live'] = htmlspecialchars(BackendUtility::getRecordTitle($table, $origRecord));
                    $versionArray['label_Stage'] = htmlspecialchars($stagesObj->getStageTitle($versionRecord['t3ver_stage']));
                    $tempStage = $stagesObj->getNextStage($versionRecord['t3ver_stage']);
                    $versionArray['label_nextStage'] = htmlspecialchars($stagesObj->getStageTitle($tempStage['uid']));
                    $tempStage = $stagesObj->getPrevStage($versionRecord['t3ver_stage']);
                    $versionArray['label_prevStage'] = htmlspecialchars($stagesObj->getStageTitle($tempStage['uid']));
                    $versionArray['path_Live'] = htmlspecialchars(
                        BackendUtility::getRecordPath($record['livepid'], '', 999));
                    $versionArray['path_Workspace'] = htmlspecialchars(
                        BackendUtility::getRecordPath($record['wspid'], '', 999));
                    $versionArray['workspace_Title'] = htmlspecialchars(\TYPO3\CMS\Workspaces\Service\WorkspaceService::getWorkspaceTitle($versionRecord['t3ver_wsid']));
                    $versionArray['workspace_Tstamp'] = $versionRecord['tstamp'];
                    $versionArray['workspace_Formated_Tstamp'] = BackendUtility::datetime($versionRecord['tstamp']);
                    $versionArray['t3ver_wsid'] = $versionRecord['t3ver_wsid'];
                    $versionArray['t3ver_oid'] = $record['t3ver_oid'];
                    $versionArray['livepid'] = $record['livepid'];
                    $versionArray['stage'] = $versionRecord['t3ver_stage'];
                    $versionArray['icon_Live'] = \TYPO3\CMS\Backend\Utility\IconUtility::mapRecordTypeToSpriteIconClass($table, $origRecord);
                    $versionArray['icon_Workspace'] = \TYPO3\CMS\Backend\Utility\IconUtility::mapRecordTypeToSpriteIconClass($table, $versionRecord);
                    $languageValue = $this->getLanguageValue($table, $versionRecord);
                    $versionArray['languageValue'] = $languageValue;
                    $versionArray['language'] = array(
                        'cls' => \TYPO3\CMS\Backend\Utility\IconUtility::getSpriteIconClasses($this->getSystemLanguageValue($languageValue, 'flagIcon')),
                        'title' => htmlspecialchars($this->getSystemLanguageValue($languageValue, 'title'))
                    );
                    $versionArray['allowedAction_nextStage'] = $isRecordTypeAllowedToModify && $stagesObj->isNextStageAllowedForUser($versionRecord['t3ver_stage']);
                    $versionArray['allowedAction_prevStage'] = $isRecordTypeAllowedToModify && $stagesObj->isPrevStageAllowedForUser($versionRecord['t3ver_stage']);
                    if ($swapAccess && $swapStage != 0 && $versionRecord['t3ver_stage'] == $swapStage) {
                        $versionArray['allowedAction_swap'] = $isRecordTypeAllowedToModify && $stagesObj->isNextStageAllowedForUser($swapStage);
                    } elseif ($swapAccess && $swapStage == 0) {
                        $versionArray['allowedAction_swap'] = $isRecordTypeAllowedToModify;
                    } else {
                        $versionArray['allowedAction_swap'] = FALSE;
                    }
                    $versionArray['allowedAction_delete'] = $isRecordTypeAllowedToModify;
                    // preview and editing of a deleted page won't work ;)
                    $versionArray['allowedAction_view'] = !$isDeletedPage && $viewUrl;
                    $versionArray['allowedAction_edit'] = $isRecordTypeAllowedToModify && !$isDeletedPage;
                    $versionArray['allowedAction_editVersionedPage'] = $isRecordTypeAllowedToModify && !$isDeletedPage;
                    $versionArray['state_Workspace'] = $recordState;

                    $versionArray = array_merge(
                        $versionArray,
                        $this->getAdditionalColumnService()->getData($combinedRecord)
                    );

                    if ($filterTxt == '' || $this->isFilterTextInVisibleColumns($filterTxt, $versionArray)) {
                        $versionIdentifier = $versionArray['id'];
                        $this->dataArray[$versionIdentifier] = $versionArray;
                    }
                }
            }
            // Suggested slot method:
            // methodName(\TYPO3\CMS\Workspaces\Service\GridDataService $gridData, array $dataArray, array $versions)
            list($this->dataArray, $versions) = $this->emitSignal(self::SIGNAL_GenerateDataArray_BeforeCaching, $this->dataArray, $versions);
            // Enrich elements after everything has been processed:
            foreach ($this->dataArray as &$element) {
                $identifier = $element['table'] . ':' . $element['t3ver_oid'];
                $element['integrity'] = array(
                    'status' => $this->getIntegrityService()->getStatusRepresentation($identifier),
                    'messages' => htmlspecialchars($this->getIntegrityService()->getIssueMessages($identifier, TRUE))
                );
            }
            $this->setDataArrayIntoCache($versions, $filterTxt);
        }
        // Suggested slot method:
        // methodName(\TYPO3\CMS\Workspaces\Service\GridDataService $gridData, array $dataArray, array $versions)
        list($this->dataArray, $versions) = $this->emitSignal(self::SIGNAL_GenerateDataArray_PostProcesss, $this->dataArray, $versions);
        $this->sortDataArray();
        $this->resolveDataArrayDependencies();
    }

    protected function resolveDataArrayDependencies() {
        $collectionService = $this->getDependencyCollectionService();
        $dependencyResolver = $collectionService->getDependencyResolver();

        foreach ($this->dataArray as $dataElement) {
            $dependencyResolver->addElement($dataElement['table'], $dataElement['uid']);
        }

        $this->dataArray = $collectionService->process($this->dataArray);
    }

    protected function getDataArray($start, $limit) {
        $dataArrayPart = array();
        $dataArrayCount = count($this->dataArray);
        $end = ($start + $limit < count($this->dataArray) ? $start + $limit : $dataArrayCount);

        // Ensure that there are numerical indexes
        $this->dataArray = array_values(($this->dataArray));
        for ($i = $start; $i < $end; $i++) {
            $dataArrayPart[] = $this->dataArray[$i];
        }

        // Ensure that collections are not cut for the pagination
        if (!empty($this->dataArray[$i][self::GridColumn_Collection])) {
            $collectionIdentifier = $this->dataArray[$i][self::GridColumn_Collection];
            for ($i = $i + 1; $i < $dataArrayCount && $collectionIdentifier === $this->dataArray[$i][self::GridColumn_Collection]; $i++) {
                $dataArrayPart[] = $this->dataArray[$i];
            }
        }

        // Suggested slot method:
        // methodName(\TYPO3\CMS\Workspaces\Service\GridDataService $gridData, array $dataArray, $start, $limit, array $dataArrayPart)
        list($this->dataArray, $start, $limit, $dataArrayPart) = $this->emitSignal(self::SIGNAL_GetDataArray_PostProcesss, $this->dataArray, $start, $limit, $dataArrayPart);
        return $dataArrayPart;
    }

    protected function initializeWorkspacesCachingFramework() {
        $this->workspacesCache = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager')->getCache('workspaces_cache');
    }

    protected function setDataArrayIntoCache(array $versions, $filterTxt) {
        $hash = $this->calculateHash($versions, $filterTxt);
        $this->workspacesCache->set($hash, $this->dataArray, array($this->currentWorkspace, 'user_' . $GLOBALS['BE_USER']->user['uid']));
    }

    protected function getDataArrayFromCache(array $versions, $filterTxt) {
        $cacheEntry = FALSE;
        $hash = $this->calculateHash($versions, $filterTxt);
        $content = $this->workspacesCache->get($hash);
        if ($content !== FALSE) {
            $this->dataArray = $content;
            $cacheEntry = TRUE;
        }
        return $cacheEntry;
    }

    protected function calculateHash(array $versions, $filterTxt) {
        $hashArray = array(
            $GLOBALS['BE_USER']->workspace,
            $GLOBALS['BE_USER']->user['uid'],
            $versions,
            $filterTxt,
            $this->sort,
            $this->sortDir,
            $this->currentWorkspace
        );
        $hash = md5(serialize($hashArray));
        return $hash;
    }

    protected function sortDataArray() {
        if (is_array($this->dataArray)) {
            switch ($this->sort) {
                case 'uid':
                case 'change':
                case 'workspace_Tstamp':
                case 't3ver_oid':
                case 'liveid':
                case 'livepid':
                case 'languageValue':
                    uasort($this->dataArray, array($this, 'intSort'));
                    break;
                case 'label_Workspace':
                case 'label_Live':
                case 'label_Stage':
                case 'workspace_Title':
                case 'path_Live':
                    // case 'path_Workspace': This is the first sorting attribute
                    uasort($this->dataArray, array($this, 'stringSort'));
                    break;
                default:
                    // Do nothing
            }
        } else {
            GeneralUtility::sysLog('Try to sort "' . $this->sort . '" in "TYPO3\\CMS\\Workspaces\\Service\\GridDataService::sortDataArray" but $this->dataArray is empty! This might be the Bug #26422 which could not reproduced yet.', 3);
        }
        // Suggested slot method:
        // methodName(\TYPO3\CMS\Workspaces\Service\GridDataService $gridData, array $dataArray, $sortColumn, $sortDirection)
        list($this->dataArray, $this->sort, $this->sortDir) = $this->emitSignal(self::SIGNAL_SortDataArray_PostProcesss, $this->dataArray, $this->sort, $this->sortDir);
    }

    protected function intSort(array $a, array $b) {
        if (!$this->isSortable($a, $b)) {
            return 0;
        }
        // First sort by using the page-path in current workspace
        $path_cmp = strcasecmp($a['path_Workspace'], $b['path_Workspace']);
        if ($path_cmp < 0) {
            return $path_cmp;
        } elseif ($path_cmp == 0) {
            if ($a[$this->sort] == $b[$this->sort]) {
                return 0;
            }
            if ($this->sortDir == 'ASC') {
                return $a[$this->sort] < $b[$this->sort] ? -1 : 1;
            } elseif ($this->sortDir == 'DESC') {
                return $a[$this->sort] > $b[$this->sort] ? -1 : 1;
            }
        } elseif ($path_cmp > 0) {
            return $path_cmp;
        }
        return 0;
    }

    protected function stringSort($a, $b) {
        if (!$this->isSortable($a, $b)) {
            return 0;
        }
        $path_cmp = strcasecmp($a['path_Workspace'], $b['path_Workspace']);
        if ($path_cmp < 0) {
            return $path_cmp;
        } elseif ($path_cmp == 0) {
            if ($a[$this->sort] == $b[$this->sort]) {
                return 0;
            }
            if ($this->sortDir == 'ASC') {
                return strcasecmp($a[$this->sort], $b[$this->sort]);
            } elseif ($this->sortDir == 'DESC') {
                return strcasecmp($a[$this->sort], $b[$this->sort]) * -1;
            }
        } elseif ($path_cmp > 0) {
            return $path_cmp;
        }
        return 0;
    }

    protected function isSortable(array $a, array $b) {
        return (
            $a[self::GridColumn_CollectionLevel] === 0 && $b[self::GridColumn_CollectionLevel] === 0
            || $a[self::GridColumn_CollectionParent] === $b[self::GridColumn_CollectionParent]
        );
    }

    protected function isFilterTextInVisibleColumns($filterText, array $versionArray) {
        if (is_array($GLOBALS['BE_USER']->uc['moduleData']['Workspaces'][$GLOBALS['BE_USER']->workspace]['columns'])) {
            foreach ($GLOBALS['BE_USER']->uc['moduleData']['Workspaces'][$GLOBALS['BE_USER']->workspace]['columns'] as $column => $value) {
                if (isset($value['hidden']) && isset($column) && isset($versionArray[$column])) {
                    if ($value['hidden'] == 0) {
                        switch ($column) {
                            case 'workspace_Tstamp':
                                if (stripos($versionArray['workspace_Formated_Tstamp'], $filterText) !== FALSE) {
                                    return TRUE;
                                }
                                break;
                            case 'change':
                                if (stripos(strval($versionArray[$column]), str_replace('%', '', $filterText)) !== FALSE) {
                                    return TRUE;
                                }
                                break;
                            default:
                                if (stripos(strval($versionArray[$column]), $filterText) !== FALSE) {
                                    return TRUE;
                                }
                        }
                    }
                }
            }
        }
        return FALSE;
    }

    protected function workspaceState($stateId, $hiddenOnline = FALSE, $hiddenOffline = FALSE) {
        $hiddenState = NULL;
        if ($hiddenOnline == 0 && $hiddenOffline == 1) {
            $hiddenState = 'hidden';
        } elseif ($hiddenOnline == 1 && $hiddenOffline == 0) {
            $hiddenState = 'unhidden';
        }
        switch ($stateId) {
            case -1:
                $state = 'new';
                break;
            case 2:
                $state = 'deleted';
                break;
            case 4:
                $state = 'moved';
                break;
            default:
                $state = ($hiddenState ?: 'modified');
        }
        return $state;
    }

    protected function getTcaEnableColumnsFieldName($table, $type) {
        $fieldName = NULL;

        if (!(empty($GLOBALS['TCA'][$table]['ctrl']['enablecolumns'][$type]))) {
            $fieldName = $GLOBALS['TCA'][$table]['ctrl']['enablecolumns'][$type];
        }

        return $fieldName;
    }

    protected function getLanguageValue($table, array $record) {
        $languageValue = 0;
        if (BackendUtility::isTableLocalizable($table)) {
            $languageField = $GLOBALS['TCA'][$table]['ctrl']['languageField'];
            if (!empty($record[$languageField])) {
                $languageValue = $record[$languageField];
            }
        }
        return $languageValue;
    }

    protected function getSystemLanguageValue($id, $key) {
        $value = NULL;
        $systemLanguages = $this->getSystemLanguages();
        if (!empty($systemLanguages[$id][$key])) {
            $value = $systemLanguages[$id][$key];
        }
        return $value;
    }

    public function getSystemLanguages() {
        if (!isset($this->systemLanguages)) {
            $translateTools = GeneralUtility::makeInstance('TYPO3\\CMS\\Backend\\Configuration\\TranslationConfigurationProvider');
            $this->systemLanguages = $translateTools->getSystemLanguages();
        }
        return $this->systemLanguages;
    }

    protected function getIntegrityService() {
        if (!isset($this->integrityService)) {
            $this->integrityService = GeneralUtility::makeInstance('TYPO3\\CMS\\Workspaces\\Service\\IntegrityService');
        }
        return $this->integrityService;
    }

    protected function emitSignal($signalName) {
        // Arguments are always ($this, [method argument], [method argument], ...)
        $signalArguments = array_merge(array($this), array_slice(func_get_args(), 1));
        $slotReturn = $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Workspaces\\Service\\GridDataService', $signalName, $signalArguments);
        return array_slice($slotReturn, 1);
    }

    protected function getDependencyCollectionService() {
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Workspaces\\Service\\Dependency\\CollectionService');
    }

    protected function getAdditionalColumnService() {
        return $this->getObjectManager()->get('TYPO3\\CMS\\Workspaces\\Service\\AdditionalColumnService');
    }

    protected function getSignalSlotDispatcher() {
        return $this->getObjectManager()->get('TYPO3\\CMS\\Extbase\\SignalSlot\\Dispatcher');
    }

    protected function getObjectManager() {
        return \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Object\\ObjectManager');
    }

}