DatabaseLogEntry.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Logging;
 
use InvalidArgumentException;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
use MediaWiki\User\UserIdentity;
use stdClass;
use Wikimedia\AtEase\AtEase;
use Wikimedia\Rdbms\IReadableDatabase;
 
class DatabaseLogEntry extends LogEntryBase {
 
    public static function getSelectQueryData() {
        $commentQuery = MediaWikiServices::getInstance()->getCommentStore()->getJoin( 'log_comment' );
 
        $tables = array_merge(
            [
                'logging',
                'logging_actor' => 'actor',
                'user'
            ],
            $commentQuery['tables']
        );
        $fields = [
            'log_id', 'log_type', 'log_action', 'log_timestamp',
            'log_namespace', 'log_title', // unused log_page
            'log_params', 'log_deleted',
            'user_id',
            'user_name',
            'log_actor',
            'log_user' => 'logging_actor.actor_user',
            'log_user_text' => 'logging_actor.actor_name'
        ] + $commentQuery['fields'];
 
        $joins = [
            'logging_actor' => [ 'JOIN', 'actor_id=log_actor' ],
            // IPs don't have an entry in user table
            'user' => [ 'LEFT JOIN', 'user_id=logging_actor.actor_user' ],
        ] + $commentQuery['joins'];
 
        return [
            'tables' => $tables,
            'fields' => $fields,
            'conds' => [],
            'options' => [],
            'join_conds' => $joins,
        ];
    }
 
    public static function newSelectQueryBuilder( IReadableDatabase $db ) {
        return new LoggingSelectQueryBuilder( $db );
    }
 
    public static function newFromRow( $row ) {
        $row = (object)$row;
        if ( isset( $row->rc_logid ) ) {
            return new RCDatabaseLogEntry( $row );
        }
 
        return new self( $row );
    }
 
    public static function newFromId( $id, IReadableDatabase $db ) {
        $row = self::newSelectQueryBuilder( $db )
            ->where( [ 'log_id' => $id ] )
            ->caller( __METHOD__ )->fetchRow();
        if ( !$row ) {
            return null;
        }
        return self::newFromRow( $row );
    }
 
    protected $row;
 
    protected $performer;
 
    protected $params;
 
    protected $revId = null;
 
    protected $legacy;
 
    protected function __construct( $row ) {
        $this->row = $row;
    }
 
    public function getId() {
        return (int)( $this->row->log_id ?? 0 );
    }
 
    protected function getRawParameters() {
        return $this->row->log_params;
    }
 
    public function isLegacy() {
        // This extracts the property
        $this->getParameters();
        return $this->legacy;
    }
 
    public function getType() {
        return $this->row->log_type;
    }
 
    public function getSubtype() {
        return $this->row->log_action;
    }
 
    public function getParameters() {
        if ( $this->params === null ) {
            $blob = $this->getRawParameters();
            AtEase::suppressWarnings();
            $params = LogEntryBase::extractParams( $blob );
            AtEase::restoreWarnings();
            if ( $params !== false ) {
                $this->params = $params;
                $this->legacy = false;
            } else {
                $this->params = LogPage::extractParams( $blob );
                $this->legacy = true;
            }
 
            if ( isset( $this->params['associated_rev_id'] ) ) {
                $this->revId = $this->params['associated_rev_id'];
                unset( $this->params['associated_rev_id'] );
            }
        }
 
        return $this->params;
    }
 
    public function getAssociatedRevId() {
        // This extracts the property
        $this->getParameters();
        return $this->revId;
    }
 
    public function getPerformerIdentity(): UserIdentity {
        if ( !$this->performer ) {
            $actorStore = MediaWikiServices::getInstance()->getActorStore();
            try {
                $this->performer = $actorStore->newActorFromRowFields(
                    $this->row->user_id ?? 0,
                    $this->row->log_user_text ?? null,
                    $this->row->log_actor ?? null
                );
            } catch ( InvalidArgumentException $e ) {
                LoggerFactory::getInstance( 'logentry' )->warning(
                    'Failed to instantiate log entry performer', [
                        'exception' => $e,
                        'log_id' => $this->getId()
                    ]
                );
                $this->performer = $actorStore->getUnknownActor();
            }
        }
        return $this->performer;
    }
 
    public function getTarget() {
        $namespace = $this->row->log_namespace;
        $page = $this->row->log_title;
        return MediaWikiServices::getInstance()->getTitleFactory()->makeTitle( $namespace, $page );
    }
 
    public function getTimestamp() {
        return wfTimestamp( TS_MW, $this->row->log_timestamp );
    }
 
    public function getComment() {
        return MediaWikiServices::getInstance()->getCommentStore()
            ->getComment( 'log_comment', $this->row )->text;
    }
 
    public function getDeleted() {
        return $this->row->log_deleted;
    }
}
 
class_alias( DatabaseLogEntry::class, 'DatabaseLogEntry' );