PHP WikiPage::doDeleteArticle方法代码示例

 /**
  * Delete $page
  */
 protected function doDelete($page)
 {
     if ($page instanceof Title) {
         $page = new WikiPage($page);
     }
     if ($this->logActions) {
         print "Delete " . $page->getTitle() . " = " . $page->getId() . "\n";
     }
     $page->doDeleteArticle('-');
 }

 public function testImportForImportSource()
 {
     $this->doImport($this->importStreamSource);
     // Imported title
     $loremIpsum = Title::newFromText('Lorem ipsum');
     $this->assertSame($loremIpsum->getArticleID(), $loremIpsum->getArticleID(Title::GAID_FOR_UPDATE));
     $categoryLoremIpsum = Title::newFromText('Category:Lorem ipsum');
     $this->assertSame($categoryLoremIpsum->getArticleID(), $categoryLoremIpsum->getArticleID(Title::GAID_FOR_UPDATE));
     $page = new WikiPage($loremIpsum);
     $page->doDeleteArticle('import test: delete page');
     $page = new WikiPage($categoryLoremIpsum);
     $page->doDeleteArticle('import test: delete page');
 }

 protected function createPage($page, $text, $model = null)
 {
     if (is_string($page)) {
         $page = Title::newFromText($page);
     }
     if ($page instanceof Title) {
         $page = new WikiPage($page);
     }
     if ($page->exists()) {
         $page->doDeleteArticle("done");
     }
     $page->doEdit($text, "testing", EDIT_NEW);
     return $page;
 }

 function run()
 {
     // Initialization
     $title = $this->title;
     // Other stuff
     $user = $this->getUser();
     $summary = $this->getSummary();
     $base = $this->getBase();
     $doer = User::newFromName($this->getPerformer());
     PageTranslationHooks::$allowTargetEdit = true;
     $error = '';
     $wikipage = new WikiPage($title);
     $ok = $wikipage->doDeleteArticle($summary, false, 0, true, $error, $user);
     if (!$ok) {
         $params = array('target' => $base, 'error' => $ok);
         $type = $this->getFull() ? 'deletefnok' : 'deletelnok';
         $entry = new ManualLogEntry('pagetranslation', $type);
         $entry->setPerformer($doer);
         $entry->setTarget($title);
         $entry->setParameters($params);
         $logid = $entry->insert();
         $entry->publish($logid);
     }
     PageTranslationHooks::$allowTargetEdit = false;
     $cache = wfGetCache(CACHE_DB);
     $pages = (array) $cache->get(wfMemcKey('pt-base', $base));
     $lastitem = array_pop($pages);
     if ($title->getPrefixedText() === $lastitem) {
         $cache->delete(wfMemcKey('pt-base', $base));
         $type = $this->getFull() ? 'deletefok' : 'deletelok';
         $entry = new ManualLogEntry('pagetranslation', $type);
         $entry->setPerformer($doer);
         $entry->setTarget(Title::newFromText($base));
         $logid = $entry->insert();
         $entry->publish($logid);
         $tpage = TranslatablePage::newFromTitle($title);
         $tpage->getTranslationPercentages(true);
         foreach ($tpage->getTranslationPages() as $page) {
             $page->invalidateCache();
         }
         $title->invalidateCache();
     }
     return true;
 }

 protected function createPage($page, $text, $model = null)
 {
     if (is_string($page)) {
         if (!preg_match('/:/', $page) && ($model === null || $model === CONTENT_MODEL_WIKITEXT)) {
             $ns = $this->getDefaultWikitextNS();
             $page = MWNamespace::getCanonicalName($ns) . ':' . $page;
         }
         $page = Title::newFromText($page);
     }
     if ($page instanceof Title) {
         $page = new WikiPage($page);
     }
     if ($page->exists()) {
         $page->doDeleteArticle("done");
     }
     $content = ContentHandler::makeContent($text, $page->getTitle(), $model);
     $page->doEditContent($content, "testing", EDIT_NEW);
     return $page;
 }

 /**
  * This method is called after an article has been saved.
  * This is the server side of IntraACL protection toolbar,
  * allowing to modify page SD together with article save.
  *
  * No modifications are made if either:
  * - Page namespace is ACL
  * - User is anonymous
  * - Users don't have the right to modify page SD
  * - 'haloacl_protect_with' request value is invalid
  *   (valid are 'unprotected', or ID/name of predefined right or THIS page SD)
  *
  * @param WikiPage $article The article which was saved
  * @param User $user        The user who saved the article
  * @param string $text      The content of the article
  *
  * @return true
  */
 public static function articleSaveComplete_SaveSD($article, User $user, $text)
 {
     global $wgUser, $wgRequest, $haclgContLang;
     if ($user->isAnon()) {
         // Don't handle protection toolbar for anonymous users
         return true;
     }
     if ($article->getTitle()->getNamespace() == HACL_NS_ACL) {
         // Don't use protection toolbar for articles in the namespace ACL.
         // Note that embedded content protection toolbar is handled nevertheless.
         return true;
     }
     // Obtain user selection
     // hacl_protected_with == '<peType>:<peID>' or 'unprotected'
     $selectedSD = $wgRequest->getVal('hacl_protected_with');
     if ($selectedSD && $selectedSD != 'unprotected') {
         // Some SD is selected by the user
         // Ignore selection of invalid SDs
         $selectedSD = array_map('intval', explode('-', $selectedSD, 2));
         if (count($selectedSD) != 2) {
             $selectedSD = NULL;
         }
     }
     if (!$selectedSD) {
         return true;
     }
     if ($selectedSD == 'unprotected') {
         $selectedSD = NULL;
     }
     // Check if current SD must be modified
     if ($article->exists()) {
         $pageSD = IACLDefinition::getSDForPE(IACL::PE_PAGE, $article->getId());
         if ($pageSD && $selectedSD) {
             // Check if page's SD ID passed as selected
             if ($pageSD['pe_type'] == $selectedSD[0] && $pageSD['pe_id'] == $selectedSD[1]) {
                 return true;
             }
             // Check if page's SD is single inclusion and it is passed as selected
             if ($pageSD['single_child'] == $selectedSD) {
                 return true;
             }
         }
     }
     // Check if no protection selected and no protection exists
     if (!$selectedSD && !$pageSD) {
         return true;
     }
     // Check if other SD is a predefined right
     // FIXME Allow selecting non-PE_RIGHTs in quick acl toolbar?
     if ($selectedSD && $selectedSD[0] != IACL::PE_RIGHT) {
         return true;
     }
     // Check SD modification rights
     $pageSDName = IACLDefinition::nameOfSD(IACL::PE_PAGE, $article->getTitle());
     $etc = haclfDisableTitlePatch();
     $pageSDTitle = Title::newFromText($pageSDName);
     haclfRestoreTitlePatch($etc);
     if (!$pageSDTitle->userCan('edit')) {
         return true;
     }
     $newSDArticle = new WikiPage($pageSDTitle);
     if ($selectedSD) {
         // Create/modify page SD
         $selectedSDTitle = IACLDefinition::getSDTitle($selectedSD);
         $content = '{{#predefined right: ' . $selectedSDTitle->getText() . "}}\n" . '{{#manage rights: assigned to = User:' . $wgUser->getName() . "}}\n";
         $newSDArticle->doEdit($content, wfMsg('hacl_comment_protect_with', $selectedSDTitle->getFullText()));
     } else {
         // Remove page SD
         $newSDArticle->doDeleteArticle(wfMsg('hacl_comment_unprotect'));
     }
     // Continue hook processing
     return true;
 }

 /**
  * @param $reason string
  * @param $suppress bool
  * @param $id int
  * @param $commit bool
  * @param $error string
  * @return bool
  */
 public function doDeleteArticle($reason, $suppress = false, $id = 0, $commit = true, &$error = '')
 {
     return $this->mPage->doDeleteArticle($reason, $suppress, $id, $commit, $error);
 }

 public function deletePage(Title $title)
 {
     $page = new \WikiPage($title);
     $page->doDeleteArticle('SPL system test: delete page');
 }

 /**
  * @covers WikiPage::exists
  */
 public function testExists()
 {
     $page = $this->newPage("WikiPageTest_testExists");
     $this->assertFalse($page->exists());
     # -----------------
     $this->createPage($page, "some text", CONTENT_MODEL_WIKITEXT);
     $this->assertTrue($page->exists());
     $page = new WikiPage($page->getTitle());
     $this->assertTrue($page->exists());
     # -----------------
     $page->doDeleteArticle("done testing");
     $this->assertFalse($page->exists());
     $page = new WikiPage($page->getTitle());
     $this->assertFalse($page->exists());
 }

 /**
  * delete article with out any confirmation (used by wall)
  *
  * @access public
  *
  * @param $reason
  * @param bool $suppress
  *
  * @return bool
  */
 public function doDeleteComment($reason, $suppress = false)
 {
     $wikiPage = new WikiPage($this->mTitle);
     if ($wikiPage->doDeleteArticle($reason, $suppress)) {
         return true;
     }
     return false;
 }

 /**
  * @param WikiPage $article
  * @param $reason
  * @param bool $suppress
  * @param string $error
  * @return bool
  */
 private function deleteArticle($article, $reason, $suppress = false, &$error = '')
 {
     wfProfileIn(__METHOD__);
     global $wgUser;
     $id = $article->getTitle()->getArticleID(Title::GAID_FOR_UPDATE);
     if (wfRunHooks('ArticleDelete', array(&$article, &$wgUser, &$reason, &$error))) {
         if ($article->doDeleteArticle($reason, $suppress, $id)) {
             wfRunHooks('ArticleDeleteComplete', array(&$article, &$wgUser, $reason, $id));
             wfProfileOut(__METHOD__);
             return true;
         }
     }
     wfProfileOut(__METHOD__);
     return false;
 }