includes/logging/ManualLogEntry.php

   1 <?php
   2 /**
   3  * Contains a class for dealing with manual log entries
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @author Niklas Laxström
  22  * @license GPL-2.0-or-later
  23  * @since 1.19
  24  */
  25
  26 use MediaWiki\ChangeTags\Taggable;
  27 use MediaWiki\Linker\LinkTarget;
  28 use MediaWiki\User\UserIdentity;
  29 use Wikimedia\Rdbms\IDatabase;
  30 use Wikimedia\Assert\Assert;
  31
  32 /**
  33  * Class for creating new log entries and inserting them into the database.
  34  *
  35  * @since 1.19
  36  */
  37 class ManualLogEntry extends LogEntryBase implements Taggable {
  38         /** @var string Type of log entry */
  39         protected $type;
  40
  41         /** @var string Sub type of log entry */
  42         protected $subtype;
  43
  44         /** @var array Parameters for log entry */
  45         protected $parameters = [];
  46
  47         /** @var array */
  48         protected $relations = [];
  49
  50         /** @var User Performer of the action for the log entry */
  51         protected $performer;
  52
  53         /** @var Title Target title for the log entry */
  54         protected $target;
  55
  56         /** @var string Timestamp of creation of the log entry */
  57         protected $timestamp;
  58
  59         /** @var string Comment for the log entry */
  60         protected $comment = '';
  61
  62         /** @var int A rev id associated to the log entry */
  63         protected $revId = 0;
  64
  65         /** @var string[] Change tags add to the log entry */
  66         protected $tags = [];
  67
  68         /** @var int Deletion state of the log entry */
  69         protected $deleted;
  70
  71         /** @var int ID of the log entry */
  72         protected $id;
  73
  74         /** @var bool Can this log entry be patrolled? */
  75         protected $isPatrollable = false;
  76
  77         /** @var bool Whether this is a legacy log entry */
  78         protected $legacy = false;
  79
  80         /**
  81          * @since 1.19
  82          * @param string $type
  83          * @param string $subtype
  84          */
  85         public function __construct( $type, $subtype ) {
  86                 $this->type = $type;
  87                 $this->subtype = $subtype;
  88         }
  89
  90         /**
  91          * Set extra log parameters.
  92          *
  93          * You can pass params to the log action message by prefixing the keys with
  94          * a number and optional type, using colons to separate the fields. The
  95          * numbering should start with number 4, the first three parameters are
  96          * hardcoded for every message.
  97          *
  98          * If you want to store stuff that should not be available in messages, don't
  99          * prefix the array key with a number and don't use the colons.
 100          *
 101          * Example:
 102          *   $entry->setParameters(
 103          *     '4::color' => 'blue',
 104          *     '5:number:count' => 3000,
 105          *     'animal' => 'dog'
 106          *   );
 107          *
 108          * @since 1.19
 109          * @param array $parameters Associative array
 110          */
 111         public function setParameters( $parameters ) {
 112                 $this->parameters = $parameters;
 113         }
 114
 115         /**
 116          * Declare arbitrary tag/value relations to this log entry.
 117          * These can be used to filter log entries later on.
 118          *
 119          * @param array $relations Map of (tag => (list of values|value))
 120          * @since 1.22
 121          */
 122         public function setRelations( array $relations ) {
 123                 $this->relations = $relations;
 124         }
 125
 126         /**
 127          * Set the user that performed the action being logged.
 128          *
 129          * @since 1.19
 130          * @param UserIdentity $performer
 131          */
 132         public function setPerformer( UserIdentity $performer ) {
 133                 $this->performer = User::newFromIdentity( $performer );
 134         }
 135
 136         /**
 137          * Set the title of the object changed.
 138          *
 139          * @since 1.19
 140          * @param LinkTarget $target
 141          */
 142         public function setTarget( LinkTarget $target ) {
 143                 $this->target = Title::newFromLinkTarget( $target );
 144         }
 145
 146         /**
 147          * Set the timestamp of when the logged action took place.
 148          *
 149          * @since 1.19
 150          * @param string $timestamp
 151          */
 152         public function setTimestamp( $timestamp ) {
 153                 $this->timestamp = $timestamp;
 154         }
 155
 156         /**
 157          * Set a comment associated with the action being logged.
 158          *
 159          * @since 1.19
 160          * @param string $comment
 161          */
 162         public function setComment( $comment ) {
 163                 $this->comment = $comment;
 164         }
 165
 166         /**
 167          * Set an associated revision id.
 168          *
 169          * For example, the ID of the revision that was inserted to mark a page move
 170          * or protection, file upload, etc.
 171          *
 172          * @since 1.27
 173          * @param int $revId
 174          */
 175         public function setAssociatedRevId( $revId ) {
 176                 $this->revId = $revId;
 177         }
 178
 179         /**
 180          * Set change tags for the log entry.
 181          *
 182          * Passing `null` means the same as empty array,
 183          * for compatibility with WikiPage::doUpdateRestrictions().
 184          *
 185          * @since 1.27
 186          * @param string|string[]|null $tags
 187          * @deprecated since 1.33 Please use addTags() instead
 188          */
 189         public function setTags( $tags ) {
 190                 if ( $this->tags ) {
 191                         wfDebug( 'Overwriting existing ManualLogEntry tags' );
 192                 }
 193                 $this->tags = [];
 194                 $this->addTags( $tags );
 195         }
 196
 197         /**
 198          * Add change tags for the log entry
 199          *
 200          * @since 1.33
 201          * @param string|string[]|null $tags Tags to apply
 202          */
 203         public function addTags( $tags ) {
 204                 if ( $tags === null ) {
 205                         return;
 206                 }
 207
 208                 if ( is_string( $tags ) ) {
 209                         $tags = [ $tags ];
 210                 }
 211                 Assert::parameterElementType( 'string', $tags, 'tags' );
 212                 $this->tags = array_unique( array_merge( $this->tags, $tags ) );
 213         }
 214
 215         /**
 216          * Set whether this log entry should be made patrollable
 217          * This shouldn't depend on config, only on whether there is full support
 218          * in the software for patrolling this log entry.
 219          * False by default
 220          *
 221          * @since 1.27
 222          * @param bool $patrollable
 223          */
 224         public function setIsPatrollable( $patrollable ) {
 225                 $this->isPatrollable = (bool)$patrollable;
 226         }
 227
 228         /**
 229          * Set the 'legacy' flag
 230          *
 231          * @since 1.25
 232          * @param bool $legacy
 233          */
 234         public function setLegacy( $legacy ) {
 235                 $this->legacy = $legacy;
 236         }
 237
 238         /**
 239          * Set the 'deleted' flag.
 240          *
 241          * @since 1.19
 242          * @param int $deleted One of LogPage::DELETED_* bitfield constants
 243          */
 244         public function setDeleted( $deleted ) {
 245                 $this->deleted = $deleted;
 246         }
 247
 248         /**
 249          * Insert the entry into the `logging` table.
 250          *
 251          * @param IDatabase|null $dbw
 252          * @return int ID of the log entry
 253          * @throws MWException
 254          */
 255         public function insert( IDatabase $dbw = null ) {
 256                 $dbw = $dbw ?: wfGetDB( DB_MASTER );
 257
 258                 if ( $this->timestamp === null ) {
 259                         $this->timestamp = wfTimestampNow();
 260                 }
 261
 262                 // Trim spaces on user supplied text
 263                 $comment = trim( $this->getComment() );
 264
 265                 $params = $this->getParameters();
 266                 $relations = $this->relations;
 267
 268                 // Additional fields for which there's no space in the database table schema
 269                 $revId = $this->getAssociatedRevId();
 270                 if ( $revId ) {
 271                         $params['associated_rev_id'] = $revId;
 272                         $relations['associated_rev_id'] = $revId;
 273                 }
 274
 275                 $data = [
 276                         'log_type' => $this->getType(),
 277                         'log_action' => $this->getSubtype(),
 278                         'log_timestamp' => $dbw->timestamp( $this->getTimestamp() ),
 279                         'log_namespace' => $this->getTarget()->getNamespace(),
 280                         'log_title' => $this->getTarget()->getDBkey(),
 281                         'log_page' => $this->getTarget()->getArticleID(),
 282                         'log_params' => LogEntryBase::makeParamBlob( $params ),
 283                 ];
 284                 if ( isset( $this->deleted ) ) {
 285                         $data['log_deleted'] = $this->deleted;
 286                 }
 287                 $data += CommentStore::getStore()->insert( $dbw, 'log_comment', $comment );
 288                 $data += ActorMigration::newMigration()
 289                         ->getInsertValues( $dbw, 'log_user', $this->getPerformer() );
 290
 291                 $dbw->insert( 'logging', $data, __METHOD__ );
 292                 $this->id = $dbw->insertId();
 293
 294                 $rows = [];
 295                 foreach ( $relations as $tag => $values ) {
 296                         if ( !strlen( $tag ) ) {
 297                                 throw new MWException( "Got empty log search tag." );
 298                         }
 299
 300                         if ( !is_array( $values ) ) {
 301                                 $values = [ $values ];
 302                         }
 303
 304                         foreach ( $values as $value ) {
 305                                 $rows[] = [
 306                                         'ls_field' => $tag,
 307                                         'ls_value' => $value,
 308                                         'ls_log_id' => $this->id
 309                                 ];
 310                         }
 311                 }
 312                 if ( count( $rows ) ) {
 313                         $dbw->insert( 'log_search', $rows, __METHOD__, [ 'IGNORE' ] );
 314                 }
 315
 316                 return $this->id;
 317         }
 318
 319         /**
 320          * Get a RecentChanges object for the log entry
 321          *
 322          * @param int $newId
 323          * @return RecentChange
 324          * @since 1.23
 325          */
 326         public function getRecentChange( $newId = 0 ) {
 327                 $formatter = LogFormatter::newFromEntry( $this );
 328                 $context = RequestContext::newExtraneousContext( $this->getTarget() );
 329                 $formatter->setContext( $context );
 330
 331                 $logpage = SpecialPage::getTitleFor( 'Log', $this->getType() );
 332                 $user = $this->getPerformer();
 333                 $ip = "";
 334                 if ( $user->isAnon() ) {
 335                         // "MediaWiki default" and friends may have
 336                         // no IP address in their name
 337                         if ( IP::isIPAddress( $user->getName() ) ) {
 338                                 $ip = $user->getName();
 339                         }
 340                 }
 341
 342                 return RecentChange::newLogEntry(
 343                         $this->getTimestamp(),
 344                         $logpage,
 345                         $user,
 346                         $formatter->getPlainActionText(),
 347                         $ip,
 348                         $this->getType(),
 349                         $this->getSubtype(),
 350                         $this->getTarget(),
 351                         $this->getComment(),
 352                         LogEntryBase::makeParamBlob( $this->getParameters() ),
 353                         $newId,
 354                         $formatter->getIRCActionComment(), // Used for IRC feeds
 355                         $this->getAssociatedRevId(), // Used for e.g. moves and uploads
 356                         $this->getIsPatrollable()
 357                 );
 358         }
 359
 360         /**
 361          * Publish the log entry.
 362          *
 363          * @param int $newId Id of the log entry.
 364          * @param string $to One of: rcandudp (default), rc, udp
 365          */
 366         public function publish( $newId, $to = 'rcandudp' ) {
 367                 $canAddTags = true;
 368                 // FIXME: this code should be removed once all callers properly call publish()
 369                 if ( $to === 'udp' && !$newId && !$this->getAssociatedRevId() ) {
 370                         \MediaWiki\Logger\LoggerFactory::getInstance( 'logging' )->warning(
 371                                 'newId and/or revId must be set when calling ManualLogEntry::publish()',
 372                                 [
 373                                         'newId' => $newId,
 374                                         'to' => $to,
 375                                         'revId' => $this->getAssociatedRevId(),
 376                                         // pass a new exception to register the stack trace
 377                                         'exception' => new RuntimeException()
 378                                 ]
 379                         );
 380                         $canAddTags = false;
 381                 }
 382
 383                 DeferredUpdates::addCallableUpdate(
 384                         function () use ( $newId, $to, $canAddTags ) {
 385                                 $log = new LogPage( $this->getType() );
 386                                 if ( !$log->isRestricted() ) {
 387                                         Hooks::runWithoutAbort( 'ManualLogEntryBeforePublish', [ $this ] );
 388                                         $rc = $this->getRecentChange( $newId );
 389
 390                                         if ( $to === 'rc' || $to === 'rcandudp' ) {
 391                                                 // save RC, passing tags so they are applied there
 392                                                 $rc->addTags( $this->getTags() );
 393                                                 $rc->save( $rc::SEND_NONE );
 394                                         } else {
 395                                                 $tags = $this->getTags();
 396                                                 if ( $tags && $canAddTags ) {
 397                                                         $revId = $this->getAssociatedRevId();
 398                                                         ChangeTags::addTags(
 399                                                                 $tags,
 400                                                                 null,
 401                                                                 $revId > 0 ? $revId : null,
 402                                                                 $newId > 0 ? $newId : null
 403                                                         );
 404                                                 }
 405                                         }
 406
 407                                         if ( $to === 'udp' || $to === 'rcandudp' ) {
 408                                                 $rc->notifyRCFeeds();
 409                                         }
 410                                 }
 411                         },
 412                         DeferredUpdates::POSTSEND,
 413                         wfGetDB( DB_MASTER )
 414                 );
 415         }
 416
 417         public function getType() {
 418                 return $this->type;
 419         }
 420
 421         public function getSubtype() {
 422                 return $this->subtype;
 423         }
 424
 425         public function getParameters() {
 426                 return $this->parameters;
 427         }
 428
 429         /**
 430          * @return User
 431          */
 432         public function getPerformer() {
 433                 return $this->performer;
 434         }
 435
 436         /**
 437          * @return Title
 438          */
 439         public function getTarget() {
 440                 return $this->target;
 441         }
 442
 443         public function getTimestamp() {
 444                 $ts = $this->timestamp ?? wfTimestampNow();
 445
 446                 return wfTimestamp( TS_MW, $ts );
 447         }
 448
 449         public function getComment() {
 450                 return $this->comment;
 451         }
 452
 453         /**
 454          * @since 1.27
 455          * @return int
 456          */
 457         public function getAssociatedRevId() {
 458                 return $this->revId;
 459         }
 460
 461         /**
 462          * @since 1.27
 463          * @return string[]
 464          */
 465         public function getTags() {
 466                 return $this->tags;
 467         }
 468
 469         /**
 470          * Whether this log entry is patrollable
 471          *
 472          * @since 1.27
 473          * @return bool
 474          */
 475         public function getIsPatrollable() {
 476                 return $this->isPatrollable;
 477         }
 478
 479         /**
 480          * @since 1.25
 481          * @return bool
 482          */
 483         public function isLegacy() {
 484                 return $this->legacy;
 485         }
 486
 487         public function getDeleted() {
 488                 return (int)$this->deleted;
 489         }
 490 }