ValidatorTask.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Linkvalidator\Task;
 
/*
 * 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\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Mail\MailMessage;
use ‪TYPO3\CMS\Core\Service\MarkerBasedTemplateService;
use ‪TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MailUtility;
use ‪TYPO3\CMS\Linkvalidator\LinkAnalyzer;
use ‪TYPO3\CMS\Scheduler\Task\AbstractTask;
 
class ‪ValidatorTask extends ‪AbstractTask
{
    protected ‪$sleepTime;
 
    protected ‪$sleepAfterFinish;
 
    protected ‪$countInARun;
 
    protected ‪$totalBrokenLink = 0;
 
    protected ‪$oldTotalBrokenLink = 0;
 
    protected ‪$templateMail;
 
    protected ‪$configuration = [];
 
    protected ‪$isDifferentToLastRun;
 
    protected ‪$emailTemplateFile;
 
    protected ‪$depth;
 
    protected ‪$page;
 
    protected ‪$email;
 
    protected ‪$emailOnBrokenLinkOnly;
 
    protected ‪$templateService;
 
    protected ‪$languageFile = 'LLL:EXT:linkvalidator/Resources/Private/Language/locallang.xlf';
 
    public function ‪getEmail()
    {
        return ‪$this->email;
    }
 
    public function ‪setEmail(‪$email)
    {
        $this->email = ‪$email;
    }
 
    public function ‪getEmailOnBrokenLinkOnly()
    {
        return ‪$this->emailOnBrokenLinkOnly;
    }
 
    public function ‪setEmailOnBrokenLinkOnly(‪$emailOnBrokenLinkOnly)
    {
        $this->emailOnBrokenLinkOnly = ‪$emailOnBrokenLinkOnly;
    }
 
    public function ‪getPage()
    {
        return ‪$this->page;
    }
 
    public function ‪setPage(‪$page)
    {
        $this->page = ‪$page;
    }
 
    public function ‪getDepth()
    {
        return ‪$this->depth;
    }
 
    public function ‪setDepth(‪$depth)
    {
        $this->depth = ‪$depth;
    }
 
    public function ‪getEmailTemplateFile()
    {
        return ‪$this->emailTemplateFile;
    }
 
    public function ‪setEmailTemplateFile(‪$emailTemplateFile)
    {
        $this->emailTemplateFile = ‪$emailTemplateFile;
    }
 
    public function ‪getConfiguration()
    {
        return ‪$this->configuration;
    }
 
    public function ‪setConfiguration(‪$configuration)
    {
        $this->configuration = ‪$configuration;
    }
 
    public function ‪execute()
    {
        $this->‪setCliArguments();
        $this->templateService = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
        $successfullyExecuted = true;
        if (!file_exists($file = GeneralUtility::getFileAbsFileName($this->emailTemplateFile))
            && !empty($this->email)
        ) {
            if ($this->emailTemplateFile === 'EXT:linkvalidator/res/mailtemplate.html') {
                // Update the default email template file path
                $this->emailTemplateFile = 'EXT:linkvalidator/Resources/Private/Templates/mailtemplate.html';
                $this->‪save();
            } else {
                $lang = $this->‪getLanguageService();
                throw new \InvalidArgumentException(
                    $lang->sL($this->languageFile . ':tasks.error.invalidEmailTemplateFile'),
                    '1295476972'
                );
            }
        }
        $htmlFile = file_get_contents($file);
        $this->templateMail = $this->templateService->getSubpart($htmlFile, '###REPORT_TEMPLATE###');
        // The array to put the content into
        $pageSections = '';
        $this->isDifferentToLastRun = false;
        $pageList = GeneralUtility::trimExplode(',', $this->page, true);
        $modTs = $this->‪loadModTsConfig($this->page);
        if (is_array($pageList)) {
            // reset broken link counts as they were stored in the serialized object
            $this->oldTotalBrokenLink = 0;
            $this->totalBrokenLink = 0;
            foreach ($pageList as ‪$page) {
                $pageSections .= $this->‪checkPageLinks($page);
            }
        }
        if ($this->totalBrokenLink != $this->oldTotalBrokenLink) {
            $this->isDifferentToLastRun = true;
        }
        if ($this->totalBrokenLink > 0
            && (!$this->emailOnBrokenLinkOnly || $this->isDifferentToLastRun)
            && !empty($this->email)
        ) {
            $successfullyExecuted = $this->‪reportEmail($pageSections, $modTs);
        }
        return $successfullyExecuted;
    }
 
    protected function ‪checkPageLinks(‪$page)
    {
        ‪$page = (int)‪$page;
        $pageSections = '';
        $pageIds = '';
        $oldLinkCounts = [];
        $modTs = $this->‪loadModTsConfig(‪$page);
        $searchFields = $this->‪getSearchField($modTs);
        $linkTypes = $this->‪getLinkTypes($modTs);
        $processor = GeneralUtility::makeInstance(LinkAnalyzer::class);
        if (‪$page === 0) {
            $rootLineHidden = false;
        } else {
            $pageRow = ‪BackendUtility::getRecord('pages', ‪$page, '*', '', false);
            if ($pageRow === null) {
                throw new \InvalidArgumentException(
                    sprintf($this->‪getLanguageService()->sL($this->languageFile . ':tasks.error.invalidPageUid'), ‪$page),
                    1502800555
                );
            }
            $rootLineHidden = $processor->getRootLineIsHidden($pageRow);
        }
        if (!$rootLineHidden || $modTs['checkhidden'] == 1) {
            $pageIds = $processor->extGetTreeList(‪$page, $this->depth, 0, '1=1', $modTs['checkhidden']);
            if (isset($pageRow) && $pageRow['hidden'] == 0 || $modTs['checkhidden'] == 1) {
                // \TYPO3\CMS\Linkvalidator\LinkAnalyzer->extGetTreeList() always adds trailing comma
                $pageIds .= ‪$page;
            }
        }
        if (!empty($pageIds)) {
            $processor->init($searchFields, $pageIds, $modTs);
            if (!empty($this->email)) {
                $oldLinkCounts = $processor->getLinkCounts(‪$page);
                $this->oldTotalBrokenLink += $oldLinkCounts['brokenlinkCount'];
            }
            $processor->getLinkStatistics($linkTypes, $modTs['checkhidden']);
            if (!empty($this->email)) {
                $linkCounts = $processor->getLinkCounts(‪$page);
                $this->totalBrokenLink += $linkCounts['brokenlinkCount'];
                $pageSections = $this->‪buildMail(‪$page, $pageIds, $linkCounts, $oldLinkCounts);
            }
        }
        return $pageSections;
    }
 
    protected function ‪loadModTsConfig(‪$page)
    {
        $parseObj = GeneralUtility::makeInstance(TypoScriptParser::class);
        $parseObj->parse($this->configuration);
        if (!empty($parseObj->errors)) {
            $languageService = $this->‪getLanguageService();
            $parseErrorMessage = $languageService->sL($this->languageFile . ':tasks.error.invalidTSconfig')
                . '<br />';
            foreach ($parseObj->errors as $errorInfo) {
                $parseErrorMessage .= $errorInfo[0] . '<br />';
            }
            throw new \Exception($parseErrorMessage, '1295476989');
        }
        $modTs = ‪BackendUtility::getPagesTSconfig(‪$page)['mod.']['linkvalidator.'] ?? [];
        $tsConfig = $parseObj->setup;
        $overrideTs = $tsConfig['mod.']['linkvalidator.'];
        if (is_array($overrideTs)) {
            ‪ArrayUtility::mergeRecursiveWithOverrule($modTs, $overrideTs);
        }
        return $modTs;
    }
 
    protected function ‪getSearchField(array $modTS)
    {
        // Get the searchFields from TypoScript
        foreach ($modTS['searchFields.'] as $table => $fieldList) {
            ‪$fields = GeneralUtility::trimExplode(',', $fieldList);
            foreach (‪$fields as $field) {
                $searchFields[$table][] = $field;
            }
        }
        return $searchFields ?? [];
    }
 
    protected function ‪getLinkTypes(array $modTS)
    {
        $linkTypes = [];
        $typesTmp = GeneralUtility::trimExplode(',', $modTS['linktypes'], true);
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['linkvalidator']['checkLinks'] ?? [] as $type => $value) {
            if (in_array($type, $typesTmp)) {
                $linkTypes[$type] = 1;
            }
        }
        return $linkTypes;
    }
 
    protected function ‪reportEmail($pageSections, array $modTsConfig)
    {
        $lang = $this->‪getLanguageService();
        $content = $this->templateService->substituteSubpart($this->templateMail, '###PAGE_SECTION###', $pageSections);
        $markerArray = [];
        $validEmailList = [];
        $sendEmail = true;
        $markerArray['totalBrokenLink'] = ‪$this->totalBrokenLink;
        $markerArray['totalBrokenLink_old'] = ‪$this->oldTotalBrokenLink;
 
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['linkvalidator']['reportEmailMarkers'] ?? [] as $userFunc) {
            $params = [
                'pObj' => &$this,
                'markerArray' => $markerArray
            ];
            $newMarkers = GeneralUtility::callUserFunction($userFunc, $params, $this);
            if (is_array($newMarkers)) {
                $markerArray = $newMarkers + $markerArray;
            }
            unset($params);
        }
        $content = $this->templateService->substituteMarkerArray($content, $markerArray, '###|###', true, true);
        $mail = GeneralUtility::makeInstance(MailMessage::class);
        if (empty($modTsConfig['mail.']['fromemail'])) {
            $modTsConfig['mail.']['fromemail'] = ‪MailUtility::getSystemFromAddress();
        }
        if (empty($modTsConfig['mail.']['fromname'])) {
            $modTsConfig['mail.']['fromname'] = ‪MailUtility::getSystemFromName();
        }
        if (GeneralUtility::validEmail($modTsConfig['mail.']['fromemail'])) {
            $mail->setFrom([$modTsConfig['mail.']['fromemail'] => $modTsConfig['mail.']['fromname']]);
        } else {
            throw new \Exception(
                $lang->sL($this->languageFile . ':tasks.error.invalidFromEmail'),
                '1295476760'
            );
        }
        if (GeneralUtility::validEmail($modTsConfig['mail.']['replytoemail'])) {
            $mail->setReplyTo([$modTsConfig['mail.']['replytoemail'] => $modTsConfig['mail.']['replytoname']]);
        }
        if (!empty($modTsConfig['mail.']['subject'])) {
            $mail->setSubject($modTsConfig['mail.']['subject']);
        } else {
            throw new \Exception(
                $lang->sL($this->languageFile . ':tasks.error.noSubject'),
                '1295476808'
            );
        }
        if (!empty($this->email)) {
            // Check if old input field value is still there and save the value a
            if (strpos($this->email, ',') !== false) {
                $emailList = GeneralUtility::trimExplode(',', $this->email, true);
                $this->email = implode(LF, $emailList);
                $this->‪save();
            } else {
                $emailList = GeneralUtility::trimExplode(LF, $this->email, true);
            }
 
            foreach ($emailList as $emailAdd) {
                if (!GeneralUtility::validEmail($emailAdd)) {
                    throw new \Exception(
                        $lang->sL($this->languageFile . ':tasks.error.invalidToEmail'),
                        '1295476821'
                    );
                }
                $validEmailList[] = $emailAdd;
            }
        }
        if (is_array($validEmailList) && !empty($validEmailList)) {
            $mail->setTo($validEmailList);
        } else {
            $sendEmail = false;
        }
        if ($sendEmail) {
            $mail->setBody($content, 'text/html');
            $mail->send();
        }
        return $sendEmail;
    }
 
    protected function ‪buildMail($curPage, $pageList, array $markerArray, array $oldBrokenLink)
    {
        $pageSectionHtml = $this->templateService->getSubpart($this->templateMail, '###PAGE_SECTION###');
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['linkvalidator']['buildMailMarkers'] ?? [] as $userFunc) {
            $params = [
                'curPage' => $curPage,
                'pageList' => $pageList,
                'markerArray' => $markerArray,
                'oldBrokenLink' => $oldBrokenLink,
                'pObj' => &$this
            ];
            $newMarkers = GeneralUtility::callUserFunction($userFunc, $params, $this);
            if (is_array($newMarkers)) {
                $markerArray = $newMarkers + $markerArray;
            }
            unset($params);
        }
        foreach ($markerArray as $markerKey => $markerValue) {
            if (empty($oldBrokenLink[$markerKey])) {
                $oldBrokenLink[$markerKey] = 0;
            }
            if ($markerValue != $oldBrokenLink[$markerKey]) {
                $this->isDifferentToLastRun = true;
            }
            $markerArray[$markerKey . '_old'] = $oldBrokenLink[$markerKey];
        }
        $markerArray['title'] = ‪BackendUtility::getRecordTitle(
            'pages',
            ‪BackendUtility::getRecord('pages', $curPage)
        );
        $content = '';
        if ($markerArray['brokenlinkCount'] > 0) {
            $content = $this->templateService->substituteMarkerArray(
                $pageSectionHtml,
                $markerArray,
                '###|###',
                true,
                true
            );
        }
        return $content;
    }
 
    public function ‪getAdditionalInformation()
    {
        $additionalInformation = [];
 
        ‪$page = (int)$this->‪getPage();
        $pageLabel = ‪$page;
        if (‪$page !== 0) {
            $pageData = ‪BackendUtility::getRecord('pages', ‪$page);
            if (!empty($pageData)) {
                $pageTitle = ‪BackendUtility::getRecordTitle('pages', $pageData);
                $pageLabel = $pageTitle . ' (' . ‪$page . ')';
            }
        }
        $lang = $this->‪getLanguageService();
        ‪$depth = (int)$this->‪getDepth();
        $additionalInformation[] = $lang->sL($this->languageFile . ':tasks.validate.page') . ': ' . $pageLabel;
        $additionalInformation[] = $lang->sL($this->languageFile . ':tasks.validate.depth') . ': '
            . $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.depth_' . (‪$depth === 999 ? 'infi' : ‪$depth));
        $additionalInformation[] = $lang->sL($this->languageFile . ':tasks.validate.email') . ': '
            . $this->‪getEmail();
 
        return implode(', ', $additionalInformation);
    }
 
    protected function ‪setCliArguments()
    {
        $_SERVER['argv'] = [
            $_SERVER['argv'][0],
            'tx_link_scheduler_link',
            '0',
            '-ss',
            '--sleepTime',
            ‪$this->sleepTime,
            '--sleepAfterFinish',
            ‪$this->sleepAfterFinish,
            '--countInARun',
            ‪$this->countInARun
        ];
    }
 
    protected function ‪getLanguageService()
    {
        return ‪$GLOBALS['LANG'];
    }
}