9.5/_backend_log_controller_8php_source.html

<?php

namespace ‪TYPO3\CMS\Belog\Controller;


/*

 * 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\Backend\View\BackendTemplateView;

use ‪TYPO3\CMS\Belog\Domain\Model\Constraint;

use ‪TYPO3\CMS\Belog\Domain\Model\LogEntry;

use ‪TYPO3\CMS\Core\Messaging\AbstractMessage;

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;


    protected ‪$view;


    public function ‪injectLogEntryRepository(\‪TYPO3\CMS\Belog\Domain\Repository\LogEntryRepository ‪$logEntryRepository)

    {

        $this->logEntryRepository = ‪$logEntryRepository;

    }


    public function ‪initializeListAction()

    {

        if (!isset($this->settings['dateFormat'])) {

            $this->settings['dateFormat'] = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['USdateFormat'] ? 'm-d-Y' : '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();

    }


    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) {

            $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] = ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('allUsers', 'Belog');

        $userGroupArray[-1] = ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('self', 'Belog');

        // List of groups, key is gr-'uid'

        $groups = ‪\TYPO3\CMS\Backend\Utility\BackendUtility::getGroupNames();

        foreach ($groups as $group) {

            $userGroupArray['gr-' . $group['uid']] = ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('group', 'Belog') . ' ' . $group['title'];

        }

        // List of users, key is us-'uid'

        $users = ‪\TYPO3\CMS\Backend\Utility\BackendUtility::getUserNames();

        foreach ($users as $user) {

            $userGroupArray['us-' . $user['uid']] = ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('user', 'Belog') . ' ' . $user['username'];

        }

        return $userGroupArray;

    }


    protected function ‪createWorkspaceListForSelectOptions()

    {

        if (!\‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility::isLoaded('workspaces')) {

            return [];

        }

        $workspaceArray = [];

        // Two meta entries: 'all' and 'live'

        $workspaceArray[-99] = ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('any', 'Belog');

        $workspaceArray[0] = ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('live', 'Belog');

        $workspaces = $this->objectManager->get(\‪TYPO3\CMS\Belog\Domain\Repository\WorkspaceRepository::class)->findAll();

        foreach ($workspaces as $workspace) {

            $workspaceArray[$workspace->getUid()] = $workspace->getUid() . ': ' . $workspace->getTitle();

        }

        return $workspaceArray;

    }


    protected function ‪forceWorkspaceSelectionIfInWorkspace(Constraint $constraint)

    {

        if (‪$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 => ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_0', 'lang'),

            1 => ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_1', 'lang'),

            2 => ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_2', 'lang'),

            3 => ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_3', 'lang'),

            4 => ‪\TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_4', 'lang'),

            999 => ‪\TYPO3\CMS\Extbase\Utility\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, date('m'), 1);

                break;

            case ‪self::TIMEFRAME_LASTMONTH:

                // Last month

                $startTime = mktime(0, 0, 0, date('m') - 1, 1);

                $endTime = mktime(0, 0, 0, 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);

    }

}