PHP WikiPage::getRevision方法代码示例

 /**
  * @since 2.2
  */
 public function getEditInfo(Title $title)
 {
     $this->page = new \WikiPage($title);
     if (class_exists('WikitextContent')) {
         $content = $this->page->getRevision()->getContent();
         $format = $content->getContentHandler()->getDefaultFormat();
         return $this->page->prepareContentForEdit($content, null, null, $format);
     }
     return $this->page->prepareTextForEdit($this->page->getRevision()->getRawText(), null, null);
 }

 /**
  * @param WikiPage $page
  * @param ParserOptions $parserOptions ParserOptions to use for the parse
  * @param int $revid ID of the revision being parsed.
  * @param bool $useParserCache Whether to use the parser cache.
  *   operation.
  * @param Content|string $content Content to parse or null to load it; may
  *   also be given as a wikitext string, for BC.
  */
 public function __construct(WikiPage $page, ParserOptions $parserOptions, $revid, $useParserCache, $content = null)
 {
     if (is_string($content)) {
         // BC: old style call
         $modelId = $page->getRevision()->getContentModel();
         $format = $page->getRevision()->getContentFormat();
         $content = ContentHandler::makeContent($content, $page->getTitle(), $modelId, $format);
     }
     $this->page = $page;
     $this->revid = $revid;
     $this->cacheable = $useParserCache;
     $this->parserOptions = $parserOptions;
     $this->content = $content;
     $this->cacheKey = ParserCache::singleton()->getKey($page, $parserOptions);
     $keyPrefix = $this->cacheKey ?: wfMemcKey('articleview', 'missingcachekey');
     parent::__construct('ArticleView', $keyPrefix . ':revid:' . $revid);
 }

 static function onPageContentSave(WikiPage &$wikiPage, User &$user, Content &$content, &$summary, $isMinor, $isWatch, $section, &$flags, Status &$status)
 {
     // get the current tags from the page
     /////////////////////////////////////
     $CurrentReferences;
     preg_match_all(self::GetLabelsRegex, $wikiPage->getText(), $matches);
     // build it as a "set"
     foreach (array_merge($matches[2], $matches[3]) as $toAdd) {
         if ($toAdd != '') {
             $CurrentReferences[$toAdd] = 1;
         }
     }
     // get the old tags from the database
     /////////////////////////////////////
     $OldReferences;
     if (($rev = $wikiPage->getRevision()) != null && ($prevRev = $rev->getPrevious()) != null) {
         preg_match_all(self::GetLabelsRegex, $prevRev->getText(), $matches);
         // build it as a "set"
         foreach (array_merge($matches[2], $matches[3]) as $toAdd) {
             if ($toAdd != '') {
                 $OldReferences[$toAdd] = 1;
             }
         }
     }
     // Resolve differences
     //////////////////////
     $DB = wfGetDB(DB_MASTER);
     $DB->begin();
     // start a transaction
     // start with the newOnes and make sure that the database is compatable, and remove them
     foreach (array_keys($CurrentReferences) as $RefToMakeSureExists) {
         if (isset($OldReferences[$RefToMakeSureExists])) {
             // if it is already in the array, then we don't have to worry about it; delete it
             unset($OldReferences[$RefToMakeSureExists]);
         } else {
             // if it doesn't exist, we need to add it
             try {
                 $DB->insert(ContentReferencerTableName, array('reference_name' => $RefToMakeSureExists, 'reference_page_name' => (string) $wikiPage->getTitle()));
             } catch (Exception $e) {
                 die($e->getMessage());
             }
         }
     }
     // now, anything left in $OldReferences has been deleted. Let's remove it from the database
     foreach (array_keys($OldReferences) as $RefToDelete) {
         try {
             $DB->delete(ContentReferencerTableName, "reference_name='{$RefToDelete}'");
         } catch (Exception $e) {
             die($e->getMessage());
         }
     }
     $DB->commit();
     // end the transaction
 }

	/**
	 * Get text content object
	 * Does *NOT* follow redirects.
	 * TODO: when is this null?
	 *
	 * @note code that wants to retrieve page content from the database should use WikiPage::getContent().
	 *
	 * @return Content|null|boolean false
	 *
	 * @since 1.21
	 */
	protected function fetchContentObject() {
		if ( $this->mContentLoaded ) {
			return $this->mContentObject;
		}

		wfProfileIn( __METHOD__ );

		$this->mContentLoaded = true;
		$this->mContent = null;

		$oldid = $this->getOldID();

		# Pre-fill content with error message so that if something
		# fails we'll have something telling us what we intended.
		//XXX: this isn't page content but a UI message. horrible.
		$this->mContentObject = new MessageContent( 'missing-revision', array( $oldid ), array() );

		if ( $oldid ) {
			# $this->mRevision might already be fetched by getOldIDFromRequest()
			if ( !$this->mRevision ) {
				$this->mRevision = Revision::newFromId( $oldid );
				if ( !$this->mRevision ) {
					wfDebug( __METHOD__ . " failed to retrieve specified revision, id $oldid\n" );
					wfProfileOut( __METHOD__ );
					return false;
				}
			}
		} else {
			if ( !$this->mPage->getLatest() ) {
				wfDebug( __METHOD__ . " failed to find page data for title " . $this->getTitle()->getPrefixedText() . "\n" );
				wfProfileOut( __METHOD__ );
				return false;
			}

			$this->mRevision = $this->mPage->getRevision();

			if ( !$this->mRevision ) {
				wfDebug( __METHOD__ . " failed to retrieve current page, rev_id " . $this->mPage->getLatest() . "\n" );
				wfProfileOut( __METHOD__ );
				return false;
			}
		}

		// @todo FIXME: Horrible, horrible! This content-loading interface just plain sucks.
		// We should instead work with the Revision object when we need it...
		$this->mContentObject = $this->mRevision->getContent( Revision::FOR_THIS_USER, $this->getContext()->getUser() ); // Loads if user is allowed
		$this->mRevIdFetched = $this->mRevision->getId();

		wfRunHooks( 'ArticleAfterFetchContentObject', array( &$this, &$this->mContentObject ) );

		wfProfileOut( __METHOD__ );

		return $this->mContentObject;
	}

 /**
  * Get text of an article from database
  * Does *NOT* follow redirects.
  *
  * @return mixed string containing article contents, or false if null
  */
 function fetchContent()
 {
     if ($this->mContentLoaded) {
         return $this->mContent;
     }
     wfProfileIn(__METHOD__);
     $this->mContentLoaded = true;
     $oldid = $this->getOldID();
     # Pre-fill content with error message so that if something
     # fails we'll have something telling us what we intended.
     $t = $this->getTitle()->getPrefixedText();
     $d = $oldid ? wfMsgExt('missingarticle-rev', array('escape'), $oldid) : '';
     $this->mContent = wfMsgNoTrans('missing-article', $t, $d);
     if ($oldid) {
         # $this->mRevision might already be fetched by getOldIDFromRequest()
         if (!$this->mRevision) {
             $this->mRevision = Revision::newFromId($oldid);
             if (!$this->mRevision) {
                 wfDebug(__METHOD__ . " failed to retrieve specified revision, id {$oldid}\n");
                 Wikia::log(__METHOD__, 1, "failed to retrieve specified revision, title '{$t}', id {$oldid}", true);
                 # Wikia change - @author macbre
                 wfProfileOut(__METHOD__);
                 return false;
             }
         }
     } else {
         if (!$this->mPage->getLatest()) {
             wfDebug(__METHOD__ . " failed to find page data for title " . $this->getTitle()->getPrefixedText() . "\n");
             wfProfileOut(__METHOD__);
             return false;
         }
         $this->mRevision = $this->mPage->getRevision();
         if (!$this->mRevision) {
             wfDebug(__METHOD__ . " failed to retrieve current page, rev_id " . $this->mPage->getLatest() . "\n");
             Wikia::log(__METHOD__, 3, "failed to retrieve current page, title '{$t}', rev_id " . $this->mPage->getLatest(), true);
             # Wikia change - @author macbre
             wfProfileOut(__METHOD__);
             return false;
         }
     }
     // @todo FIXME: Horrible, horrible! This content-loading interface just plain sucks.
     // We should instead work with the Revision object when we need it...
     $this->mContent = $this->mRevision->getText(Revision::FOR_THIS_USER);
     // Loads if user is allowed
     $this->mRevIdFetched = $this->mRevision->getId();
     wfRunHooks('ArticleAfterFetchContent', array(&$this, &$this->mContent));
     wfProfileOut(__METHOD__);
     return $this->mContent;
 }

 /**
  * Get text of an article from database
  * Does *NOT* follow redirects.
  *
  * @param $oldid Int: 0 for whatever the latest revision is
  * @return mixed string containing article contents, or false if null
  */
 function fetchContent($oldid = 0)
 {
     if ($this->mContentLoaded) {
         return $this->mContent;
     }
     # Pre-fill content with error message so that if something
     # fails we'll have something telling us what we intended.
     $t = $this->getTitle()->getPrefixedText();
     $d = $oldid ? wfMsgExt('missingarticle-rev', array('escape'), $oldid) : '';
     $this->mContent = wfMsgNoTrans('missing-article', $t, $d);
     if ($oldid) {
         $revision = Revision::newFromId($oldid);
         if (!$revision) {
             wfDebug(__METHOD__ . " failed to retrieve specified revision, id {$oldid}\n");
             return false;
         }
         // Revision title doesn't match the page title given?
         if ($this->mPage->getID() != $revision->getPage()) {
             $function = array(get_class($this->mPage), 'newFromID');
             $this->mPage = call_user_func($function, $revision->getPage());
             if (!$this->mPage->getId()) {
                 wfDebug(__METHOD__ . " failed to get page data linked to revision id {$oldid}\n");
                 return false;
             }
         }
     } else {
         if (!$this->mPage->getLatest()) {
             wfDebug(__METHOD__ . " failed to find page data for title " . $this->getTitle()->getPrefixedText() . "\n");
             return false;
         }
         $revision = $this->mPage->getRevision();
         if (!$revision) {
             wfDebug(__METHOD__ . " failed to retrieve current page, rev_id " . $this->mPage->getLatest() . "\n");
             return false;
         }
     }
     // @todo FIXME: Horrible, horrible! This content-loading interface just plain sucks.
     // We should instead work with the Revision object when we need it...
     $this->mContent = $revision->getText(Revision::FOR_THIS_USER);
     // Loads if user is allowed
     $this->mRevIdFetched = $revision->getId();
     $this->mContentLoaded = true;
     $this->mRevision =& $revision;
     wfRunHooks('ArticleAfterFetchContent', array(&$this, &$this->mContent));
     return $this->mContent;
 }

 /**
  * @param ParserOutput $parserOutput
  * @param WikiPage $page
  * @param ParserOptions $popts
  * @param string $cacheTime Time when the cache was generated
  * @param int $revId Revision ID that was parsed
  */
 public function save($parserOutput, $page, $popts, $cacheTime = null, $revId = null)
 {
     $expire = $parserOutput->getCacheExpiry();
     if ($expire > 0) {
         $cacheTime = $cacheTime ?: wfTimestampNow();
         if (!$revId) {
             $revision = $page->getRevision();
             $revId = $revision ? $revision->getId() : null;
         }
         $optionsKey = new CacheTime();
         $optionsKey->mUsedOptions = $parserOutput->getUsedOptions();
         $optionsKey->updateCacheExpiry($expire);
         $optionsKey->setCacheTime($cacheTime);
         $parserOutput->setCacheTime($cacheTime);
         $optionsKey->setCacheRevisionId($revId);
         $parserOutput->setCacheRevisionId($revId);
         $parserOutputKey = $this->getParserOutputKey($page, $popts->optionsHash($optionsKey->mUsedOptions, $page->getTitle()));
         // Save the timestamp so that we don't have to load the revision row on view
         $parserOutput->setTimestamp($page->getTimestamp());
         $msg = "Saved in parser cache with key {$parserOutputKey}" . " and timestamp {$cacheTime}" . " and revision id {$revId}" . "\n";
         $parserOutput->mText .= "\n<!-- {$msg} -->\n";
         wfDebug($msg);
         // Save the parser output
         $this->mMemc->set($parserOutputKey, $parserOutput, $expire);
         // ...and its pointer
         $this->mMemc->set($this->getOptionsKey($page), $optionsKey, $expire);
         Hooks::run('ParserCacheSaveComplete', array($this, $parserOutput, $page->getTitle(), $popts, $revId));
     } else {
         wfDebug("Parser output was marked as uncacheable and has not been saved.\n");
     }
 }

 /**
  * @covers WikiPage::doRollback
  */
 public function testDoRollbackFailureSameContent()
 {
     $admin = new User();
     $admin->setName("Admin");
     $admin->addGroup("sysop");
     #XXX: make the test user a sysop...
     $text = "one";
     $page = $this->newPage("WikiPageTest_testDoRollback");
     $page->doEditContent(ContentHandler::makeContent($text, $page->getTitle(), CONTENT_MODEL_WIKITEXT), "section one", EDIT_NEW, false, $admin);
     $rev1 = $page->getRevision();
     $user1 = new User();
     $user1->setName("127.0.1.11");
     $user1->addGroup("sysop");
     #XXX: make the test user a sysop...
     $text .= "\n\ntwo";
     $page = new WikiPage($page->getTitle());
     $page->doEditContent(ContentHandler::makeContent($text, $page->getTitle(), CONTENT_MODEL_WIKITEXT), "adding section two", 0, false, $user1);
     # now, do a the rollback from the same user was doing the edit before
     $resultDetails = array();
     $token = $user1->getEditToken(array($page->getTitle()->getPrefixedText(), $user1->getName()), null);
     $errors = $page->doRollback($user1->getName(), "testing revert same user", $token, false, $resultDetails, $admin);
     $this->assertEquals(array(), $errors, "Rollback failed same user");
     # now, try the rollback
     $resultDetails = array();
     $token = $admin->getEditToken(array($page->getTitle()->getPrefixedText(), $user1->getName()), null);
     $errors = $page->doRollback($user1->getName(), "testing revert", $token, false, $resultDetails, $admin);
     $this->assertEquals(array(array('alreadyrolled', 'WikiPageTest testDoRollback', '127.0.1.11', 'Admin')), $errors, "Rollback not failed");
     $page = new WikiPage($page->getTitle());
     $this->assertEquals($rev1->getSha1(), $page->getRevision()->getSha1(), "rollback did not revert to the correct revision");
     $this->assertEquals("one", $page->getContent()->getNativeData());
 }

 /**
  * Get the current content of the page. This is basically similar to
  * WikiPage::getContent( Revision::RAW ) except that when the page doesn't exist an empty
  * content object is returned instead of null.
  *
  * @since 1.21
  * @return Content
  */
 protected function getCurrentContent()
 {
     $rev = $this->page->getRevision();
     $content = $rev ? $rev->getContent(Revision::RAW) : null;
     if ($content === false || $content === null) {
         if (!$this->contentModel) {
             $this->contentModel = $this->getTitle()->getContentModel();
         }
         $handler = ContentHandler::getForModelID($this->contentModel);
         return $handler->makeEmptyContent();
     } else {
         # nasty side-effect, but needed for consistency
         $this->contentModel = $rev->getContentModel();
         $this->contentFormat = $rev->getContentFormat();
         return $content;
     }
 }

 /**
  * Get the current content of the page. This is basically similar to
  * WikiPage::getContent( Revision::RAW ) except that when the page doesn't exist an empty
  * content object is returned instead of null.
  *
  * @since 1.21
  * @return Content
  */
 protected function getCurrentContent()
 {
     $rev = $this->page->getRevision();
     $content = $rev ? $rev->getContent(Revision::RAW) : null;
     if ($content === false || $content === null) {
         if (!$this->contentModel) {
             $this->contentModel = $this->getTitle()->getContentModel();
         }
         $handler = ContentHandler::getForModelID($this->contentModel);
         return $handler->makeEmptyContent();
     } elseif (!$this->undidRev) {
         // Content models should always be the same since we error
         // out if they are different before this point (in ->edit()).
         // The exception being, during an undo, the current revision might
         // differ from the prior revision.
         $logger = LoggerFactory::getInstance('editpage');
         if ($this->contentModel !== $rev->getContentModel()) {
             $logger->warning("Overriding content model from current edit {prev} to {new}", ['prev' => $this->contentModel, 'new' => $rev->getContentModel(), 'title' => $this->getTitle()->getPrefixedDBkey(), 'method' => __METHOD__]);
             $this->contentModel = $rev->getContentModel();
         }
         // Given that the content models should match, the current selected
         // format should be supported.
         if (!$content->isSupportedFormat($this->contentFormat)) {
             $logger->warning("Current revision content format unsupported. Overriding {prev} to {new}", ['prev' => $this->contentFormat, 'new' => $rev->getContentFormat(), 'title' => $this->getTitle()->getPrefixedDBkey(), 'method' => __METHOD__]);
             $this->contentFormat = $rev->getContentFormat();
         }
     }
     return $content;
 }

 /**
  * Produce page output suitable for indexing.
  *
  * Specific content handlers may override it if they need different content handling.
  *
  * @param WikiPage    $page
  * @param ParserCache $cache
  * @return ParserOutput
  */
 public function getParserOutputForIndexing(WikiPage $page, ParserCache $cache = null)
 {
     $parserOptions = $page->makeParserOptions('canonical');
     $revId = $page->getRevision()->getId();
     if ($cache) {
         $parserOutput = $cache->get($page, $parserOptions);
     }
     if (empty($parserOutput)) {
         $parserOutput = $page->getContent()->getParserOutput($page->getTitle(), $revId, $parserOptions);
         if ($cache) {
             $cache->save($parserOutput, $page, $parserOptions);
         }
     }
     return $parserOutput;
 }

 /**
  * @todo FIXME: the above rollback test is better, but it keeps failing in jenkins for some reason.
  */
 public function testDoRollback()
 {
     $admin = new User();
     $admin->setName("Admin");
     $text = "one";
     $page = $this->newPage("WikiPageTest_testDoRollback");
     $page->doEditContent(ContentHandler::makeContent($text, $page->getTitle(), CONTENT_MODEL_WIKITEXT), "section one", EDIT_NEW, false, $admin);
     $rev1 = $page->getRevision();
     $user1 = new User();
     $user1->setName("127.0.1.11");
     $text .= "\n\ntwo";
     $page = new WikiPage($page->getTitle());
     $page->doEditContent(ContentHandler::makeContent($text, $page->getTitle(), CONTENT_MODEL_WIKITEXT), "adding section two", 0, false, $user1);
     # now, try the rollback
     $admin->addGroup("sysop");
     #XXX: make the test user a sysop...
     $token = $admin->getEditToken(array($page->getTitle()->getPrefixedText(), $user1->getName()), null);
     $errors = $page->doRollback($user1->getName(), "testing revert", $token, false, $details, $admin);
     if ($errors) {
         $this->fail("Rollback failed:\n" . print_r($errors, true) . ";\n" . print_r($details, true));
     }
     $page = new WikiPage($page->getTitle());
     $this->assertEquals($rev1->getSha1(), $page->getRevision()->getSha1(), "rollback did not revert to the correct revision");
     $this->assertEquals("one", $page->getContent()->getNativeData());
 }