| blob | ad45b44e2dcac9332aec1b23809b2875f50850f1 |
1 <?php
2 /**
3 * File for articles
4 * @file
5 */
7 /**
8 * Class representing a MediaWiki article and history.
9 *
10 * See design.txt for an overview.
11 * Note: edit user interface and cache support functions have been
12 * moved to separate EditPage and HTMLFileCache classes.
13 *
14 */
16 /**@{{
17 * @private
18 */
43 /**@}}*/
45 /**
46 * Constructor and clear the article
47 * @param $title Reference to a Title object.
48 * @param $oldId Integer revision ID, null to fetch from request, zero for current
49 */
53 }
55 /**
56 * Tell the page view functions that this view was redirected
57 * from another page on the wiki.
58 * @param $from Title object.
59 */
62 }
64 /**
65 * If this page is a redirect, get its target
66 *
67 * The target will be fetched from the redirect table if possible.
68 * If this page doesn't have an entry there, call insertRedirect()
69 * @return mixed Title object, or null if this page is not a redirect
70 */
77 # Query the redirect table
82 __METHOD__
83 );
88 # This page doesn't have an entry in the redirect table
90 }
92 /**
93 * Insert an entry for this page into the redirect table.
94 *
95 * Don't call this function directly unless you know what you're doing.
96 * @return Title object
97 */
109 }
111 /**
112 * Get the Title object this page redirects to
113 *
114 * @return mixed false, Title of in-wiki target, or string with URL
115 */
119 }
121 /**
122 * Get the Title object this text redirects to
123 *
124 * @return mixed false, Title of in-wiki target, or string with URL
125 */
128 # process if title object is valid and not special:userlogout
132 // Offsite wikis need an HTTP redirect.
133 //
134 // This can be hard to reverse and may produce loops,
135 // so they may be disabled in the site configuration.
139 }
142 // Gotta handle redirects to special pages differently:
143 // Fill the HTTP response "Location" header and ignore
144 // the rest of the page we're on.
145 //
146 // This can be hard to reverse, so they may be disabled.
149 // rolleyes
152 }
153 }
155 }
156 }
157 // No or invalid redirect
159 }
161 /**
162 * get the title object of the article
163 */
166 }
168 /**
169 * Clear the object
170 * @private
171 */
189 }
191 /**
192 * Note that getContent/loadContent do not follow redirects anymore.
193 * If you need to fetch redirectable content easily, try
194 * the shortcut in Article::followContent()
195 * FIXME
196 * @todo There are still side-effects in this!
197 * In general, you should use the Revision class, not Article,
198 * to fetch text for purposes other than page views.
199 *
200 * @return Return the text of this revision
201 */
216 }
223 }
224 }
226 /**
227 * This function returns the text of a section, specified by a number ($section).
228 * A section is text under a heading like == Heading == or \<h1\>Heading\</h1\>, or
229 * the first section before any such heading (section 0).
230 *
231 * If a section contains subsections, these are also returned.
232 *
233 * @param $text String: text to look in
234 * @param $section Integer: section number
235 * @return string text of the requested section
236 * @deprecated
237 */
241 }
243 /**
244 * @return int The oldid of the article that is to be shown, 0 for the
245 * current revision
246 */
250 }
252 }
254 /**
255 * Sets $this->mRedirectUrl to a correct URL if the query parameters are incorrect
256 *
257 * @return int The old id for the request
258 */
271 }
277 # TODO
278 }
279 }
280 # unused:
281 # $lastid = $oldid;
282 }
286 }
288 }
290 /**
291 * Load the revision (including text) into this object
292 */
296 # Query variables :P
299 # Pre-fill content with error message so that if something
300 # fails we'll have something telling us what we intended.
303 }
306 /**
307 * Fetch a page record with the given conditions
308 * @param Database $dbr
309 * @param array $conditions
310 * @private
311 */
325 );
331 __METHOD__
332 );
335 }
337 /**
338 * @param Database $dbr
339 * @param Title $title
340 */
345 }
347 /**
348 * @param Database $dbr
349 * @param int $id
350 */
353 }
355 /**
356 * Set the general counter, title etc data loaded from
357 * some source.
358 *
359 * @param object $data
360 * @private
361 */
366 }
374 # Old-fashioned restrictions.
384 }
386 }
389 }
391 /**
392 * Get text of an article from database
393 * Does *NOT* follow redirects.
394 * @param int $oldid 0 for whatever the latest revision is
395 * @return string
396 */
400 }
404 # Pre-fill content with error message so that if something
405 # fails we'll have something telling us what we intended.
415 }
420 }
427 wfDebug( __METHOD__." failed to find page data for title " . $this->mTitle->getPrefixedText() . "\n" );
429 }
431 }
436 }
437 }
439 // FIXME: Horrible, horrible! This content-loading interface just plain sucks.
440 // We should instead work with the Revision object when we need it...
455 }
457 /**
458 * Read/write accessor to select FOR UPDATE
459 *
460 * @param $x Mixed: FIXME
461 */
464 }
466 /**
467 * Get the database which should be used for reads
468 *
469 * @return Database
470 * @deprecated - just call wfGetDB( DB_MASTER ) instead
471 */
475 }
477 /**
478 * Get options for all SELECT statements
479 *
480 * @param $options Array: an optional options array which'll be appended to
481 * the default
482 * @return Array: options
483 */
490 }
491 }
493 }
495 /**
496 * @return int Page ID
497 */
503 }
504 }
506 /**
507 * @return bool Whether or not the page exists in the database
508 */
511 }
513 /**
514 * @return int The view count for the page
515 */
525 }
526 }
528 }
530 /**
531 * Determine whether a page would be suitable for being counted as an
532 * article in the site_stats table based on the title & its content
533 *
534 * @param $text String: text to analyze
535 * @return bool
536 */
541 return
545 }
547 /**
548 * Tests if the article text represents a redirect
549 *
550 * @param $text String: FIXME
551 * @return bool
552 */
558 // Apparently loadPageData was never called
563 }
565 }
567 /**
568 * Returns true if the currently-referenced revision is the current edit
569 * to this page (and it exists).
570 * @return bool
571 */
573 # If no oldid, this is the current version.
580 }
582 /**
583 * Loads everything except the text
584 * This isn't necessary for all uses, so it's only done if needed.
585 * @private
586 */
591 # New or non-existent articles have no user information
603 }
604 }
607 // Check if the field has been filled by ParserCache::get()
610 }
612 }
617 }
622 }
627 }
632 }
637 }
639 /**
640 * @param $limit Integer: default 0.
641 * @param $offset Integer: default 0.
642 */
644 # XXX: this is expensive; cache this info somewhere.
657 GROUP BY rev_user, rev_user_text, user_real_name
669 }
673 }
675 /**
676 * This is the default action of the script: just view the page of
677 * the given title.
678 */
691 # Get variables from query string
694 # getOldID may want us to redirect somewhere else
699 }
709 # Discourage indexing of printable versions, but encourage following
715 # Honour customised robot policies for this namespace
719 }
722 # If we got diff and oldid in the query, we want to see a
723 # diff page instead of the article.
729 // DifferenceEngine directly fetched the revision:
733 // Needed to get the page's current revision
736 # Run view updates for current revision only
738 }
741 }
750 # tell wgOut that output is taken care of
755 }
756 }
758 # Should the parser cache be used?
763 }
767 // This is an internally redirected page view.
768 // We'll need a backlink to the source page for navigation.
774 // Set the fragment if one was specified in the redirect
778 }
780 }
782 // This is an externally redirected view, from some other wiki.
783 // If it was reported from a trusted site, supply a backlink.
790 }
791 }
797 // Ensure that UI elements requiring revision ID have
798 // the correct version information.
801 }
802 }
803 # Fetch content and check for errors
807 # Failed to load, replace text with error message
814 }
815 }
817 # Another whitelist check in case oldid is altering the title
823 }
825 # We're looking at an old revision
829 // FIXME: This would be a nice place to load the 'no such page' text.
840 // and we are allowed to see...
841 }
842 }
843 }
844 }
848 // Pages containing custom CSS or JavaScript get special treatment
851 // Give hooks a chance to customise the output
853 // Wrap the whole lot in a <pre> and don't parse
859 }
861 # Don't append the subtitle if this was an old revision
866 # Display content and save to parser cache
869 # Display content, don't attempt to save to parser cache
870 # Don't show section-edit links on old revisions... this way lies madness.
873 }
874 # Display content and don't save to parser cache
875 # With timing hack -- TS 2006-07-26
880 # Timing hack
884 }
888 }
889 }
890 }
891 /* title may have been set from the cache */
895 }
897 # check if we're displaying a [[User talk:x.x.x.x]] anonymous talk page
900 }
902 # If we have been passed an &rcid= parameter, we want to give the user a
903 # chance to mark this new article as patrolled.
904 if( !is_null( $rcid ) && $rcid != 0 && $wgUser->isAllowed( 'patrol' ) && $this->mTitle->exists() ) {
910 ) .
911 '</div>'
912 );
913 }
915 # Trackbacks
921 }
923 /*
924 * Should the parser cache be used?
925 */
935 }
940 # Display redirect
946 }
950 else
956 }
966 );
978 }
986 }
988 }
996 }
1001 {
1004 }
1010 }
1017 }
1019 /**
1020 * Handle action=purge
1021 */
1028 }
1041 }
1042 }
1044 /**
1045 * Perform the actions of a page purging
1046 */
1049 // Invalidate the cache
1053 // Commit the transaction before the purge is sent
1057 // Send purge
1060 }
1067 }
1069 }
1071 }
1073 /**
1074 * Insert a new empty page record for this article.
1075 * This *must* be followed up by creating a revision
1076 * and running $this->updateToLatest( $rev_id );
1077 * or else the record will be left in a funky state.
1078 * Best if all done inside a transaction.
1079 *
1080 * @param Database $dbw
1081 * @return int The newly created page_id key
1082 * @private
1083 */
1107 }
1109 /**
1110 * Update the page record to point to a newly saved revision.
1111 *
1112 * @param Database $dbw
1113 * @param Revision $revision For ID number, and text used to set
1114 length and redirect status fields
1115 * @param int $lastRevision If given, will not overwrite the page field
1116 * when different from the currently set value.
1117 * Giving 0 indicates the new page flag should
1118 * be set on.
1119 * @param bool $lastRevIsRedirect If given, will optimize adding and
1120 * removing rows in redirect table.
1121 * @return bool true on success, false on failure
1122 * @private
1123 */
1124 function updateRevisionOn( &$dbw, $revision, $lastRevision = null, $lastRevIsRedirect = null ) {
1132 # An extra check against threads stepping on each other
1134 }
1143 ),
1145 __METHOD__ );
1151 }
1155 }
1157 /**
1158 * Add row to the redirect table if this is a redirect, remove otherwise.
1159 *
1160 * @param Database $dbw
1161 * @param $redirectTitle a title object pointing to the redirect target,
1162 * or NULL if this is not a redirect
1163 * @param bool $lastRevIsRedirect If given, will optimize adding and
1164 * removing rows in redirect table.
1165 * @return bool true on success, false on failure
1166 * @private
1167 */
1170 // Always update redirects (target link might have changed)
1171 // Update/Insert if we don't know if the last revision was a redirect or not
1172 // Delete if changing from redirect to non-redirect
1180 // This title is a redirect, Add/Update row in the redirect table
1185 );
1189 // This is not a redirect, remove row from redirect table
1192 }
1198 }
1201 }
1203 /**
1204 * If the given revision is newer than the currently set page_latest,
1205 * update the page record. Otherwise, do nothing.
1206 *
1207 * @param Database $dbw
1208 * @param Revision $revision
1209 */
1219 __METHOD__ );
1224 }
1228 # No or missing previous revision; mark the page as new
1231 }
1236 }
1238 /**
1239 * @return string Complete article text, or null if error
1240 */
1245 // Whole-page edit; let the text through unmolested.
1252 }
1257 }
1261 # Inserting a new section
1267 # Replacing an existing section; roll out the big guns
1270 }
1272 }
1276 }
1278 /**
1279 * @deprecated use Article::doEdit()
1280 */
1281 function insertNewArticle( $text, $summary, $isminor, $watchthis, $suppressRC=false, $comment=false, $bot=false ) {
1287 # If this is a comment, add the summary as headline
1290 }
1300 }
1306 }
1307 }
1309 }
1311 /**
1312 * @deprecated use Article::doEdit()
1313 */
1314 function updateArticle( $text, $summary, $minor, $watchthis, $forceBot = false, $sectionanchor = '' ) {
1327 }
1333 }
1334 }
1340 }
1342 }
1344 /**
1345 * Article::doEdit()
1346 *
1347 * Change an existing article or create a new article. Updates RC and all necessary caches,
1348 * optionally via the deferred update array.
1349 *
1350 * $wgUser must be set before calling this function.
1351 *
1352 * @param string $text New text
1353 * @param string $summary Edit summary
1354 * @param integer $flags bitfield:
1355 * EDIT_NEW
1356 * Article is known or assumed to be non-existent, create a new one
1357 * EDIT_UPDATE
1358 * Article is known or assumed to be pre-existing, update it
1359 * EDIT_MINOR
1360 * Mark this edit minor, if the user is allowed to do so
1361 * EDIT_SUPPRESS_RC
1362 * Do not log the change in recentchanges
1363 * EDIT_FORCE_BOT
1364 * Mark the edit a "bot" edit regardless of user rights
1365 * EDIT_DEFER_UPDATES
1366 * Defer some of the updates until the end of index.php
1367 * EDIT_AUTOSUMMARY
1368 * Fill in blank summaries with generated text where possible
1369 *
1370 * If neither EDIT_NEW nor EDIT_UPDATE is specified, the status of the article will be detected.
1371 * If EDIT_UPDATE is specified and the article doesn't exist, the function will return false. If
1372 * EDIT_NEW is specified and the article does exist, a duplicate key error will cause an exception
1373 * to be thrown from the Database. These two conditions are also possible with auto-detection due
1374 * to MediaWiki's performance-optimised locking strategy.
1375 * @param $baseRevId, the revision ID this edit was based off, if any
1376 *
1377 * @return bool success
1378 */
1391 }
1392 }
1397 {
1401 }
1403 # Silently ignore EDIT_MINOR if not allowed
1410 # Provide autosummaries if one is not provided and autosummaries are enabled.
1413 }
1423 # Update article, but only if changed.
1425 # Make sure the revision is either completely inserted or not inserted at all
1428 }
1444 # Article gone missing
1448 }
1456 ) );
1461 # Update page
1465 /* Belated edit conflict! Run away!! */
1471 # Update recentchanges
1477 # Mark as patrolled if the user can do so
1481 }
1482 }
1485 }
1488 // Keep the same revision ID, but do some updates on it
1490 // Update page_touched, this is usually implicit in the page update
1491 // Other cache updates are done in onArticleEdit()
1493 }
1497 }
1500 # Invalidate cache of this article and all pages using this article
1501 # as a template. Partly deferred.
1504 # Update links tables, site stats, etc.
1506 }
1508 # Create new article
1510 # Set statistics members
1511 # We work out if it's countable after PST to avoid counter drift
1512 # when articles are created with {{subst:}}
1518 # Add the page record; stake our claim on this title!
1519 # This will fail with a database query exception if the article already exists
1522 # Save the revision text...
1528 ) );
1533 # Update the page record with revision data
1541 # Mark as patrolled if the user can
1542 if( ($GLOBALS['wgUseRCPatrol'] || $GLOBALS['wgUseNPPatrol']) && $wgUser->isAllowed( 'autopatrol' ) ) {
1545 }
1546 }
1550 # Update links, etc.
1553 # Clear caches
1558 }
1562 }
1567 }
1571 }
1573 /**
1574 * @deprecated wrapper for doRedirect
1575 */
1578 }
1580 /**
1581 * Output a redirect back to the article.
1582 * This is typically used after an edit.
1583 *
1584 * @param boolean $noRedir Add redirect=no
1585 * @param string $sectionAnchor section to redirect to, including "#"
1586 * @param string $extraQuery, extra query params
1587 */
1596 }
1598 }
1600 /**
1601 * Mark this particular edit/page as patrolled
1602 */
1607 # Check patrol config options
1612 }
1614 # If we haven't been given an rc_id value, we can't do anything
1618 {
1621 }
1624 // Only new pages can be patrolled if the general patrolling is off....???
1625 // @fixme -- is this necessary? Shouldn't we only bother controlling the
1626 // front end here?
1629 }
1631 # Check permissions
1635 {
1638 }
1640 # Handle the 'MarkPatrolled' hook
1643 }
1645 #It would be nice to see where the user had actually come from, but for now just guess
1649 # If it's left up to us, check that the user is allowed to patrol this edit
1650 # If the user has the "autopatrol" right, then we'll assume there are no
1651 # other conditions stopping them doing so
1654 # Graceful error handling, as we've done before here...
1655 # (If the recent change doesn't exist, then it doesn't matter whether
1656 # the user is allowed to patrol it or not; nothing is going to happen
1658 # The user made this edit, and can't patrol it
1659 # Tell them so, and then back off
1664 }
1665 }
1667 # Check that the revision isn't patrolled already
1668 # Prevents duplicate log entries
1670 # Mark the edit as patrolled
1674 }
1676 # Inform the user
1680 }
1682 /**
1683 * User-interface handler for the "watch" action
1684 */
1693 }
1697 }
1704 }
1707 }
1709 /**
1710 * Add this page to $wgUser's watchlist
1711 * @return bool true on successful watch operation
1712 */
1717 }
1723 }
1726 }
1728 /**
1729 * User interface handler for the "unwatch" action.
1730 */
1738 }
1742 }
1749 }
1752 }
1754 /**
1755 * Stop watching a page
1756 * @return bool true on successful unwatch
1757 */
1762 }
1768 }
1771 }
1773 /**
1774 * action=protect handler
1775 */
1779 }
1781 /**
1782 * action=unprotect handler (alias)
1783 */
1786 }
1788 /**
1789 * Update the article's restriction field, and leave a log entry.
1790 *
1791 * @param array $limit set of restriction keys
1792 * @param string $reason
1793 * @return bool true on success
1794 */
1799 if( array() != $this->mTitle->getUserPermissionsErrors( 'protect', $wgUser ) || wfReadOnly() || $id == 0 ) {
1801 }
1805 }
1807 // Take this opportunity to purge out expired restrictions
1810 # FIXME: Same limitations as described in ProtectionForm.php (line 37);
1811 # we expect a single selection, but the schema allows otherwise.
1824 # If nothing's changed, do nothing
1835 $expiry_description = ' (' . wfMsgForContent( 'protect-expiring', $wgContLang->timeanddate( $expiry, false, false ) ).')';
1836 }
1838 # Prepare a null revision to be added to the history
1844 }
1845 $comment = $wgContLang->ucfirst( wfMsgForContent( $comment_type, $this->mTitle->getPrefixedText() ) );
1847 # Only restrictions with the 'protect' right can cascade...
1848 # Otherwise, people who cannot normally protect can "protect" pages via transclusion
1850 # FIXME: can $restriction be an array or what? (same as fixme above)
1854 }
1855 }
1860 }
1871 # Update restrictions table
1881 }
1882 }
1884 # Insert a null revision
1888 # Update page record
1897 );
1902 # Update the protection log
1909 }
1915 }
1917 /**
1918 * Take an array of page restrictions and flatten it to a string
1919 * suitable for insertion into the page_restrictions field.
1920 * @param array $limit
1921 * @return string
1922 * @private
1923 */
1927 }
1933 }
1934 }
1936 }
1938 /**
1939 * Auto-generates a deletion reason
1940 * @param bool &$hasHistory Whether the page has a history
1941 */
1943 {
1946 // Get the last revision
1950 // Get the article's contents
1953 // If the page is blank, use the text from the previous revision,
1954 // which can only be blank if there's a move/import/protect dummy revision involved
1956 {
1959 {
1962 }
1963 }
1965 // Find out if there was only one contributor
1966 // Only scan the last 20 revisions
1968 $res = $dbw->select('revision', 'rev_user_text', array('rev_page' => $this->getID()), __METHOD__,
1971 // This page has no revisions, which is very weird
1975 else
1979 // Try to find a second contributor
1984 }
1985 }
1988 // Generate the summary with a '$1' placeholder
1990 // The current revision is blank and the one before is also
1991 // blank. It's just not our lucky day
1996 else
1998 }
2000 // Replace newlines with spaces to prevent uglyness
2002 // Calculate the maximum amount of chars to get
2003 // Max content length = max comment length - length of the comment (excl. $1) - '...'
2006 // Remove possible unfinished links
2008 // Now replace the '$1' placeholder
2011 }
2014 /*
2015 * UI entry point for page deletion
2016 */
2029 // Entry from drop down menu + additional comment
2033 }
2034 # Flag to hide all contents of the archived revisions
2037 # This code desperately needs to be totally rewritten
2039 # Read-only check...
2043 }
2045 # Check permissions
2051 }
2055 # Better double-check that it hasn't been deleted yet!
2062 }
2064 # Hack for big sites
2071 }
2079 }
2081 }
2083 // Generate deletion reason
2087 // If the page has a history, insert a warning
2090 $wgOut->addHTML( '<strong>' . wfMsg( 'historywarning' ) . ' ' . $skin->historyLink() . '</strong>' );
2095 }
2096 }
2099 }
2101 /**
2102 * @return bool whether or not the page surpasses $wgDeleteRevisionsLimit revisions
2103 */
2109 }
2111 }
2113 /**
2114 * @return int approximate revision count
2115 */
2118 // For an exact count...
2119 //return $dbr->selectField( 'revision', 'COUNT(*)',
2120 // array( 'rev_page' => $this->getId() ), __METHOD__ );
2123 }
2125 /**
2126 * Get the last N authors
2127 * @param int $num Number of revisions to get
2128 * @param string $revLatest The latest rev_id, selected from the master (optional)
2129 * @return array Array of authors, duplicates not removed
2130 */
2134 // First try the slave
2135 // If that doesn't have the latest revision, try the master
2144 'rev_page = page_id'
2148 ) )
2149 );
2153 }
2160 }
2166 }
2169 }
2171 /**
2172 * Output deletion confirmation dialog
2173 * @param $reason string Prefilled reason
2174 */
2181 $wgOut->setSubtitle( wfMsg( 'delete-backlink', $wgUser->getSkin()->makeKnownLinkObj( $this->mTitle ) ) );
2187 $suppress .= Xml::checkLabel( wfMsg( 'revdelete-suppress' ), 'wpSuppress', 'wpSuppress', false, array( 'tabindex' => '2' ) );
2191 }
2193 $form = Xml::openElement( 'form', array( 'method' => 'post', 'action' => $this->mTitle->getLocalURL( 'action=delete' ), 'id' => 'deleteconfirm' ) ) .
2195 Xml::tags( 'legend', null, wfMsgExt( 'delete-legend', array( 'parsemag', 'escapenoentities' ) ) ) .
2200 "</td>
2205 "</td>
2206 </tr>
2210 "</td>
2212 Xml::input( 'wpReason', 60, $reason, array( 'type' => 'text', 'maxlength' => '255', 'tabindex' => '2', 'id' => 'wpReason' ) ) .
2213 "</td>
2214 </tr>
2215 <tr>
2216 <td></td>
2218 Xml::checkLabel( wfMsg( 'watchthis' ), 'wpWatch', 'wpWatch', $wgUser->getBoolOption( 'watchdeletion' ) || $this->mTitle->userIsWatching(), array( 'tabindex' => '3' ) ) .
2219 "</td>
2220 </tr>
2221 $suppress
2222 <tr>
2223 <td></td>
2225 Xml::submitButton( wfMsg( 'deletepage' ), array( 'name' => 'wpConfirmB', 'id' => 'wpConfirmB', 'tabindex' => '4' ) ) .
2226 "</td>
2235 $link = $skin->makeLink ( 'MediaWiki:Deletereason-dropdown', wfMsgHtml( 'delete-edit-reasonlist' ) );
2237 }
2241 }
2244 /**
2245 * Show relevant lines from the deletion log
2246 */
2250 }
2253 /**
2254 * Perform a deletion and output success or failure messages
2255 */
2279 else
2281 }
2282 }
2283 }
2285 /**
2286 * Back-end article deletion
2287 * Deletes the article with database consistency, writes logs, purges caches
2288 * Returns success
2289 */
2303 }
2308 // Bitfields to further suppress the content
2311 // This should be 15...
2318 }
2321 // For now, shunt the revision data into the archive table.
2322 // Text is *not* removed from the text table; bulk storage
2323 // is left intact to avoid breaking block-compression or
2324 // immutable storage schemes.
2325 //
2326 // For backwards compatibility, note that some older archive
2327 // table entries will have ar_text and ar_flags fields still.
2328 //
2329 // In the future, we may keep revisions and mark them with
2330 // the rev_deleted field, which is reserved for this purpose.
2349 'page_id = rev_page'
2350 ), __METHOD__
2351 );
2353 # Delete restrictions for it
2356 # Fix category table counts
2362 }
2365 # Now that it's safely backed up, delete it
2371 }
2373 # If using cascading deletes, we can skip some explicit deletes
2380 # Delete outgoing links
2388 }
2390 # If using cleanup triggers, we can skip some manual deletes
2393 # Clean up recentchanges entries...
2396 __METHOD__ );
2397 }
2400 # Clear caches
2403 # Clear the cached article id so the interface doesn't act like we exist
2407 # Log the deletion, if the page was suppressed, log it at Oversight instead
2411 # Make sure logging got through
2415 }
2417 /**
2418 * Roll back the most recent consecutive set of edits to a page
2419 * from the same user; fails if there are no eligible edits to
2420 * roll back to, e.g. user is the sole contributor. This function
2421 * performs permissions checks on $wgUser, then calls commitRollback()
2422 * to do the dirty work
2423 *
2424 * @param string $fromP - Name of the user whose edits to rollback.
2425 * @param string $summary - Custom summary. Set to default summary if empty.
2426 * @param string $token - Rollback token.
2427 * @param bool $bot - If true, mark all reverted edits as bot.
2428 *
2429 * @param array $resultDetails contains result-specific array of additional values
2430 * 'alreadyrolled' : 'current' (rev)
2431 * success : 'summary' (str), 'current' (rev), 'target' (rev)
2432 *
2433 * @return array of errors, each error formatted as
2434 * array(messagekey, param1, param2, ...).
2435 * On success, the array is empty. This array can also be passed to
2436 * OutputPage::showPermissionsErrorPage().
2437 */
2442 # Check permissions
2450 }
2451 # If there were errors, bail out now
2456 }
2458 /**
2459 * Backend implementation of doRollback(), please refer there for parameter
2460 * and return value documentation
2461 *
2462 * NOTE: This function does NOT check ANY permissions, it just commits the
2463 * rollback to the DB Therefore, you should only call this function direct-
2464 * ly if you want to use custom permissions checks. If you don't, use
2465 * doRollback() instead.
2466 */
2473 }
2475 # Get the last editor
2478 # Something wrong... no page?
2480 }
2489 ));
2490 }
2492 # Get the last edit not by this guy
2502 );
2504 # No one else ever edited this page
2506 } else if( $s->rev_deleted & REVISION::DELETED_TEXT || $s->rev_deleted & REVISION::DELETED_USER ) {
2507 # Only admins can see this text
2509 }
2513 # Mark all reverted edits as bot
2515 }
2517 # Mark all reverted edits as patrolled
2519 }
2527 ), __METHOD__
2528 );
2529 }
2531 # Generate the edit summary if necessary
2535 }
2537 # Allow the custom summary to use the same args as the default message
2542 );
2545 # Save
2561 );
2563 }
2565 /**
2566 * User interface for rollback operations
2567 */
2577 $details
2578 );
2583 }
2587 }
2588 if( isset( $result[0][0] ) && ( $result[0][0] == 'alreadyrolled' || $result[0][0] == 'cantrollback' ) ){
2596 $wgOut->addWikiMsgArray( 'editcomment', array( $wgUser->getSkin()->formatComment( $current->getComment() ) ), array( 'replaceafter' ) );
2597 }
2598 }
2600 }
2601 # Display permissions errors before read-only message -- there's no
2602 # point in misleading the user into thinking the inability to rollback
2603 # is only temporary.
2605 # array_diff is completely broken for arrays of arrays, sigh. Re-
2606 # move any 'readonlytext' error manually.
2611 }
2612 }
2615 }
2619 }
2629 $wgOut->addHtml( wfMsgExt( 'rollback-success', array( 'parse', 'replaceafter' ), $old, $new ) );
2635 }
2636 }
2639 /**
2640 * Do standard deferred updates after page view
2641 * @private
2642 */
2647 # Don't update page view counters on views from bot users (bug 14044)
2653 }
2654 }
2656 # Update newtalk / watchlist notification status
2658 }
2660 /**
2661 * Prepare text which is about to be saved.
2662 * Returns a stdclass with source, pst and output members
2663 */
2665 if ( $this->mPreparedEdit && $this->mPreparedEdit->newText == $text && $this->mPreparedEdit->revid == $revid) {
2666 // Already prepared
2668 }
2681 }
2683 /**
2684 * Do standard deferred updates after page edit.
2685 * Update links tables, site stats, search index and message cache.
2686 * Every 100th edit, prune the recent changes table.
2687 *
2688 * @private
2689 * @param $text New text of the article
2690 * @param $summary Edit summary
2691 * @param $minoredit Minor edit
2692 * @param $timestamp_of_pagechange Timestamp associated with the page change
2693 * @param $newid rev_id value of the new revision
2694 * @param $changed Whether or not the content actually changed
2695 */
2696 function editUpdates( $text, $summary, $minoredit, $timestamp_of_pagechange, $newid, $changed = true ) {
2701 # Parse the text
2702 # Be careful not to double-PST: $text is usually already PST-ed once
2709 }
2711 # Save it to the parser cache
2715 }
2717 # Update the links tables
2723 // Flush old entries from the `recentchanges` table; we do this on
2724 // random requests so as to avoid an increase in writes for no good reason
2731 }
2732 }
2741 }
2748 # If this is another user's talk page, update newtalk
2749 # Don't do this if $changed = false otherwise some idiot can null-edit a
2750 # load of user talk pages and piss people off, nor if it's a minor edit
2751 # by a properly-flagged bot.
2752 if( $this->mTitle->getNamespace() == NS_USER_TALK && $shortTitle != $wgUser->getTitleKey() && $changed
2757 // An anonymous user
2760 }
2763 }
2764 }
2765 }
2769 }
2772 }
2774 /**
2775 * Perform article updates on a special page creation.
2776 *
2777 * @param Revision $rev
2778 *
2779 * @todo This is a shitty interface function. Kill it and replace the
2780 * other shitty functions like editUpdates and such so it's not needed
2781 * anymore.
2782 */
2788 }
2790 /**
2791 * Generate the navigation links when browsing through an article revisions
2792 * It shows the information as:
2793 * Revision as of \<date\>; view current revision
2794 * \<- Previous version | Next Version -\>
2795 *
2796 * @private
2797 * @param string $oldid Revision ID of this article revision
2798 */
2804 }
2819 ? $sk->makeKnownLinkObj( $this->mTitle, wfMsg( 'previousrevision' ), 'direction=prev&oldid='.$oldid )
2826 : $sk->makeKnownLinkObj( $this->mTitle, wfMsg( 'nextrevision' ), 'direction=next&oldid='.$oldid );
2835 // We don't handle top deleted edits too well
2838 // If revision was hidden from sysops
2845 // Bolden oversighted content
2848 }
2850 }
2851 # Show user links if allowed to see them. Normally they
2852 # are hidden regardless, but since we can already see the text here...
2857 ? 'revision-info-current'
2860 $r = "\n\t\t\t\t<div id=\"mw-{$infomsg}\">" . wfMsg( $infomsg, $td, $userlinks ) . "</div>\n" .
2862 "\n\t\t\t\t<div id=\"mw-revision-nav\">" . $cdel . wfMsg( 'revision-nav', $prevdiff, $prevlink, $lnk, $curdiff, $nextlink, $nextdiff ) . "</div>\n\t\t\t";
2864 }
2866 /**
2867 * This function is called right before saving the wikitext,
2868 * so we can do things like signatures and links-in-context.
2869 *
2870 * @param string $text
2871 */
2874 return $wgParser->preSaveTransform( $text, $this->mTitle, $wgUser, ParserOptions::newFromUser( $wgUser ) );
2875 }
2877 /* Caching functions */
2879 /**
2880 * checkLastModified returns true if it has taken care of all
2881 * output to the client that is necessary for this request.
2882 * (that is, it has sent a cached version of the page)
2883 */
2889 }
2901 }
2904 }
2905 }
2907 /**
2908 * Check if the page can be cached
2909 * @return bool
2910 */
2920 //check for non-standard user language; this covers uselang,
2921 //and extensions for auto-detecting user language.
2941 //extension may have reason to disable file caching on some pages.
2943 }
2946 }
2948 /**
2949 * Loads page_touched and returns a value indicating if it should be used
2950 *
2951 */
2955 }
2957 }
2959 /**
2960 * Get the page_touched field
2961 */
2963 # Ensure that page data has been loaded
2966 }
2968 }
2970 /**
2971 * Get the page_latest field
2972 */
2976 }
2978 }
2980 /**
2981 * Edit an article without doing all that other stuff
2982 * The article must already exist; link tables etc
2983 * are not updated, caches are not flushed.
2984 *
2985 * @param string $text text submitted
2986 * @param string $comment comment submitted
2987 * @param bool $minor whereas it's a minor modification
2988 */
2999 ) );
3007 }
3009 /**
3010 * Used to increment the view counter
3011 *
3012 * @static
3013 * @param integer $id article id
3014 */
3027 }
3029 # Not important enough to warrant an error page in case of failure
3036 # Most of the time (or on SQL errors), skip row count check
3039 }
3059 }
3063 }
3068 }
3070 }
3072 /**#@+
3073 * The onArticle*() functions are supposed to be a kind of hooks
3074 * which should be called whenever any of the specified actions
3075 * are done.
3076 *
3077 * This is a good place to put code to clear caches, for instance.
3078 *
3079 * This is called on page move and undelete, as well as edit
3080 * @static
3081 * @param $title_obj a title object
3082 */
3085 # The talk page isn't in the regular link tables, so we need to update manually:
3090 }
3097 }
3102 // Update existence markers on article/talk tabs...
3107 }
3114 # File cache
3118 }
3120 # Messages
3123 }
3124 # Images
3128 }
3129 # User talk pages
3133 }
3134 }
3136 /**
3137 * Purge caches on page update etc
3138 */
3142 // Invalidate caches of articles which include this page
3145 // Invalidate the caches of all pages which redirect here
3148 # Purge squid for this page only
3151 # Clear file cache
3155 }
3156 }
3158 /**#@-*/
3160 /**
3161 * Overriden by ImagePage class, only present here to avoid a fatal error
3162 * Called for ?action=revert
3163 */
3167 }
3169 /**
3170 * Info about this page
3171 * Called for ?action=info when $wgAllowPageInfo is on.
3172 *
3173 * @public
3174 */
3181 }
3192 // This doesn't quite make sense; the user is asking for
3193 // information about the _page_, not the message... -- RC
3197 ? 'noarticletext'
3200 }
3211 __METHOD__,
3217 $wgOut->addHTML( "<ul><li>" . wfMsg("numwatchers", $wgLang->formatNum( $numwatchers ) ) . '</li>' );
3218 $wgOut->addHTML( "<li>" . wfMsg('numedits', $wgLang->formatNum( $pageInfo['edits'] ) ) . '</li>');
3220 $wgOut->addHTML( '<li>' . wfMsg("numtalkedits", $wgLang->formatNum( $talkInfo['edits'] ) ) . '</li>');
3221 }
3222 $wgOut->addHTML( '<li>' . wfMsg("numauthors", $wgLang->formatNum( $pageInfo['authors'] ) ) . '</li>' );
3224 $wgOut->addHTML( '<li>' . wfMsg('numtalkauthors', $wgLang->formatNum( $talkInfo['authors'] ) ) . '</li>' );
3225 }
3228 }
3229 }
3231 /**
3232 * Return the total number of edits and number of unique editors
3233 * on a given page. If page does not exist, returns false.
3234 *
3235 * @param Title $title
3236 * @return array
3237 * @private
3238 */
3243 }
3253 __METHOD__,
3260 __METHOD__,
3264 }
3266 /**
3267 * Return a list of templates used by this article.
3268 * Uses the templatelinks table
3269 *
3270 * @return array Array of Title objects
3271 */
3277 }
3283 __METHOD__ );
3288 }
3289 }
3290 }
3293 }
3295 /**
3296 * Returns a list of hidden categories this page is a member of.
3297 * Uses the page_props and categorylinks tables.
3298 *
3299 * @return array Array of Title objects
3300 */
3306 }
3313 __METHOD__ );
3318 }
3319 }
3320 }
3323 }
3325 /**
3326 * Return an applicable autosummary if one exists for the given edit.
3327 * @param string $oldtext The previous text of the page.
3328 * @param string $newtext The submitted text of the page.
3329 * @param bitmask $flags A bitmask of flags submitted for the edit.
3330 * @return string An appropriate autosummary, or an empty string.
3331 */
3333 # Decide what kind of autosummary is needed.
3335 # Redirect autosummaries
3339 }
3341 # New page autosummaries
3343 # If they're making a new article, give its text, truncated, in the summary.
3350 }
3352 # Blanking autosummaries
3356 # Removing more than 90% of the article
3361 '...'
3362 );
3364 }
3366 # If we reach this point, there's no applicable autosummary for our case, so our
3367 # autosummary is empty.
3369 }
3371 /**
3372 * Add the primary page-view wikitext to the output buffer
3373 * Saves the text into the parser cache if possible.
3374 * Updates templatelinks if it is out of date.
3375 *
3376 * @param string $text
3377 * @param bool $cache
3378 */
3392 }
3395 // templatelinks table may have become out of sync,
3396 // especially if using variable-based transclusions.
3397 // For paranoia, check if things have changed and if
3398 // so apply updates to the database. This will ensure
3399 // that cascaded protections apply as soon as the changes
3400 // are visible.
3402 # Get templates from templatelinks
3411 __METHOD__ );
3419 }
3420 }
3421 }
3423 # Get templates from parser output.
3429 }
3431 # Get the diff
3435 # Whee, link updates time.
3444 }
3445 }
3448 }
3450 /**
3451 * Update all the appropriate counts in the category table, given that
3452 * we've added the categories $added and deleted the categories $deleted.
3453 *
3454 * @param $added array The names of categories that were added
3455 * @param $deleted array The names of categories that were deleted
3456 * @return null
3457 */
3462 # First make sure the rows exist. If one of the "deleted" ones didn't
3463 # exist, we might legitimately not create it, but it's simpler to just
3464 # create it and then give it a negative value, since the value is bogus
3465 # anyway.
3466 #
3467 # Sometimes I wish we had INSERT ... ON DUPLICATE KEY UPDATE.
3470 # Okay, nothing to do
3472 }
3476 }
3487 }
3494 __METHOD__
3495 );
3496 }
3502 __METHOD__
3503 );
3504 }
3505 }
3506 }