includes/logging/LogEntry.php

   1 <?php
   2 /**
   3  * Contain classes for dealing with individual log entries
   4  *
   5  * This is how I see the log system history:
   6  * - appending to plain wiki pages
   7  * - formatting log entries based on database fields
   8  * - user is now part of the action message
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  23  * http://www.gnu.org/copyleft/gpl.html
  24  *
  25  * @file
  26  * @author Niklas Laxström
  27  * @license http://www.gnu.org/copyleft/gpl.html GNU General Public License 2.0 or later
  28  * @since 1.19
  29  */
  30
  31 /**
  32  * Interface for log entries. Every log entry has these methods.
  33  * @since 1.19
  34  */
  35 interface LogEntry {
  36         /**
  37          * The main log type.
  38          * @return string
  39          */
  40         public function getType();
  41
  42         /**
  43          * The log subtype.
  44          * @return string
  45          */
  46         public function getSubtype();
  47
  48         /**
  49          * The full logtype in format maintype/subtype.
  50          * @return string
  51          */
  52         public function getFullType();
  53
  54         /**
  55          * Get the extra parameters stored for this message.
  56          * @return array
  57          */
  58         public function getParameters();
  59
  60         /**
  61          * Get the user for performed this action.
  62          * @return User
  63          */
  64         public function getPerformer();
  65
  66         /**
  67          * Get the target page of this action.
  68          * @return Title
  69          */
  70         public function getTarget();
  71
  72         /**
  73          * Get the timestamp when the action was executed.
  74          * @return string
  75          */
  76         public function getTimestamp();
  77
  78         /**
  79          * Get the user provided comment.
  80          * @return string
  81          */
  82         public function getComment();
  83
  84         /**
  85          * Get the access restriction.
  86          * @return string
  87          */
  88         public function getDeleted();
  89
  90         /**
  91          * @param int $field One of LogPage::DELETED_* bitfield constants
  92          * @return bool
  93          */
  94         public function isDeleted( $field );
  95 }
  96
  97 /**
  98  * Extends the LogEntryInterface with some basic functionality
  99  * @since 1.19
 100  */
 101 abstract class LogEntryBase implements LogEntry {
 102         public function getFullType() {
 103                 return $this->getType() . '/' . $this->getSubtype();
 104         }
 105
 106         public function isDeleted( $field ) {
 107                 return ( $this->getDeleted() & $field ) === $field;
 108         }
 109
 110         /**
 111          * Whether the parameters for this log are stored in new or
 112          * old format.
 113          * @return bool
 114          */
 115         public function isLegacy() {
 116                 return false;
 117         }
 118 }
 119
 120 /**
 121  * This class wraps around database result row.
 122  * @since 1.19
 123  */
 124 class DatabaseLogEntry extends LogEntryBase {
 125         // Static->
 126
 127         /**
 128          * Returns array of information that is needed for querying
 129          * log entries. Array contains the following keys:
 130          * tables, fields, conds, options and join_conds
 131          * @return array
 132          */
 133         public static function getSelectQueryData() {
 134                 $tables = array( 'logging', 'user' );
 135                 $fields = array(
 136                         'log_id', 'log_type', 'log_action', 'log_timestamp',
 137                         'log_user', 'log_user_text',
 138                         'log_namespace', 'log_title', // unused log_page
 139                         'log_comment', 'log_params', 'log_deleted',
 140                         'user_id', 'user_name', 'user_editcount',
 141                 );
 142
 143                 $joins = array(
 144                         // IP's don't have an entry in user table
 145                         'user' => array( 'LEFT JOIN', 'log_user=user_id' ),
 146                 );
 147
 148                 return array(
 149                         'tables' => $tables,
 150                         'fields' => $fields,
 151                         'conds' => array(),
 152                         'options' => array(),
 153                         'join_conds' => $joins,
 154                 );
 155         }
 156
 157         /**
 158          * Constructs new LogEntry from database result row.
 159          * Supports rows from both logging and recentchanges table.
 160          * @param stdClass|array $row
 161          * @return DatabaseLogEntry
 162          */
 163         public static function newFromRow( $row ) {
 164                 $row = (object)$row;
 165                 if ( isset( $row->rc_logid ) ) {
 166                         return new RCDatabaseLogEntry( $row );
 167                 } else {
 168                         return new self( $row );
 169                 }
 170         }
 171
 172         // Non-static->
 173
 174         /** @var stdClass Database result row. */
 175         protected $row;
 176
 177         /** @var User */
 178         protected $performer;
 179
 180         /** @var bool Whether the parameters for this log entry are stored in new
 181          *    or old format.
 182          */
 183         protected $legacy;
 184
 185         protected function __construct( $row ) {
 186                 $this->row = $row;
 187         }
 188
 189         /**
 190          * Returns the unique database id.
 191          * @return int
 192          */
 193         public function getId() {
 194                 return (int)$this->row->log_id;
 195         }
 196
 197         /**
 198          * Returns whatever is stored in the database field.
 199          * @return string
 200          */
 201         protected function getRawParameters() {
 202                 return $this->row->log_params;
 203         }
 204
 205         // LogEntryBase->
 206
 207         public function isLegacy() {
 208                 // This does the check
 209                 $this->getParameters();
 210
 211                 return $this->legacy;
 212         }
 213
 214         // LogEntry->
 215
 216         public function getType() {
 217                 return $this->row->log_type;
 218         }
 219
 220         public function getSubtype() {
 221                 return $this->row->log_action;
 222         }
 223
 224         public function getParameters() {
 225                 if ( !isset( $this->params ) ) {
 226                         $blob = $this->getRawParameters();
 227                         wfSuppressWarnings();
 228                         $params = unserialize( $blob );
 229                         wfRestoreWarnings();
 230                         if ( $params !== false ) {
 231                                 $this->params = $params;
 232                                 $this->legacy = false;
 233                         } else {
 234                                 $this->params = $blob === '' ? array() : explode( "\n", $blob );
 235                                 $this->legacy = true;
 236                         }
 237                 }
 238
 239                 return $this->params;
 240         }
 241
 242         public function getPerformer() {
 243                 if ( !$this->performer ) {
 244                         $userId = (int)$this->row->log_user;
 245                         if ( $userId !== 0 ) { // logged-in users
 246                                 if ( isset( $this->row->user_name ) ) {
 247                                         $this->performer = User::newFromRow( $this->row );
 248                                 } else {
 249                                         $this->performer = User::newFromId( $userId );
 250                                 }
 251                         } else { // IP users
 252                                 $userText = $this->row->log_user_text;
 253                                 $this->performer = User::newFromName( $userText, false );
 254                         }
 255                 }
 256
 257                 return $this->performer;
 258         }
 259
 260         public function getTarget() {
 261                 $namespace = $this->row->log_namespace;
 262                 $page = $this->row->log_title;
 263                 $title = Title::makeTitle( $namespace, $page );
 264
 265                 return $title;
 266         }
 267
 268         public function getTimestamp() {
 269                 return wfTimestamp( TS_MW, $this->row->log_timestamp );
 270         }
 271
 272         public function getComment() {
 273                 return $this->row->log_comment;
 274         }
 275
 276         public function getDeleted() {
 277                 return $this->row->log_deleted;
 278         }
 279 }
 280
 281 class RCDatabaseLogEntry extends DatabaseLogEntry {
 282
 283         public function getId() {
 284                 return $this->row->rc_logid;
 285         }
 286
 287         protected function getRawParameters() {
 288                 return $this->row->rc_params;
 289         }
 290
 291         // LogEntry->
 292
 293         public function getType() {
 294                 return $this->row->rc_log_type;
 295         }
 296
 297         public function getSubtype() {
 298                 return $this->row->rc_log_action;
 299         }
 300
 301         public function getPerformer() {
 302                 if ( !$this->performer ) {
 303                         $userId = (int)$this->row->rc_user;
 304                         if ( $userId !== 0 ) {
 305                                 $this->performer = User::newFromId( $userId );
 306                         } else {
 307                                 $userText = $this->row->rc_user_text;
 308                                 // Might be an IP, don't validate the username
 309                                 $this->performer = User::newFromName( $userText, false );
 310                         }
 311                 }
 312
 313                 return $this->performer;
 314         }
 315
 316         public function getTarget() {
 317                 $namespace = $this->row->rc_namespace;
 318                 $page = $this->row->rc_title;
 319                 $title = Title::makeTitle( $namespace, $page );
 320
 321                 return $title;
 322         }
 323
 324         public function getTimestamp() {
 325                 return wfTimestamp( TS_MW, $this->row->rc_timestamp );
 326         }
 327
 328         public function getComment() {
 329                 return $this->row->rc_comment;
 330         }
 331
 332         public function getDeleted() {
 333                 return $this->row->rc_deleted;
 334         }
 335 }
 336
 337 /**
 338  * Class for creating log entries manually, for
 339  * example to inject them into the database.
 340  * @since 1.19
 341  */
 342 class ManualLogEntry extends LogEntryBase {
 343         /** @var string Type of log entry */
 344         protected $type;
 345
 346         /** @var string Sub type of log entry */
 347         protected $subtype;
 348
 349         /** @var array Parameters for log entry */
 350         protected $parameters = array();
 351
 352         /** @var array */
 353         protected $relations = array();
 354
 355         /** @var User Performer of the action for the log entry */
 356         protected $performer;
 357
 358         /** @var Title Target title for the log entry */
 359         protected $target;
 360
 361         /** @var string Timestamp of creation of the log entry */
 362         protected $timestamp;
 363
 364         /** @var string Comment for the log entry */
 365         protected $comment = '';
 366
 367         /** @var int Deletion state of the log entry */
 368         protected $deleted;
 369
 370         /** @var int ID of the log entry */
 371         protected $id;
 372
 373         /**
 374          * Constructor.
 375          *
 376          * @since 1.19
 377          *
 378          * @param string $type
 379          * @param string $subtype
 380          */
 381         public function __construct( $type, $subtype ) {
 382                 $this->type = $type;
 383                 $this->subtype = $subtype;
 384         }
 385
 386         /**
 387          * Set extra log parameters.
 388          *
 389          * You can pass params to the log action message by prefixing the keys with
 390          * a number and optional type, using colons to separate the fields. The
 391          * numbering should start with number 4, the first three parameters are
 392          * hardcoded for every message. Example:
 393          * $entry->setParameters(
 394          *   '4::color' => 'blue',
 395          *   '5:number:count' => 3000,
 396          *   'animal' => 'dog'
 397          * );
 398          *
 399          * @since 1.19
 400          *
 401          * @param array $parameters Associative array
 402          */
 403         public function setParameters( $parameters ) {
 404                 $this->parameters = $parameters;
 405         }
 406
 407         /**
 408          * Declare arbitrary tag/value relations to this log entry.
 409          * These can be used to filter log entries later on.
 410          *
 411          * @param array $relations Map of (tag => (list of values|value))
 412          * @since 1.22
 413          */
 414         public function setRelations( array $relations ) {
 415                 $this->relations = $relations;
 416         }
 417
 418         /**
 419          * Set the user that performed the action being logged.
 420          *
 421          * @since 1.19
 422          *
 423          * @param User $performer
 424          */
 425         public function setPerformer( User $performer ) {
 426                 $this->performer = $performer;
 427         }
 428
 429         /**
 430          * Set the title of the object changed.
 431          *
 432          * @since 1.19
 433          *
 434          * @param Title $target
 435          */
 436         public function setTarget( Title $target ) {
 437                 $this->target = $target;
 438         }
 439
 440         /**
 441          * Set the timestamp of when the logged action took place.
 442          *
 443          * @since 1.19
 444          *
 445          * @param string $timestamp
 446          */
 447         public function setTimestamp( $timestamp ) {
 448                 $this->timestamp = $timestamp;
 449         }
 450
 451         /**
 452          * Set a comment associated with the action being logged.
 453          *
 454          * @since 1.19
 455          *
 456          * @param string $comment
 457          */
 458         public function setComment( $comment ) {
 459                 $this->comment = $comment;
 460         }
 461
 462         /**
 463          * TODO: document
 464          *
 465          * @since 1.19
 466          *
 467          * @param int $deleted
 468          */
 469         public function setDeleted( $deleted ) {
 470                 $this->deleted = $deleted;
 471         }
 472
 473         /**
 474          * Inserts the entry into the logging table.
 475          * @param IDatabase $dbw
 476          * @return int ID of the log entry
 477          * @throws MWException
 478          */
 479         public function insert( IDatabase $dbw = null ) {
 480                 global $wgContLang;
 481
 482                 $dbw = $dbw ?: wfGetDB( DB_MASTER );
 483                 $id = $dbw->nextSequenceValue( 'logging_log_id_seq' );
 484
 485                 if ( $this->timestamp === null ) {
 486                         $this->timestamp = wfTimestampNow();
 487                 }
 488
 489                 # Trim spaces on user supplied text
 490                 $comment = trim( $this->getComment() );
 491
 492                 # Truncate for whole multibyte characters.
 493                 $comment = $wgContLang->truncate( $comment, 255 );
 494
 495                 $data = array(
 496                         'log_id' => $id,
 497                         'log_type' => $this->getType(),
 498                         'log_action' => $this->getSubtype(),
 499                         'log_timestamp' => $dbw->timestamp( $this->getTimestamp() ),
 500                         'log_user' => $this->getPerformer()->getId(),
 501                         'log_user_text' => $this->getPerformer()->getName(),
 502                         'log_namespace' => $this->getTarget()->getNamespace(),
 503                         'log_title' => $this->getTarget()->getDBkey(),
 504                         'log_page' => $this->getTarget()->getArticleID(),
 505                         'log_comment' => $comment,
 506                         'log_params' => serialize( (array)$this->getParameters() ),
 507                 );
 508                 if ( isset( $this->deleted ) ) {
 509                         $data['log_deleted'] = $this->deleted;
 510                 }
 511
 512                 $dbw->insert( 'logging', $data, __METHOD__ );
 513                 $this->id = !is_null( $id ) ? $id : $dbw->insertId();
 514
 515                 $rows = array();
 516                 foreach ( $this->relations as $tag => $values ) {
 517                         if ( !strlen( $tag ) ) {
 518                                 throw new MWException( "Got empty log search tag." );
 519                         }
 520
 521                         if ( !is_array( $values ) ) {
 522                                 $values = array( $values );
 523                         }
 524
 525                         foreach ( $values as $value ) {
 526                                 $rows[] = array(
 527                                         'ls_field' => $tag,
 528                                         'ls_value' => $value,
 529                                         'ls_log_id' => $this->id
 530                                 );
 531                         }
 532                 }
 533                 if ( count( $rows ) ) {
 534                         $dbw->insert( 'log_search', $rows, __METHOD__, 'IGNORE' );
 535                 }
 536
 537                 // Update any bloom filter cache
 538                 $member = $this->getTarget()->getNamespace() . ':' . $this->getTarget()->getDBkey();
 539                 BloomCache::get( 'main' )->insert( wfWikiId(), 'TitleHasLogs', $member );
 540
 541                 return $this->id;
 542         }
 543
 544         /**
 545          * Get a RecentChanges object for the log entry
 546          * @param int $newId
 547          * @return RecentChange
 548          * @since 1.23
 549          */
 550         public function getRecentChange( $newId = 0 ) {
 551                 $formatter = LogFormatter::newFromEntry( $this );
 552                 $context = RequestContext::newExtraneousContext( $this->getTarget() );
 553                 $formatter->setContext( $context );
 554
 555                 $logpage = SpecialPage::getTitleFor( 'Log', $this->getType() );
 556                 $user = $this->getPerformer();
 557                 $ip = "";
 558                 if ( $user->isAnon() ) {
 559                         /*
 560                          * "MediaWiki default" and friends may have
 561                          * no IP address in their name
 562                          */
 563                         if ( IP::isIPAddress( $user->getName() ) ) {
 564                                 $ip = $user->getName();
 565                         }
 566                 }
 567
 568                 return RecentChange::newLogEntry(
 569                         $this->getTimestamp(),
 570                         $logpage,
 571                         $user,
 572                         $formatter->getPlainActionText(),
 573                         $ip,
 574                         $this->getType(),
 575                         $this->getSubtype(),
 576                         $this->getTarget(),
 577                         $this->getComment(),
 578                         serialize( (array)$this->getParameters() ),
 579                         $newId,
 580                         $formatter->getIRCActionComment() // Used for IRC feeds
 581                 );
 582         }
 583
 584         /**
 585          * Publishes the log entry.
 586          * @param int $newId Id of the log entry.
 587          * @param string $to One of: rcandudp (default), rc, udp
 588          */
 589         public function publish( $newId, $to = 'rcandudp' ) {
 590                 $log = new LogPage( $this->getType() );
 591                 if ( $log->isRestricted() ) {
 592                         return;
 593                 }
 594
 595                 $rc = $this->getRecentChange( $newId );
 596
 597                 if ( $to === 'rc' || $to === 'rcandudp' ) {
 598                         $rc->save( 'pleasedontudp' );
 599                 }
 600
 601                 if ( $to === 'udp' || $to === 'rcandudp' ) {
 602                         $rc->notifyRCFeeds();
 603                 }
 604         }
 605
 606         // LogEntry->
 607
 608         public function getType() {
 609                 return $this->type;
 610         }
 611
 612         public function getSubtype() {
 613                 return $this->subtype;
 614         }
 615
 616         public function getParameters() {
 617                 return $this->parameters;
 618         }
 619
 620         /**
 621          * @return User
 622          */
 623         public function getPerformer() {
 624                 return $this->performer;
 625         }
 626
 627         /**
 628          * @return Title
 629          */
 630         public function getTarget() {
 631                 return $this->target;
 632         }
 633
 634         public function getTimestamp() {
 635                 $ts = $this->timestamp !== null ? $this->timestamp : wfTimestampNow();
 636
 637                 return wfTimestamp( TS_MW, $ts );
 638         }
 639
 640         public function getComment() {
 641                 return $this->comment;
 642         }
 643
 644         public function getDeleted() {
 645                 return (int)$this->deleted;
 646         }
 647 }