Remove deprecated function Article::doEdit() and WikiPage::doEdit()
[lhc/web/wiklou.git] / includes / page / WikiPage.php
1 <?php
2 /**
3 * Base representation for a MediaWiki page.
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 */
22
23 use \MediaWiki\Logger\LoggerFactory;
24 use \MediaWiki\MediaWikiServices;
25
26 /**
27 * Class representing a MediaWiki article and history.
28 *
29 * Some fields are public only for backwards-compatibility. Use accessors.
30 * In the past, this class was part of Article.php and everything was public.
31 */
32 class WikiPage implements Page, IDBAccessObject {
33 // Constants for $mDataLoadedFrom and related
34
35 /**
36 * @var Title
37 */
38 public $mTitle = null;
39
40 /**@{{
41 * @protected
42 */
43 public $mDataLoaded = false; // !< Boolean
44 public $mIsRedirect = false; // !< Boolean
45 public $mLatest = false; // !< Integer (false means "not loaded")
46 /**@}}*/
47
48 /** @var stdClass Map of cache fields (text, parser output, ect) for a proposed/new edit */
49 public $mPreparedEdit = false;
50
51 /**
52 * @var int
53 */
54 protected $mId = null;
55
56 /**
57 * @var int One of the READ_* constants
58 */
59 protected $mDataLoadedFrom = self::READ_NONE;
60
61 /**
62 * @var Title
63 */
64 protected $mRedirectTarget = null;
65
66 /**
67 * @var Revision
68 */
69 protected $mLastRevision = null;
70
71 /**
72 * @var string Timestamp of the current revision or empty string if not loaded
73 */
74 protected $mTimestamp = '';
75
76 /**
77 * @var string
78 */
79 protected $mTouched = '19700101000000';
80
81 /**
82 * @var string
83 */
84 protected $mLinksUpdated = '19700101000000';
85
86 const PURGE_CDN_CACHE = 1; // purge CDN cache for page variant URLs
87 const PURGE_CLUSTER_PCACHE = 2; // purge parser cache in the local datacenter
88 const PURGE_GLOBAL_PCACHE = 4; // set page_touched to clear parser cache in all datacenters
89 const PURGE_ALL = 7;
90
91 /**
92 * Constructor and clear the article
93 * @param Title $title Reference to a Title object.
94 */
95 public function __construct( Title $title ) {
96 $this->mTitle = $title;
97 }
98
99 /**
100 * Makes sure that the mTitle object is cloned
101 * to the newly cloned WikiPage.
102 */
103 public function __clone() {
104 $this->mTitle = clone $this->mTitle;
105 }
106
107 /**
108 * Create a WikiPage object of the appropriate class for the given title.
109 *
110 * @param Title $title
111 *
112 * @throws MWException
113 * @return WikiPage|WikiCategoryPage|WikiFilePage
114 */
115 public static function factory( Title $title ) {
116 $ns = $title->getNamespace();
117
118 if ( $ns == NS_MEDIA ) {
119 throw new MWException( "NS_MEDIA is a virtual namespace; use NS_FILE." );
120 } elseif ( $ns < 0 ) {
121 throw new MWException( "Invalid or virtual namespace $ns given." );
122 }
123
124 $page = null;
125 if ( !Hooks::run( 'WikiPageFactory', [ $title, &$page ] ) ) {
126 return $page;
127 }
128
129 switch ( $ns ) {
130 case NS_FILE:
131 $page = new WikiFilePage( $title );
132 break;
133 case NS_CATEGORY:
134 $page = new WikiCategoryPage( $title );
135 break;
136 default:
137 $page = new WikiPage( $title );
138 }
139
140 return $page;
141 }
142
143 /**
144 * Constructor from a page id
145 *
146 * @param int $id Article ID to load
147 * @param string|int $from One of the following values:
148 * - "fromdb" or WikiPage::READ_NORMAL to select from a replica DB
149 * - "fromdbmaster" or WikiPage::READ_LATEST to select from the master database
150 *
151 * @return WikiPage|null
152 */
153 public static function newFromID( $id, $from = 'fromdb' ) {
154 // page id's are never 0 or negative, see bug 61166
155 if ( $id < 1 ) {
156 return null;
157 }
158
159 $from = self::convertSelectType( $from );
160 $db = wfGetDB( $from === self::READ_LATEST ? DB_MASTER : DB_REPLICA );
161 $row = $db->selectRow(
162 'page', self::selectFields(), [ 'page_id' => $id ], __METHOD__ );
163 if ( !$row ) {
164 return null;
165 }
166 return self::newFromRow( $row, $from );
167 }
168
169 /**
170 * Constructor from a database row
171 *
172 * @since 1.20
173 * @param object $row Database row containing at least fields returned by selectFields().
174 * @param string|int $from Source of $data:
175 * - "fromdb" or WikiPage::READ_NORMAL: from a replica DB
176 * - "fromdbmaster" or WikiPage::READ_LATEST: from the master DB
177 * - "forupdate" or WikiPage::READ_LOCKING: from the master DB using SELECT FOR UPDATE
178 * @return WikiPage
179 */
180 public static function newFromRow( $row, $from = 'fromdb' ) {
181 $page = self::factory( Title::newFromRow( $row ) );
182 $page->loadFromRow( $row, $from );
183 return $page;
184 }
185
186 /**
187 * Convert 'fromdb', 'fromdbmaster' and 'forupdate' to READ_* constants.
188 *
189 * @param object|string|int $type
190 * @return mixed
191 */
192 private static function convertSelectType( $type ) {
193 switch ( $type ) {
194 case 'fromdb':
195 return self::READ_NORMAL;
196 case 'fromdbmaster':
197 return self::READ_LATEST;
198 case 'forupdate':
199 return self::READ_LOCKING;
200 default:
201 // It may already be an integer or whatever else
202 return $type;
203 }
204 }
205
206 /**
207 * @todo Move this UI stuff somewhere else
208 *
209 * @see ContentHandler::getActionOverrides
210 */
211 public function getActionOverrides() {
212 return $this->getContentHandler()->getActionOverrides();
213 }
214
215 /**
216 * Returns the ContentHandler instance to be used to deal with the content of this WikiPage.
217 *
218 * Shorthand for ContentHandler::getForModelID( $this->getContentModel() );
219 *
220 * @return ContentHandler
221 *
222 * @since 1.21
223 */
224 public function getContentHandler() {
225 return ContentHandler::getForModelID( $this->getContentModel() );
226 }
227
228 /**
229 * Get the title object of the article
230 * @return Title Title object of this page
231 */
232 public function getTitle() {
233 return $this->mTitle;
234 }
235
236 /**
237 * Clear the object
238 * @return void
239 */
240 public function clear() {
241 $this->mDataLoaded = false;
242 $this->mDataLoadedFrom = self::READ_NONE;
243
244 $this->clearCacheFields();
245 }
246
247 /**
248 * Clear the object cache fields
249 * @return void
250 */
251 protected function clearCacheFields() {
252 $this->mId = null;
253 $this->mRedirectTarget = null; // Title object if set
254 $this->mLastRevision = null; // Latest revision
255 $this->mTouched = '19700101000000';
256 $this->mLinksUpdated = '19700101000000';
257 $this->mTimestamp = '';
258 $this->mIsRedirect = false;
259 $this->mLatest = false;
260 // Bug 57026: do not clear mPreparedEdit since prepareTextForEdit() already checks
261 // the requested rev ID and content against the cached one for equality. For most
262 // content types, the output should not change during the lifetime of this cache.
263 // Clearing it can cause extra parses on edit for no reason.
264 }
265
266 /**
267 * Clear the mPreparedEdit cache field, as may be needed by mutable content types
268 * @return void
269 * @since 1.23
270 */
271 public function clearPreparedEdit() {
272 $this->mPreparedEdit = false;
273 }
274
275 /**
276 * Return the list of revision fields that should be selected to create
277 * a new page.
278 *
279 * @return array
280 */
281 public static function selectFields() {
282 global $wgContentHandlerUseDB, $wgPageLanguageUseDB;
283
284 $fields = [
285 'page_id',
286 'page_namespace',
287 'page_title',
288 'page_restrictions',
289 'page_is_redirect',
290 'page_is_new',
291 'page_random',
292 'page_touched',
293 'page_links_updated',
294 'page_latest',
295 'page_len',
296 ];
297
298 if ( $wgContentHandlerUseDB ) {
299 $fields[] = 'page_content_model';
300 }
301
302 if ( $wgPageLanguageUseDB ) {
303 $fields[] = 'page_lang';
304 }
305
306 return $fields;
307 }
308
309 /**
310 * Fetch a page record with the given conditions
311 * @param IDatabase $dbr
312 * @param array $conditions
313 * @param array $options
314 * @return object|bool Database result resource, or false on failure
315 */
316 protected function pageData( $dbr, $conditions, $options = [] ) {
317 $fields = self::selectFields();
318
319 // Avoid PHP 7.1 warning of passing $this by reference
320 $wikiPage = $this;
321
322 Hooks::run( 'ArticlePageDataBefore', [ &$wikiPage, &$fields ] );
323
324 $row = $dbr->selectRow( 'page', $fields, $conditions, __METHOD__, $options );
325
326 Hooks::run( 'ArticlePageDataAfter', [ &$this, &$row ] );
327
328 return $row;
329 }
330
331 /**
332 * Fetch a page record matching the Title object's namespace and title
333 * using a sanitized title string
334 *
335 * @param IDatabase $dbr
336 * @param Title $title
337 * @param array $options
338 * @return object|bool Database result resource, or false on failure
339 */
340 public function pageDataFromTitle( $dbr, $title, $options = [] ) {
341 return $this->pageData( $dbr, [
342 'page_namespace' => $title->getNamespace(),
343 'page_title' => $title->getDBkey() ], $options );
344 }
345
346 /**
347 * Fetch a page record matching the requested ID
348 *
349 * @param IDatabase $dbr
350 * @param int $id
351 * @param array $options
352 * @return object|bool Database result resource, or false on failure
353 */
354 public function pageDataFromId( $dbr, $id, $options = [] ) {
355 return $this->pageData( $dbr, [ 'page_id' => $id ], $options );
356 }
357
358 /**
359 * Load the object from a given source by title
360 *
361 * @param object|string|int $from One of the following:
362 * - A DB query result object.
363 * - "fromdb" or WikiPage::READ_NORMAL to get from a replica DB.
364 * - "fromdbmaster" or WikiPage::READ_LATEST to get from the master DB.
365 * - "forupdate" or WikiPage::READ_LOCKING to get from the master DB
366 * using SELECT FOR UPDATE.
367 *
368 * @return void
369 */
370 public function loadPageData( $from = 'fromdb' ) {
371 $from = self::convertSelectType( $from );
372 if ( is_int( $from ) && $from <= $this->mDataLoadedFrom ) {
373 // We already have the data from the correct location, no need to load it twice.
374 return;
375 }
376
377 if ( is_int( $from ) ) {
378 list( $index, $opts ) = DBAccessObjectUtils::getDBOptions( $from );
379 $data = $this->pageDataFromTitle( wfGetDB( $index ), $this->mTitle, $opts );
380
381 if ( !$data
382 && $index == DB_REPLICA
383 && wfGetLB()->getServerCount() > 1
384 && wfGetLB()->hasOrMadeRecentMasterChanges()
385 ) {
386 $from = self::READ_LATEST;
387 list( $index, $opts ) = DBAccessObjectUtils::getDBOptions( $from );
388 $data = $this->pageDataFromTitle( wfGetDB( $index ), $this->mTitle, $opts );
389 }
390 } else {
391 // No idea from where the caller got this data, assume replica DB.
392 $data = $from;
393 $from = self::READ_NORMAL;
394 }
395
396 $this->loadFromRow( $data, $from );
397 }
398
399 /**
400 * Load the object from a database row
401 *
402 * @since 1.20
403 * @param object|bool $data DB row containing fields returned by selectFields() or false
404 * @param string|int $from One of the following:
405 * - "fromdb" or WikiPage::READ_NORMAL if the data comes from a replica DB
406 * - "fromdbmaster" or WikiPage::READ_LATEST if the data comes from the master DB
407 * - "forupdate" or WikiPage::READ_LOCKING if the data comes from
408 * the master DB using SELECT FOR UPDATE
409 */
410 public function loadFromRow( $data, $from ) {
411 $lc = LinkCache::singleton();
412 $lc->clearLink( $this->mTitle );
413
414 if ( $data ) {
415 $lc->addGoodLinkObjFromRow( $this->mTitle, $data );
416
417 $this->mTitle->loadFromRow( $data );
418
419 // Old-fashioned restrictions
420 $this->mTitle->loadRestrictions( $data->page_restrictions );
421
422 $this->mId = intval( $data->page_id );
423 $this->mTouched = wfTimestamp( TS_MW, $data->page_touched );
424 $this->mLinksUpdated = wfTimestampOrNull( TS_MW, $data->page_links_updated );
425 $this->mIsRedirect = intval( $data->page_is_redirect );
426 $this->mLatest = intval( $data->page_latest );
427 // Bug 37225: $latest may no longer match the cached latest Revision object.
428 // Double-check the ID of any cached latest Revision object for consistency.
429 if ( $this->mLastRevision && $this->mLastRevision->getId() != $this->mLatest ) {
430 $this->mLastRevision = null;
431 $this->mTimestamp = '';
432 }
433 } else {
434 $lc->addBadLinkObj( $this->mTitle );
435
436 $this->mTitle->loadFromRow( false );
437
438 $this->clearCacheFields();
439
440 $this->mId = 0;
441 }
442
443 $this->mDataLoaded = true;
444 $this->mDataLoadedFrom = self::convertSelectType( $from );
445 }
446
447 /**
448 * @return int Page ID
449 */
450 public function getId() {
451 if ( !$this->mDataLoaded ) {
452 $this->loadPageData();
453 }
454 return $this->mId;
455 }
456
457 /**
458 * @return bool Whether or not the page exists in the database
459 */
460 public function exists() {
461 if ( !$this->mDataLoaded ) {
462 $this->loadPageData();
463 }
464 return $this->mId > 0;
465 }
466
467 /**
468 * Check if this page is something we're going to be showing
469 * some sort of sensible content for. If we return false, page
470 * views (plain action=view) will return an HTTP 404 response,
471 * so spiders and robots can know they're following a bad link.
472 *
473 * @return bool
474 */
475 public function hasViewableContent() {
476 return $this->mTitle->isKnown();
477 }
478
479 /**
480 * Tests if the article content represents a redirect
481 *
482 * @return bool
483 */
484 public function isRedirect() {
485 if ( !$this->mDataLoaded ) {
486 $this->loadPageData();
487 }
488
489 return (bool)$this->mIsRedirect;
490 }
491
492 /**
493 * Returns the page's content model id (see the CONTENT_MODEL_XXX constants).
494 *
495 * Will use the revisions actual content model if the page exists,
496 * and the page's default if the page doesn't exist yet.
497 *
498 * @return string
499 *
500 * @since 1.21
501 */
502 public function getContentModel() {
503 if ( $this->exists() ) {
504 $cache = ObjectCache::getMainWANInstance();
505
506 return $cache->getWithSetCallback(
507 $cache->makeKey( 'page', 'content-model', $this->getLatest() ),
508 $cache::TTL_MONTH,
509 function () {
510 $rev = $this->getRevision();
511 if ( $rev ) {
512 // Look at the revision's actual content model
513 return $rev->getContentModel();
514 } else {
515 $title = $this->mTitle->getPrefixedDBkey();
516 wfWarn( "Page $title exists but has no (visible) revisions!" );
517 return $this->mTitle->getContentModel();
518 }
519 }
520 );
521 }
522
523 // use the default model for this page
524 return $this->mTitle->getContentModel();
525 }
526
527 /**
528 * Loads page_touched and returns a value indicating if it should be used
529 * @return bool True if this page exists and is not a redirect
530 */
531 public function checkTouched() {
532 if ( !$this->mDataLoaded ) {
533 $this->loadPageData();
534 }
535 return ( $this->mId && !$this->mIsRedirect );
536 }
537
538 /**
539 * Get the page_touched field
540 * @return string Containing GMT timestamp
541 */
542 public function getTouched() {
543 if ( !$this->mDataLoaded ) {
544 $this->loadPageData();
545 }
546 return $this->mTouched;
547 }
548
549 /**
550 * Get the page_links_updated field
551 * @return string|null Containing GMT timestamp
552 */
553 public function getLinksTimestamp() {
554 if ( !$this->mDataLoaded ) {
555 $this->loadPageData();
556 }
557 return $this->mLinksUpdated;
558 }
559
560 /**
561 * Get the page_latest field
562 * @return int The rev_id of current revision
563 */
564 public function getLatest() {
565 if ( !$this->mDataLoaded ) {
566 $this->loadPageData();
567 }
568 return (int)$this->mLatest;
569 }
570
571 /**
572 * Get the Revision object of the oldest revision
573 * @return Revision|null
574 */
575 public function getOldestRevision() {
576
577 // Try using the replica DB first, then try the master
578 $continue = 2;
579 $db = wfGetDB( DB_REPLICA );
580 $revSelectFields = Revision::selectFields();
581
582 $row = null;
583 while ( $continue ) {
584 $row = $db->selectRow(
585 [ 'page', 'revision' ],
586 $revSelectFields,
587 [
588 'page_namespace' => $this->mTitle->getNamespace(),
589 'page_title' => $this->mTitle->getDBkey(),
590 'rev_page = page_id'
591 ],
592 __METHOD__,
593 [
594 'ORDER BY' => 'rev_timestamp ASC'
595 ]
596 );
597
598 if ( $row ) {
599 $continue = 0;
600 } else {
601 $db = wfGetDB( DB_MASTER );
602 $continue--;
603 }
604 }
605
606 return $row ? Revision::newFromRow( $row ) : null;
607 }
608
609 /**
610 * Loads everything except the text
611 * This isn't necessary for all uses, so it's only done if needed.
612 */
613 protected function loadLastEdit() {
614 if ( $this->mLastRevision !== null ) {
615 return; // already loaded
616 }
617
618 $latest = $this->getLatest();
619 if ( !$latest ) {
620 return; // page doesn't exist or is missing page_latest info
621 }
622
623 if ( $this->mDataLoadedFrom == self::READ_LOCKING ) {
624 // Bug 37225: if session S1 loads the page row FOR UPDATE, the result always
625 // includes the latest changes committed. This is true even within REPEATABLE-READ
626 // transactions, where S1 normally only sees changes committed before the first S1
627 // SELECT. Thus we need S1 to also gets the revision row FOR UPDATE; otherwise, it
628 // may not find it since a page row UPDATE and revision row INSERT by S2 may have
629 // happened after the first S1 SELECT.
630 // https://dev.mysql.com/doc/refman/5.0/en/set-transaction.html#isolevel_repeatable-read
631 $flags = Revision::READ_LOCKING;
632 $revision = Revision::newFromPageId( $this->getId(), $latest, $flags );
633 } elseif ( $this->mDataLoadedFrom == self::READ_LATEST ) {
634 // Bug T93976: if page_latest was loaded from the master, fetch the
635 // revision from there as well, as it may not exist yet on a replica DB.
636 // Also, this keeps the queries in the same REPEATABLE-READ snapshot.
637 $flags = Revision::READ_LATEST;
638 $revision = Revision::newFromPageId( $this->getId(), $latest, $flags );
639 } else {
640 $dbr = wfGetDB( DB_REPLICA );
641 $revision = Revision::newKnownCurrent( $dbr, $this->getId(), $latest );
642 }
643
644 if ( $revision ) { // sanity
645 $this->setLastEdit( $revision );
646 }
647 }
648
649 /**
650 * Set the latest revision
651 * @param Revision $revision
652 */
653 protected function setLastEdit( Revision $revision ) {
654 $this->mLastRevision = $revision;
655 $this->mTimestamp = $revision->getTimestamp();
656 }
657
658 /**
659 * Get the latest revision
660 * @return Revision|null
661 */
662 public function getRevision() {
663 $this->loadLastEdit();
664 if ( $this->mLastRevision ) {
665 return $this->mLastRevision;
666 }
667 return null;
668 }
669
670 /**
671 * Get the content of the current revision. No side-effects...
672 *
673 * @param int $audience One of:
674 * Revision::FOR_PUBLIC to be displayed to all users
675 * Revision::FOR_THIS_USER to be displayed to $wgUser
676 * Revision::RAW get the text regardless of permissions
677 * @param User $user User object to check for, only if FOR_THIS_USER is passed
678 * to the $audience parameter
679 * @return Content|null The content of the current revision
680 *
681 * @since 1.21
682 */
683 public function getContent( $audience = Revision::FOR_PUBLIC, User $user = null ) {
684 $this->loadLastEdit();
685 if ( $this->mLastRevision ) {
686 return $this->mLastRevision->getContent( $audience, $user );
687 }
688 return null;
689 }
690
691 /**
692 * @return string MW timestamp of last article revision
693 */
694 public function getTimestamp() {
695 // Check if the field has been filled by WikiPage::setTimestamp()
696 if ( !$this->mTimestamp ) {
697 $this->loadLastEdit();
698 }
699
700 return wfTimestamp( TS_MW, $this->mTimestamp );
701 }
702
703 /**
704 * Set the page timestamp (use only to avoid DB queries)
705 * @param string $ts MW timestamp of last article revision
706 * @return void
707 */
708 public function setTimestamp( $ts ) {
709 $this->mTimestamp = wfTimestamp( TS_MW, $ts );
710 }
711
712 /**
713 * @param int $audience One of:
714 * Revision::FOR_PUBLIC to be displayed to all users
715 * Revision::FOR_THIS_USER to be displayed to the given user
716 * Revision::RAW get the text regardless of permissions
717 * @param User $user User object to check for, only if FOR_THIS_USER is passed
718 * to the $audience parameter
719 * @return int User ID for the user that made the last article revision
720 */
721 public function getUser( $audience = Revision::FOR_PUBLIC, User $user = null ) {
722 $this->loadLastEdit();
723 if ( $this->mLastRevision ) {
724 return $this->mLastRevision->getUser( $audience, $user );
725 } else {
726 return -1;
727 }
728 }
729
730 /**
731 * Get the User object of the user who created the page
732 * @param int $audience One of:
733 * Revision::FOR_PUBLIC to be displayed to all users
734 * Revision::FOR_THIS_USER to be displayed to the given user
735 * Revision::RAW get the text regardless of permissions
736 * @param User $user User object to check for, only if FOR_THIS_USER is passed
737 * to the $audience parameter
738 * @return User|null
739 */
740 public function getCreator( $audience = Revision::FOR_PUBLIC, User $user = null ) {
741 $revision = $this->getOldestRevision();
742 if ( $revision ) {
743 $userName = $revision->getUserText( $audience, $user );
744 return User::newFromName( $userName, false );
745 } else {
746 return null;
747 }
748 }
749
750 /**
751 * @param int $audience One of:
752 * Revision::FOR_PUBLIC to be displayed to all users
753 * Revision::FOR_THIS_USER to be displayed to the given user
754 * Revision::RAW get the text regardless of permissions
755 * @param User $user User object to check for, only if FOR_THIS_USER is passed
756 * to the $audience parameter
757 * @return string Username of the user that made the last article revision
758 */
759 public function getUserText( $audience = Revision::FOR_PUBLIC, User $user = null ) {
760 $this->loadLastEdit();
761 if ( $this->mLastRevision ) {
762 return $this->mLastRevision->getUserText( $audience, $user );
763 } else {
764 return '';
765 }
766 }
767
768 /**
769 * @param int $audience One of:
770 * Revision::FOR_PUBLIC to be displayed to all users
771 * Revision::FOR_THIS_USER to be displayed to the given user
772 * Revision::RAW get the text regardless of permissions
773 * @param User $user User object to check for, only if FOR_THIS_USER is passed
774 * to the $audience parameter
775 * @return string Comment stored for the last article revision
776 */
777 public function getComment( $audience = Revision::FOR_PUBLIC, User $user = null ) {
778 $this->loadLastEdit();
779 if ( $this->mLastRevision ) {
780 return $this->mLastRevision->getComment( $audience, $user );
781 } else {
782 return '';
783 }
784 }
785
786 /**
787 * Returns true if last revision was marked as "minor edit"
788 *
789 * @return bool Minor edit indicator for the last article revision.
790 */
791 public function getMinorEdit() {
792 $this->loadLastEdit();
793 if ( $this->mLastRevision ) {
794 return $this->mLastRevision->isMinor();
795 } else {
796 return false;
797 }
798 }
799
800 /**
801 * Determine whether a page would be suitable for being counted as an
802 * article in the site_stats table based on the title & its content
803 *
804 * @param object|bool $editInfo (false): object returned by prepareTextForEdit(),
805 * if false, the current database state will be used
806 * @return bool
807 */
808 public function isCountable( $editInfo = false ) {
809 global $wgArticleCountMethod;
810
811 if ( !$this->mTitle->isContentPage() ) {
812 return false;
813 }
814
815 if ( $editInfo ) {
816 $content = $editInfo->pstContent;
817 } else {
818 $content = $this->getContent();
819 }
820
821 if ( !$content || $content->isRedirect() ) {
822 return false;
823 }
824
825 $hasLinks = null;
826
827 if ( $wgArticleCountMethod === 'link' ) {
828 // nasty special case to avoid re-parsing to detect links
829
830 if ( $editInfo ) {
831 // ParserOutput::getLinks() is a 2D array of page links, so
832 // to be really correct we would need to recurse in the array
833 // but the main array should only have items in it if there are
834 // links.
835 $hasLinks = (bool)count( $editInfo->output->getLinks() );
836 } else {
837 $hasLinks = (bool)wfGetDB( DB_REPLICA )->selectField( 'pagelinks', 1,
838 [ 'pl_from' => $this->getId() ], __METHOD__ );
839 }
840 }
841
842 return $content->isCountable( $hasLinks );
843 }
844
845 /**
846 * If this page is a redirect, get its target
847 *
848 * The target will be fetched from the redirect table if possible.
849 * If this page doesn't have an entry there, call insertRedirect()
850 * @return Title|null Title object, or null if this page is not a redirect
851 */
852 public function getRedirectTarget() {
853 if ( !$this->mTitle->isRedirect() ) {
854 return null;
855 }
856
857 if ( $this->mRedirectTarget !== null ) {
858 return $this->mRedirectTarget;
859 }
860
861 // Query the redirect table
862 $dbr = wfGetDB( DB_REPLICA );
863 $row = $dbr->selectRow( 'redirect',
864 [ 'rd_namespace', 'rd_title', 'rd_fragment', 'rd_interwiki' ],
865 [ 'rd_from' => $this->getId() ],
866 __METHOD__
867 );
868
869 // rd_fragment and rd_interwiki were added later, populate them if empty
870 if ( $row && !is_null( $row->rd_fragment ) && !is_null( $row->rd_interwiki ) ) {
871 $this->mRedirectTarget = Title::makeTitle(
872 $row->rd_namespace, $row->rd_title,
873 $row->rd_fragment, $row->rd_interwiki
874 );
875 return $this->mRedirectTarget;
876 }
877
878 // This page doesn't have an entry in the redirect table
879 $this->mRedirectTarget = $this->insertRedirect();
880 return $this->mRedirectTarget;
881 }
882
883 /**
884 * Insert an entry for this page into the redirect table if the content is a redirect
885 *
886 * The database update will be deferred via DeferredUpdates
887 *
888 * Don't call this function directly unless you know what you're doing.
889 * @return Title|null Title object or null if not a redirect
890 */
891 public function insertRedirect() {
892 $content = $this->getContent();
893 $retval = $content ? $content->getUltimateRedirectTarget() : null;
894 if ( !$retval ) {
895 return null;
896 }
897
898 // Update the DB post-send if the page has not cached since now
899 $that = $this;
900 $latest = $this->getLatest();
901 DeferredUpdates::addCallableUpdate(
902 function () use ( $that, $retval, $latest ) {
903 $that->insertRedirectEntry( $retval, $latest );
904 },
905 DeferredUpdates::POSTSEND,
906 wfGetDB( DB_MASTER )
907 );
908
909 return $retval;
910 }
911
912 /**
913 * Insert or update the redirect table entry for this page to indicate it redirects to $rt
914 * @param Title $rt Redirect target
915 * @param int|null $oldLatest Prior page_latest for check and set
916 */
917 public function insertRedirectEntry( Title $rt, $oldLatest = null ) {
918 $dbw = wfGetDB( DB_MASTER );
919 $dbw->startAtomic( __METHOD__ );
920
921 if ( !$oldLatest || $oldLatest == $this->lockAndGetLatest() ) {
922 $dbw->upsert(
923 'redirect',
924 [
925 'rd_from' => $this->getId(),
926 'rd_namespace' => $rt->getNamespace(),
927 'rd_title' => $rt->getDBkey(),
928 'rd_fragment' => $rt->getFragment(),
929 'rd_interwiki' => $rt->getInterwiki(),
930 ],
931 [ 'rd_from' ],
932 [
933 'rd_namespace' => $rt->getNamespace(),
934 'rd_title' => $rt->getDBkey(),
935 'rd_fragment' => $rt->getFragment(),
936 'rd_interwiki' => $rt->getInterwiki(),
937 ],
938 __METHOD__
939 );
940 }
941
942 $dbw->endAtomic( __METHOD__ );
943 }
944
945 /**
946 * Get the Title object or URL this page redirects to
947 *
948 * @return bool|Title|string False, Title of in-wiki target, or string with URL
949 */
950 public function followRedirect() {
951 return $this->getRedirectURL( $this->getRedirectTarget() );
952 }
953
954 /**
955 * Get the Title object or URL to use for a redirect. We use Title
956 * objects for same-wiki, non-special redirects and URLs for everything
957 * else.
958 * @param Title $rt Redirect target
959 * @return bool|Title|string False, Title object of local target, or string with URL
960 */
961 public function getRedirectURL( $rt ) {
962 if ( !$rt ) {
963 return false;
964 }
965
966 if ( $rt->isExternal() ) {
967 if ( $rt->isLocal() ) {
968 // Offsite wikis need an HTTP redirect.
969 // This can be hard to reverse and may produce loops,
970 // so they may be disabled in the site configuration.
971 $source = $this->mTitle->getFullURL( 'redirect=no' );
972 return $rt->getFullURL( [ 'rdfrom' => $source ] );
973 } else {
974 // External pages without "local" bit set are not valid
975 // redirect targets
976 return false;
977 }
978 }
979
980 if ( $rt->isSpecialPage() ) {
981 // Gotta handle redirects to special pages differently:
982 // Fill the HTTP response "Location" header and ignore the rest of the page we're on.
983 // Some pages are not valid targets.
984 if ( $rt->isValidRedirectTarget() ) {
985 return $rt->getFullURL();
986 } else {
987 return false;
988 }
989 }
990
991 return $rt;
992 }
993
994 /**
995 * Get a list of users who have edited this article, not including the user who made
996 * the most recent revision, which you can get from $article->getUser() if you want it
997 * @return UserArrayFromResult
998 */
999 public function getContributors() {
1000 // @todo FIXME: This is expensive; cache this info somewhere.
1001
1002 $dbr = wfGetDB( DB_REPLICA );
1003
1004 if ( $dbr->implicitGroupby() ) {
1005 $realNameField = 'user_real_name';
1006 } else {
1007 $realNameField = 'MIN(user_real_name) AS user_real_name';
1008 }
1009
1010 $tables = [ 'revision', 'user' ];
1011
1012 $fields = [
1013 'user_id' => 'rev_user',
1014 'user_name' => 'rev_user_text',
1015 $realNameField,
1016 'timestamp' => 'MAX(rev_timestamp)',
1017 ];
1018
1019 $conds = [ 'rev_page' => $this->getId() ];
1020
1021 // The user who made the top revision gets credited as "this page was last edited by
1022 // John, based on contributions by Tom, Dick and Harry", so don't include them twice.
1023 $user = $this->getUser();
1024 if ( $user ) {
1025 $conds[] = "rev_user != $user";
1026 } else {
1027 $conds[] = "rev_user_text != {$dbr->addQuotes( $this->getUserText() )}";
1028 }
1029
1030 // Username hidden?
1031 $conds[] = "{$dbr->bitAnd( 'rev_deleted', Revision::DELETED_USER )} = 0";
1032
1033 $jconds = [
1034 'user' => [ 'LEFT JOIN', 'rev_user = user_id' ],
1035 ];
1036
1037 $options = [
1038 'GROUP BY' => [ 'rev_user', 'rev_user_text' ],
1039 'ORDER BY' => 'timestamp DESC',
1040 ];
1041
1042 $res = $dbr->select( $tables, $fields, $conds, __METHOD__, $options, $jconds );
1043 return new UserArrayFromResult( $res );
1044 }
1045
1046 /**
1047 * Should the parser cache be used?
1048 *
1049 * @param ParserOptions $parserOptions ParserOptions to check
1050 * @param int $oldId
1051 * @return bool
1052 */
1053 public function shouldCheckParserCache( ParserOptions $parserOptions, $oldId ) {
1054 return $parserOptions->getStubThreshold() == 0
1055 && $this->exists()
1056 && ( $oldId === null || $oldId === 0 || $oldId === $this->getLatest() )
1057 && $this->getContentHandler()->isParserCacheSupported();
1058 }
1059
1060 /**
1061 * Get a ParserOutput for the given ParserOptions and revision ID.
1062 *
1063 * The parser cache will be used if possible. Cache misses that result
1064 * in parser runs are debounced with PoolCounter.
1065 *
1066 * @since 1.19
1067 * @param ParserOptions $parserOptions ParserOptions to use for the parse operation
1068 * @param null|int $oldid Revision ID to get the text from, passing null or 0 will
1069 * get the current revision (default value)
1070 * @param bool $forceParse Force reindexing, regardless of cache settings
1071 * @return bool|ParserOutput ParserOutput or false if the revision was not found
1072 */
1073 public function getParserOutput(
1074 ParserOptions $parserOptions, $oldid = null, $forceParse = false
1075 ) {
1076 $useParserCache =
1077 ( !$forceParse ) && $this->shouldCheckParserCache( $parserOptions, $oldid );
1078 wfDebug( __METHOD__ .
1079 ': using parser cache: ' . ( $useParserCache ? 'yes' : 'no' ) . "\n" );
1080 if ( $parserOptions->getStubThreshold() ) {
1081 wfIncrStats( 'pcache.miss.stub' );
1082 }
1083
1084 if ( $useParserCache ) {
1085 $parserOutput = ParserCache::singleton()->get( $this, $parserOptions );
1086 if ( $parserOutput !== false ) {
1087 return $parserOutput;
1088 }
1089 }
1090
1091 if ( $oldid === null || $oldid === 0 ) {
1092 $oldid = $this->getLatest();
1093 }
1094
1095 $pool = new PoolWorkArticleView( $this, $parserOptions, $oldid, $useParserCache );
1096 $pool->execute();
1097
1098 return $pool->getParserOutput();
1099 }
1100
1101 /**
1102 * Do standard deferred updates after page view (existing or missing page)
1103 * @param User $user The relevant user
1104 * @param int $oldid Revision id being viewed; if not given or 0, latest revision is assumed
1105 */
1106 public function doViewUpdates( User $user, $oldid = 0 ) {
1107 if ( wfReadOnly() ) {
1108 return;
1109 }
1110
1111 Hooks::run( 'PageViewUpdates', [ $this, $user ] );
1112 // Update newtalk / watchlist notification status
1113 try {
1114 $user->clearNotification( $this->mTitle, $oldid );
1115 } catch ( DBError $e ) {
1116 // Avoid outage if the master is not reachable
1117 MWExceptionHandler::logException( $e );
1118 }
1119 }
1120
1121 /**
1122 * Perform the actions of a page purging
1123 * @param integer $flags Bitfield of WikiPage::PURGE_* constants
1124 * @return bool
1125 */
1126 public function doPurge( $flags = self::PURGE_ALL ) {
1127 // Avoid PHP 7.1 warning of passing $this by reference
1128 $wikiPage = $this;
1129
1130 if ( !Hooks::run( 'ArticlePurge', [ &$wikiPage ] ) ) {
1131 return false;
1132 }
1133
1134 if ( ( $flags & self::PURGE_GLOBAL_PCACHE ) == self::PURGE_GLOBAL_PCACHE ) {
1135 // Set page_touched in the database to invalidate all DC caches
1136 $this->mTitle->invalidateCache();
1137 } elseif ( ( $flags & self::PURGE_CLUSTER_PCACHE ) == self::PURGE_CLUSTER_PCACHE ) {
1138 // Delete the parser options key in the local cluster to invalidate the DC cache
1139 ParserCache::singleton()->deleteOptionsKey( $this );
1140 // Avoid sending HTTP 304s in ViewAction to the client who just issued the purge
1141 $cache = ObjectCache::getLocalClusterInstance();
1142 $cache->set(
1143 $cache->makeKey( 'page', 'last-dc-purge', $this->getId() ),
1144 wfTimestamp( TS_MW ),
1145 $cache::TTL_HOUR
1146 );
1147 }
1148
1149 if ( ( $flags & self::PURGE_CDN_CACHE ) == self::PURGE_CDN_CACHE ) {
1150 // Clear any HTML file cache
1151 HTMLFileCache::clearFileCache( $this->getTitle() );
1152 // Send purge after any page_touched above update was committed
1153 DeferredUpdates::addUpdate(
1154 new CdnCacheUpdate( $this->mTitle->getCdnUrls() ),
1155 DeferredUpdates::PRESEND
1156 );
1157 }
1158
1159 if ( $this->mTitle->getNamespace() == NS_MEDIAWIKI ) {
1160 $messageCache = MessageCache::singleton();
1161 $messageCache->updateMessageOverride( $this->mTitle, $this->getContent() );
1162 }
1163
1164 return true;
1165 }
1166
1167 /**
1168 * Get the last time a user explicitly purged the page via action=purge
1169 *
1170 * @return string|bool TS_MW timestamp or false
1171 * @since 1.28
1172 */
1173 public function getLastPurgeTimestamp() {
1174 $cache = ObjectCache::getLocalClusterInstance();
1175
1176 return $cache->get( $cache->makeKey( 'page', 'last-dc-purge', $this->getId() ) );
1177 }
1178
1179 /**
1180 * Insert a new empty page record for this article.
1181 * This *must* be followed up by creating a revision
1182 * and running $this->updateRevisionOn( ... );
1183 * or else the record will be left in a funky state.
1184 * Best if all done inside a transaction.
1185 *
1186 * @param IDatabase $dbw
1187 * @param int|null $pageId Custom page ID that will be used for the insert statement
1188 *
1189 * @return bool|int The newly created page_id key; false if the row was not
1190 * inserted, e.g. because the title already existed or because the specified
1191 * page ID is already in use.
1192 */
1193 public function insertOn( $dbw, $pageId = null ) {
1194 $pageIdForInsert = $pageId ?: $dbw->nextSequenceValue( 'page_page_id_seq' );
1195 $dbw->insert(
1196 'page',
1197 [
1198 'page_id' => $pageIdForInsert,
1199 'page_namespace' => $this->mTitle->getNamespace(),
1200 'page_title' => $this->mTitle->getDBkey(),
1201 'page_restrictions' => '',
1202 'page_is_redirect' => 0, // Will set this shortly...
1203 'page_is_new' => 1,
1204 'page_random' => wfRandom(),
1205 'page_touched' => $dbw->timestamp(),
1206 'page_latest' => 0, // Fill this in shortly...
1207 'page_len' => 0, // Fill this in shortly...
1208 ],
1209 __METHOD__,
1210 'IGNORE'
1211 );
1212
1213 if ( $dbw->affectedRows() > 0 ) {
1214 $newid = $pageId ?: $dbw->insertId();
1215 $this->mId = $newid;
1216 $this->mTitle->resetArticleID( $newid );
1217
1218 return $newid;
1219 } else {
1220 return false; // nothing changed
1221 }
1222 }
1223
1224 /**
1225 * Update the page record to point to a newly saved revision.
1226 *
1227 * @param IDatabase $dbw
1228 * @param Revision $revision For ID number, and text used to set
1229 * length and redirect status fields
1230 * @param int $lastRevision If given, will not overwrite the page field
1231 * when different from the currently set value.
1232 * Giving 0 indicates the new page flag should be set on.
1233 * @param bool $lastRevIsRedirect If given, will optimize adding and
1234 * removing rows in redirect table.
1235 * @return bool Success; false if the page row was missing or page_latest changed
1236 */
1237 public function updateRevisionOn( $dbw, $revision, $lastRevision = null,
1238 $lastRevIsRedirect = null
1239 ) {
1240 global $wgContentHandlerUseDB;
1241
1242 // Assertion to try to catch T92046
1243 if ( (int)$revision->getId() === 0 ) {
1244 throw new InvalidArgumentException(
1245 __METHOD__ . ': Revision has ID ' . var_export( $revision->getId(), 1 )
1246 );
1247 }
1248
1249 $content = $revision->getContent();
1250 $len = $content ? $content->getSize() : 0;
1251 $rt = $content ? $content->getUltimateRedirectTarget() : null;
1252
1253 $conditions = [ 'page_id' => $this->getId() ];
1254
1255 if ( !is_null( $lastRevision ) ) {
1256 // An extra check against threads stepping on each other
1257 $conditions['page_latest'] = $lastRevision;
1258 }
1259
1260 $row = [ /* SET */
1261 'page_latest' => $revision->getId(),
1262 'page_touched' => $dbw->timestamp( $revision->getTimestamp() ),
1263 'page_is_new' => ( $lastRevision === 0 ) ? 1 : 0,
1264 'page_is_redirect' => $rt !== null ? 1 : 0,
1265 'page_len' => $len,
1266 ];
1267
1268 if ( $wgContentHandlerUseDB ) {
1269 $row['page_content_model'] = $revision->getContentModel();
1270 }
1271
1272 $dbw->update( 'page',
1273 $row,
1274 $conditions,
1275 __METHOD__ );
1276
1277 $result = $dbw->affectedRows() > 0;
1278 if ( $result ) {
1279 $this->updateRedirectOn( $dbw, $rt, $lastRevIsRedirect );
1280 $this->setLastEdit( $revision );
1281 $this->mLatest = $revision->getId();
1282 $this->mIsRedirect = (bool)$rt;
1283 // Update the LinkCache.
1284 LinkCache::singleton()->addGoodLinkObj(
1285 $this->getId(),
1286 $this->mTitle,
1287 $len,
1288 $this->mIsRedirect,
1289 $this->mLatest,
1290 $revision->getContentModel()
1291 );
1292 }
1293
1294 return $result;
1295 }
1296
1297 /**
1298 * Add row to the redirect table if this is a redirect, remove otherwise.
1299 *
1300 * @param IDatabase $dbw
1301 * @param Title $redirectTitle Title object pointing to the redirect target,
1302 * or NULL if this is not a redirect
1303 * @param null|bool $lastRevIsRedirect If given, will optimize adding and
1304 * removing rows in redirect table.
1305 * @return bool True on success, false on failure
1306 * @private
1307 */
1308 public function updateRedirectOn( $dbw, $redirectTitle, $lastRevIsRedirect = null ) {
1309 // Always update redirects (target link might have changed)
1310 // Update/Insert if we don't know if the last revision was a redirect or not
1311 // Delete if changing from redirect to non-redirect
1312 $isRedirect = !is_null( $redirectTitle );
1313
1314 if ( !$isRedirect && $lastRevIsRedirect === false ) {
1315 return true;
1316 }
1317
1318 if ( $isRedirect ) {
1319 $this->insertRedirectEntry( $redirectTitle );
1320 } else {
1321 // This is not a redirect, remove row from redirect table
1322 $where = [ 'rd_from' => $this->getId() ];
1323 $dbw->delete( 'redirect', $where, __METHOD__ );
1324 }
1325
1326 if ( $this->getTitle()->getNamespace() == NS_FILE ) {
1327 RepoGroup::singleton()->getLocalRepo()->invalidateImageRedirect( $this->getTitle() );
1328 }
1329
1330 return ( $dbw->affectedRows() != 0 );
1331 }
1332
1333 /**
1334 * If the given revision is newer than the currently set page_latest,
1335 * update the page record. Otherwise, do nothing.
1336 *
1337 * @deprecated since 1.24, use updateRevisionOn instead
1338 *
1339 * @param IDatabase $dbw
1340 * @param Revision $revision
1341 * @return bool
1342 */
1343 public function updateIfNewerOn( $dbw, $revision ) {
1344
1345 $row = $dbw->selectRow(
1346 [ 'revision', 'page' ],
1347 [ 'rev_id', 'rev_timestamp', 'page_is_redirect' ],
1348 [
1349 'page_id' => $this->getId(),
1350 'page_latest=rev_id' ],
1351 __METHOD__ );
1352
1353 if ( $row ) {
1354 if ( wfTimestamp( TS_MW, $row->rev_timestamp ) >= $revision->getTimestamp() ) {
1355 return false;
1356 }
1357 $prev = $row->rev_id;
1358 $lastRevIsRedirect = (bool)$row->page_is_redirect;
1359 } else {
1360 // No or missing previous revision; mark the page as new
1361 $prev = 0;
1362 $lastRevIsRedirect = null;
1363 }
1364
1365 $ret = $this->updateRevisionOn( $dbw, $revision, $prev, $lastRevIsRedirect );
1366
1367 return $ret;
1368 }
1369
1370 /**
1371 * Get the content that needs to be saved in order to undo all revisions
1372 * between $undo and $undoafter. Revisions must belong to the same page,
1373 * must exist and must not be deleted
1374 * @param Revision $undo
1375 * @param Revision $undoafter Must be an earlier revision than $undo
1376 * @return Content|bool Content on success, false on failure
1377 * @since 1.21
1378 * Before we had the Content object, this was done in getUndoText
1379 */
1380 public function getUndoContent( Revision $undo, Revision $undoafter = null ) {
1381 $handler = $undo->getContentHandler();
1382 return $handler->getUndoContent( $this->getRevision(), $undo, $undoafter );
1383 }
1384
1385 /**
1386 * Returns true if this page's content model supports sections.
1387 *
1388 * @return bool
1389 *
1390 * @todo The skin should check this and not offer section functionality if
1391 * sections are not supported.
1392 * @todo The EditPage should check this and not offer section functionality
1393 * if sections are not supported.
1394 */
1395 public function supportsSections() {
1396 return $this->getContentHandler()->supportsSections();
1397 }
1398
1399 /**
1400 * @param string|int|null|bool $sectionId Section identifier as a number or string
1401 * (e.g. 0, 1 or 'T-1'), null/false or an empty string for the whole page
1402 * or 'new' for a new section.
1403 * @param Content $sectionContent New content of the section.
1404 * @param string $sectionTitle New section's subject, only if $section is "new".
1405 * @param string $edittime Revision timestamp or null to use the current revision.
1406 *
1407 * @throws MWException
1408 * @return Content|null New complete article content, or null if error.
1409 *
1410 * @since 1.21
1411 * @deprecated since 1.24, use replaceSectionAtRev instead
1412 */
1413 public function replaceSectionContent(
1414 $sectionId, Content $sectionContent, $sectionTitle = '', $edittime = null
1415 ) {
1416
1417 $baseRevId = null;
1418 if ( $edittime && $sectionId !== 'new' ) {
1419 $dbr = wfGetDB( DB_REPLICA );
1420 $rev = Revision::loadFromTimestamp( $dbr, $this->mTitle, $edittime );
1421 // Try the master if this thread may have just added it.
1422 // This could be abstracted into a Revision method, but we don't want
1423 // to encourage loading of revisions by timestamp.
1424 if ( !$rev
1425 && wfGetLB()->getServerCount() > 1
1426 && wfGetLB()->hasOrMadeRecentMasterChanges()
1427 ) {
1428 $dbw = wfGetDB( DB_MASTER );
1429 $rev = Revision::loadFromTimestamp( $dbw, $this->mTitle, $edittime );
1430 }
1431 if ( $rev ) {
1432 $baseRevId = $rev->getId();
1433 }
1434 }
1435
1436 return $this->replaceSectionAtRev( $sectionId, $sectionContent, $sectionTitle, $baseRevId );
1437 }
1438
1439 /**
1440 * @param string|int|null|bool $sectionId Section identifier as a number or string
1441 * (e.g. 0, 1 or 'T-1'), null/false or an empty string for the whole page
1442 * or 'new' for a new section.
1443 * @param Content $sectionContent New content of the section.
1444 * @param string $sectionTitle New section's subject, only if $section is "new".
1445 * @param int|null $baseRevId
1446 *
1447 * @throws MWException
1448 * @return Content|null New complete article content, or null if error.
1449 *
1450 * @since 1.24
1451 */
1452 public function replaceSectionAtRev( $sectionId, Content $sectionContent,
1453 $sectionTitle = '', $baseRevId = null
1454 ) {
1455
1456 if ( strval( $sectionId ) === '' ) {
1457 // Whole-page edit; let the whole text through
1458 $newContent = $sectionContent;
1459 } else {
1460 if ( !$this->supportsSections() ) {
1461 throw new MWException( "sections not supported for content model " .
1462 $this->getContentHandler()->getModelID() );
1463 }
1464
1465 // Bug 30711: always use current version when adding a new section
1466 if ( is_null( $baseRevId ) || $sectionId === 'new' ) {
1467 $oldContent = $this->getContent();
1468 } else {
1469 $rev = Revision::newFromId( $baseRevId );
1470 if ( !$rev ) {
1471 wfDebug( __METHOD__ . " asked for bogus section (page: " .
1472 $this->getId() . "; section: $sectionId)\n" );
1473 return null;
1474 }
1475
1476 $oldContent = $rev->getContent();
1477 }
1478
1479 if ( !$oldContent ) {
1480 wfDebug( __METHOD__ . ": no page text\n" );
1481 return null;
1482 }
1483
1484 $newContent = $oldContent->replaceSection( $sectionId, $sectionContent, $sectionTitle );
1485 }
1486
1487 return $newContent;
1488 }
1489
1490 /**
1491 * Check flags and add EDIT_NEW or EDIT_UPDATE to them as needed.
1492 * @param int $flags
1493 * @return int Updated $flags
1494 */
1495 public function checkFlags( $flags ) {
1496 if ( !( $flags & EDIT_NEW ) && !( $flags & EDIT_UPDATE ) ) {
1497 if ( $this->exists() ) {
1498 $flags |= EDIT_UPDATE;
1499 } else {
1500 $flags |= EDIT_NEW;
1501 }
1502 }
1503
1504 return $flags;
1505 }
1506
1507 /**
1508 * Change an existing article or create a new article. Updates RC and all necessary caches,
1509 * optionally via the deferred update array.
1510 *
1511 * @param Content $content New content
1512 * @param string $summary Edit summary
1513 * @param int $flags Bitfield:
1514 * EDIT_NEW
1515 * Article is known or assumed to be non-existent, create a new one
1516 * EDIT_UPDATE
1517 * Article is known or assumed to be pre-existing, update it
1518 * EDIT_MINOR
1519 * Mark this edit minor, if the user is allowed to do so
1520 * EDIT_SUPPRESS_RC
1521 * Do not log the change in recentchanges
1522 * EDIT_FORCE_BOT
1523 * Mark the edit a "bot" edit regardless of user rights
1524 * EDIT_AUTOSUMMARY
1525 * Fill in blank summaries with generated text where possible
1526 * EDIT_INTERNAL
1527 * Signal that the page retrieve/save cycle happened entirely in this request.
1528 *
1529 * If neither EDIT_NEW nor EDIT_UPDATE is specified, the status of the
1530 * article will be detected. If EDIT_UPDATE is specified and the article
1531 * doesn't exist, the function will return an edit-gone-missing error. If
1532 * EDIT_NEW is specified and the article does exist, an edit-already-exists
1533 * error will be returned. These two conditions are also possible with
1534 * auto-detection due to MediaWiki's performance-optimised locking strategy.
1535 *
1536 * @param bool|int $baseRevId The revision ID this edit was based off, if any.
1537 * This is not the parent revision ID, rather the revision ID for older
1538 * content used as the source for a rollback, for example.
1539 * @param User $user The user doing the edit
1540 * @param string $serialFormat Format for storing the content in the
1541 * database.
1542 * @param array|null $tags Change tags to apply to this edit
1543 * Callers are responsible for permission checks
1544 * (with ChangeTags::canAddTagsAccompanyingChange)
1545 * @param Int $undidRevId Id of revision that was undone or 0
1546 *
1547 * @throws MWException
1548 * @return Status Possible errors:
1549 * edit-hook-aborted: The ArticleSave hook aborted the edit but didn't
1550 * set the fatal flag of $status.
1551 * edit-gone-missing: In update mode, but the article didn't exist.
1552 * edit-conflict: In update mode, the article changed unexpectedly.
1553 * edit-no-change: Warning that the text was the same as before.
1554 * edit-already-exists: In creation mode, but the article already exists.
1555 *
1556 * Extensions may define additional errors.
1557 *
1558 * $return->value will contain an associative array with members as follows:
1559 * new: Boolean indicating if the function attempted to create a new article.
1560 * revision: The revision object for the inserted revision, or null.
1561 *
1562 * @since 1.21
1563 * @throws MWException
1564 */
1565 public function doEditContent(
1566 Content $content, $summary, $flags = 0, $baseRevId = false,
1567 User $user = null, $serialFormat = null, $tags = [], $undidRevId = 0
1568 ) {
1569 global $wgUser, $wgUseAutomaticEditSummaries;
1570
1571 // Old default parameter for $tags was null
1572 if ( $tags === null ) {
1573 $tags = [];
1574 }
1575
1576 // Low-level sanity check
1577 if ( $this->mTitle->getText() === '' ) {
1578 throw new MWException( 'Something is trying to edit an article with an empty title' );
1579 }
1580 // Make sure the given content type is allowed for this page
1581 if ( !$content->getContentHandler()->canBeUsedOn( $this->mTitle ) ) {
1582 return Status::newFatal( 'content-not-allowed-here',
1583 ContentHandler::getLocalizedName( $content->getModel() ),
1584 $this->mTitle->getPrefixedText()
1585 );
1586 }
1587
1588 // Load the data from the master database if needed.
1589 // The caller may already loaded it from the master or even loaded it using
1590 // SELECT FOR UPDATE, so do not override that using clear().
1591 $this->loadPageData( 'fromdbmaster' );
1592
1593 $user = $user ?: $wgUser;
1594 $flags = $this->checkFlags( $flags );
1595
1596 // Avoid PHP 7.1 warning of passing $this by reference
1597 $wikiPage = $this;
1598
1599 // Trigger pre-save hook (using provided edit summary)
1600 $hookStatus = Status::newGood( [] );
1601 $hook_args = [ &$wikiPage, &$user, &$content, &$summary,
1602 $flags & EDIT_MINOR, null, null, &$flags, &$hookStatus ];
1603 // Check if the hook rejected the attempted save
1604 if ( !Hooks::run( 'PageContentSave', $hook_args ) ) {
1605 if ( $hookStatus->isOK() ) {
1606 // Hook returned false but didn't call fatal(); use generic message
1607 $hookStatus->fatal( 'edit-hook-aborted' );
1608 }
1609
1610 return $hookStatus;
1611 }
1612
1613 $old_revision = $this->getRevision(); // current revision
1614 $old_content = $this->getContent( Revision::RAW ); // current revision's content
1615
1616 if ( $old_content && $old_content->getModel() !== $content->getModel() ) {
1617 $tags[] = 'mw-contentmodelchange';
1618 }
1619
1620 // Provide autosummaries if one is not provided and autosummaries are enabled
1621 if ( $wgUseAutomaticEditSummaries && ( $flags & EDIT_AUTOSUMMARY ) && $summary == '' ) {
1622 $handler = $content->getContentHandler();
1623 $summary = $handler->getAutosummary( $old_content, $content, $flags );
1624 }
1625
1626 // Avoid statsd noise and wasted cycles check the edit stash (T136678)
1627 if ( ( $flags & EDIT_INTERNAL ) || ( $flags & EDIT_FORCE_BOT ) ) {
1628 $useCache = false;
1629 } else {
1630 $useCache = true;
1631 }
1632
1633 // Get the pre-save transform content and final parser output
1634 $editInfo = $this->prepareContentForEdit( $content, null, $user, $serialFormat, $useCache );
1635 $pstContent = $editInfo->pstContent; // Content object
1636 $meta = [
1637 'bot' => ( $flags & EDIT_FORCE_BOT ),
1638 'minor' => ( $flags & EDIT_MINOR ) && $user->isAllowed( 'minoredit' ),
1639 'serialized' => $editInfo->pst,
1640 'serialFormat' => $serialFormat,
1641 'baseRevId' => $baseRevId,
1642 'oldRevision' => $old_revision,
1643 'oldContent' => $old_content,
1644 'oldId' => $this->getLatest(),
1645 'oldIsRedirect' => $this->isRedirect(),
1646 'oldCountable' => $this->isCountable(),
1647 'tags' => ( $tags !== null ) ? (array)$tags : [],
1648 'undidRevId' => $undidRevId
1649 ];
1650
1651 // Actually create the revision and create/update the page
1652 if ( $flags & EDIT_UPDATE ) {
1653 $status = $this->doModify( $pstContent, $flags, $user, $summary, $meta );
1654 } else {
1655 $status = $this->doCreate( $pstContent, $flags, $user, $summary, $meta );
1656 }
1657
1658 // Promote user to any groups they meet the criteria for
1659 DeferredUpdates::addCallableUpdate( function () use ( $user ) {
1660 $user->addAutopromoteOnceGroups( 'onEdit' );
1661 $user->addAutopromoteOnceGroups( 'onView' ); // b/c
1662 } );
1663
1664 return $status;
1665 }
1666
1667 /**
1668 * @param Content $content Pre-save transform content
1669 * @param integer $flags
1670 * @param User $user
1671 * @param string $summary
1672 * @param array $meta
1673 * @return Status
1674 * @throws DBUnexpectedError
1675 * @throws Exception
1676 * @throws FatalError
1677 * @throws MWException
1678 */
1679 private function doModify(
1680 Content $content, $flags, User $user, $summary, array $meta
1681 ) {
1682 global $wgUseRCPatrol;
1683
1684 // Update article, but only if changed.
1685 $status = Status::newGood( [ 'new' => false, 'revision' => null ] );
1686
1687 // Convenience variables
1688 $now = wfTimestampNow();
1689 $oldid = $meta['oldId'];
1690 /** @var $oldContent Content|null */
1691 $oldContent = $meta['oldContent'];
1692 $newsize = $content->getSize();
1693
1694 if ( !$oldid ) {
1695 // Article gone missing
1696 $status->fatal( 'edit-gone-missing' );
1697
1698 return $status;
1699 } elseif ( !$oldContent ) {
1700 // Sanity check for bug 37225
1701 throw new MWException( "Could not find text for current revision {$oldid}." );
1702 }
1703
1704 // @TODO: pass content object?!
1705 $revision = new Revision( [
1706 'page' => $this->getId(),
1707 'title' => $this->mTitle, // for determining the default content model
1708 'comment' => $summary,
1709 'minor_edit' => $meta['minor'],
1710 'text' => $meta['serialized'],
1711 'len' => $newsize,
1712 'parent_id' => $oldid,
1713 'user' => $user->getId(),
1714 'user_text' => $user->getName(),
1715 'timestamp' => $now,
1716 'content_model' => $content->getModel(),
1717 'content_format' => $meta['serialFormat'],
1718 ] );
1719
1720 $changed = !$content->equals( $oldContent );
1721
1722 $dbw = wfGetDB( DB_MASTER );
1723
1724 if ( $changed ) {
1725 $prepStatus = $content->prepareSave( $this, $flags, $oldid, $user );
1726 $status->merge( $prepStatus );
1727 if ( !$status->isOK() ) {
1728 return $status;
1729 }
1730
1731 $dbw->startAtomic( __METHOD__ );
1732 // Get the latest page_latest value while locking it.
1733 // Do a CAS style check to see if it's the same as when this method
1734 // started. If it changed then bail out before touching the DB.
1735 $latestNow = $this->lockAndGetLatest();
1736 if ( $latestNow != $oldid ) {
1737 $dbw->endAtomic( __METHOD__ );
1738 // Page updated or deleted in the mean time
1739 $status->fatal( 'edit-conflict' );
1740
1741 return $status;
1742 }
1743
1744 // At this point we are now comitted to returning an OK
1745 // status unless some DB query error or other exception comes up.
1746 // This way callers don't have to call rollback() if $status is bad
1747 // unless they actually try to catch exceptions (which is rare).
1748
1749 // Save the revision text
1750 $revisionId = $revision->insertOn( $dbw );
1751 // Update page_latest and friends to reflect the new revision
1752 if ( !$this->updateRevisionOn( $dbw, $revision, null, $meta['oldIsRedirect'] ) ) {
1753 throw new MWException( "Failed to update page row to use new revision." );
1754 }
1755
1756 Hooks::run( 'NewRevisionFromEditComplete',
1757 [ $this, $revision, $meta['baseRevId'], $user ] );
1758
1759 // Update recentchanges
1760 if ( !( $flags & EDIT_SUPPRESS_RC ) ) {
1761 // Mark as patrolled if the user can do so
1762 $patrolled = $wgUseRCPatrol && !count(
1763 $this->mTitle->getUserPermissionsErrors( 'autopatrol', $user ) );
1764 // Add RC row to the DB
1765 RecentChange::notifyEdit(
1766 $now,
1767 $this->mTitle,
1768 $revision->isMinor(),
1769 $user,
1770 $summary,
1771 $oldid,
1772 $this->getTimestamp(),
1773 $meta['bot'],
1774 '',
1775 $oldContent ? $oldContent->getSize() : 0,
1776 $newsize,
1777 $revisionId,
1778 $patrolled,
1779 $meta['tags']
1780 );
1781 }
1782
1783 $user->incEditCount();
1784
1785 $dbw->endAtomic( __METHOD__ );
1786 $this->mTimestamp = $now;
1787 } else {
1788 // Bug 32948: revision ID must be set to page {{REVISIONID}} and
1789 // related variables correctly. Likewise for {{REVISIONUSER}} (T135261).
1790 $revision->setId( $this->getLatest() );
1791 $revision->setUserIdAndName(
1792 $this->getUser( Revision::RAW ),
1793 $this->getUserText( Revision::RAW )
1794 );
1795 }
1796
1797 if ( $changed ) {
1798 // Return the new revision to the caller
1799 $status->value['revision'] = $revision;
1800 } else {
1801 $status->warning( 'edit-no-change' );
1802 // Update page_touched as updateRevisionOn() was not called.
1803 // Other cache updates are managed in onArticleEdit() via doEditUpdates().
1804 $this->mTitle->invalidateCache( $now );
1805 }
1806
1807 // Do secondary updates once the main changes have been committed...
1808 DeferredUpdates::addUpdate(
1809 new AtomicSectionUpdate(
1810 $dbw,
1811 __METHOD__,
1812 function () use (
1813 $revision, &$user, $content, $summary, &$flags,
1814 $changed, $meta, &$status
1815 ) {
1816 // Update links tables, site stats, etc.
1817 $this->doEditUpdates(
1818 $revision,
1819 $user,
1820 [
1821 'changed' => $changed,
1822 'oldcountable' => $meta['oldCountable'],
1823 'oldrevision' => $meta['oldRevision']
1824 ]
1825 );
1826 // Avoid PHP 7.1 warning of passing $this by reference
1827 $wikiPage = $this;
1828 // Trigger post-save hook
1829 $params = [ &$wikiPage, &$user, $content, $summary, $flags & EDIT_MINOR,
1830 null, null, &$flags, $revision, &$status, $meta['baseRevId'],
1831 $meta['undidRevId'] ];
1832 Hooks::run( 'PageContentSaveComplete', $params );
1833 }
1834 ),
1835 DeferredUpdates::PRESEND
1836 );
1837
1838 return $status;
1839 }
1840
1841 /**
1842 * @param Content $content Pre-save transform content
1843 * @param integer $flags
1844 * @param User $user
1845 * @param string $summary
1846 * @param array $meta
1847 * @return Status
1848 * @throws DBUnexpectedError
1849 * @throws Exception
1850 * @throws FatalError
1851 * @throws MWException
1852 */
1853 private function doCreate(
1854 Content $content, $flags, User $user, $summary, array $meta
1855 ) {
1856 global $wgUseRCPatrol, $wgUseNPPatrol;
1857
1858 $status = Status::newGood( [ 'new' => true, 'revision' => null ] );
1859
1860 $now = wfTimestampNow();
1861 $newsize = $content->getSize();
1862 $prepStatus = $content->prepareSave( $this, $flags, $meta['oldId'], $user );
1863 $status->merge( $prepStatus );
1864 if ( !$status->isOK() ) {
1865 return $status;
1866 }
1867
1868 $dbw = wfGetDB( DB_MASTER );
1869 $dbw->startAtomic( __METHOD__ );
1870
1871 // Add the page record unless one already exists for the title
1872 $newid = $this->insertOn( $dbw );
1873 if ( $newid === false ) {
1874 $dbw->endAtomic( __METHOD__ ); // nothing inserted
1875 $status->fatal( 'edit-already-exists' );
1876
1877 return $status; // nothing done
1878 }
1879
1880 // At this point we are now comitted to returning an OK
1881 // status unless some DB query error or other exception comes up.
1882 // This way callers don't have to call rollback() if $status is bad
1883 // unless they actually try to catch exceptions (which is rare).
1884
1885 // @TODO: pass content object?!
1886 $revision = new Revision( [
1887 'page' => $newid,
1888 'title' => $this->mTitle, // for determining the default content model
1889 'comment' => $summary,
1890 'minor_edit' => $meta['minor'],
1891 'text' => $meta['serialized'],
1892 'len' => $newsize,
1893 'user' => $user->getId(),
1894 'user_text' => $user->getName(),
1895 'timestamp' => $now,
1896 'content_model' => $content->getModel(),
1897 'content_format' => $meta['serialFormat'],
1898 ] );
1899
1900 // Save the revision text...
1901 $revisionId = $revision->insertOn( $dbw );
1902 // Update the page record with revision data
1903 if ( !$this->updateRevisionOn( $dbw, $revision, 0 ) ) {
1904 throw new MWException( "Failed to update page row to use new revision." );
1905 }
1906
1907 Hooks::run( 'NewRevisionFromEditComplete', [ $this, $revision, false, $user ] );
1908
1909 // Update recentchanges
1910 if ( !( $flags & EDIT_SUPPRESS_RC ) ) {
1911 // Mark as patrolled if the user can do so
1912 $patrolled = ( $wgUseRCPatrol || $wgUseNPPatrol ) &&
1913 !count( $this->mTitle->getUserPermissionsErrors( 'autopatrol', $user ) );
1914 // Add RC row to the DB
1915 RecentChange::notifyNew(
1916 $now,
1917 $this->mTitle,
1918 $revision->isMinor(),
1919 $user,
1920 $summary,
1921 $meta['bot'],
1922 '',
1923 $newsize,
1924 $revisionId,
1925 $patrolled,
1926 $meta['tags']
1927 );
1928 }
1929
1930 $user->incEditCount();
1931
1932 $dbw->endAtomic( __METHOD__ );
1933 $this->mTimestamp = $now;
1934
1935 // Return the new revision to the caller
1936 $status->value['revision'] = $revision;
1937
1938 // Do secondary updates once the main changes have been committed...
1939 DeferredUpdates::addUpdate(
1940 new AtomicSectionUpdate(
1941 $dbw,
1942 __METHOD__,
1943 function () use (
1944 $revision, &$user, $content, $summary, &$flags, $meta, &$status
1945 ) {
1946 // Update links, etc.
1947 $this->doEditUpdates( $revision, $user, [ 'created' => true ] );
1948 // Avoid PHP 7.1 warning of passing $this by reference
1949 $wikiPage = $this;
1950 // Trigger post-create hook
1951 $params = [ &$wikiPage, &$user, $content, $summary,
1952 $flags & EDIT_MINOR, null, null, &$flags, $revision ];
1953 Hooks::run( 'PageContentInsertComplete', $params );
1954 // Trigger post-save hook
1955 $params = array_merge( $params, [ &$status, $meta['baseRevId'] ] );
1956 Hooks::run( 'PageContentSaveComplete', $params );
1957 }
1958 ),
1959 DeferredUpdates::PRESEND
1960 );
1961
1962 return $status;
1963 }
1964
1965 /**
1966 * Get parser options suitable for rendering the primary article wikitext
1967 *
1968 * @see ContentHandler::makeParserOptions
1969 *
1970 * @param IContextSource|User|string $context One of the following:
1971 * - IContextSource: Use the User and the Language of the provided
1972 * context
1973 * - User: Use the provided User object and $wgLang for the language,
1974 * so use an IContextSource object if possible.
1975 * - 'canonical': Canonical options (anonymous user with default
1976 * preferences and content language).
1977 * @return ParserOptions
1978 */
1979 public function makeParserOptions( $context ) {
1980 $options = $this->getContentHandler()->makeParserOptions( $context );
1981
1982 if ( $this->getTitle()->isConversionTable() ) {
1983 // @todo ConversionTable should become a separate content model, so
1984 // we don't need special cases like this one.
1985 $options->disableContentConversion();
1986 }
1987
1988 return $options;
1989 }
1990
1991 /**
1992 * Prepare content which is about to be saved.
1993 * Returns a stdClass with source, pst and output members
1994 *
1995 * @param Content $content
1996 * @param Revision|int|null $revision Revision object. For backwards compatibility, a
1997 * revision ID is also accepted, but this is deprecated.
1998 * @param User|null $user
1999 * @param string|null $serialFormat
2000 * @param bool $useCache Check shared prepared edit cache
2001 *
2002 * @return object
2003 *
2004 * @since 1.21
2005 */
2006 public function prepareContentForEdit(
2007 Content $content, $revision = null, User $user = null,
2008 $serialFormat = null, $useCache = true
2009 ) {
2010 global $wgContLang, $wgUser, $wgAjaxEditStash;
2011
2012 if ( is_object( $revision ) ) {
2013 $revid = $revision->getId();
2014 } else {
2015 $revid = $revision;
2016 // This code path is deprecated, and nothing is known to
2017 // use it, so performance here shouldn't be a worry.
2018 if ( $revid !== null ) {
2019 $revision = Revision::newFromId( $revid, Revision::READ_LATEST );
2020 } else {
2021 $revision = null;
2022 }
2023 }
2024
2025 $user = is_null( $user ) ? $wgUser : $user;
2026 // XXX: check $user->getId() here???
2027
2028 // Use a sane default for $serialFormat, see bug 57026
2029 if ( $serialFormat === null ) {
2030 $serialFormat = $content->getContentHandler()->getDefaultFormat();
2031 }
2032
2033 if ( $this->mPreparedEdit
2034 && isset( $this->mPreparedEdit->newContent )
2035 && $this->mPreparedEdit->newContent->equals( $content )
2036 && $this->mPreparedEdit->revid == $revid
2037 && $this->mPreparedEdit->format == $serialFormat
2038 // XXX: also check $user here?
2039 ) {
2040 // Already prepared
2041 return $this->mPreparedEdit;
2042 }
2043
2044 // The edit may have already been prepared via api.php?action=stashedit
2045 $cachedEdit = $useCache && $wgAjaxEditStash
2046 ? ApiStashEdit::checkCache( $this->getTitle(), $content, $user )
2047 : false;
2048
2049 $popts = ParserOptions::newFromUserAndLang( $user, $wgContLang );
2050 Hooks::run( 'ArticlePrepareTextForEdit', [ $this, $popts ] );
2051
2052 $edit = (object)[];
2053 if ( $cachedEdit ) {
2054 $edit->timestamp = $cachedEdit->timestamp;
2055 } else {
2056 $edit->timestamp = wfTimestampNow();
2057 }
2058 // @note: $cachedEdit is safely not used if the rev ID was referenced in the text
2059 $edit->revid = $revid;
2060
2061 if ( $cachedEdit ) {
2062 $edit->pstContent = $cachedEdit->pstContent;
2063 } else {
2064 $edit->pstContent = $content
2065 ? $content->preSaveTransform( $this->mTitle, $user, $popts )
2066 : null;
2067 }
2068
2069 $edit->format = $serialFormat;
2070 $edit->popts = $this->makeParserOptions( 'canonical' );
2071 if ( $cachedEdit ) {
2072 $edit->output = $cachedEdit->output;
2073 } else {
2074 if ( $revision ) {
2075 // We get here if vary-revision is set. This means that this page references
2076 // itself (such as via self-transclusion). In this case, we need to make sure
2077 // that any such self-references refer to the newly-saved revision, and not
2078 // to the previous one, which could otherwise happen due to replica DB lag.
2079 $oldCallback = $edit->popts->getCurrentRevisionCallback();
2080 $edit->popts->setCurrentRevisionCallback(
2081 function ( Title $title, $parser = false ) use ( $revision, &$oldCallback ) {
2082 if ( $title->equals( $revision->getTitle() ) ) {
2083 return $revision;
2084 } else {
2085 return call_user_func( $oldCallback, $title, $parser );
2086 }
2087 }
2088 );
2089 } else {
2090 // Try to avoid a second parse if {{REVISIONID}} is used
2091 $edit->popts->setSpeculativeRevIdCallback( function () {
2092 return 1 + (int)wfGetDB( DB_MASTER )->selectField(
2093 'revision',
2094 'MAX(rev_id)',
2095 [],
2096 __METHOD__
2097 );
2098 } );
2099 }
2100 $edit->output = $edit->pstContent
2101 ? $edit->pstContent->getParserOutput( $this->mTitle, $revid, $edit->popts )
2102 : null;
2103 }
2104
2105 $edit->newContent = $content;
2106 $edit->oldContent = $this->getContent( Revision::RAW );
2107
2108 // NOTE: B/C for hooks! don't use these fields!
2109 $edit->newText = $edit->newContent
2110 ? ContentHandler::getContentText( $edit->newContent )
2111 : '';
2112 $edit->oldText = $edit->oldContent
2113 ? ContentHandler::getContentText( $edit->oldContent )
2114 : '';
2115 $edit->pst = $edit->pstContent ? $edit->pstContent->serialize( $serialFormat ) : '';
2116
2117 if ( $edit->output ) {
2118 $edit->output->setCacheTime( wfTimestampNow() );
2119 }
2120
2121 // Process cache the result
2122 $this->mPreparedEdit = $edit;
2123
2124 return $edit;
2125 }
2126
2127 /**
2128 * Do standard deferred updates after page edit.
2129 * Update links tables, site stats, search index and message cache.
2130 * Purges pages that include this page if the text was changed here.
2131 * Every 100th edit, prune the recent changes table.
2132 *
2133 * @param Revision $revision
2134 * @param User $user User object that did the revision
2135 * @param array $options Array of options, following indexes are used:
2136 * - changed: boolean, whether the revision changed the content (default true)
2137 * - created: boolean, whether the revision created the page (default false)
2138 * - moved: boolean, whether the page was moved (default false)
2139 * - restored: boolean, whether the page was undeleted (default false)
2140 * - oldrevision: Revision object for the pre-update revision (default null)
2141 * - oldcountable: boolean, null, or string 'no-change' (default null):
2142 * - boolean: whether the page was counted as an article before that
2143 * revision, only used in changed is true and created is false
2144 * - null: if created is false, don't update the article count; if created
2145 * is true, do update the article count
2146 * - 'no-change': don't update the article count, ever
2147 */
2148 public function doEditUpdates( Revision $revision, User $user, array $options = [] ) {
2149 global $wgRCWatchCategoryMembership;
2150
2151 $options += [
2152 'changed' => true,
2153 'created' => false,
2154 'moved' => false,
2155 'restored' => false,
2156 'oldrevision' => null,
2157 'oldcountable' => null
2158 ];
2159 $content = $revision->getContent();
2160
2161 $logger = LoggerFactory::getInstance( 'SaveParse' );
2162
2163 // See if the parser output before $revision was inserted is still valid
2164 $editInfo = false;
2165 if ( !$this->mPreparedEdit ) {
2166 $logger->debug( __METHOD__ . ": No prepared edit...\n" );
2167 } elseif ( $this->mPreparedEdit->output->getFlag( 'vary-revision' ) ) {
2168 $logger->info( __METHOD__ . ": Prepared edit has vary-revision...\n" );
2169 } elseif ( $this->mPreparedEdit->output->getFlag( 'vary-revision-id' )
2170 && $this->mPreparedEdit->output->getSpeculativeRevIdUsed() !== $revision->getId()
2171 ) {
2172 $logger->info( __METHOD__ . ": Prepared edit has vary-revision-id with wrong ID...\n" );
2173 } elseif ( $this->mPreparedEdit->output->getFlag( 'vary-user' ) && !$options['changed'] ) {
2174 $logger->info( __METHOD__ . ": Prepared edit has vary-user and is null...\n" );
2175 } else {
2176 wfDebug( __METHOD__ . ": Using prepared edit...\n" );
2177 $editInfo = $this->mPreparedEdit;
2178 }
2179
2180 if ( !$editInfo ) {
2181 // Parse the text again if needed. Be careful not to do pre-save transform twice:
2182 // $text is usually already pre-save transformed once. Avoid using the edit stash
2183 // as any prepared content from there or in doEditContent() was already rejected.
2184 $editInfo = $this->prepareContentForEdit( $content, $revision, $user, null, false );
2185 }
2186
2187 // Save it to the parser cache.
2188 // Make sure the cache time matches page_touched to avoid double parsing.
2189 ParserCache::singleton()->save(
2190 $editInfo->output, $this, $editInfo->popts,
2191 $revision->getTimestamp(), $editInfo->revid
2192 );
2193
2194 // Update the links tables and other secondary data
2195 if ( $content ) {
2196 $recursive = $options['changed']; // bug 50785
2197 $updates = $content->getSecondaryDataUpdates(
2198 $this->getTitle(), null, $recursive, $editInfo->output
2199 );
2200 foreach ( $updates as $update ) {
2201 if ( $update instanceof LinksUpdate ) {
2202 $update->setRevision( $revision );
2203 $update->setTriggeringUser( $user );
2204 }
2205 DeferredUpdates::addUpdate( $update );
2206 }
2207 if ( $wgRCWatchCategoryMembership
2208 && $this->getContentHandler()->supportsCategories() === true
2209 && ( $options['changed'] || $options['created'] )
2210 && !$options['restored']
2211 ) {
2212 // Note: jobs are pushed after deferred updates, so the job should be able to see
2213 // the recent change entry (also done via deferred updates) and carry over any
2214 // bot/deletion/IP flags, ect.
2215 JobQueueGroup::singleton()->lazyPush( new CategoryMembershipChangeJob(
2216 $this->getTitle(),
2217 [
2218 'pageId' => $this->getId(),
2219 'revTimestamp' => $revision->getTimestamp()
2220 ]
2221 ) );
2222 }
2223 }
2224
2225 // Avoid PHP 7.1 warning of passing $this by reference
2226 $wikiPage = $this;
2227
2228 Hooks::run( 'ArticleEditUpdates', [ &$wikiPage, &$editInfo, $options['changed'] ] );
2229
2230 if ( Hooks::run( 'ArticleEditUpdatesDeleteFromRecentchanges', [ &$wikiPage ] ) ) {
2231 // Flush old entries from the `recentchanges` table
2232 if ( mt_rand( 0, 9 ) == 0 ) {
2233 JobQueueGroup::singleton()->lazyPush( RecentChangesUpdateJob::newPurgeJob() );
2234 }
2235 }
2236
2237 if ( !$this->exists() ) {
2238 return;
2239 }
2240
2241 $id = $this->getId();
2242 $title = $this->mTitle->getPrefixedDBkey();
2243 $shortTitle = $this->mTitle->getDBkey();
2244
2245 if ( $options['oldcountable'] === 'no-change' ||
2246 ( !$options['changed'] && !$options['moved'] )
2247 ) {
2248 $good = 0;
2249 } elseif ( $options['created'] ) {
2250 $good = (int)$this->isCountable( $editInfo );
2251 } elseif ( $options['oldcountable'] !== null ) {
2252 $good = (int)$this->isCountable( $editInfo ) - (int)$options['oldcountable'];
2253 } else {
2254 $good = 0;
2255 }
2256 $edits = $options['changed'] ? 1 : 0;
2257 $total = $options['created'] ? 1 : 0;
2258
2259 DeferredUpdates::addUpdate( new SiteStatsUpdate( 0, $edits, $good, $total ) );
2260 DeferredUpdates::addUpdate( new SearchUpdate( $id, $title, $content ) );
2261
2262 // If this is another user's talk page, update newtalk.
2263 // Don't do this if $options['changed'] = false (null-edits) nor if
2264 // it's a minor edit and the user doesn't want notifications for those.
2265 if ( $options['changed']
2266 && $this->mTitle->getNamespace() == NS_USER_TALK
2267 && $shortTitle != $user->getTitleKey()
2268 && !( $revision->isMinor() && $user->isAllowed( 'nominornewtalk' ) )
2269 ) {
2270 $recipient = User::newFromName( $shortTitle, false );
2271 if ( !$recipient ) {
2272 wfDebug( __METHOD__ . ": invalid username\n" );
2273 } else {
2274 // Avoid PHP 7.1 warning of passing $this by reference
2275 $wikiPage = $this;
2276
2277 // Allow extensions to prevent user notification
2278 // when a new message is added to their talk page
2279 if ( Hooks::run( 'ArticleEditUpdateNewTalk', [ &$wikiPage, $recipient ] ) ) {
2280 if ( User::isIP( $shortTitle ) ) {
2281 // An anonymous user
2282 $recipient->setNewtalk( true, $revision );
2283 } elseif ( $recipient->isLoggedIn() ) {
2284 $recipient->setNewtalk( true, $revision );
2285 } else {
2286 wfDebug( __METHOD__ . ": don't need to notify a nonexistent user\n" );
2287 }
2288 }
2289 }
2290 }
2291
2292 if ( $this->mTitle->getNamespace() == NS_MEDIAWIKI ) {
2293 MessageCache::singleton()->updateMessageOverride( $this->mTitle, $content );
2294 }
2295
2296 if ( $options['created'] ) {
2297 self::onArticleCreate( $this->mTitle );
2298 } elseif ( $options['changed'] ) { // bug 50785
2299 self::onArticleEdit( $this->mTitle, $revision );
2300 }
2301
2302 ResourceLoaderWikiModule::invalidateModuleCache(
2303 $this->mTitle, $options['oldrevision'], $revision, wfWikiID()
2304 );
2305 }
2306
2307 /**
2308 * Update the article's restriction field, and leave a log entry.
2309 * This works for protection both existing and non-existing pages.
2310 *
2311 * @param array $limit Set of restriction keys
2312 * @param array $expiry Per restriction type expiration
2313 * @param int &$cascade Set to false if cascading protection isn't allowed.
2314 * @param string $reason
2315 * @param User $user The user updating the restrictions
2316 * @param string|string[] $tags Change tags to add to the pages and protection log entries
2317 * ($user should be able to add the specified tags before this is called)
2318 * @return Status Status object; if action is taken, $status->value is the log_id of the
2319 * protection log entry.
2320 */
2321 public function doUpdateRestrictions( array $limit, array $expiry,
2322 &$cascade, $reason, User $user, $tags = null
2323 ) {
2324 global $wgCascadingRestrictionLevels, $wgContLang;
2325
2326 if ( wfReadOnly() ) {
2327 return Status::newFatal( 'readonlytext', wfReadOnlyReason() );
2328 }
2329
2330 $this->loadPageData( 'fromdbmaster' );
2331 $restrictionTypes = $this->mTitle->getRestrictionTypes();
2332 $id = $this->getId();
2333
2334 if ( !$cascade ) {
2335 $cascade = false;
2336 }
2337
2338 // Take this opportunity to purge out expired restrictions
2339 Title::purgeExpiredRestrictions();
2340
2341 // @todo FIXME: Same limitations as described in ProtectionForm.php (line 37);
2342 // we expect a single selection, but the schema allows otherwise.
2343 $isProtected = false;
2344 $protect = false;
2345 $changed = false;
2346
2347 $dbw = wfGetDB( DB_MASTER );
2348
2349 foreach ( $restrictionTypes as $action ) {
2350 if ( !isset( $expiry[$action] ) || $expiry[$action] === $dbw->getInfinity() ) {
2351 $expiry[$action] = 'infinity';
2352 }
2353 if ( !isset( $limit[$action] ) ) {
2354 $limit[$action] = '';
2355 } elseif ( $limit[$action] != '' ) {
2356 $protect = true;
2357 }
2358
2359 // Get current restrictions on $action
2360 $current = implode( '', $this->mTitle->getRestrictions( $action ) );
2361 if ( $current != '' ) {
2362 $isProtected = true;
2363 }
2364
2365 if ( $limit[$action] != $current ) {
2366 $changed = true;
2367 } elseif ( $limit[$action] != '' ) {
2368 // Only check expiry change if the action is actually being
2369 // protected, since expiry does nothing on an not-protected
2370 // action.
2371 if ( $this->mTitle->getRestrictionExpiry( $action ) != $expiry[$action] ) {
2372 $changed = true;
2373 }
2374 }
2375 }
2376
2377 if ( !$changed && $protect && $this->mTitle->areRestrictionsCascading() != $cascade ) {
2378 $changed = true;
2379 }
2380
2381 // If nothing has changed, do nothing
2382 if ( !$changed ) {
2383 return Status::newGood();
2384 }
2385
2386 if ( !$protect ) { // No protection at all means unprotection
2387 $revCommentMsg = 'unprotectedarticle-comment';
2388 $logAction = 'unprotect';
2389 } elseif ( $isProtected ) {
2390 $revCommentMsg = 'modifiedarticleprotection-comment';
2391 $logAction = 'modify';
2392 } else {
2393 $revCommentMsg = 'protectedarticle-comment';
2394 $logAction = 'protect';
2395 }
2396
2397 // Truncate for whole multibyte characters
2398 $reason = $wgContLang->truncate( $reason, 255 );
2399
2400 $logRelationsValues = [];
2401 $logRelationsField = null;
2402 $logParamsDetails = [];
2403
2404 // Null revision (used for change tag insertion)
2405 $nullRevision = null;
2406
2407 if ( $id ) { // Protection of existing page
2408 // Avoid PHP 7.1 warning of passing $this by reference
2409 $wikiPage = $this;
2410
2411 if ( !Hooks::run( 'ArticleProtect', [ &$wikiPage, &$user, $limit, $reason ] ) ) {
2412 return Status::newGood();
2413 }
2414
2415 // Only certain restrictions can cascade...
2416 $editrestriction = isset( $limit['edit'] )
2417 ? [ $limit['edit'] ]
2418 : $this->mTitle->getRestrictions( 'edit' );
2419 foreach ( array_keys( $editrestriction, 'sysop' ) as $key ) {
2420 $editrestriction[$key] = 'editprotected'; // backwards compatibility
2421 }
2422 foreach ( array_keys( $editrestriction, 'autoconfirmed' ) as $key ) {
2423 $editrestriction[$key] = 'editsemiprotected'; // backwards compatibility
2424 }
2425
2426 $cascadingRestrictionLevels = $wgCascadingRestrictionLevels;
2427 foreach ( array_keys( $cascadingRestrictionLevels, 'sysop' ) as $key ) {
2428 $cascadingRestrictionLevels[$key] = 'editprotected'; // backwards compatibility
2429 }
2430 foreach ( array_keys( $cascadingRestrictionLevels, 'autoconfirmed' ) as $key ) {
2431 $cascadingRestrictionLevels[$key] = 'editsemiprotected'; // backwards compatibility
2432 }
2433
2434 // The schema allows multiple restrictions
2435 if ( !array_intersect( $editrestriction, $cascadingRestrictionLevels ) ) {
2436 $cascade = false;
2437 }
2438
2439 // insert null revision to identify the page protection change as edit summary
2440 $latest = $this->getLatest();
2441 $nullRevision = $this->insertProtectNullRevision(
2442 $revCommentMsg,
2443 $limit,
2444 $expiry,
2445 $cascade,
2446 $reason,
2447 $user
2448 );
2449
2450 if ( $nullRevision === null ) {
2451 return Status::newFatal( 'no-null-revision', $this->mTitle->getPrefixedText() );
2452 }
2453
2454 $logRelationsField = 'pr_id';
2455
2456 // Update restrictions table
2457 foreach ( $limit as $action => $restrictions ) {
2458 $dbw->delete(
2459 'page_restrictions',
2460 [
2461 'pr_page' => $id,
2462 'pr_type' => $action
2463 ],
2464 __METHOD__
2465 );
2466 if ( $restrictions != '' ) {
2467 $cascadeValue = ( $cascade && $action == 'edit' ) ? 1 : 0;
2468 $dbw->insert(
2469 'page_restrictions',
2470 [
2471 'pr_id' => $dbw->nextSequenceValue( 'page_restrictions_pr_id_seq' ),
2472 'pr_page' => $id,
2473 'pr_type' => $action,
2474 'pr_level' => $restrictions,
2475 'pr_cascade' => $cascadeValue,
2476 'pr_expiry' => $dbw->encodeExpiry( $expiry[$action] )
2477 ],
2478 __METHOD__
2479 );
2480 $logRelationsValues[] = $dbw->insertId();
2481 $logParamsDetails[] = [
2482 'type' => $action,
2483 'level' => $restrictions,
2484 'expiry' => $expiry[$action],
2485 'cascade' => (bool)$cascadeValue,
2486 ];
2487 }
2488 }
2489
2490 // Clear out legacy restriction fields
2491 $dbw->update(
2492 'page',
2493 [ 'page_restrictions' => '' ],
2494 [ 'page_id' => $id ],
2495 __METHOD__
2496 );
2497
2498 // Avoid PHP 7.1 warning of passing $this by reference
2499 $wikiPage = $this;
2500
2501 Hooks::run( 'NewRevisionFromEditComplete',
2502 [ $this, $nullRevision, $latest, $user ] );
2503 Hooks::run( 'ArticleProtectComplete', [ &$wikiPage, &$user, $limit, $reason ] );
2504 } else { // Protection of non-existing page (also known as "title protection")
2505 // Cascade protection is meaningless in this case
2506 $cascade = false;
2507
2508 if ( $limit['create'] != '' ) {
2509 $dbw->replace( 'protected_titles',
2510 [ [ 'pt_namespace', 'pt_title' ] ],
2511 [
2512 'pt_namespace' => $this->mTitle->getNamespace(),
2513 'pt_title' => $this->mTitle->getDBkey(),
2514 'pt_create_perm' => $limit['create'],
2515 'pt_timestamp' => $dbw->timestamp(),
2516 'pt_expiry' => $dbw->encodeExpiry( $expiry['create'] ),
2517 'pt_user' => $user->getId(),
2518 'pt_reason' => $reason,
2519 ], __METHOD__
2520 );
2521 $logParamsDetails[] = [
2522 'type' => 'create',
2523 'level' => $limit['create'],
2524 'expiry' => $expiry['create'],
2525 ];
2526 } else {
2527 $dbw->delete( 'protected_titles',
2528 [
2529 'pt_namespace' => $this->mTitle->getNamespace(),
2530 'pt_title' => $this->mTitle->getDBkey()
2531 ], __METHOD__
2532 );
2533 }
2534 }
2535
2536 $this->mTitle->flushRestrictions();
2537 InfoAction::invalidateCache( $this->mTitle );
2538
2539 if ( $logAction == 'unprotect' ) {
2540 $params = [];
2541 } else {
2542 $protectDescriptionLog = $this->protectDescriptionLog( $limit, $expiry );
2543 $params = [
2544 '4::description' => $protectDescriptionLog, // parameter for IRC
2545 '5:bool:cascade' => $cascade,
2546 'details' => $logParamsDetails, // parameter for localize and api
2547 ];
2548 }
2549
2550 // Update the protection log
2551 $logEntry = new ManualLogEntry( 'protect', $logAction );
2552 $logEntry->setTarget( $this->mTitle );
2553 $logEntry->setComment( $reason );
2554 $logEntry->setPerformer( $user );
2555 $logEntry->setParameters( $params );
2556 if ( !is_null( $nullRevision ) ) {
2557 $logEntry->setAssociatedRevId( $nullRevision->getId() );
2558 }
2559 $logEntry->setTags( $tags );
2560 if ( $logRelationsField !== null && count( $logRelationsValues ) ) {
2561 $logEntry->setRelations( [ $logRelationsField => $logRelationsValues ] );
2562 }
2563 $logId = $logEntry->insert();
2564 $logEntry->publish( $logId );
2565
2566 return Status::newGood( $logId );
2567 }
2568
2569 /**
2570 * Insert a new null revision for this page.
2571 *
2572 * @param string $revCommentMsg Comment message key for the revision
2573 * @param array $limit Set of restriction keys
2574 * @param array $expiry Per restriction type expiration
2575 * @param int $cascade Set to false if cascading protection isn't allowed.
2576 * @param string $reason
2577 * @param User|null $user
2578 * @return Revision|null Null on error
2579 */
2580 public function insertProtectNullRevision( $revCommentMsg, array $limit,
2581 array $expiry, $cascade, $reason, $user = null
2582 ) {
2583 $dbw = wfGetDB( DB_MASTER );
2584
2585 // Prepare a null revision to be added to the history
2586 $editComment = wfMessage(
2587 $revCommentMsg,
2588 $this->mTitle->getPrefixedText(),
2589 $user ? $user->getName() : ''
2590 )->inContentLanguage()->text();
2591 if ( $reason ) {
2592 $editComment .= wfMessage( 'colon-separator' )->inContentLanguage()->text() . $reason;
2593 }
2594 $protectDescription = $this->protectDescription( $limit, $expiry );
2595 if ( $protectDescription ) {
2596 $editComment .= wfMessage( 'word-separator' )->inContentLanguage()->text();
2597 $editComment .= wfMessage( 'parentheses' )->params( $protectDescription )
2598 ->inContentLanguage()->text();
2599 }
2600 if ( $cascade ) {
2601 $editComment .= wfMessage( 'word-separator' )->inContentLanguage()->text();
2602 $editComment .= wfMessage( 'brackets' )->params(
2603 wfMessage( 'protect-summary-cascade' )->inContentLanguage()->text()
2604 )->inContentLanguage()->text();
2605 }
2606
2607 $nullRev = Revision::newNullRevision( $dbw, $this->getId(), $editComment, true, $user );
2608 if ( $nullRev ) {
2609 $nullRev->insertOn( $dbw );
2610
2611 // Update page record and touch page
2612 $oldLatest = $nullRev->getParentId();
2613 $this->updateRevisionOn( $dbw, $nullRev, $oldLatest );
2614 }
2615
2616 return $nullRev;
2617 }
2618
2619 /**
2620 * @param string $expiry 14-char timestamp or "infinity", or false if the input was invalid
2621 * @return string
2622 */
2623 protected function formatExpiry( $expiry ) {
2624 global $wgContLang;
2625
2626 if ( $expiry != 'infinity' ) {
2627 return wfMessage(
2628 'protect-expiring',
2629 $wgContLang->timeanddate( $expiry, false, false ),
2630 $wgContLang->date( $expiry, false, false ),
2631 $wgContLang->time( $expiry, false, false )
2632 )->inContentLanguage()->text();
2633 } else {
2634 return wfMessage( 'protect-expiry-indefinite' )
2635 ->inContentLanguage()->text();
2636 }
2637 }
2638
2639 /**
2640 * Builds the description to serve as comment for the edit.
2641 *
2642 * @param array $limit Set of restriction keys
2643 * @param array $expiry Per restriction type expiration
2644 * @return string
2645 */
2646 public function protectDescription( array $limit, array $expiry ) {
2647 $protectDescription = '';
2648
2649 foreach ( array_filter( $limit ) as $action => $restrictions ) {
2650 # $action is one of $wgRestrictionTypes = [ 'create', 'edit', 'move', 'upload' ].
2651 # All possible message keys are listed here for easier grepping:
2652 # * restriction-create
2653 # * restriction-edit
2654 # * restriction-move
2655 # * restriction-upload
2656 $actionText = wfMessage( 'restriction-' . $action )->inContentLanguage()->text();
2657 # $restrictions is one of $wgRestrictionLevels = [ '', 'autoconfirmed', 'sysop' ],
2658 # with '' filtered out. All possible message keys are listed below:
2659 # * protect-level-autoconfirmed
2660 # * protect-level-sysop
2661 $restrictionsText = wfMessage( 'protect-level-' . $restrictions )
2662 ->inContentLanguage()->text();
2663
2664 $expiryText = $this->formatExpiry( $expiry[$action] );
2665
2666 if ( $protectDescription !== '' ) {
2667 $protectDescription .= wfMessage( 'word-separator' )->inContentLanguage()->text();
2668 }
2669 $protectDescription .= wfMessage( 'protect-summary-desc' )
2670 ->params( $actionText, $restrictionsText, $expiryText )
2671 ->inContentLanguage()->text();
2672 }
2673
2674 return $protectDescription;
2675 }
2676
2677 /**
2678 * Builds the description to serve as comment for the log entry.
2679 *
2680 * Some bots may parse IRC lines, which are generated from log entries which contain plain
2681 * protect description text. Keep them in old format to avoid breaking compatibility.
2682 * TODO: Fix protection log to store structured description and format it on-the-fly.
2683 *
2684 * @param array $limit Set of restriction keys
2685 * @param array $expiry Per restriction type expiration
2686 * @return string
2687 */
2688 public function protectDescriptionLog( array $limit, array $expiry ) {
2689 global $wgContLang;
2690
2691 $protectDescriptionLog = '';
2692
2693 foreach ( array_filter( $limit ) as $action => $restrictions ) {
2694 $expiryText = $this->formatExpiry( $expiry[$action] );
2695 $protectDescriptionLog .= $wgContLang->getDirMark() .
2696 "[$action=$restrictions] ($expiryText)";
2697 }
2698
2699 return trim( $protectDescriptionLog );
2700 }
2701
2702 /**
2703 * Take an array of page restrictions and flatten it to a string
2704 * suitable for insertion into the page_restrictions field.
2705 *
2706 * @param string[] $limit
2707 *
2708 * @throws MWException
2709 * @return string
2710 */
2711 protected static function flattenRestrictions( $limit ) {
2712 if ( !is_array( $limit ) ) {
2713 throw new MWException( __METHOD__ . ' given non-array restriction set' );
2714 }
2715
2716 $bits = [];
2717 ksort( $limit );
2718
2719 foreach ( array_filter( $limit ) as $action => $restrictions ) {
2720 $bits[] = "$action=$restrictions";
2721 }
2722
2723 return implode( ':', $bits );
2724 }
2725
2726 /**
2727 * Same as doDeleteArticleReal(), but returns a simple boolean. This is kept around for
2728 * backwards compatibility, if you care about error reporting you should use
2729 * doDeleteArticleReal() instead.
2730 *
2731 * Deletes the article with database consistency, writes logs, purges caches
2732 *
2733 * @param string $reason Delete reason for deletion log
2734 * @param bool $suppress Suppress all revisions and log the deletion in
2735 * the suppression log instead of the deletion log
2736 * @param int $u1 Unused
2737 * @param bool $u2 Unused
2738 * @param array|string &$error Array of errors to append to
2739 * @param User $user The deleting user
2740 * @return bool True if successful
2741 */
2742 public function doDeleteArticle(
2743 $reason, $suppress = false, $u1 = null, $u2 = null, &$error = '', User $user = null
2744 ) {
2745 $status = $this->doDeleteArticleReal( $reason, $suppress, $u1, $u2, $error, $user );
2746 return $status->isGood();
2747 }
2748
2749 /**
2750 * Back-end article deletion
2751 * Deletes the article with database consistency, writes logs, purges caches
2752 *
2753 * @since 1.19
2754 *
2755 * @param string $reason Delete reason for deletion log
2756 * @param bool $suppress Suppress all revisions and log the deletion in
2757 * the suppression log instead of the deletion log
2758 * @param int $u1 Unused
2759 * @param bool $u2 Unused
2760 * @param array|string &$error Array of errors to append to
2761 * @param User $user The deleting user
2762 * @param array $tags Tags to apply to the deletion action
2763 * @return Status Status object; if successful, $status->value is the log_id of the
2764 * deletion log entry. If the page couldn't be deleted because it wasn't
2765 * found, $status is a non-fatal 'cannotdelete' error
2766 */
2767 public function doDeleteArticleReal(
2768 $reason, $suppress = false, $u1 = null, $u2 = null, &$error = '', User $user = null,
2769 $tags = [], $logsubtype = 'delete'
2770 ) {
2771 global $wgUser, $wgContentHandlerUseDB;
2772
2773 wfDebug( __METHOD__ . "\n" );
2774
2775 $status = Status::newGood();
2776
2777 if ( $this->mTitle->getDBkey() === '' ) {
2778 $status->error( 'cannotdelete',
2779 wfEscapeWikiText( $this->getTitle()->getPrefixedText() ) );
2780 return $status;
2781 }
2782
2783 // Avoid PHP 7.1 warning of passing $this by reference
2784 $wikiPage = $this;
2785
2786 $user = is_null( $user ) ? $wgUser : $user;
2787 if ( !Hooks::run( 'ArticleDelete',
2788 [ &$wikiPage, &$user, &$reason, &$error, &$status, $suppress ]
2789 ) ) {
2790 if ( $status->isOK() ) {
2791 // Hook aborted but didn't set a fatal status
2792 $status->fatal( 'delete-hook-aborted' );
2793 }
2794 return $status;
2795 }
2796
2797 $dbw = wfGetDB( DB_MASTER );
2798 $dbw->startAtomic( __METHOD__ );
2799
2800 $this->loadPageData( self::READ_LATEST );
2801 $id = $this->getId();
2802 // T98706: lock the page from various other updates but avoid using
2803 // WikiPage::READ_LOCKING as that will carry over the FOR UPDATE to
2804 // the revisions queries (which also JOIN on user). Only lock the page
2805 // row and CAS check on page_latest to see if the trx snapshot matches.
2806 $lockedLatest = $this->lockAndGetLatest();
2807 if ( $id == 0 || $this->getLatest() != $lockedLatest ) {
2808 $dbw->endAtomic( __METHOD__ );
2809 // Page not there or trx snapshot is stale
2810 $status->error( 'cannotdelete',
2811 wfEscapeWikiText( $this->getTitle()->getPrefixedText() ) );
2812 return $status;
2813 }
2814
2815 // Given the lock above, we can be confident in the title and page ID values
2816 $namespace = $this->getTitle()->getNamespace();
2817 $dbKey = $this->getTitle()->getDBkey();
2818
2819 // At this point we are now comitted to returning an OK
2820 // status unless some DB query error or other exception comes up.
2821 // This way callers don't have to call rollback() if $status is bad
2822 // unless they actually try to catch exceptions (which is rare).
2823
2824 // we need to remember the old content so we can use it to generate all deletion updates.
2825 $revision = $this->getRevision();
2826 try {
2827 $content = $this->getContent( Revision::RAW );
2828 } catch ( Exception $ex ) {
2829 wfLogWarning( __METHOD__ . ': failed to load content during deletion! '
2830 . $ex->getMessage() );
2831
2832 $content = null;
2833 }
2834
2835 $fields = Revision::selectFields();
2836 $bitfield = false;
2837
2838 // Bitfields to further suppress the content
2839 if ( $suppress ) {
2840 $bitfield = Revision::SUPPRESSED_ALL;
2841 $fields = array_diff( $fields, [ 'rev_deleted' ] );
2842 }
2843
2844 // For now, shunt the revision data into the archive table.
2845 // Text is *not* removed from the text table; bulk storage
2846 // is left intact to avoid breaking block-compression or
2847 // immutable storage schemes.
2848 // In the future, we may keep revisions and mark them with
2849 // the rev_deleted field, which is reserved for this purpose.
2850
2851 // Get all of the page revisions
2852 $res = $dbw->select(
2853 'revision',
2854 $fields,
2855 [ 'rev_page' => $id ],
2856 __METHOD__,
2857 'FOR UPDATE'
2858 );
2859 // Build their equivalent archive rows
2860 $rowsInsert = [];
2861 foreach ( $res as $row ) {
2862 $rowInsert = [
2863 'ar_namespace' => $namespace,
2864 'ar_title' => $dbKey,
2865 'ar_comment' => $row->rev_comment,
2866 'ar_user' => $row->rev_user,
2867 'ar_user_text' => $row->rev_user_text,
2868 'ar_timestamp' => $row->rev_timestamp,
2869 'ar_minor_edit' => $row->rev_minor_edit,
2870 'ar_rev_id' => $row->rev_id,
2871 'ar_parent_id' => $row->rev_parent_id,
2872 'ar_text_id' => $row->rev_text_id,
2873 'ar_text' => '',
2874 'ar_flags' => '',
2875 'ar_len' => $row->rev_len,
2876 'ar_page_id' => $id,
2877 'ar_deleted' => $suppress ? $bitfield : $row->rev_deleted,
2878 'ar_sha1' => $row->rev_sha1,
2879 ];
2880 if ( $wgContentHandlerUseDB ) {
2881 $rowInsert['ar_content_model'] = $row->rev_content_model;
2882 $rowInsert['ar_content_format'] = $row->rev_content_format;
2883 }
2884 $rowsInsert[] = $rowInsert;
2885 }
2886 // Copy them into the archive table
2887 $dbw->insert( 'archive', $rowsInsert, __METHOD__ );
2888 // Save this so we can pass it to the ArticleDeleteComplete hook.
2889 $archivedRevisionCount = $dbw->affectedRows();
2890
2891 // Clone the title and wikiPage, so we have the information we need when
2892 // we log and run the ArticleDeleteComplete hook.
2893 $logTitle = clone $this->mTitle;
2894 $wikiPageBeforeDelete = clone $this;
2895
2896 // Now that it's safely backed up, delete it
2897 $dbw->delete( 'page', [ 'page_id' => $id ], __METHOD__ );
2898 $dbw->delete( 'revision', [ 'rev_page' => $id ], __METHOD__ );
2899
2900 // Log the deletion, if the page was suppressed, put it in the suppression log instead
2901 $logtype = $suppress ? 'suppress' : 'delete';
2902
2903 $logEntry = new ManualLogEntry( $logtype, $logsubtype );
2904 $logEntry->setPerformer( $user );
2905 $logEntry->setTarget( $logTitle );
2906 $logEntry->setComment( $reason );
2907 $logEntry->setTags( $tags );
2908 $logid = $logEntry->insert();
2909
2910 $dbw->onTransactionPreCommitOrIdle(
2911 function () use ( $dbw, $logEntry, $logid ) {
2912 // Bug 56776: avoid deadlocks (especially from FileDeleteForm)
2913 $logEntry->publish( $logid );
2914 },
2915 __METHOD__
2916 );
2917
2918 $dbw->endAtomic( __METHOD__ );
2919
2920 $this->doDeleteUpdates( $id, $content, $revision );
2921
2922 Hooks::run( 'ArticleDeleteComplete', [
2923 &$wikiPageBeforeDelete,
2924 &$user,
2925 $reason,
2926 $id,
2927 $content,
2928 $logEntry,
2929 $archivedRevisionCount
2930 ] );
2931 $status->value = $logid;
2932
2933 // Show log excerpt on 404 pages rather than just a link
2934 $cache = ObjectCache::getMainStashInstance();
2935 $key = wfMemcKey( 'page-recent-delete', md5( $logTitle->getPrefixedText() ) );
2936 $cache->set( $key, 1, $cache::TTL_DAY );
2937
2938 return $status;
2939 }
2940
2941 /**
2942 * Lock the page row for this title+id and return page_latest (or 0)
2943 *
2944 * @return integer Returns 0 if no row was found with this title+id
2945 * @since 1.27
2946 */
2947 public function lockAndGetLatest() {
2948 return (int)wfGetDB( DB_MASTER )->selectField(
2949 'page',
2950 'page_latest',
2951 [
2952 'page_id' => $this->getId(),
2953 // Typically page_id is enough, but some code might try to do
2954 // updates assuming the title is the same, so verify that
2955 'page_namespace' => $this->getTitle()->getNamespace(),
2956 'page_title' => $this->getTitle()->getDBkey()
2957 ],
2958 __METHOD__,
2959 [ 'FOR UPDATE' ]
2960 );
2961 }
2962
2963 /**
2964 * Do some database updates after deletion
2965 *
2966 * @param int $id The page_id value of the page being deleted
2967 * @param Content|null $content Optional page content to be used when determining
2968 * the required updates. This may be needed because $this->getContent()
2969 * may already return null when the page proper was deleted.
2970 * @param Revision|null $revision The latest page revision
2971 */
2972 public function doDeleteUpdates( $id, Content $content = null, Revision $revision = null ) {
2973 try {
2974 $countable = $this->isCountable();
2975