LogFormatter.php

Go to the documentation of this file.

<?php
class LogFormatter {
    // Audience options for viewing usernames, comments, and actions
    const FOR_PUBLIC = 1;
    const FOR_THIS_USER = 2;

    // Static->

    public static function newFromEntry( LogEntry $entry ) {
        global $wgLogActionsHandlers;
        $fulltype = $entry->getFullType();
        $wildcard = $entry->getType() . '/*';
        $handler = '';

        if ( isset( $wgLogActionsHandlers[$fulltype] ) ) {
            $handler = $wgLogActionsHandlers[$fulltype];
        } elseif ( isset( $wgLogActionsHandlers[$wildcard] ) ) {
            $handler = $wgLogActionsHandlers[$wildcard];
        }

        if ( $handler !== '' && is_string( $handler ) && class_exists( $handler ) ) {
            return new $handler( $entry );
        }

        return new LegacyLogFormatter( $entry );
    }

    public static function newFromRow( $row ) {
        return self::newFromEntry( DatabaseLogEntry::newFromRow( $row ) );
    }

    // Nonstatic->

    protected $entry;

    protected $audience = self::FOR_PUBLIC;

    protected $linkFlood = false;

    protected $plaintext = false;

    protected $irctext = false;

    protected function __construct( LogEntry $entry ) {
        $this->entry = $entry;
        $this->context = RequestContext::getMain();
    }

    public function setContext( IContextSource $context ) {
        $this->context = $context;
    }

    public function setAudience( $audience ) {
        $this->audience = ( $audience == self::FOR_THIS_USER )
            ? self::FOR_THIS_USER
            : self::FOR_PUBLIC;
    }

    protected function canView( $field ) {
        if ( $this->audience == self::FOR_THIS_USER ) {
            return LogEventsList::userCanBitfield(
                $this->entry->getDeleted(), $field, $this->context->getUser() );
        } else {
            return !$this->entry->isDeleted( $field );
        }
    }

    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;
        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;
                    //case 'revision': // Revision deletion
                    //case 'event': // Log deletion
                        // see https://svn.wikimedia.org/viewvc/mediawiki/trunk/phase3/includes/LogPage.php?&pathrev=97044&r1=97043&r2=97044
                    //default:
                }
                break;

            case 'patrol':
                // https://svn.wikimedia.org/viewvc/mediawiki/trunk/phase3/includes/PatrolLog.php?&pathrev=97495&r1=97494&r2=97495
                // 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[0] )->inContentLanguage()->escaped();
                    break;
                case 'unprotect':
                    $text = wfMessage( 'unprotectedarticle' )
                        ->rawParams( $target )->inContentLanguage()->escaped();
                    break;
                case 'modify':
                    $text = wfMessage( 'modifiedarticleprotection' )
                        ->rawParams( $target . ' ' . $parameters[0] )->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':
                        $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 'suppress' --private log -- aaron  (sign your messages so we know who to blame in a few years :-D)
            // default:
        }
        if ( is_null( $text ) ) {
            $text = $this->getPlainActionText();
        }

        $this->plaintext = false;
        $this->irctext = false;
        return $text;
    }

    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->styleRestricedElement( $element );
            }
        } else {
            $performer = $this->getPerformerElement() . $this->msg( 'word-separator' )->text();
            $element = $performer . $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 = array();

        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 ( strpos( $key, ':' ) === false ) {
                continue;
            }
            list( $index, $type, ) = explode( ':', $key, 3 );
            $params[$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 ) );
            for ( $i = 4; $i < $max; $i++ ) {
                if ( !isset( $params[$i] ) ) {
                    $params[$i] = '';
                }
            }
        }
        return $params;
    }

    protected function getMessageParameters() {
        if ( isset( $this->parsedParameters ) ) {
            return $this->parsedParameters;
        }

        $entry = $this->entry;
        $params = $this->extractParameters();
        $params[0] = Message::rawParam( $this->getPerformerElement() );
        $params[1] = $this->canView( LogPage::DELETED_USER ) ? $entry->getPerformer()->getName() : '';
        $params[2] = Message::rawParam( $this->makePageLink( $entry->getTarget() ) );

        // Bad things happens if the numbers are not in correct order
        ksort( $params );
        return $this->parsedParameters = $params;
    }

    protected function formatParameterValue( $type, $value ) {
        $saveLinkFlood = $this->linkFlood;

        switch ( strtolower( trim( $type ) ) ) {
            case 'raw':
                $value = Message::rawParam( $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 );
                $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 = array() ) {
        if ( !$this->plaintext ) {
            $link = Linker::link( $title, null, array(), $parameters );
        } else {
            if ( !$title instanceof Title ) {
                throw new MWException( "Expected title, got null" );
            }
            $link = '[[' . $title->getPrefixedText() . ']]';
        }
        return $link;
    }

    public function getPerformerElement() {
        if ( $this->canView( LogPage::DELETED_USER ) ) {
            $performer = $this->entry->getPerformer();
            $element = $this->makeUserLink( $performer );
            if ( $this->entry->isDeleted( LogPage::DELETED_USER ) ) {
                $element = $this->styleRestricedElement( $element );
            }
        } else {
            $element = $this->getRestrictedElement( 'rev-deleted-user' );
        }

        return $element;
    }

    public function getComment() {
        if ( $this->canView( LogPage::DELETED_COMMENT ) ) {
            $comment = Linker::commentBlock( $this->entry->getComment() );
            // No hard coded spaces thanx
            $element = ltrim( $comment );
            if ( $this->entry->isDeleted( LogPage::DELETED_COMMENT ) ) {
                $element = $this->styleRestricedElement( $element );
            }
        } else {
            $element = $this->getRestrictedElement( 'rev-deleted-comment' );
        }

        return $element;
    }

    protected function getRestrictedElement( $message ) {
        if ( $this->plaintext ) {
            return $this->msg( $message )->text();
        }

        $content = $this->msg( $message )->escaped();
        $attribs = array( 'class' => 'history-deleted' );
        return Html::rawElement( 'span', $attribs, $content );
    }

    protected function styleRestricedElement( $content ) {
        if ( $this->plaintext ) {
            return $content;
        }
        $attribs = array( 'class' => 'history-deleted' );
        return Html::rawElement( 'span', $attribs, $content );
    }

    protected function msg( $key ) {
        return $this->context->msg( $key );
    }

    protected function makeUserLink( User $user ) {
        if ( $this->plaintext ) {
            $element = $user->getName();
        } else {
            $element = Linker::userLink(
                $user->getId(),
                $user->getName()
            );

            if ( $this->linkFlood ) {
                $element .= Linker::userToolLinksRedContribs(
                    $user->getId(),
                    $user->getName(),
                    $user->getEditCount()
                );
            }
        }
        return $element;
    }

    public function getPreloadTitles() {
        return array();
    }

    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();
    }

}

class LegacyLogFormatter extends LogFormatter {

    private $comment = null;

    private $revert = null;

    public function getComment() {
        if ( $this->comment === null ) {
            $this->comment = parent::getComment();
        }

        // Make sure we execute the LogLine hook so that we immediately return
        // the correct value.
        if ( $this->revert === null ) {
            $this->getActionLinks();
        }

        return $this->comment;
    }

    protected function getActionMessage() {
        $entry = $this->entry;
        $action = LogPage::actionText(
            $entry->getType(),
            $entry->getSubtype(),
            $entry->getTarget(),
            $this->plaintext ? null : $this->context->getSkin(),
            (array)$entry->getParameters(),
            !$this->plaintext // whether to filter [[]] links
        );

        $performer = $this->getPerformerElement();
        if ( !$this->irctext ) {
            $action = $performer . $this->msg( 'word-separator' )->text() . $action;
        }

        return $action;
    }

    public function getActionLinks() {
        if ( $this->revert !== null ) {
            return $this->revert;
        }

        if ( $this->entry->isDeleted( LogPage::DELETED_ACTION ) ) {
            return $this->revert = '';
        }

        $title = $this->entry->getTarget();
        $type = $this->entry->getType();
        $subtype = $this->entry->getSubtype();

        // Show unblock/change block link
        if ( ( $type == 'block' || $type == 'suppress' ) && ( $subtype == 'block' || $subtype == 'reblock' ) ) {
            if ( !$this->context->getUser()->isAllowed( 'block' ) ) {
                return '';
            }

            $links = array(
                Linker::linkKnown(
                    SpecialPage::getTitleFor( 'Unblock', $title->getDBkey() ),
                    $this->msg( 'unblocklink' )->escaped()
                ),
                Linker::linkKnown(
                    SpecialPage::getTitleFor( 'Block', $title->getDBkey() ),
                    $this->msg( 'change-blocklink' )->escaped()
                )
            );
            return $this->msg( 'parentheses' )->rawParams(
                $this->context->getLanguage()->pipeList( $links ) )->escaped();
        // Show change protection link
        } elseif ( $type == 'protect' && ( $subtype == 'protect' || $subtype == 'modify' || $subtype == 'unprotect' ) ) {
            $links = array(
                Linker::link( $title,
                    $this->msg( 'hist' )->escaped(),
                    array(),
                    array(
                        'action' => 'history',
                        'offset' => $this->entry->getTimestamp()
                    )
                )
            );
            if ( $this->context->getUser()->isAllowed( 'protect' ) ) {
                $links[] = Linker::linkKnown(
                    $title,
                    $this->msg( 'protect_change' )->escaped(),
                    array(),
                    array( 'action' => 'protect' )
                );
            }
            return $this->msg( 'parentheses' )->rawParams(
                $this->context->getLanguage()->pipeList( $links ) )->escaped();
        // Show unmerge link
        } elseif ( $type == 'merge' && $subtype == 'merge' ) {
            if ( !$this->context->getUser()->isAllowed( 'mergehistory' ) ) {
                return '';
            }

            $params = $this->extractParameters();
            $revert = Linker::linkKnown(
                SpecialPage::getTitleFor( 'MergeHistory' ),
                $this->msg( 'revertmerge' )->escaped(),
                array(),
                array(
                    'target' => $params[3],
                    'dest' => $title->getPrefixedDBkey(),
                    'mergepoint' => $params[4]
                )
            );
            return $this->msg( 'parentheses' )->rawParams( $revert )->escaped();
        }

        // Do nothing. The implementation is handled by the hook modifiying the
        // passed-by-ref parameters. This also changes the default value so that
        // getComment() and getActionLinks() do not call them indefinitely.
        $this->revert = '';

        // This is to populate the $comment member of this instance so that it
        // can be modified when calling the hook just below.
        if ( $this->comment === null ) {
            $this->getComment();
        }

        $params = $this->entry->getParameters();

        wfRunHooks( 'LogLine', array( $type, $subtype, $title, $params,
            &$this->comment, &$this->revert, $this->entry->getTimestamp() ) );

        return $this->revert;
    }
}