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  *
  34  * @since 1.19
  35  */
  36 interface LogEntry {
  37
  38         /**
  39          * The main log type.
  40          *
  41          * @return string
  42          */
  43         public function getType();
  44
  45         /**
  46          * The log subtype.
  47          *
  48          * @return string
  49          */
  50         public function getSubtype();
  51
  52         /**
  53          * The full logtype in format maintype/subtype.
  54          *
  55          * @return string
  56          */
  57         public function getFullType();
  58
  59         /**
  60          * Get the extra parameters stored for this message.
  61          *
  62          * @return array
  63          */
  64         public function getParameters();
  65
  66         /**
  67          * Get the user for performed this action.
  68          *
  69          * @return User
  70          */
  71         public function getPerformer();
  72
  73         /**
  74          * Get the target page of this action.
  75          *
  76          * @return Title
  77          */
  78         public function getTarget();
  79
  80         /**
  81          * Get the timestamp when the action was executed.
  82          *
  83          * @return string
  84          */
  85         public function getTimestamp();
  86
  87         /**
  88          * Get the user provided comment.
  89          *
  90          * @return string
  91          */
  92         public function getComment();
  93
  94         /**
  95          * Get the access restriction.
  96          *
  97          * @return string
  98          */
  99         public function getDeleted();
 100
 101         /**
 102          * @param int $field One of LogPage::DELETED_* bitfield constants
 103          * @return bool
 104          */
 105         public function isDeleted( $field );
 106 }
 107
 108 /**
 109  * Extends the LogEntryInterface with some basic functionality
 110  *
 111  * @since 1.19
 112  */
 113 abstract class LogEntryBase implements LogEntry {
 114
 115         public function getFullType() {
 116                 return $this->getType() . '/' . $this->getSubtype();
 117         }
 118
 119         public function isDeleted( $field ) {
 120                 return ( $this->getDeleted() & $field ) === $field;
 121         }
 122
 123         /**
 124          * Whether the parameters for this log are stored in new or
 125          * old format.
 126          *
 127          * @return bool
 128          */
 129         public function isLegacy() {
 130                 return false;
 131         }
 132
 133         /**
 134          * Create a blob from a parameter array
 135          *
 136          * @since 1.26
 137          * @param array $params
 138          * @return string
 139          */
 140         public static function makeParamBlob( $params ) {
 141                 return serialize( (array)$params );
 142         }
 143
 144         /**
 145          * Extract a parameter array from a blob
 146          *
 147          * @since 1.26
 148          * @param string $blob
 149          * @return array
 150          */
 151         public static function extractParams( $blob ) {
 152                 return unserialize( $blob );
 153         }
 154 }
 155
 156 /**
 157  * This class wraps around database result row.
 158  *
 159  * @since 1.19
 160  */
 161 class DatabaseLogEntry extends LogEntryBase {
 162
 163         /**
 164          * Returns array of information that is needed for querying
 165          * log entries. Array contains the following keys:
 166          * tables, fields, conds, options and join_conds
 167          *
 168          * @return array
 169          */
 170         public static function getSelectQueryData() {
 171                 $tables = array( 'logging', 'user' );
 172                 $fields = array(
 173                         'log_id', 'log_type', 'log_action', 'log_timestamp',
 174                         'log_user', 'log_user_text',
 175                         'log_namespace', 'log_title', // unused log_page
 176                         'log_comment', 'log_params', 'log_deleted',
 177                         'user_id', 'user_name', 'user_editcount',
 178                 );
 179
 180                 $joins = array(
 181                         // IPs don't have an entry in user table
 182                         'user' => array( 'LEFT JOIN', 'log_user=user_id' ),
 183                 );
 184
 185                 return array(
 186                         'tables' => $tables,
 187                         'fields' => $fields,
 188                         'conds' => array(),
 189                         'options' => array(),
 190                         'join_conds' => $joins,
 191                 );
 192         }
 193
 194         /**
 195          * Constructs new LogEntry from database result row.
 196          * Supports rows from both logging and recentchanges table.
 197          *
 198          * @param stdClass|array $row
 199          * @return DatabaseLogEntry
 200          */
 201         public static function newFromRow( $row ) {
 202                 $row = (object)$row;
 203                 if ( isset( $row->rc_logid ) ) {
 204                         return new RCDatabaseLogEntry( $row );
 205                 } else {
 206                         return new self( $row );
 207                 }
 208         }
 209
 210         /** @var stdClass Database result row. */
 211         protected $row;
 212
 213         /** @var User */
 214         protected $performer;
 215
 216         /** @var array Parameters for log entry */
 217         protected $params;
 218
 219         /** @var int A rev id associated to the log entry */
 220         protected $revId = null;
 221
 222         /** @var bool Whether the parameters for this log entry are stored in new or old format. */
 223         protected $legacy;
 224
 225         protected function __construct( $row ) {
 226                 $this->row = $row;
 227         }
 228
 229         /**
 230          * Returns the unique database id.
 231          *
 232          * @return int
 233          */
 234         public function getId() {
 235                 return (int)$this->row->log_id;
 236         }
 237
 238         /**
 239          * Returns whatever is stored in the database field.
 240          *
 241          * @return string
 242          */
 243         protected function getRawParameters() {
 244                 return $this->row->log_params;
 245         }
 246
 247         public function isLegacy() {
 248                 // This extracts the property
 249                 $this->getParameters();
 250                 return $this->legacy;
 251         }
 252
 253         public function getType() {
 254                 return $this->row->log_type;
 255         }
 256
 257         public function getSubtype() {
 258                 return $this->row->log_action;
 259         }
 260
 261         public function getParameters() {
 262                 if ( !isset( $this->params ) ) {
 263                         $blob = $this->getRawParameters();
 264                         MediaWiki\suppressWarnings();
 265                         $params = LogEntryBase::extractParams( $blob );
 266                         MediaWiki\restoreWarnings();
 267                         if ( $params !== false ) {
 268                                 $this->params = $params;
 269                                 $this->legacy = false;
 270                         } else {
 271                                 $this->params = LogPage::extractParams( $blob );
 272                                 $this->legacy = true;
 273                         }
 274
 275                         if ( isset( $this->params['associated_rev_id'] ) ) {
 276                                 $this->revId = $this->params['associated_rev_id'];
 277                                 unset( $this->params['associated_rev_id'] );
 278                         }
 279                 }
 280
 281                 return $this->params;
 282         }
 283
 284         public function getAssociatedRevId() {
 285                 // This extracts the property
 286                 $this->getParameters();
 287                 return $this->revId;
 288         }
 289
 290         public function getPerformer() {
 291                 if ( !$this->performer ) {
 292                         $userId = (int)$this->row->log_user;
 293                         if ( $userId !== 0 ) {
 294                                 // logged-in users
 295                                 if ( isset( $this->row->user_name ) ) {
 296                                         $this->performer = User::newFromRow( $this->row );
 297                                 } else {
 298                                         $this->performer = User::newFromId( $userId );
 299                                 }
 300                         } else {
 301                                 // IP users
 302                                 $userText = $this->row->log_user_text;
 303                                 $this->performer = User::newFromName( $userText, false );
 304                         }
 305                 }
 306
 307                 return $this->performer;
 308         }
 309
 310         public function getTarget() {
 311                 $namespace = $this->row->log_namespace;
 312                 $page = $this->row->log_title;
 313                 $title = Title::makeTitle( $namespace, $page );
 314
 315                 return $title;
 316         }
 317
 318         public function getTimestamp() {
 319                 return wfTimestamp( TS_MW, $this->row->log_timestamp );
 320         }
 321
 322         public function getComment() {
 323                 return $this->row->log_comment;
 324         }
 325
 326         public function getDeleted() {
 327                 return $this->row->log_deleted;
 328         }
 329 }
 330
 331 class RCDatabaseLogEntry extends DatabaseLogEntry {
 332
 333         public function getId() {
 334                 return $this->row->rc_logid;
 335         }
 336
 337         protected function getRawParameters() {
 338                 return $this->row->rc_params;
 339         }
 340
 341         public function getAssociatedRevId() {
 342                 return $this->row->rc_this_oldid;
 343         }
 344
 345         public function getType() {
 346                 return $this->row->rc_log_type;
 347         }
 348
 349         public function getSubtype() {
 350                 return $this->row->rc_log_action;
 351         }
 352
 353         public function getPerformer() {
 354                 if ( !$this->performer ) {
 355                         $userId = (int)$this->row->rc_user;
 356                         if ( $userId !== 0 ) {
 357                                 $this->performer = User::newFromId( $userId );
 358                         } else {
 359                                 $userText = $this->row->rc_user_text;
 360                                 // Might be an IP, don't validate the username
 361                                 $this->performer = User::newFromName( $userText, false );
 362                         }
 363                 }
 364
 365                 return $this->performer;
 366         }
 367
 368         public function getTarget() {
 369                 $namespace = $this->row->rc_namespace;
 370                 $page = $this->row->rc_title;
 371                 $title = Title::makeTitle( $namespace, $page );
 372
 373                 return $title;
 374         }
 375
 376         public function getTimestamp() {
 377                 return wfTimestamp( TS_MW, $this->row->rc_timestamp );
 378         }
 379
 380         public function getComment() {
 381                 return $this->row->rc_comment;
 382         }
 383
 384         public function getDeleted() {
 385                 return $this->row->rc_deleted;
 386         }
 387 }
 388
 389 /**
 390  * Class for creating log entries manually, to inject them into the database.
 391  *
 392  * @since 1.19
 393  */
 394 class ManualLogEntry extends LogEntryBase {
 395         /** @var string Type of log entry */
 396         protected $type;
 397
 398         /** @var string Sub type of log entry */
 399         protected $subtype;
 400
 401         /** @var array Parameters for log entry */
 402         protected $parameters = array();
 403
 404         /** @var array */
 405         protected $relations = array();
 406
 407         /** @var User Performer of the action for the log entry */
 408         protected $performer;
 409
 410         /** @var Title Target title for the log entry */
 411         protected $target;
 412
 413         /** @var string Timestamp of creation of the log entry */
 414         protected $timestamp;
 415
 416         /** @var string Comment for the log entry */
 417         protected $comment = '';
 418
 419         /** @var int A rev id associated to the log entry */
 420         protected $revId = 0;
 421
 422         /** @var int Deletion state of the log entry */
 423         protected $deleted;
 424
 425         /** @var int ID of the log entry */
 426         protected $id;
 427
 428         /** @var bool Whether this is a legacy log entry */
 429         protected $legacy = false;
 430
 431         /**
 432          * Constructor.
 433          *
 434          * @since 1.19
 435          * @param string $type
 436          * @param string $subtype
 437          */
 438         public function __construct( $type, $subtype ) {
 439                 $this->type = $type;
 440                 $this->subtype = $subtype;
 441         }
 442
 443         /**
 444          * Set extra log parameters.
 445          *
 446          * You can pass params to the log action message by prefixing the keys with
 447          * a number and optional type, using colons to separate the fields. The
 448          * numbering should start with number 4, the first three parameters are
 449          * hardcoded for every message.
 450          *
 451          * If you want to store stuff that should not be available in messages, don't
 452          * prefix the array key with a number and don't use the colons.
 453          *
 454          * Example:
 455          *   $entry->setParameters(
 456          *     '4::color' => 'blue',
 457          *     '5:number:count' => 3000,
 458          *     'animal' => 'dog'
 459          *   );
 460          *
 461          * @since 1.19
 462          * @param array $parameters Associative array
 463          */
 464         public function setParameters( $parameters ) {
 465                 $this->parameters = $parameters;
 466         }
 467
 468         /**
 469          * Declare arbitrary tag/value relations to this log entry.
 470          * These can be used to filter log entries later on.
 471          *
 472          * @param array $relations Map of (tag => (list of values|value))
 473          * @since 1.22
 474          */
 475         public function setRelations( array $relations ) {
 476                 $this->relations = $relations;
 477         }
 478
 479         /**
 480          * Set the user that performed the action being logged.
 481          *
 482          * @since 1.19
 483          * @param User $performer
 484          */
 485         public function setPerformer( User $performer ) {
 486                 $this->performer = $performer;
 487         }
 488
 489         /**
 490          * Set the title of the object changed.
 491          *
 492          * @since 1.19
 493          * @param Title $target
 494          */
 495         public function setTarget( Title $target ) {
 496                 $this->target = $target;
 497         }
 498
 499         /**
 500          * Set the timestamp of when the logged action took place.
 501          *
 502          * @since 1.19
 503          * @param string $timestamp
 504          */
 505         public function setTimestamp( $timestamp ) {
 506                 $this->timestamp = $timestamp;
 507         }
 508
 509         /**
 510          * Set a comment associated with the action being logged.
 511          *
 512          * @since 1.19
 513          * @param string $comment
 514          */
 515         public function setComment( $comment ) {
 516                 $this->comment = $comment;
 517         }
 518
 519         /**
 520          * Set an associated revision id.
 521          *
 522          * For example, the ID of the revision that was inserted to mark a page move
 523          * or protection, file upload, etc.
 524          *
 525          * @since 1.27
 526          * @param int $revId
 527          */
 528         public function setAssociatedRevId( $revId ) {
 529                 $this->revId = $revId;
 530         }
 531
 532         /**
 533          * Set the 'legacy' flag
 534          *
 535          * @since 1.25
 536          * @param bool $legacy
 537          */
 538         public function setLegacy( $legacy ) {
 539                 $this->legacy = $legacy;
 540         }
 541
 542         /**
 543          * Set the 'deleted' flag.
 544          *
 545          * @since 1.19
 546          * @param int $deleted One of LogPage::DELETED_* bitfield constants
 547          */
 548         public function setDeleted( $deleted ) {
 549                 $this->deleted = $deleted;
 550         }
 551
 552         /**
 553          * Insert the entry into the `logging` table.
 554          *
 555          * @param IDatabase $dbw
 556          * @return int ID of the log entry
 557          * @throws MWException
 558          */
 559         public function insert( IDatabase $dbw = null ) {
 560                 global $wgContLang;
 561
 562                 $dbw = $dbw ?: wfGetDB( DB_MASTER );
 563                 $id = $dbw->nextSequenceValue( 'logging_log_id_seq' );
 564
 565                 if ( $this->timestamp === null ) {
 566                         $this->timestamp = wfTimestampNow();
 567                 }
 568
 569                 // Trim spaces on user supplied text
 570                 $comment = trim( $this->getComment() );
 571
 572                 // Truncate for whole multibyte characters.
 573                 $comment = $wgContLang->truncate( $comment, 255 );
 574
 575                 $params = $this->getParameters();
 576                 $relations = $this->relations;
 577
 578                 // Additional fields for which there's no space in the database table schema
 579                 $revId = $this->getAssociatedRevId();
 580                 if ( $revId ) {
 581                         $params['associated_rev_id'] = $revId;
 582                         $relations['associated_rev_id'] = $revId;
 583                 }
 584
 585                 $data = array(
 586                         'log_id' => $id,
 587                         'log_type' => $this->getType(),
 588                         'log_action' => $this->getSubtype(),
 589                         'log_timestamp' => $dbw->timestamp( $this->getTimestamp() ),
 590                         'log_user' => $this->getPerformer()->getId(),
 591                         'log_user_text' => $this->getPerformer()->getName(),
 592                         'log_namespace' => $this->getTarget()->getNamespace(),
 593                         'log_title' => $this->getTarget()->getDBkey(),
 594                         'log_page' => $this->getTarget()->getArticleID(),
 595                         'log_comment' => $comment,
 596                         'log_params' => LogEntryBase::makeParamBlob( $params ),
 597                 );
 598                 if ( isset( $this->deleted ) ) {
 599                         $data['log_deleted'] = $this->deleted;
 600                 }
 601
 602                 $dbw->insert( 'logging', $data, __METHOD__ );
 603                 $this->id = !is_null( $id ) ? $id : $dbw->insertId();
 604
 605                 $rows = array();
 606                 foreach ( $relations as $tag => $values ) {
 607                         if ( !strlen( $tag ) ) {
 608                                 throw new MWException( "Got empty log search tag." );
 609                         }
 610
 611                         if ( !is_array( $values ) ) {
 612                                 $values = array( $values );
 613                         }
 614
 615                         foreach ( $values as $value ) {
 616                                 $rows[] = array(
 617                                         'ls_field' => $tag,
 618                                         'ls_value' => $value,
 619                                         'ls_log_id' => $this->id
 620                                 );
 621                         }
 622                 }
 623                 if ( count( $rows ) ) {
 624                         $dbw->insert( 'log_search', $rows, __METHOD__, 'IGNORE' );
 625                 }
 626
 627                 return $this->id;
 628         }
 629
 630         /**
 631          * Get a RecentChanges object for the log entry
 632          *
 633          * @param int $newId
 634          * @return RecentChange
 635          * @since 1.23
 636          */
 637         public function getRecentChange( $newId = 0 ) {
 638                 $formatter = LogFormatter::newFromEntry( $this );
 639                 $context = RequestContext::newExtraneousContext( $this->getTarget() );
 640                 $formatter->setContext( $context );
 641
 642                 $logpage = SpecialPage::getTitleFor( 'Log', $this->getType() );
 643                 $user = $this->getPerformer();
 644                 $ip = "";
 645                 if ( $user->isAnon() ) {
 646                         // "MediaWiki default" and friends may have
 647                         // no IP address in their name
 648                         if ( IP::isIPAddress( $user->getName() ) ) {
 649                                 $ip = $user->getName();
 650                         }
 651                 }
 652
 653                 return RecentChange::newLogEntry(
 654                         $this->getTimestamp(),
 655                         $logpage,
 656                         $user,
 657                         $formatter->getPlainActionText(),
 658                         $ip,
 659                         $this->getType(),
 660                         $this->getSubtype(),
 661                         $this->getTarget(),
 662                         $this->getComment(),
 663                         LogEntryBase::makeParamBlob( $this->getParameters() ),
 664                         $newId,
 665                         $formatter->getIRCActionComment(), // Used for IRC feeds
 666                         $this->getAssociatedRevId() // Used for e.g. moves and uploads
 667                 );
 668         }
 669
 670         /**
 671          * Publish the log entry.
 672          *
 673          * @param int $newId Id of the log entry.
 674          * @param string $to One of: rcandudp (default), rc, udp
 675          * @return RecentChange|null
 676          */
 677         public function publish( $newId, $to = 'rcandudp' ) {
 678                 $log = new LogPage( $this->getType() );
 679                 if ( $log->isRestricted() ) {
 680                         return null;
 681                 }
 682
 683                 $rc = $this->getRecentChange( $newId );
 684
 685                 if ( $to === 'rc' || $to === 'rcandudp' ) {
 686                         $rc->save( 'pleasedontudp' );
 687                 }
 688
 689                 if ( $to === 'udp' || $to === 'rcandudp' ) {
 690                         $rc->notifyRCFeeds();
 691                 }
 692
 693                 // Log the autopatrol if an associated rev id was passed
 694                 if ( $this->getAssociatedRevId() > 0 &&
 695                         $rc->getAttribute( 'rc_patrolled' ) === 1 ) {
 696                         PatrolLog::record( $rc, true, $this->getPerformer() );
 697                 }
 698
 699                 return $rc;
 700         }
 701
 702         public function getType() {
 703                 return $this->type;
 704         }
 705
 706         public function getSubtype() {
 707                 return $this->subtype;
 708         }
 709
 710         public function getParameters() {
 711                 return $this->parameters;
 712         }
 713
 714         /**
 715          * @return User
 716          */
 717         public function getPerformer() {
 718                 return $this->performer;
 719         }
 720
 721         /**
 722          * @return Title
 723          */
 724         public function getTarget() {
 725                 return $this->target;
 726         }
 727
 728         public function getTimestamp() {
 729                 $ts = $this->timestamp !== null ? $this->timestamp : wfTimestampNow();
 730
 731                 return wfTimestamp( TS_MW, $ts );
 732         }
 733
 734         public function getComment() {
 735                 return $this->comment;
 736         }
 737
 738         /**
 739          * @since 1.27
 740          * @return int
 741          */
 742         public function getAssociatedRevId() {
 743                 return $this->revId;
 744         }
 745
 746         /**
 747          * @since 1.25
 748          * @return bool
 749          */
 750         public function isLegacy() {
 751                 return $this->legacy;
 752         }
 753
 754         public function getDeleted() {
 755                 return (int)$this->deleted;
 756         }
 757 }