BackendLogController.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Belog\Controller;
 
use ‪TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Belog\Domain\Model\Constraint;
use ‪TYPO3\CMS\Belog\Domain\Model\LogEntry;
use ‪TYPO3\CMS\Belog\Domain\Repository\LogEntryRepository;
use ‪TYPO3\CMS\Belog\Domain\Repository\WorkspaceRepository;
use ‪TYPO3\CMS\Core\Messaging\AbstractMessage;
use ‪TYPO3\CMS\Core\Page\PageRenderer;
use ‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Mvc\Controller\ActionController;
use ‪TYPO3\CMS\Extbase\Persistence\QueryResultInterface;
use ‪TYPO3\CMS\Extbase\Utility\LocalizationUtility;
 
class ‪BackendLogController extends ‪ActionController
{
    private const ‪TIMEFRAME_THISWEEK = 0;
 
    private const ‪TIMEFRAME_LASTWEEK = 1;
 
    private const ‪TIMEFRAME_LASTSEVENDAYS = 2;
 
    private const ‪TIMEFRAME_THISMONTH = 10;
 
    private const ‪TIMEFRAME_LASTMONTH = 11;
 
    private const ‪TIMEFRAME_LAST31DAYS = 12;
 
    private const ‪TIMEFRAME_CUSTOM = 30;
 
    protected ‪$logEntryRepository;
 
    public function ‪injectLogEntryRepository(‪LogEntryRepository ‪$logEntryRepository)
    {
        $this->logEntryRepository = ‪$logEntryRepository;
    }
 
    public function ‪initializeListAction()
    {
        if (!isset($this->settings['dateFormat'])) {
            $this->settings['dateFormat'] = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'] ?: 'd-m-Y';
        }
        if (!isset($this->settings['timeFormat'])) {
            $this->settings['timeFormat'] = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['hhmm'];
        }
        $constraintConfiguration = $this->arguments->getArgument('constraint')->getPropertyMappingConfiguration();
        $constraintConfiguration->allowAllProperties();
        GeneralUtility::makeInstance(PageRenderer::class)
            ->loadRequireJsModule('TYPO3/CMS/Backend/GlobalEventHandler');
    }
 
    public function ‪listAction(Constraint $constraint = null, int $pageId = null, string $layout = 'Default')
    {
        // Constraint object handling:
        // If there is none from GET, try to get it from BE user data, else create new
        if ($constraint === null) {
            $constraint = $this->‪getConstraintFromBeUserData();
        } else {
            $this->‪persistConstraintInBeUserData($constraint);
        }
        $constraint->setPageId($pageId);
        $this->‪resetConstraintsOnMemoryExhaustionError();
        $this->‪setStartAndEndTimeFromTimeSelector($constraint);
        $this->‪forceWorkspaceSelectionIfInWorkspace($constraint);
        $logEntries = $this->logEntryRepository->findByConstraint($constraint);
        $groupedLogEntries = $this->‪groupLogEntriesByPageAndDay($logEntries, $constraint->getGroupByPage());
        $this->view->assignMultiple([
            'pageId' => $pageId,
            'layout' => $layout,
            'groupedLogEntries' => $groupedLogEntries,
            'constraint' => $constraint,
            'userGroups' => $this->‪createUserAndGroupListForSelectOptions(),
            'workspaces' => $this->‪createWorkspaceListForSelectOptions(),
            'pageDepths' => $this->‪createPageDepthOptions(),
        ]);
    }
 
    public function ‪deleteMessageAction(int $errorUid)
    {
        $logEntry = $this->logEntryRepository->findByUid($errorUid);
        if (!$logEntry) {
            $this->‪addFlashMessage(‪LocalizationUtility::translate('actions.delete.noRowFound', 'belog') ?? '', '', ‪AbstractMessage::WARNING);
            $this->‪redirect('list');
        }
        $numberOfDeletedRows = $this->logEntryRepository->deleteByMessageDetails($logEntry);
        $this->‪addFlashMessage(sprintf(‪LocalizationUtility::translate('actions.delete.message', 'belog') ?? '', $numberOfDeletedRows));
        $this->‪redirect('list');
    }
 
    protected function ‪getConstraintFromBeUserData()
    {
        $serializedConstraint = ‪$GLOBALS['BE_USER']->getModuleData(static::class);
        $constraint = null;
        if (is_string($serializedConstraint) && !empty($serializedConstraint)) {
            $constraint = @unserialize($serializedConstraint, ['allowed_classes' => [Constraint::class, \DateTime::class]]);
        }
        return $constraint ?: $this->objectManager->get(Constraint::class);
    }
 
    protected function ‪persistConstraintInBeUserData(Constraint $constraint)
    {
        ‪$GLOBALS['BE_USER']->pushModuleData(static::class, serialize($constraint));
    }
 
    protected function ‪resetConstraintsOnMemoryExhaustionError()
    {
        $reservedMemory = new \SplFixedArray(187500); // 3M
        register_shutdown_function(function () use (&$reservedMemory): void {
            $reservedMemory = null; // free the reserved memory
            $error = error_get_last();
            if (strpos($error['message'], 'Allowed memory size of') !== false) {
                $constraint = $this->objectManager->get(Constraint::class);
                $this->‪persistConstraintInBeUserData($constraint);
            }
        });
    }
 
    protected function ‪groupLogEntriesByPageAndDay(QueryResultInterface $logEntries, $groupByPage = false)
    {
        $targetStructure = [];
        foreach ($logEntries as $entry) {
            // Create page split list or flat list
            if ($groupByPage) {
                $pid = $entry->getEventPid();
            } else {
                $pid = -1;
            }
            // Create array if it is not defined yet
            if (!is_array($targetStructure[$pid])) {
                $targetStructure[$pid] = [];
            }
            // Get day timestamp of log entry and create sub array if needed
            $timestampDay = strtotime(strftime('%d.%m.%Y', $entry->getTstamp()));
            if (!is_array($targetStructure[$pid][$timestampDay])) {
                $targetStructure[$pid][$timestampDay] = [];
            }
            // Add row
            $targetStructure[$pid][$timestampDay][] = $entry;
        }
        ksort($targetStructure);
        return $targetStructure;
    }
 
    protected function ‪createUserAndGroupListForSelectOptions()
    {
        $userGroupArray = [];
        // Two meta entries: 'all' and 'self'
        $userGroupArray[0] = ‪LocalizationUtility::translate('allUsers', 'Belog');
        $userGroupArray[-1] = ‪LocalizationUtility::translate('self', 'Belog');
        // List of groups, key is gr-'uid'
        $groups = ‪BackendUtility::getGroupNames();
        foreach ($groups as $group) {
            $userGroupArray['gr-' . $group['uid']] = ‪LocalizationUtility::translate('group', 'Belog') . ' ' . $group['title'];
        }
        // List of users, key is us-'uid'
        $users = ‪BackendUtility::getUserNames();
        foreach ($users as $user) {
            $userGroupArray['us-' . $user['uid']] = ‪LocalizationUtility::translate('user', 'Belog') . ' ' . $user['username'];
        }
        return $userGroupArray;
    }
 
    protected function ‪createWorkspaceListForSelectOptions()
    {
        if (!‪ExtensionManagementUtility::isLoaded('workspaces')) {
            return [];
        }
        $workspaceArray = [];
        // Two meta entries: 'all' and 'live'
        $workspaceArray[-99] = ‪LocalizationUtility::translate('any', 'Belog');
        $workspaceArray[0] = ‪LocalizationUtility::translate('live', 'Belog');
        $workspaces = $this->objectManager->get(WorkspaceRepository::class)->findAll();
        foreach ($workspaces as $workspace) {
            $workspaceArray[$workspace->getUid()] = $workspace->getUid() . ': ' . $workspace->getTitle();
        }
        return $workspaceArray;
    }
 
    protected function ‪forceWorkspaceSelectionIfInWorkspace(Constraint $constraint)
    {
        if (!‪ExtensionManagementUtility::isLoaded('workspaces')) {
            $this->view->assign('showWorkspaceSelector', false);
        } elseif (‪$GLOBALS['BE_USER']->workspace !== 0) {
            $constraint->setWorkspaceUid(‪$GLOBALS['BE_USER']->workspace);
            $this->view->assign('showWorkspaceSelector', false);
        } else {
            $this->view->assign('showWorkspaceSelector', true);
        }
    }
 
    protected function ‪createPageDepthOptions()
    {
        $options = [
            0 => ‪LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_0', 'lang'),
            1 => ‪LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_1', 'lang'),
            2 => ‪LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_2', 'lang'),
            3 => ‪LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_3', 'lang'),
            4 => ‪LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_4', 'lang'),
            999 => ‪LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_infi', 'lang')
        ];
        return $options;
    }
 
    protected function ‪setStartAndEndTimeFromTimeSelector(Constraint $constraint)
    {
        $startTime = 0;
        $endTime = ‪$GLOBALS['EXEC_TIME'];
        // @TODO: Refactor this construct
        switch ($constraint->getTimeFrame()) {
            case ‪self::TIMEFRAME_THISWEEK:
                // This week
                $week = (date('w') ?: 7) - 1;
                $startTime = mktime(0, 0, 0) - $week * 3600 * 24;
                break;
            case ‪self::TIMEFRAME_LASTWEEK:
                // Last week
                $week = (date('w') ?: 7) - 1;
                $startTime = mktime(0, 0, 0) - ($week + 7) * 3600 * 24;
                $endTime = mktime(0, 0, 0) - $week * 3600 * 24;
                break;
            case ‪self::TIMEFRAME_LASTSEVENDAYS:
                // Last 7 days
                $startTime = mktime(0, 0, 0) - 7 * 3600 * 24;
                break;
            case ‪self::TIMEFRAME_THISMONTH:
                // This month
                $startTime = mktime(0, 0, 0, (int)date('m'), 1);
                break;
            case ‪self::TIMEFRAME_LASTMONTH:
                // Last month
                $startTime = mktime(0, 0, 0, (int)date('m') - 1, 1);
                $endTime = mktime(0, 0, 0, (int)date('m'), 1);
                break;
            case ‪self::TIMEFRAME_LAST31DAYS:
                // Last 31 days
                $startTime = mktime(0, 0, 0) - 31 * 3600 * 24;
                break;
            case ‪self::TIMEFRAME_CUSTOM:
                $startTime = $constraint->getManualDateStart() ? $constraint->getManualDateStart()->getTimestamp() : 0;
                $endTime = $constraint->getManualDateStop() ? $constraint->getManualDateStop()->getTimestamp() : 0;
                if ($endTime <= $startTime) {
                    $endTime = ‪$GLOBALS['EXEC_TIME'];
                }
                break;
            default:
        }
        $constraint->setStartTimestamp($startTime);
        $constraint->setEndTimestamp($endTime);
    }
}