LogEntry.php

Go to the documentation of this file.

<?php
interface LogEntry {
    public function getType();

    public function getSubtype();

    public function getFullType();

    public function getParameters();

    public function getPerformer();

    public function getTarget();

    public function getTimestamp();

    public function getComment();

    public function getDeleted();

    public function isDeleted( $field );
}

abstract class LogEntryBase implements LogEntry {
    public function getFullType() {
        return $this->getType() . '/' . $this->getSubtype();
    }

    public function isDeleted( $field ) {
        return ( $this->getDeleted() & $field ) === $field;
    }

    public function isLegacy() {
        return false;
    }
}

class DatabaseLogEntry extends LogEntryBase {
    // Static->

    public static function getSelectQueryData() {
        $tables = array( 'logging', 'user' );
        $fields = array(
            'log_id', 'log_type', 'log_action', 'log_timestamp',
            'log_user', 'log_user_text',
            'log_namespace', 'log_title', // unused log_page
            'log_comment', 'log_params', 'log_deleted',
            'user_id', 'user_name', 'user_editcount',
        );

        $joins = array(
            // IP's don't have an entry in user table
            'user' => array( 'LEFT JOIN', 'log_user=user_id' ),
        );

        return array(
            'tables' => $tables,
            'fields' => $fields,
            'conds' => array(),
            'options' => array(),
            'join_conds' => $joins,
        );
    }

    public static function newFromRow( $row ) {
        $row = (object)$row;
        if ( isset( $row->rc_logid ) ) {
            return new RCDatabaseLogEntry( $row );
        } else {
            return new self( $row );
        }
    }

    // Non-static->

    protected $row;

    protected $performer;

    protected $legacy;

    protected function __construct( $row ) {
        $this->row = $row;
    }

    public function getId() {
        return (int)$this->row->log_id;
    }

    protected function getRawParameters() {
        return $this->row->log_params;
    }

    // LogEntryBase->

    public function isLegacy() {
        // This does the check
        $this->getParameters();

        return $this->legacy;
    }

    // LogEntry->

    public function getType() {
        return $this->row->log_type;
    }

    public function getSubtype() {
        return $this->row->log_action;
    }

    public function getParameters() {
        if ( !isset( $this->params ) ) {
            $blob = $this->getRawParameters();
            wfSuppressWarnings();
            $params = unserialize( $blob );
            wfRestoreWarnings();
            if ( $params !== false ) {
                $this->params = $params;
                $this->legacy = false;
            } else {
                $this->params = $blob === '' ? array() : explode( "\n", $blob );
                $this->legacy = true;
            }
        }

        return $this->params;
    }

    public function getPerformer() {
        if ( !$this->performer ) {
            $userId = (int)$this->row->log_user;
            if ( $userId !== 0 ) { // logged-in users
                if ( isset( $this->row->user_name ) ) {
                    $this->performer = User::newFromRow( $this->row );
                } else {
                    $this->performer = User::newFromId( $userId );
                }
            } else { // IP users
                $userText = $this->row->log_user_text;
                $this->performer = User::newFromName( $userText, false );
            }
        }

        return $this->performer;
    }

    public function getTarget() {
        $namespace = $this->row->log_namespace;
        $page = $this->row->log_title;
        $title = Title::makeTitle( $namespace, $page );

        return $title;
    }

    public function getTimestamp() {
        return wfTimestamp( TS_MW, $this->row->log_timestamp );
    }

    public function getComment() {
        return $this->row->log_comment;
    }

    public function getDeleted() {
        return $this->row->log_deleted;
    }
}

class RCDatabaseLogEntry extends DatabaseLogEntry {

    public function getId() {
        return $this->row->rc_logid;
    }

    protected function getRawParameters() {
        return $this->row->rc_params;
    }

    // LogEntry->

    public function getType() {
        return $this->row->rc_log_type;
    }

    public function getSubtype() {
        return $this->row->rc_log_action;
    }

    public function getPerformer() {
        if ( !$this->performer ) {
            $userId = (int)$this->row->rc_user;
            if ( $userId !== 0 ) {
                $this->performer = User::newFromId( $userId );
            } else {
                $userText = $this->row->rc_user_text;
                // Might be an IP, don't validate the username
                $this->performer = User::newFromName( $userText, false );
            }
        }

        return $this->performer;
    }

    public function getTarget() {
        $namespace = $this->row->rc_namespace;
        $page = $this->row->rc_title;
        $title = Title::makeTitle( $namespace, $page );

        return $title;
    }

    public function getTimestamp() {
        return wfTimestamp( TS_MW, $this->row->rc_timestamp );
    }

    public function getComment() {
        return $this->row->rc_comment;
    }

    public function getDeleted() {
        return $this->row->rc_deleted;
    }
}

class ManualLogEntry extends LogEntryBase {
    protected $type;

    protected $subtype;

    protected $parameters = array();

    protected $relations = array();

    protected $performer;

    protected $target;

    protected $timestamp;

    protected $comment = '';

    protected $deleted;

    protected $id;

    public function __construct( $type, $subtype ) {
        $this->type = $type;
        $this->subtype = $subtype;
    }

    public function setParameters( $parameters ) {
        $this->parameters = $parameters;
    }

    public function setRelations( array $relations ) {
        $this->relations = $relations;
    }

    public function setPerformer( User $performer ) {
        $this->performer = $performer;
    }

    public function setTarget( Title $target ) {
        $this->target = $target;
    }

    public function setTimestamp( $timestamp ) {
        $this->timestamp = $timestamp;
    }

    public function setComment( $comment ) {
        $this->comment = $comment;
    }

    public function setDeleted( $deleted ) {
        $this->deleted = $deleted;
    }

    public function insert( IDatabase $dbw = null ) {
        global $wgContLang;

        $dbw = $dbw ?: wfGetDB( DB_MASTER );
        $id = $dbw->nextSequenceValue( 'logging_log_id_seq' );

        if ( $this->timestamp === null ) {
            $this->timestamp = wfTimestampNow();
        }

        # Trim spaces on user supplied text
        $comment = trim( $this->getComment() );

        # Truncate for whole multibyte characters.
        $comment = $wgContLang->truncate( $comment, 255 );

        $data = array(
            'log_id' => $id,
            'log_type' => $this->getType(),
            'log_action' => $this->getSubtype(),
            'log_timestamp' => $dbw->timestamp( $this->getTimestamp() ),
            'log_user' => $this->getPerformer()->getId(),
            'log_user_text' => $this->getPerformer()->getName(),
            'log_namespace' => $this->getTarget()->getNamespace(),
            'log_title' => $this->getTarget()->getDBkey(),
            'log_page' => $this->getTarget()->getArticleID(),
            'log_comment' => $comment,
            'log_params' => serialize( (array)$this->getParameters() ),
        );
        if ( isset( $this->deleted ) ) {
            $data['log_deleted'] = $this->deleted;
        }

        $dbw->insert( 'logging', $data, __METHOD__ );
        $this->id = !is_null( $id ) ? $id : $dbw->insertId();

        $rows = array();
        foreach ( $this->relations as $tag => $values ) {
            if ( !strlen( $tag ) ) {
                throw new MWException( "Got empty log search tag." );
            }

            if ( !is_array( $values ) ) {
                $values = array( $values );
            }

            foreach ( $values as $value ) {
                $rows[] = array(
                    'ls_field' => $tag,
                    'ls_value' => $value,
                    'ls_log_id' => $this->id
                );
            }
        }
        if ( count( $rows ) ) {
            $dbw->insert( 'log_search', $rows, __METHOD__, 'IGNORE' );
        }

        // Update any bloom filter cache
        $member = $this->getTarget()->getNamespace() . ':' . $this->getTarget()->getDBkey();
        BloomCache::get( 'main' )->insert( wfWikiId(), 'TitleHasLogs', $member );

        return $this->id;
    }

    public function getRecentChange( $newId = 0 ) {
        $formatter = LogFormatter::newFromEntry( $this );
        $context = RequestContext::newExtraneousContext( $this->getTarget() );
        $formatter->setContext( $context );

        $logpage = SpecialPage::getTitleFor( 'Log', $this->getType() );
        $user = $this->getPerformer();
        $ip = "";
        if ( $user->isAnon() ) {
            /*
             * "MediaWiki default" and friends may have
             * no IP address in their name
             */
            if ( IP::isIPAddress( $user->getName() ) ) {
                $ip = $user->getName();
            }
        }

        return RecentChange::newLogEntry(
            $this->getTimestamp(),
            $logpage,
            $user,
            $formatter->getPlainActionText(),
            $ip,
            $this->getType(),
            $this->getSubtype(),
            $this->getTarget(),
            $this->getComment(),
            serialize( (array)$this->getParameters() ),
            $newId,
            $formatter->getIRCActionComment() // Used for IRC feeds
        );
    }

    public function publish( $newId, $to = 'rcandudp' ) {
        $log = new LogPage( $this->getType() );
        if ( $log->isRestricted() ) {
            return;
        }

        $rc = $this->getRecentChange( $newId );

        if ( $to === 'rc' || $to === 'rcandudp' ) {
            $rc->save( 'pleasedontudp' );
        }

        if ( $to === 'udp' || $to === 'rcandudp' ) {
            $rc->notifyRCFeeds();
        }
    }

    // LogEntry->

    public function getType() {
        return $this->type;
    }

    public function getSubtype() {
        return $this->subtype;
    }

    public function getParameters() {
        return $this->parameters;
    }

    public function getPerformer() {
        return $this->performer;
    }

    public function getTarget() {
        return $this->target;
    }

    public function getTimestamp() {
        $ts = $this->timestamp !== null ? $this->timestamp : wfTimestampNow();

        return wfTimestamp( TS_MW, $ts );
    }

    public function getComment() {
        return $this->comment;
    }

    public function getDeleted() {
        return (int)$this->deleted;
    }
}