Example #1
0
function addAPage($ncat, $unixName, $source, $title)
{
    $now = new ODate();
    $nsource = new DB_PageSource();
    $nsource->setText($source);
    $nsource->save();
    $nmeta = new DB_PageMetadata();
    $nmeta->setTitle($title);
    $nmeta->setUnixName($unixName);
    $nmeta->setOwnerUserId(1);
    $nmeta->save();
    $nrev = new DB_PageRevision();
    $nrev->setSiteId(1);
    $nrev->setSourceId($nsource->getSourceId());
    $nrev->setMetadataId($nmeta->getMetadataId());
    $nrev->setFlagNew(true);
    $nrev->setDateLastEdited($now);
    $nrev->setUserId(1);
    $nrev->obtainPK();
    $npage = new DB_Page();
    $npage->setSiteId(1);
    $npage->setCategoryId($ncat->getCategoryId());
    $npage->setRevisionId($nrev->getRevisionId());
    $npage->setSourceId($nsource->getSourceId());
    $npage->setMetadataId($nmeta->getMetadataId());
    $npage->setTitle($title);
    $npage->setUnixName($unixName);
    $npage->setDateLastEdited($now);
    $npage->setDateCreated($now);
    $npage->setLastEditUserId(1);
    $npage->setOwnerUserId(1);
    $npage->save();
    $nrev->setPageId($npage->getPageId());
    $nrev->save();
    $ncomp = new DB_PageCompiled();
    $ncomp->setPageId($npage->getPageId());
    $ncomp->setDateCompiled($now);
    $ncomp->save();
}
Example #2
0
 public function save($args)
 {
     $db = Database::connection();
     $db->begin();
     // simple argument checking
     if (!isset($args['page'])) {
         throw new Wikidot_Facade_Exception_WrongArguments("Page argument must be passed");
     }
     $pm = new WDPermissionManager();
     $now = new ODate();
     // page (existant or not) name
     $arg_page = WDStringUtils::toUnixName($args['page']);
     // parse the rest (beside page name)
     unset($args['page']);
     $this->parseArgs($args, array("performer", "site"));
     try {
         // parse page name to figure out if it points to an existant page
         $page = $this->_parsePage($this->site, $arg_page);
         $new = false;
         // check permissions to edit the page
         $pm->hasPagePermission('edit', $this->performer, $page->getCategory(), $page);
     } catch (Wikidot_Facade_Exception_WrongArguments $e) {
         if ($this->source === null) {
             $this->source = "";
         }
         if ($this->title === null) {
             $this->title = $arg_page;
         }
         $new = true;
         $category_name = preg_replace('/^([^:]*):.*$/', '\\1', $arg_page);
         if ($category_name == $arg_page) {
             $category_name = '_default';
         }
         $category = $this->_getOrCreateCategory($this->site, $category_name);
         $page = new DB_Page();
         $page->setSiteId($this->site->getSiteId());
         $page->setCategoryId($category->getCategoryId());
         $page->setUnixName($arg_page);
         $page->setDateCreated(new ODate());
         $page->setOwnerUserId($this->performer->getUserId());
         $page->save();
         $compiled = new DB_PageCompiled();
         $compiled->setPageId($page->getPageId());
         $compiled->save();
     }
     // get current revision and metadata
     if (!$new) {
         $cur_rev = $page->getCurrentRevision();
         $cur_meta = $cur_rev->getMetadata();
     }
     // construct new metadata
     if ($new) {
         $new_meta = new DB_PageMetadata();
         $new_meta->setUnixName($arg_page);
         $new_meta->setOwnerUserId($this->performer->getUserId());
     } else {
         $new_meta = clone $cur_meta;
         $new_meta->setNew(true);
         $new_meta->setMetadataId(null);
     }
     // construct new revision
     $new_rev = new DB_PageRevision();
     $new_rev->setSiteId($this->site->getSiteId());
     $new_rev->setPageId($page->getPageId());
     $new_rev->setUserId($this->performer->getUserId());
     $new_rev->setDateLastEdited($now);
     if ($new) {
         $new_rev->setRevisionNumber(0);
     } else {
         $new_rev->setRevisionNumber($cur_rev->getRevisionNumber() + 1);
     }
     $src_changed = false;
     $title_changed = false;
     $parent_changed = false;
     $tags_changed = false;
     // handle source change
     if ($new || $this->source !== null && $page->getSource() != $this->source) {
         $new_src = new DB_PageSource();
         $new_src->setText($this->source);
         $new_src->save();
         $new_rev->setSourceId($new_src->getSourceId());
         $src_changed = true;
     } else {
         $new_rev->setSourceId($cur_rev->getSourceId());
         $new_rev->setSinceFullSource($cur_rev->getSinceFullSource());
         $new_rev->setDiffSource($cur_rev->getDiffSource());
     }
     // handle tags change
     if ($this->tags) {
         $new_tags = $this->tags;
         $cur_tags = $page->getTagsAsArray();
         sort($cur_tags);
         sort($new_tags);
         if ($cur_tags != $new_tags) {
             $tags_changed = true;
             $tags_deleted = array();
             $tags_added = array();
             foreach ($cur_tags as $tag) {
                 if (!in_array($tag, $new_tags)) {
                     $c = new Criteria();
                     $c->add('page_id', $page->getPageId());
                     $c->add('tag', $tag);
                     if ($t = DB_PageTagPeer::instance()->selectOne($c)) {
                         $t->delete();
                         $tags_deleted[] = $tag;
                     }
                 }
             }
             foreach ($new_tags as $tag) {
                 if (!in_array($tag, $cur_tags)) {
                     $t = new DB_PageTag();
                     $t->getPageId($page->getPageId());
                     $t->setSiteId($this->site->getSiteId());
                     $t->setTag($tag);
                     $t->save();
                     $tags_added[] = $tag;
                 }
             }
         }
     }
     // handle metadata: title change
     if ($new || $this->title !== null && $cur_meta->getTitle() != $this->title) {
         $new_meta->setTitle($this->title);
         $page->setTitle($this->title);
         $title_changed = true;
     }
     // handle metadata: parent page change
     if ($this->parent_page) {
         if (!$cur_meta->getParentPageId() || $cur_meta->getParentPageId() != $this->parent_page->getPageId()) {
             $new_meta->setParentPageId($this->parent_page->getPageId());
             $parent_changed = true;
         }
     }
     if ($this->clear_parent_page && $page->getParentPageId()) {
         $new_meta->setParentPageId(null);
         $parent_changed = true;
     }
     $meta_changed = $title_changed || $parent_changed;
     // decide whether to use previous metadata or create a new object
     if ($meta_changed) {
         $new_meta->save();
         $new_rev->setMetadataId($new_meta->getMetadataId());
     } else {
         $new_rev->setMetadataId($cur_meta->getMetadataId());
     }
     // set flag on revision
     if ($new) {
         $new_rev->setFlagNew(true);
     } else {
         if ($src_changed) {
             $new_rev->setFlagText(true);
         }
         if ($title_changed) {
             $new_rev->setFlagTitle(true);
         }
         if ($parent_changed) {
             $new_rev->setFlagMeta(true);
         }
     }
     if ($src_changed || $meta_changed || $tags_changed) {
         $new_rev->save();
         $page->setSourceId($new_rev->getSourceId());
         $page->setDateLastEdited($now);
         $page->setMetadataId($new_rev->getMetadataId());
         $page->setRevisionNumber($new_rev->getRevisionNumber());
         $page->setRevisionId($new_rev->getRevisionId());
         $page->save();
         $db->commit();
         $GLOBALS['site'] = $this->site;
         $outdater = new Outdater();
         if ($src_changed) {
             $outdater->pageEvent("source_changed", $page);
         }
         if ($title_changed) {
             $outdater->pageEvent("title_changed", $page);
         }
         if ($parent_changed) {
             $outdater->pageEvent("parent_changed", $page);
         }
         if ($tags_changed) {
             $outdater->pageEvent("tag_changed", $page);
         }
     } else {
         /* This place is reached when API client tries to set source or
          * title or parent page or tags that are already set (in the DB)
          * to the same value.
          * 
          * Let's suppose doing nothing is the desired behavior in this case
          * 
          * Other possible way to react can be raising an exception.
          * But it should be different from Wikidot_Facade_Exception_WrongArguments
          * because this one implies client error (and client does not need
          * to know the exact database state).
          */
     }
 }
Example #3
0
 public function savePageEvent($runData)
 {
     $pl = $runData->getParameterList();
     $pageId = $pl->getParameterValue("page_id");
     $mode = $pl->getParameterValue("mode");
     if ($pl->getParameterValue("form")) {
         $data = array();
         $newpages = array();
         foreach ($runData->getParameterList()->asArray() as $name => $val) {
             $m = array();
             if (preg_match("/^field_(.*)\$/", $name, $m)) {
                 $data[$m[1]] = $val;
             }
         }
         $source = Wikidot_Yaml::dump($data);
     } else {
         $source = trim($pl->getParameterValue("source"));
     }
     $comments = trim($pl->getParameterValue("comments"));
     $title = trim($pl->getParameterValue("title"));
     $userId = $runData->getUserId();
     if ($userId == null) {
         $userString = $runData->createIpString();
     }
     if ($title === '') {
         $title = null;
     }
     $unixName = $pl->getParameterValue("wiki_page");
     $unixName = WDStringUtils::toUnixName($unixName);
     // purify! (for sure)
     $lockId = $pl->getParameterValue("lock_id");
     $lockSecret = $pl->getParameterValue("lock_secret");
     $site = $runData->getTemp("site");
     // validate input first
     $db = Database::connection();
     $db->begin();
     // remove old locks.
     if (strlen8($title) > 128) {
         throw new ProcessException(_("Title of the page should not be longer than 128 characters."), "title_too_long");
     }
     // if page source not too long...
     if (strlen8($source) > 200000) {
         throw new ProcessException(_("Source of the page should not be longer than 200 000 characters which is large enough. Pages longer than that can indicate improper usage \tof the wiki site."), "source_too_long");
     }
     // if comment too long
     if (strlen8($comments) > 210) {
         throw new ProcessException(_("The changes comment is longer than 200 characters. Please keep this description short and informative. And no longer than this limit please..."), "comment_too_long");
     }
     $autoincrement = false;
     $nowDate = new ODate();
     if ($pageId === null || $pageId === '') {
         if (preg_match(';^([a-z0-9]+:)?' . self::$AUTOINCREMENT_PAGE . '$;', $unixName)) {
             $autoincrement = true;
         }
         if (!$autoincrement) {
             DB_PageEditLockPeer::instance()->deleteOutdatedByPageName($site->getSiteId(), $unixName);
         }
         // a page should be created!
         // extract category name
         if (strpos($unixName, ':') != false) {
             // ok, there is category!
             $exp = explode(':', $unixName);
             $categoryName = $exp[0];
         } else {
             // no category name, "_default" assumed
             $categoryName = "_default";
         }
         // check if category exists. if not - create it!
         $category = DB_CategoryPeer::instance()->selectByName($categoryName, $site->getSiteId(), false);
         if ($category == null) {
             // create the category - just clone the default category!!!
             $category = DB_CategoryPeer::instance()->selectByName("_default", $site->getSiteId(), false);
             $category->setName($categoryName);
             // fill with some important things - we assume the _default category exists!!! IT REALLY SHOULD!!!
             $category->setCategoryId(null);
             $category->setNew(true);
             // this will make it INSERT, not UPDATE on save()
             $category->setPerPageDiscussion(null);
             //default value
             // set default permissions theme and license
             $category->setPermissionsDefault(true);
             $category->setThemeDefault(true);
             $category->setLicenseDefault(true);
             $category->setNavDefault(true);
             $category->save();
         }
         // first look at permissions!
         WDPermissionManager::instance()->hasPagePermission('create', $runData->getUser(), $category);
         // check the locks!
         // check if the lock still exists.
         if (!$autoincrement) {
             $c = new Criteria();
             $c->add("lock_id", $lockId);
             $c->add("secret", $lockSecret);
             $lock = DB_PageEditLockPeer::instance()->selectOne($c);
             if ($lock == null) {
                 $page = DB_PagePeer::instance()->selectByName($site->getSiteId(), $unixName);
                 if ($page != null) {
                     // page exists!!! error!
                     $runData->ajaxResponseAdd("noLockError", "other_locks");
                     $runData->ajaxResponseAdd("pageExists", true);
                     $runData->ajaxResponseAdd("locked", true);
                     //well, it is somehow locked...
                     $runData->setModuleTemplate("edit/NewPageExistsWinModule");
                     $runData->contextAdd("nonrecoverable", true);
                     $runData->ajaxResponseAdd("nonrecoverable", true);
                     $db->commit();
                     return;
                 }
                 // check if we can TRANSPARENTLY recreate the lock IF there is no
                 // conflicting lock and the revision_id has not changed.
                 $lock = new DB_PageEditLock();
                 $lock->setPageUnixName($unixName);
                 $lock->setSiteId($site->getSiteId());
                 $lock->setUserId($runData->getUserId());
                 $lock->setUserString($runData->getSession()->getIpAddress());
                 $lock->setDateStarted(new ODate());
                 $lock->setDateLastAccessed(new ODate());
                 $lock->setMode("page");
                 $conflictLocks = $lock->getConflicts();
                 if ($conflictLocks == null) {
                     // safely recreate lock
                     $secret = md5(time() . rand(1000, 9999));
                     $lock->setSecret($secret);
                     $lock->setSessionId($runData->getSession()->getSessionId());
                     $lock->save();
                     $lockId = $lock->getLockId();
                     // send back new lock information
                     $runData->ajaxResponseAdd("lockRecreated", true);
                     $runData->ajaxResponseAdd("lockId", $lockId);
                     $runData->ajaxResponseAdd("lockSecret", $secret);
                     $runData->ajaxResponseAdd('timeLeft', 60 * 15);
                 } else {
                     $runData->ajaxResponseAdd("noLockError", "other_locks");
                     $runData->setModuleTemplate("edit/LockInterceptedWinModule");
                     $runData->contextAdd("locks", $conflictLocks);
                     $db->commit();
                     return;
                 }
             } else {
                 $lock->setDateLastAccessed(new ODate());
                 $lock->save();
                 $runData->ajaxResponseAdd('timeLeft', 60 * 15);
             }
         }
         /* Change unixName to integer. */
         if ($autoincrement) {
             /* Check max number taken. */
             $db = Database::connection();
             $q = "select max(substring(unix_name from '[0-9]+')::integer) + 1 as max from page where category_id={$category->getCategoryId()} AND unix_name ~ '^([a-z0-9]+:)?[0-9]+\$'";
             $r = $db->query($q);
             $row = $r->nextRow();
             $unixName = $row['max'];
             if ($category->getName() != '_default') {
                 $unixName = $category->getName() . ':' . $unixName;
             }
             $runData->ajaxResponseAdd('pageUnixName', $unixName);
         }
         $page = new DB_Page();
         $page->obtainPK();
         $pageRevision = new DB_PageRevision();
         $pageRevision->setSiteId($site->getSiteId());
         $pageRevision->setPageId($page->getPageId());
         $pageRevision->setFlagNew(true);
         $pageRevision->setComments($comments);
         $pageRevision->obtainPK();
         $pageRevision->setDateLastEdited($nowDate);
         $pageRevision->setPageId($page->getPageId());
         $page->setRevisionId($pageRevision->getRevisionId());
         $pageSource = new DB_PageSource();
         $pageSource->setText($source);
         $pageSource->save();
         $pageRevision->setSourceId($pageSource->getSourceId());
         $pageMetadata = new DB_PageMetadata();
         $pageMetadata->setTitle($title);
         $pageMetadata->setUnixName($unixName);
         if ($userId) {
             $pageMetadata->setOwnerUserId($userId);
         }
         $pageMetadata->save();
         $pageRevision->setMetadataId($pageMetadata->getMetadataId());
         $pageCompiled = new DB_PageCompiled();
         $pageCompiled->setPageId($page->getPageId());
         $newPage = true;
         // update the page object
         $page->setUnixName($unixName);
         $page->setDateCreated($nowDate);
         $page->setSiteId($site->getSiteId());
         $page->setSourceId($pageSource->getSourceId());
         $page->setMetadataId($pageMetadata->getMetadataId());
         $page->setTitle($title);
         $page->setDateLastEdited($nowDate);
         $pageCompiled = new DB_PageCompiled();
         $pageCompiled->setPageId($page->getPageId());
         $pageCompiled->outdate();
         $newPage = true;
         $page->setCategoryId($category->getCategoryId());
         // now set user_id, user_string
         if ($userId) {
             $pageRevision->setUserId($userId);
             $page->setLastEditUserId($userId);
         } else {
             $pageRevision->setUserId(0);
             $page->setLastEditUserId(0);
             $pageRevision->setUserString($userString);
             $page->setLastEditUserString($userString);
         }
         $page->setOwnerUserId($userId);
         $pageRevision->save();
         $page->setRevisionId($pageRevision->getRevisionId());
         $page->save();
         $pageCompiled->save();
         $sourceChanged = true;
         $outdater = new Outdater();
         $outdater->pageEvent("new_page", $page);
         // index page
         if (!$autoincrement) {
             $c = new Criteria();
             $c->add("lock_id", $lockId);
             DB_PageEditLockPeer::instance()->delete($c);
         }
         EventLogger::instance()->logNewPage($page);
     } else {
         // THE PAGE ALREADY EXISTS
         DB_PageEditLockPeer::instance()->deleteOutdated($pageId);
         $c = new Criteria();
         $c->add("page_id", $pageId);
         $c->setForUpdate(true);
         $page = DB_PagePeer::instance()->selectOne($c);
         if ($page == null) {
             throw new ProcessException(_("Page does not exist."));
         }
         // check permissions
         $category = $page->getCategory();
         WDPermissionManager::instance()->hasPagePermission('edit', $runData->getUser(), $category, $page);
         // check if the lock still exists.
         $c = new Criteria();
         $c->add("lock_id", $lockId);
         $c->add("secret", $lockSecret);
         $lock = DB_PageEditLockPeer::instance()->selectOne($c);
         if ($lock == null) {
             OzoneLogger::instance()->debug("no lock");
             // no lock!!! not good.
             if ($page->getRevisionId() != $pl->getParameterValue("revision_id")) {
                 // this is nonrecoverable.
                 // author should stop editing now!!!
                 OzoneLogger::instance()->debug("page changed");
                 $runData->ajaxResponseAdd("noLockError", "page_changed");
                 $runData->setModuleTemplate("edit/LockInterceptedWinModule");
                 $runData->contextAdd("nonrecoverable", true);
                 $runData->ajaxResponseAdd("nonrecoverable", true);
                 $db->commit();
                 return;
             }
             // check if we can TRANSPARENTLY recreate the lock IF there is no
             // conflicting lock and the revision_id has not changed.
             $lock = new DB_PageEditLock();
             $lock->setPageId($page->getPageId());
             $lock->setPageUnixName($page->getUnixName());
             $lock->setSiteId($site->getSiteId());
             $lock->setUserId($runData->getUserId());
             $lock->setUserString($runData->getSession()->getIpAddress());
             $lock->setDateStarted(new ODate());
             $lock->setDateLastAccessed(new ODate());
             $lock->setMode($mode);
             if ($mode == "section") {
                 $rangeStart = $pl->getParameterValue("range_start");
                 $rangeEnd = $pl->getParameterValue("range_end");
                 $lock->setRangeStart($rangeStart);
                 $lock->setRangeEnd($rangeEnd);
             }
             $conflictLocks = $lock->getConflicts();
             if ($conflictLocks == null) {
                 // safely recreate lock
                 $secret = md5(time() . rand(1000, 9999));
                 $lock->setSecret($secret);
                 $lock->setSessionId($runData->getSession()->getSessionId());
                 $lock->save();
                 $lockId = $lock->getLockId();
                 // send back new lock information
                 $runData->ajaxResponseAdd("lockRecreated", true);
                 $runData->ajaxResponseAdd("lockId", $lockId);
                 $runData->ajaxResponseAdd("lockSecret", $secret);
                 $runData->ajaxResponseAdd('timeLeft', 60 * 15);
             } else {
                 $runData->ajaxResponseAdd("noLockError", "other_locks");
                 $runData->setModuleTemplate("edit/LockInterceptedWinModule");
                 $runData->contextAdd("locks", $conflictLocks);
                 $db->commit();
                 return;
             }
         } else {
             $lock->setDateLastAccessed(new ODate());
             $lock->save();
             $runData->ajaxResponseAdd('timeLeft', 60 * 15);
             // here is a good place to check conditions for
             // "save & continue" which when first called
             // creates new revision, but the subsequent calls
             // do not.
         }
         // check if source or metadata has changed. if neither is changed - do nothing
         // get current revision
         $currentRevision = $page->getCurrentRevision();
         // compare source text
         $oldSourceText = $page->getSource();
         $sourceChanged = false;
         if ($mode == "append") {
             $source = $oldSourceText . "\n\n" . $source;
         }
         if ($mode == "section") {
             $rangeStart = $lock->getRangeStart();
             //$pl->getParameterValue("range_start");
             $rangeEnd = $lock->getRangeEnd();
             //$pl->getParameterValue("range_end");
             $s2 = explode("\n", $oldSourceText);
             // fix source last empty line
             if (!ereg("\n\$", $source)) {
                 $source .= "\n";
             }
             array_splice($s2, $rangeStart, $rangeEnd - $rangeStart + 1, explode("\n", $source));
             $source = implode("\n", $s2);
         }
         if ($oldSourceText !== $source) {
             $sourceChanged = true;
         }
         // create new revision
         $pageRevision = new DB_PageRevision();
         $pageRevision->setSiteId($site->getSiteId());
         // compare metadata
         $metadataChanged = false;
         $oldMetadata = $page->getMetadata();
         // title
         if ($mode == 'page') {
             // check only if the whole page is edited
             if ($title !== $oldMetadata->getTitle()) {
                 $pageRevision->setFlagTitle(true);
                 $metadataChanged = true;
             }
         }
         // and act accordingly to the situation
         if ($sourceChanged == false && $metadataChanged == false) {
             $c = new Criteria();
             $c->add("lock_id", $lockId);
             DB_PageEditLockPeer::instance()->delete($c);
             $db->commit();
             return;
         }
         $pageRevision->setPageId($page->getPageId());
         $pageRevision->setDateLastEdited($nowDate);
         $pageRevision->setRevisionNumber($currentRevision->getRevisionNumber() + 1);
         if ($sourceChanged) {
             $fullSource = false;
             // first check if store new source as a diff or as a full-source.
             if (true || $currentRevision->getSinceFullSource() > 9) {
                 $fullSource = true;
             } else {
                 // also compare size of diff against size of new source.
                 // must be less than %50 to qualify
                 $differ = new ODiff();
                 $diff = $differ->diffString($oldSourceText, $source);
                 if (strlen($diff) > 0.5 * strlen($source)) {
                     $fullSource = true;
                 }
             }
             $pageSource = new DB_PageSource();
             if ($fullSource) {
                 $pageSource->setText($source);
             } else {
                 $pageSource->setText($diff);
                 $pageRevision->setDiffSource(true);
                 $pageRevision->setSinceFullSource($currentRevision->getSinceFullSource() + 1);
             }
             $pageSource->save();
             $pageRevision->setSourceId($pageSource->getSourceId());
             $pageRevision->setFlagText(true);
         } else {
             // copy source id
             $pageRevision->setSourceId($currentRevision->getSourceId());
             $pageRevision->setSinceFullSource($currentRevision->getSinceFullSource());
             $pageRevision->setDiffSource($currentRevision->getDiffSource());
         }
         if ($metadataChanged) {
             $pageMetadata = clone $oldMetadata;
             $pageMetadata->setNew(true);
             $pageMetadata->setMetadataId(null);
             $pageMetadata->setTitle($title);
             $pageMetadata->save();
             $pageRevision->setMetadataId($pageMetadata->getMetadataId());
         } else {
             // copy metadata id
             $pageRevision->setMetadataId($currentRevision->getMetadataId());
         }
         // now set user_id, user_string
         if ($userId) {
             $pageRevision->setUserId($userId);
             $page->setLastEditUserId($userId);
         } else {
             $pageRevision->setUserId(0);
             $page->setLastEditUserId(0);
             $pageRevision->setUserString($userString);
             $page->setLastEditUserString($userString);
         }
         $pageRevision->setComments($comments);
         $pageRevision->save();
         $page->setRevisionId($pageRevision->getRevisionId());
         // update Page object
         $page->setSourceId($pageRevision->getSourceId());
         if ($mode == 'page') {
             $page->setTitle($title);
         }
         $page->setDateLastEdited($nowDate);
         $page->setMetadataId($pageRevision->getMetadataId());
         $page->setRevisionNumber($pageRevision->getRevisionNumber());
         $page->save();
         // also if "section edit" - find other locks that refer to
         // blocks with higher line numbers and change start/end accordingly
         if ($mode == "section") {
             $c = new Criteria();
             $c->add("page_id", $pageId);
             $c->add("range_start", $lock->getRangeEnd(), ">=");
             $c->add("mode", "section");
             $laterLocks = DB_PageEditLockPeer::instance()->select($c);
             if (count($laterLocks) > 0) {
                 // take the length of the current lock
                 $sectionLength = $lock->getRangeEnd() - $lock->getRangeStart() + 1;
                 $newSourceLength = count(explode("\n", trim($pl->getParameterValue("source")))) + 1;
                 // +1 for the new line at the end
                 $lengthDifference = $newSourceLength - $sectionLength;
                 foreach ($laterLocks as $llock) {
                     $llock->setRangeStart($llock->getRangeStart() + $lengthDifference);
                     $llock->setRangeEnd($llock->getRangeEnd() + $lengthDifference);
                     $llock->save();
                 }
             }
         }
         // OUTDATING PARTY!!!
         $outdater = new Outdater();
         if ($sourceChanged) {
             $outdater->pageEvent("source_changed", $page);
         }
         if ($metadataChanged) {
             $outdater->pageEvent("title_changed", $page);
         }
         // index page
         EventLogger::instance()->logSavePage($page);
     }
     // remove lock too?
     if (!$pl->getParameterValue("and_continue") && !$autoincrement) {
         $c = new Criteria();
         $c->add("lock_id", $lockId);
         DB_PageEditLockPeer::instance()->delete($c);
         $runData->ajaxResponseAdd("revisionId", $pageRevision->getRevisionId());
     }
     $db->commit();
 }
Example #4
0
 public function restoreSite($nsite, $dump)
 {
     $superSettings = $dump['superSettings'];
     $settings = $dump['settings'];
     $superSettings->setNew(true);
     $superSettings->setSiteId($nsite->getSiteId());
     $superSettings->save();
     // site_settings
     $settings->setNew(true);
     $settings->setSiteId($nsite->getSiteId());
     $settings->save();
     $forumSettings = $dump['forumSettings'];
     $forumSettings->setNew(true);
     $forumSettings->setSiteId($nsite->getSiteId());
     $forumSettings->save();
     // add user as admin
     $owner = $this->owner;
     if ($owner) {
         $admin = new DB_Admin();
         $admin->setSiteId($nsite->getSiteId());
         $admin->setUserId($owner->getUserId());
         $admin->setFounder(true);
         // will be nonremovable ;-)
         $admin->save();
         $member = new DB_Member();
         $member->setSiteId($nsite->getSiteId());
         $member->setUserId($owner->getUserId());
         $member->setDateJoined(new ODate());
         $member->save();
     }
     $categories = $dump['categories'];
     foreach ($categories as $category) {
         $cat = clone $category;
         $cat->setNew(true);
         $cat->setCategoryId(null);
         $cat->setSiteId($nsite->getSiteId());
         $cat->save();
         // get pages
         $pages = $dump['pages'][$category->getCategoryId()];
         foreach ($pages as $page) {
             $newUnixName = $page->getUnixName();
             $now = new ODate();
             // create new page object based on the existing page
             $nsource = new DB_PageSource();
             $nsource->setText($page->getTemp("source"));
             $nsource->save();
             $meta = $page->getTemp("meta");
             $nmeta = new DB_PageMetadata();
             $nmeta->setTitle($meta->getTitle());
             $nmeta->setUnixName($newUnixName);
             if ($owner) {
                 $nmeta->setOwnerUserId($owner->getUserId());
             } else {
                 $nmeta->setOwnerUserId($meta->getOwnerUserId());
             }
             $nmeta->save();
             $nrev = new DB_PageRevision();
             $nrev->setSiteId($nsite->getSiteId());
             $nrev->setSourceId($nsource->getSourceId());
             $nrev->setMetadataId($nmeta->getMetadataId());
             $nrev->setFlagNew(true);
             $nrev->setDateLastEdited($now);
             $nrev->setUserId($owner->getUserId());
             $nrev->obtainPK();
             $npage = new DB_Page();
             $npage->setSiteId($nsite->getSiteId());
             $npage->setCategoryId($cat->getCategoryId());
             $npage->setRevisionId($nrev->getRevisionId());
             $npage->setSourceId($nsource->getSourceId());
             $npage->setMetadataId($nmeta->getMetadataId());
             $npage->setTitle($page->getTitle());
             $npage->setUnixName($newUnixName);
             $npage->setDateLastEdited($now);
             $npage->setLastEditUserId($owner->getUserId());
             $npage->setOwnerUserId($owner->getUserId());
             $npage->save();
             $nrev->setPageId($npage->getPageId());
             $nrev->save();
             $ncomp = new DB_PageCompiled();
             $ncomp->setPageId($npage->getPageId());
             $ncomp->setDateCompiled($now);
             $ncomp->save();
         }
     }
     $od = new Outdater();
     $od->recompileWholeSite($nsite);
 }