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                 global $wgActorTableSchemaMigrationStage;
 257
 258                 $dbw = $dbw ?: wfGetDB( DB_MASTER );
 259
 260                 if ( $this->timestamp === null ) {
 261                         $this->timestamp = wfTimestampNow();
 262                 }
 263
 264                 // Trim spaces on user supplied text
 265                 $comment = trim( $this->getComment() );
 266
 267                 $params = $this->getParameters();
 268                 $relations = $this->relations;
 269
 270                 // Ensure actor relations are set
 271                 if ( ( $wgActorTableSchemaMigrationStage & SCHEMA_COMPAT_WRITE_NEW ) &&
 272                         empty( $relations['target_author_actor'] )
 273                 ) {
 274                         $actorIds = [];
 275                         if ( !empty( $relations['target_author_id'] ) ) {
 276                                 foreach ( $relations['target_author_id'] as $id ) {
 277                                         $actorIds[] = User::newFromId( $id )->getActorId( $dbw );
 278                                 }
 279                         }
 280                         if ( !empty( $relations['target_author_ip'] ) ) {
 281                                 foreach ( $relations['target_author_ip'] as $ip ) {
 282                                         $actorIds[] = User::newFromName( $ip, false )->getActorId( $dbw );
 283                                 }
 284                         }
 285                         if ( $actorIds ) {
 286                                 $relations['target_author_actor'] = $actorIds;
 287                                 $params['authorActors'] = $actorIds;
 288                         }
 289                 }
 290                 if ( !( $wgActorTableSchemaMigrationStage & SCHEMA_COMPAT_WRITE_OLD ) ) {
 291                         unset( $relations['target_author_id'], $relations['target_author_ip'] );
 292                         unset( $params['authorIds'], $params['authorIPs'] );
 293                 }
 294
 295                 // Additional fields for which there's no space in the database table schema
 296                 $revId = $this->getAssociatedRevId();
 297                 if ( $revId ) {
 298                         $params['associated_rev_id'] = $revId;
 299                         $relations['associated_rev_id'] = $revId;
 300                 }
 301
 302                 $data = [
 303                         'log_type' => $this->getType(),
 304                         'log_action' => $this->getSubtype(),
 305                         'log_timestamp' => $dbw->timestamp( $this->getTimestamp() ),
 306                         'log_namespace' => $this->getTarget()->getNamespace(),
 307                         'log_title' => $this->getTarget()->getDBkey(),
 308                         'log_page' => $this->getTarget()->getArticleID(),
 309                         'log_params' => LogEntryBase::makeParamBlob( $params ),
 310                 ];
 311                 if ( isset( $this->deleted ) ) {
 312                         $data['log_deleted'] = $this->deleted;
 313                 }
 314                 $data += CommentStore::getStore()->insert( $dbw, 'log_comment', $comment );
 315                 $data += ActorMigration::newMigration()
 316                         ->getInsertValues( $dbw, 'log_user', $this->getPerformer() );
 317
 318                 $dbw->insert( 'logging', $data, __METHOD__ );
 319                 $this->id = $dbw->insertId();
 320
 321                 $rows = [];
 322                 foreach ( $relations as $tag => $values ) {
 323                         if ( !strlen( $tag ) ) {
 324                                 throw new MWException( "Got empty log search tag." );
 325                         }
 326
 327                         if ( !is_array( $values ) ) {
 328                                 $values = [ $values ];
 329                         }
 330
 331                         foreach ( $values as $value ) {
 332                                 $rows[] = [
 333                                         'ls_field' => $tag,
 334                                         'ls_value' => $value,
 335                                         'ls_log_id' => $this->id
 336                                 ];
 337                         }
 338                 }
 339                 if ( count( $rows ) ) {
 340                         $dbw->insert( 'log_search', $rows, __METHOD__, [ 'IGNORE' ] );
 341                 }
 342
 343                 return $this->id;
 344         }
 345
 346         /**
 347          * Get a RecentChanges object for the log entry
 348          *
 349          * @param int $newId
 350          * @return RecentChange
 351          * @since 1.23
 352          */
 353         public function getRecentChange( $newId = 0 ) {
 354                 $formatter = LogFormatter::newFromEntry( $this );
 355                 $context = RequestContext::newExtraneousContext( $this->getTarget() );
 356                 $formatter->setContext( $context );
 357
 358                 $logpage = SpecialPage::getTitleFor( 'Log', $this->getType() );
 359                 $user = $this->getPerformer();
 360                 $ip = "";
 361                 if ( $user->isAnon() ) {
 362                         // "MediaWiki default" and friends may have
 363                         // no IP address in their name
 364                         if ( IP::isIPAddress( $user->getName() ) ) {
 365                                 $ip = $user->getName();
 366                         }
 367                 }
 368
 369                 return RecentChange::newLogEntry(
 370                         $this->getTimestamp(),
 371                         $logpage,
 372                         $user,
 373                         $formatter->getPlainActionText(),
 374                         $ip,
 375                         $this->getType(),
 376                         $this->getSubtype(),
 377                         $this->getTarget(),
 378                         $this->getComment(),
 379                         LogEntryBase::makeParamBlob( $this->getParameters() ),
 380                         $newId,
 381                         $formatter->getIRCActionComment(), // Used for IRC feeds
 382                         $this->getAssociatedRevId(), // Used for e.g. moves and uploads
 383                         $this->getIsPatrollable()
 384                 );
 385         }
 386
 387         /**
 388          * Publish the log entry.
 389          *
 390          * @param int $newId Id of the log entry.
 391          * @param string $to One of: rcandudp (default), rc, udp
 392          */
 393         public function publish( $newId, $to = 'rcandudp' ) {
 394                 $canAddTags = true;
 395                 // FIXME: this code should be removed once all callers properly call publish()
 396                 if ( $to === 'udp' && !$newId && !$this->getAssociatedRevId() ) {
 397                         \MediaWiki\Logger\LoggerFactory::getInstance( 'logging' )->warning(
 398                                 'newId and/or revId must be set when calling ManualLogEntry::publish()',
 399                                 [
 400                                         'newId' => $newId,
 401                                         'to' => $to,
 402                                         'revId' => $this->getAssociatedRevId(),
 403                                         // pass a new exception to register the stack trace
 404                                         'exception' => new RuntimeException()
 405                                 ]
 406                         );
 407                         $canAddTags = false;
 408                 }
 409
 410                 DeferredUpdates::addCallableUpdate(
 411                         function () use ( $newId, $to, $canAddTags ) {
 412                                 $log = new LogPage( $this->getType() );
 413                                 if ( !$log->isRestricted() ) {
 414                                         Hooks::runWithoutAbort( 'ManualLogEntryBeforePublish', [ $this ] );
 415                                         $rc = $this->getRecentChange( $newId );
 416
 417                                         if ( $to === 'rc' || $to === 'rcandudp' ) {
 418                                                 // save RC, passing tags so they are applied there
 419                                                 $rc->addTags( $this->getTags() );
 420                                                 $rc->save( $rc::SEND_NONE );
 421                                         } else {
 422                                                 $tags = $this->getTags();
 423                                                 if ( $tags && $canAddTags ) {
 424                                                         $revId = $this->getAssociatedRevId();
 425                                                         ChangeTags::addTags(
 426                                                                 $tags,
 427                                                                 null,
 428                                                                 $revId > 0 ? $revId : null,
 429                                                                 $newId > 0 ? $newId : null
 430                                                         );
 431                                                 }
 432                                         }
 433
 434                                         if ( $to === 'udp' || $to === 'rcandudp' ) {
 435                                                 $rc->notifyRCFeeds();
 436                                         }
 437                                 }
 438                         },
 439                         DeferredUpdates::POSTSEND,
 440                         wfGetDB( DB_MASTER )
 441                 );
 442         }
 443
 444         public function getType() {
 445                 return $this->type;
 446         }
 447
 448         public function getSubtype() {
 449                 return $this->subtype;
 450         }
 451
 452         public function getParameters() {
 453                 return $this->parameters;
 454         }
 455
 456         /**
 457          * @return User
 458          */
 459         public function getPerformer() {
 460                 return $this->performer;
 461         }
 462
 463         /**
 464          * @return Title
 465          */
 466         public function getTarget() {
 467                 return $this->target;
 468         }
 469
 470         public function getTimestamp() {
 471                 $ts = $this->timestamp ?? wfTimestampNow();
 472
 473                 return wfTimestamp( TS_MW, $ts );
 474         }
 475
 476         public function getComment() {
 477                 return $this->comment;
 478         }
 479
 480         /**
 481          * @since 1.27
 482          * @return int
 483          */
 484         public function getAssociatedRevId() {
 485                 return $this->revId;
 486         }
 487
 488         /**
 489          * @since 1.27
 490          * @return string[]
 491          */
 492         public function getTags() {
 493                 return $this->tags;
 494         }
 495
 496         /**
 497          * Whether this log entry is patrollable
 498          *
 499          * @since 1.27
 500          * @return bool
 501          */
 502         public function getIsPatrollable() {
 503                 return $this->isPatrollable;
 504         }
 505
 506         /**
 507          * @since 1.25
 508          * @return bool
 509          */
 510         public function isLegacy() {
 511                 return $this->legacy;
 512         }
 513
 514         public function getDeleted() {
 515                 return (int)$this->deleted;
 516         }
 517 }