LogFormatter.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Logging;
 
use MediaWiki\Api\ApiQueryBase;
use MediaWiki\Api\ApiResult;
use MediaWiki\CommentFormatter\CommentFormatter;
use MediaWiki\Context\IContextSource;
use MediaWiki\Context\RequestContext;
use MediaWiki\Html\Html;
use MediaWiki\Language\Language;
use MediaWiki\Linker\Linker;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Title\Title;
use MediaWiki\User\User;
use MediaWiki\User\UserEditTracker;
use MediaWiki\User\UserIdentity;
use stdClass;
use Wikimedia\HtmlArmor\HtmlArmor;
use Wikimedia\Message\MessageParam;
use Wikimedia\Message\MessageSpecifier;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class LogFormatter {
    // Audience options for viewing usernames, comments, and actions
    public const FOR_PUBLIC = 1;
    public const FOR_THIS_USER = 2;
 
    // Static->
 
    public static function newFromEntry( LogEntry $entry ) {
        wfDeprecated( __METHOD__, '1.42' );
        return MediaWikiServices::getInstance()->getLogFormatterFactory()->newFromEntry( $entry );
    }
 
    public static function newFromRow( $row ) {
        wfDeprecated( __METHOD__, '1.42' );
        return self::newFromEntry( DatabaseLogEntry::newFromRow( $row ) );
    }
 
    // Nonstatic->
 
    protected $entry;
 
    protected $audience = self::FOR_PUBLIC;
 
    public $context;
 
    protected $linkFlood = false;
 
    protected $plaintext = false;
 
    protected $irctext = false;
 
    private $linkRenderer;
 
    private $contentLanguage;
 
    private $commentFormatter;
 
    private $userEditTracker;
 
    protected $parsedParameters;
 
    public function __construct( LogEntry $entry ) {
        $this->entry = $entry;
        $this->context = RequestContext::getMain();
    }
 
    public function setContext( IContextSource $context ) {
        $this->context = $context;
    }
 
    public function setLinkRenderer( LinkRenderer $linkRenderer ) {
        $this->linkRenderer = $linkRenderer;
    }
 
    public function getLinkRenderer() {
        if ( $this->linkRenderer !== null ) {
            return $this->linkRenderer;
        } else {
            wfDeprecated( static::class . " without all required services", '1.42' );
            return MediaWikiServices::getInstance()->getLinkRenderer();
        }
    }
 
    final public function setContentLanguage( Language $contentLanguage ) {
        $this->contentLanguage = $contentLanguage;
    }
 
    final public function getContentLanguage(): Language {
        if ( $this->contentLanguage === null ) {
            wfDeprecated( static::class . " without all required services", '1.42' );
            $this->contentLanguage = MediaWikiServices::getInstance()->getContentLanguage();
        }
        return $this->contentLanguage;
    }
 
    final public function setCommentFormatter( CommentFormatter $commentFormatter ) {
        $this->commentFormatter = $commentFormatter;
    }
 
    final public function getCommentFormatter(): CommentFormatter {
        if ( $this->commentFormatter === null ) {
            wfDeprecated( static::class . " without all required services", '1.42' );
            $this->commentFormatter = MediaWikiServices::getInstance()->getCommentFormatter();
        }
        return $this->commentFormatter;
    }
 
    final public function setUserEditTracker( UserEditTracker $userEditTracker ) {
        $this->userEditTracker = $userEditTracker;
    }
 
    final public function getUserEditTracker(): UserEditTracker {
        if ( $this->userEditTracker === null ) {
            wfDeprecated( static::class . " without all required services", '1.42' );
            $this->userEditTracker = MediaWikiServices::getInstance()->getUserEditTracker();
        }
        return $this->userEditTracker;
    }
 
    public function setAudience( $audience ) {
        $this->audience = ( $audience == self::FOR_THIS_USER )
            ? self::FOR_THIS_USER
            : self::FOR_PUBLIC;
    }
 
    public function canViewLogType() {
        // If the user doesn't have the right permission to view the specific
        // log type, return false
        $logRestrictions = $this->context->getConfig()->get( MainConfigNames::LogRestrictions );
        $type = $this->entry->getType();
        return !isset( $logRestrictions[$type] )
            || $this->context->getAuthority()->isAllowed( $logRestrictions[$type] );
    }
 
    protected function canView( $field ) {
        if ( $this->audience == self::FOR_THIS_USER ) {
            return LogEventsList::userCanBitfield(
                $this->entry->getDeleted(), $field, $this->context->getAuthority() ) &&
                self::canViewLogType();
        } else {
            return !$this->entry->isDeleted( $field ) && self::canViewLogType();
        }
    }
 
    public function setShowUserToolLinks( $value ) {
        $this->linkFlood = $value;
    }
 
    public function getPlainActionText() {
        $this->plaintext = true;
        $text = $this->getActionText();
        $this->plaintext = false;
 
        return $text;
    }
 
    public function getIRCActionComment() {
        $actionComment = $this->getIRCActionText();
        $comment = $this->entry->getComment();
 
        if ( $comment != '' ) {
            if ( $actionComment == '' ) {
                $actionComment = $comment;
            } else {
                $actionComment .= wfMessage( 'colon-separator' )->inContentLanguage()->text() . $comment;
            }
        }
 
        return $actionComment;
    }
 
    public function getIRCActionText() {
        $this->plaintext = true;
        $this->irctext = true;
 
        $entry = $this->entry;
        $parameters = $entry->getParameters();
        // @see LogPage::actionText()
        // Text of title the action is aimed at.
        $target = $entry->getTarget()->getPrefixedText();
        $text = null;
        $contLang = $this->getContentLanguage();
        switch ( $entry->getType() ) {
            case 'move':
                switch ( $entry->getSubtype() ) {
                    case 'move':
                        $movesource = $parameters['4::target'];
                        $text = wfMessage( '1movedto2' )
                            ->rawParams( $target, $movesource )->inContentLanguage()->escaped();
                        break;
                    case 'move_redir':
                        $movesource = $parameters['4::target'];
                        $text = wfMessage( '1movedto2_redir' )
                            ->rawParams( $target, $movesource )->inContentLanguage()->escaped();
                        break;
                    case 'move-noredirect':
                        break;
                    case 'move_redir-noredirect':
                        break;
                }
                break;
 
            case 'delete':
                switch ( $entry->getSubtype() ) {
                    case 'delete':
                        $text = wfMessage( 'deletedarticle' )
                            ->rawParams( $target )->inContentLanguage()->escaped();
                        break;
                    case 'restore':
                        $text = wfMessage( 'undeletedarticle' )
                            ->rawParams( $target )->inContentLanguage()->escaped();
                        break;
                }
                break;
 
            case 'patrol':
                // https://github.com/wikimedia/mediawiki/commit/1a05f8faf78675dc85984f27f355b8825b43efff
                // Create a diff link to the patrolled revision
                if ( $entry->getSubtype() === 'patrol' ) {
                    $diffLink = htmlspecialchars(
                        wfMessage( 'patrol-log-diff', $parameters['4::curid'] )
                            ->inContentLanguage()->text() );
                    $text = wfMessage( 'patrol-log-line', $diffLink, "[[$target]]", "" )
                        ->inContentLanguage()->text();
                } else {
                    // broken??
                }
                break;
 
            case 'protect':
                switch ( $entry->getSubtype() ) {
                    case 'protect':
                        $text = wfMessage( 'protectedarticle' )
                            ->rawParams( $target . ' ' . $parameters['4::description'] )
                            ->inContentLanguage()
                            ->escaped();
                        break;
                    case 'unprotect':
                        $text = wfMessage( 'unprotectedarticle' )
                            ->rawParams( $target )->inContentLanguage()->escaped();
                        break;
                    case 'modify':
                        $text = wfMessage( 'modifiedarticleprotection' )
                            ->rawParams( $target . ' ' . $parameters['4::description'] )
                            ->inContentLanguage()
                            ->escaped();
                        break;
                    case 'move_prot':
                        $text = wfMessage( 'movedarticleprotection' )
                            ->rawParams( $target, $parameters['4::oldtitle'] )->inContentLanguage()->escaped();
                        break;
                }
                break;
 
            case 'newusers':
                switch ( $entry->getSubtype() ) {
                    case 'newusers':
                    case 'create':
                        $text = wfMessage( 'newuserlog-create-entry' )
                            ->inContentLanguage()->escaped();
                        break;
                    case 'create2':
                    case 'byemail':
                        $text = wfMessage( 'newuserlog-create2-entry' )
                            ->rawParams( $target )->inContentLanguage()->escaped();
                        break;
                    case 'autocreate':
                        $text = wfMessage( 'newuserlog-autocreate-entry' )
                            ->inContentLanguage()->escaped();
                        break;
                }
                break;
 
            case 'upload':
                switch ( $entry->getSubtype() ) {
                    case 'upload':
                        $text = wfMessage( 'uploadedimage' )
                            ->rawParams( $target )->inContentLanguage()->escaped();
                        break;
                    case 'overwrite':
                    case 'revert':
                        $text = wfMessage( 'overwroteimage' )
                            ->rawParams( $target )->inContentLanguage()->escaped();
                        break;
                }
                break;
 
            case 'rights':
                if ( count( $parameters['4::oldgroups'] ) ) {
                    $oldgroups = implode( ', ', $parameters['4::oldgroups'] );
                } else {
                    $oldgroups = wfMessage( 'rightsnone' )->inContentLanguage()->escaped();
                }
                if ( count( $parameters['5::newgroups'] ) ) {
                    $newgroups = implode( ', ', $parameters['5::newgroups'] );
                } else {
                    $newgroups = wfMessage( 'rightsnone' )->inContentLanguage()->escaped();
                }
                switch ( $entry->getSubtype() ) {
                    case 'rights':
                        $text = wfMessage( 'rightslogentry' )
                            ->rawParams( $target, $oldgroups, $newgroups )->inContentLanguage()->escaped();
                        break;
                    case 'autopromote':
                        $text = wfMessage( 'rightslogentry-autopromote' )
                            ->rawParams( $target, $oldgroups, $newgroups )->inContentLanguage()->escaped();
                        break;
                }
                break;
 
            case 'merge':
                switch ( $entry->getSubtype() ) {
                    case 'merge':
                        $text = wfMessage( 'pagemerge-logentry' )
                            ->rawParams( $target, $parameters['4::dest'], $parameters['5::mergepoint'] )
                            ->inContentLanguage()->escaped();
                        break;
 
                    case 'merge-into':
                        // Nothing for IRC (already covered by the log at the source page)
                        return '';
                }
                break;
 
            case 'block':
                switch ( $entry->getSubtype() ) {
                    case 'block':
                        // Keep compatibility with extensions by checking for
                        // new key (5::duration/6::flags) or old key (0/optional 1)
                        if ( $entry->isLegacy() ) {
                            $rawDuration = $parameters[0];
                            $rawFlags = $parameters[1] ?? '';
                        } else {
                            $rawDuration = $parameters['5::duration'];
                            $rawFlags = $parameters['6::flags'];
                        }
                        $duration = $contLang->translateBlockExpiry(
                            $rawDuration,
                            null,
                            (int)wfTimestamp( TS::UNIX, $entry->getTimestamp() )
                        );
                        $flags = BlockLogFormatter::formatBlockFlags( $rawFlags, $contLang );
                        $text = wfMessage( 'blocklogentry' )
                            ->rawParams( $target, $duration, $flags )->inContentLanguage()->escaped();
                        break;
                    case 'unblock':
                        $text = wfMessage( 'unblocklogentry' )
                            ->rawParams( $target )->inContentLanguage()->escaped();
                        break;
                    case 'reblock':
                        $duration = $contLang->translateBlockExpiry(
                            $parameters['5::duration'],
                            null,
                            (int)wfTimestamp( TS::UNIX, $entry->getTimestamp() )
                        );
                        $flags = BlockLogFormatter::formatBlockFlags( $parameters['6::flags'],
                            $contLang );
                        $text = wfMessage( 'reblock-logentry' )
                            ->rawParams( $target, $duration, $flags )->inContentLanguage()->escaped();
                        break;
                }
                break;
 
            case 'import':
                switch ( $entry->getSubtype() ) {
                    case 'upload':
                        $text = wfMessage( 'import-logentry-upload' )
                            ->rawParams( $target )->inContentLanguage()->escaped();
                        break;
                    case 'interwiki':
                        $text = wfMessage( 'import-logentry-interwiki' )
                            ->rawParams( $target )->inContentLanguage()->escaped();
                        break;
                }
                break;
            // case 'suppress' --private log -- aaron  (so we know who to blame in a few years :-D)
            // default:
        }
 
        $this->plaintext = false;
        $this->irctext = false;
 
        return $text ?? $this->getPlainActionText();
    }
 
    public function getActionText() {
        if ( $this->canView( LogPage::DELETED_ACTION ) ) {
            $element = $this->getActionMessage();
            if ( $element instanceof Message ) {
                $element = $this->plaintext ? $element->text() : $element->escaped();
            }
            if ( $this->entry->isDeleted( LogPage::DELETED_ACTION ) ) {
                $element = $this->styleRestrictedElement( $element );
            }
        } else {
            $sep = $this->msg( 'word-separator' );
            $sep = $this->plaintext ? $sep->text() : $sep->escaped();
            $performer = $this->getPerformerElement();
            $element = $performer . $sep . $this->getRestrictedElement( 'rev-deleted-event' );
        }
 
        return $element;
    }
 
    protected function getActionMessage() {
        $message = $this->msg( $this->getMessageKey() );
        $message->params( $this->getMessageParameters() );
 
        return $message;
    }
 
    protected function getMessageKey() {
        $type = $this->entry->getType();
        $subtype = $this->entry->getSubtype();
 
        return "logentry-$type-$subtype";
    }
 
    public function getActionLinks() {
        return '';
    }
 
    protected function extractParameters() {
        $entry = $this->entry;
        $params = [];
 
        if ( $entry->isLegacy() ) {
            foreach ( $entry->getParameters() as $index => $value ) {
                $params[$index + 3] = $value;
            }
        }
 
        // Filter out parameters which are not in format #:foo
        foreach ( $entry->getParameters() as $key => $value ) {
            if ( !str_contains( $key, ':' ) ) {
                continue;
            }
            [ $index, $type, ] = explode( ':', $key, 3 );
            if ( ctype_digit( $index ) ) {
                $params[(int)$index - 1] = $this->formatParameterValue( $type, $value );
            }
        }
 
        /* Message class doesn't like non consecutive numbering.
         * Fill in missing indexes with empty strings to avoid
         * incorrect renumbering.
         */
        if ( count( $params ) ) {
            $max = max( array_keys( $params ) );
            // index 0 to 2 are added in getMessageParameters
            for ( $i = 3; $i < $max; $i++ ) {
                if ( !isset( $params[$i] ) ) {
                    $params[$i] = '';
                }
            }
        }
 
        return $params;
    }
 
    protected function getMessageParameters() {
        if ( $this->parsedParameters !== null ) {
            return $this->parsedParameters;
        }
 
        $entry = $this->entry;
        $params = $this->extractParameters();
        $params[0] = Message::rawParam( $this->getPerformerElement() );
        $params[1] = $this->canView( LogPage::DELETED_USER ) ? $entry->getPerformerIdentity()->getName() : '';
        $params[2] = Message::rawParam( $this->makePageLink( $entry->getTarget() ) );
 
        // Bad things happens if the numbers are not in correct order
        ksort( $params );
 
        $this->parsedParameters = $params;
        return $this->parsedParameters;
    }
 
    protected function formatParameterValue( $type, $value ) {
        $saveLinkFlood = $this->linkFlood;
 
        switch ( strtolower( trim( $type ) ) ) {
            case 'raw':
                $value = Message::rawParam( $value );
                break;
            case 'list':
                $value = $this->context->getLanguage()->commaList( $value );
                break;
            case 'msg':
                $value = $this->msg( $value )->text();
                break;
            case 'msg-content':
                $value = $this->msg( $value )->inContentLanguage()->text();
                break;
            case 'number':
                $value = Message::numParam( $value );
                break;
            case 'user':
                $user = User::newFromName( $value );
                $value = $user->getName();
                break;
            case 'user-link':
                $this->setShowUserToolLinks( false );
 
                $user = User::newFromName( $value );
 
                if ( !$user ) {
                    $value = $this->msg( 'empty-username' )->text();
                } else {
                    $value = Message::rawParam( $this->makeUserLink( $user ) );
                    $this->setShowUserToolLinks( $saveLinkFlood );
                }
                break;
            case 'title':
                $title = Title::newFromText( $value );
                $value = $title->getPrefixedText();
                break;
            case 'title-link':
                $title = Title::newFromText( $value );
                $value = Message::rawParam( $this->makePageLink( $title ) );
                break;
            case 'plain':
                // Plain text, nothing to do
            default:
                // Catch other types and use the old behavior (return as-is)
        }
 
        return $value;
    }
 
    protected function makePageLink( ?Title $title = null, $parameters = [], $html = null ) {
        if ( !$title instanceof Title ) {
            $msg = $this->msg( 'invalidtitle' )->text();
            if ( $this->plaintext ) {
                return $msg;
            } else {
                return Html::element( 'span', [ 'class' => 'mw-invalidtitle' ], $msg );
            }
        }
 
        if ( $this->plaintext ) {
            $link = '[[' . $title->getPrefixedText() . ']]';
        } else {
            $html = $html !== null ? new HtmlArmor( $html ) : $html;
            $link = $this->getLinkRenderer()->makeLink( $title, $html, [], $parameters );
        }
 
        return $link;
    }
 
    public function getPerformerElement() {
        if ( $this->canView( LogPage::DELETED_USER ) ) {
            $performerIdentity = $this->entry->getPerformerIdentity();
            $element = $this->makeUserLink( $performerIdentity );
            if ( $this->entry->isDeleted( LogPage::DELETED_USER ) ) {
                $element = $this->styleRestrictedElement( $element );
            }
        } else {
            $element = $this->getRestrictedElement( 'rev-deleted-user' );
        }
 
        return $element;
    }
 
    public function getComment() {
        if ( $this->canView( LogPage::DELETED_COMMENT ) ) {
            $comment = $this->getCommentFormatter()
                ->formatBlock( $this->entry->getComment() );
            // No hard coded spaces thanx
            $element = ltrim( $comment );
            if ( $this->entry->isDeleted( LogPage::DELETED_COMMENT ) ) {
                $element = $this->styleRestrictedElement( $element );
            }
        } else {
            $element = $this->getRestrictedElement( 'rev-deleted-comment' );
        }
 
        return $element;
    }
 
    protected function getRestrictedElement( $message ) {
        if ( $this->plaintext ) {
            return $this->msg( $message )->text();
        }
 
        return $this->styleRestrictedElement( $this->msg( $message )->escaped() );
    }
 
    protected function styleRestrictedElement( $content ) {
        if ( $this->plaintext ) {
            return $content;
        }
        $attribs = [ 'class' => [ 'history-deleted' ] ];
        if ( $this->entry->isDeleted( LogPage::DELETED_RESTRICTED ) ) {
            $attribs['class'][] = 'mw-history-suppressed';
        }
 
        return Html::rawElement( 'span', $attribs, $content );
    }
 
    protected function msg( $key, ...$params ) {
        return $this->context->msg( $key, ...$params );
    }
 
    protected function makeUserLink( UserIdentity $user, $toolFlags = 0 ) {
        if ( $this->plaintext ) {
            $element = $user->getName();
        } else {
            $element = Linker::userLink(
                $user->getId(),
                $user->getName()
            );
            if ( $this->linkFlood ) {
                $editCount = $this->getUserEditTracker()->getUserEditCount( $user );
 
                $element .= Linker::userToolLinks(
                    $user->getId(),
                    $user->getName(),
                    true, // redContribsWhenNoEdits
                    $toolFlags,
                    $editCount,
                    // do not render parentheses in the HTML markup (CSS will provide)
                    false
                );
            }
        }
 
        return $element;
    }
 
    public function getPreloadTitles() {
        return [];
    }
 
    public function getMessageParametersForTesting() {
        // This function was added because getMessageParameters() is
        // protected and a change from protected to public caused
        // problems with extensions
        return $this->getMessageParameters();
    }
 
    protected function getParametersForApi() {
        return $this->entry->getParameters();
    }
 
    public function formatParametersForApi() {
        $logParams = [];
        foreach ( $this->getParametersForApi() as $key => $value ) {
            $vals = explode( ':', $key, 3 );
            if ( count( $vals ) !== 3 ) {
                if ( $value instanceof \__PHP_Incomplete_Class ) {
                    wfLogWarning( 'Log entry of type ' . $this->entry->getFullType() .
                        ' contains unrecoverable extra parameters.' );
                    continue;
                }
                $logParams[$key] = $value;
                continue;
            }
            $logParams += $this->formatParameterValueForApi( $vals[2], $vals[1], $value );
        }
        ApiResult::setIndexedTagName( $logParams, 'param' );
        ApiResult::setArrayType( $logParams, 'assoc' );
 
        return $logParams;
    }
 
    protected function formatParameterValueForApi( $name, $type, $value ) {
        $type = strtolower( trim( $type ) );
        switch ( $type ) {
            case 'bool':
                $value = (bool)$value;
                break;
 
            case 'number':
                if ( is_int( $value ) || ctype_digit( (string)$value ) ) {
                    $value = (int)$value;
                } else {
                    $value = (float)$value;
                }
                break;
 
            case 'array':
            case 'assoc':
            case 'kvp':
                if ( is_array( $value ) ) {
                    ApiResult::setArrayType( $value, $type );
                }
                break;
 
            case 'timestamp':
                $value = wfTimestamp( TS::ISO_8601, $value );
                break;
 
            case 'msg':
            case 'msg-content':
                $msg = $this->msg( $value );
                if ( $type === 'msg-content' ) {
                    $msg->inContentLanguage();
                }
                $value = [];
                $value["{$name}_key"] = $msg->getKey();
                if ( $msg->getParams() ) {
                    $value["{$name}_params"] = $msg->getParams();
                }
                $value["{$name}_text"] = $msg->text();
                return $value;
 
            case 'title':
            case 'title-link':
                $title = Title::newFromText( $value );
                if ( !$title ) {
                    $title = SpecialPage::getTitleFor( 'Badtitle', $value );
                }
                $value = [];
                ApiQueryBase::addTitleInfo( $value, $title, "{$name}_" );
                return $value;
 
            case 'user':
            case 'user-link':
                $user = User::newFromName( $value );
                if ( $user ) {
                    $value = $user->getName();
                }
                break;
 
            default:
                // do nothing
                break;
        }
 
        return [ $name => $value ];
    }
}
 
class_alias( LogFormatter::class, 'LogFormatter' );