function testCreateThreadOfMessages()
{
$message1 = new Phorum_message();
$message1->create(1, 'Message 1', 'la la');
$message2 = new Phorum_message();
$message2->create(1, 'Message 2', 'wow', $message1->getThreadId(), $message1->getMessageId());
$message3 = new Phorum_message();
$message3->create(1, 'Message 3', 'cool', $message1->getThreadId(), $message1->getMessageId());
$messages = Phorum_message::GetMessages(array("thread" => $message1->getThreadId()));
if (count($messages) != 3) {
$this->fail("Creating a thread of messages failed.");
}
$message1->delete(PHORUM_DELETE_TREE);
$message2->fetch();
$message3->fetch();
if ($message2->exists() || $message3->exists()) {
$this->fail("Thread not deleted correctly");
}
} // fn testCreateThreadOfMessages
<script type="text/javascript">
window.close();
window.opener.location.reload();
</script>
<?php
exit;
}
}
if (!isset($connectedToOnlineServer)
|| $connectedToOnlineServer == true) {
$f_comment_id = Input::Get("f_comment_id", "int");
$banned = false;
$comment = new Phorum_message($f_comment_id);
if ($comment->exists()) {
$banIp = Input::Get("f_ban_ip", 'checkbox');
if ($banIp) {
$banItem = new Phorum_ban_item();
$banItem->create(PHORUM_BAD_IPS, false, $comment->getIpAddress());
$banned = true;
} else {
Phorum_ban_item::DeleteMatching(PHORUM_BAD_IPS, false, $comment->getIpAddress());
}
$banEmail = Input::Get("f_ban_email", 'checkbox');
if ($banEmail) {
$banItem = new Phorum_ban_item();
$banItem->create(PHORUM_BAD_EMAILS, false, $comment->getEmail());
$banned = true;
} else {
Phorum_ban_item::DeleteMatching(PHORUM_BAD_EMAILS, false, $comment->getEmail());
/**
* Performs the action; returns true on success, false on error.
*
* @param $p_context - the current context object
* @return bool
*/
public function takeAction(CampContext &$p_context)
{
$p_context->default_url->reset_parameter('f_'.$this->m_name);
$p_context->url->reset_parameter('f_'.$this->m_name);
if (!is_null($this->m_error)) {
return false;
}
// Check that the article exists.
$articleMetaObj = $p_context->default_article;
if (!$articleMetaObj->defined) {
$this->m_error = new PEAR_Error('The article was not selected. You must view an article in order to post comments.',
ACTION_SUBMIT_COMMENT_ERR_NO_ARTICLE);
return false;
}
if (!$articleMetaObj->comments_enabled || $articleMetaObj->comments_locked) {
$this->m_error = new PEAR_Error('Comments are not enabled for this publication/article.',
ACTION_SUBMIT_COMMENT_ERR_NOT_ENABLED);
return false;
}
// Get the publication.
$publicationObj = new Publication($articleMetaObj->publication->identifier);
$forum = new Phorum_forum($publicationObj->getForumId());
if (!$forum->exists()) {
$forum->create();
$forum->setName($publicationObj->getName());
$publicationObj->setForumId($forum->getForumId());
}
$forumId = $forum->getForumId();
$user = $p_context->user;
if ($user->defined) {
$phorumUser = Phorum_user::GetByUserName($user->uname);
if (is_null($phorumUser)) {
$phorumUser = new Phorum_user();
}
$userId = $user->identifier;
$userEmail = $user->email;
$userRealName = $user->name;
$userPasswd = $user->password_encrypted;
// Check if the phorum user existed or was created successfuly.
// If not, set the error code to 'internal error' and exit.
if (!Phorum_user::CampUserExists($userId)
&& !$phorumUser->create($user->uname, $userPasswd, $userEmail, $userId)) {
$this->m_error = new PEAR_Error('There was an internal error when submitting the comment (code 1).',
ACTION_SUBMIT_COMMENT_ERR_INTERNAL);
return false;
}
} else {
if ($forum->getPublicPermissions() & (PHORUM_USER_ALLOW_NEW_TOPIC | PHORUM_USER_ALLOW_REPLY)) {
if (!isset($this->m_properties['reader_email'])) {
$this->m_error = new PEAR_Error('EMail field is empty. You must fill in your EMail address.',
ACTION_SUBMIT_COMMENT_ERR_NO_EMAIL);
return false;
}
$userId = null;
$userEmail = $this->m_properties['reader_email'];
$userRealName = $userEmail;
} else {
$this->m_error = new PEAR_Error('You must be a registered user in order to submit a comment. Please subscribe or log in if you already have a subscription.',
ACTION_SUBMIT_COMMENT_ERR_NO_PUBLIC);
return false;
}
}
// Validate the CAPTCHA code if it was enabled for the current publication.
if ($publicationObj->isCaptchaEnabled()) {
if ($this->_processCaptcha() === FALSE) {
return FALSE;
}
}
// Check if the reader was banned from posting comments.
if (Phorum_user::IsBanned($userRealName, $userEmail)) {
$this->m_error = new PEAR_Error('You are banned from submitting comments.',
ACTION_SUBMIT_COMMENT_ERR_BANNED);
return false;
}
// Create the first post message (if needed)
$articleObj = new Article($articleMetaObj->language->number, $articleMetaObj->number);
$firstPost = $this->CreateFirstComment($articleObj, $forumId);
if (is_null($firstPost)) {
$this->m_error = new PEAR_Error('There was an internal error when submitting the comment (code 2).',
ACTION_SUBMIT_COMMENT_ERR_INTERNAL);
return false;
}
// Set the parent to the currently viewed comment if a certain existing
// comment was selected. Otherwise, set the parent identifier to the root message.
$parentMessage = new Phorum_message($p_context->comment->identifier);
if (!$parentMessage->exists()) {
$parentMessage = $firstPost;
}
// Create the comment. If there was an error creating the comment set the
// error code to 'internal error' and exit.
$commentObj = new Phorum_message();
if (!$commentObj->create($forumId, $this->m_properties['subject'],
$this->m_properties['content'], $firstPost->getThreadId(),
$parentMessage->getMessageId(), $this->m_properties['nickname'], $userEmail,
is_null($userId) ? 0 : $userId)) {
$this->m_error = new PEAR_Error('There was an internal error when submitting the comment (code 3).',
ACTION_SUBMIT_COMMENT_ERR_INTERNAL);
return false;
}
// If the user was unknown (public comment) and public comments were moderated
// or the user was known (subscriber comment) and subscriber comments were moderated
// set the comment status to 'hold'. Otherwise, set the status to 'approved'.
if ((!is_null($userId) && $publicationObj->commentsSubscribersModerated())
|| (is_null($userId) && $publicationObj->commentsPublicModerated())) {
$commentObj->setStatus(PHORUM_STATUS_HOLD);
} else {
$commentObj->setStatus(PHORUM_STATUS_APPROVED);
}
// Link the message to the current article.
$isFirstMessage = ($firstPost->getThreadId() == 0);
ArticleComment::Link($articleMetaObj->number, $articleMetaObj->language->number,
$commentObj->getMessageId(), $isFirstMessage);
$p_context->comment = new MetaComment($commentObj->getMessageId());
$p_context->default_url->reset_parameter('f_comment_reader_email');
$p_context->default_url->reset_parameter('f_comment_subject');
$p_context->default_url->reset_parameter('f_comment_content');
$p_context->default_url->reset_parameter('f_submit_comment');
$p_context->default_url->reset_parameter('f_captcha_code');
$p_context->url->reset_parameter('f_comment_reader_email');
$p_context->url->reset_parameter('f_comment_subject');
$p_context->url->reset_parameter('f_comment_content');
$p_context->url->reset_parameter('f_submit_comment');
$p_context->url->reset_parameter('f_captcha_code');
$this->m_properties['rejected'] = false;
$this->m_error = ACTION_OK;
return true;
}
/**
* Create the first message for an article, which is a blank message
* with the title of the article as the subject.
*
* @param Article $p_article
* @param int $p_forumId
* @return mixed
* The comment created (or the one that already exists) on success,
* or false on error.
*/
function camp_comment_first_post($p_article, $p_forumId)
{
// Check if the first post already exists.
$articleNumber = $p_article->getArticleNumber();
$languageId = $p_article->getLanguageId();
$firstPostId = ArticleComment::GetCommentThreadId($articleNumber, $languageId);
if ($firstPostId) {
$firstPost = new Phorum_message($firstPostId);
if ($firstPost->exists()) {
return $firstPost;
}
// Unlink the message from the current article.
ArticleComment::Unlink($articleNumber, $languageId, $firstPostId);
}
// Get article creator
$user = new User($p_article->getCreatorId());
if ($user->exists()) {
$userId = $user->getUserId();
$userEmail = $user->getEmail();
$userPasswd = $user->getPassword();
$userName = $user->getUserName();
$userRealName = $user->getRealName();
// Create phorum user if necessary
$phorumUser = Phorum_user::GetByUserName($userName);
if (!is_object($phorumUser)) {
$phorumUser = new Phorum_user();
}
if (!$phorumUser->CampUserExists($userId)
&& !$phorumUser->create($userName, $userPasswd, $userEmail, $userId)) {
return false;
}
} else {
$userId = null;
$userEmail = '';
$userRealName = '';
}
// Create the comment.
$title = $p_article->getTitle();
$commentObj = new Phorum_message();
if ($commentObj->create($p_forumId,
$title,
'',
0,
0,
$userRealName,
$userEmail,
is_null($userId) ? 0 : $userId)) {
// Link the message to the current article.
ArticleComment::Link($articleNumber, $languageId, $commentObj->getMessageId(), true);
return $commentObj;
} else {
return false;
}
} // fn camp_comment_first_post
if (SystemPref::Get("UseDBReplication") == 'Y') {
$dbReplicationObj = new DbReplication();
$connectedToOnlineServer = $dbReplicationObj->connect();
if ($connectedToOnlineServer == false) {
camp_html_add_msg(getGS("Comments Disabled: you are either offline or not able to reach the Online server"));
camp_html_goto_page(camp_html_article_url($articleObj, $f_language_selected, "edit.php"));
}
}
// process all comments
foreach ($_REQUEST as $name => $value) {
if (strstr($name, "comment_action_")) {
$parts = explode("_", $name);
$messageId = $parts[2];
$comment = new Phorum_message($messageId);
if (!$comment->exists()) {
continue;
}
switch ($value) {
case "inbox":
$comment->setStatus(PHORUM_STATUS_HOLD);
break;
case "hide":
$comment->setStatus(PHORUM_STATUS_HIDDEN);
break;
case "delete":
// Not allowed to delete first post.
if ($comment->getMessageId() != $comment->getThreadId()) {
$comment->delete();
ArticleComment::Unlink(null, null, $messageId);
}
/**
* Returns an article comments list based on the given parameters.
*
* @param array $p_parameters
* An array of ComparisonOperation objects
* @param string $p_order
* An array of columns and directions to order by
* @param integer $p_start
* The record number to start the list
* @param integer $p_limit
* The offset. How many records from $p_start will be retrieved.
* @param integer $p_count
* The total count of the elements; this count is computed without
* applying the start ($p_start) and limit parameters ($p_limit)
*
* @return array $articleCommentsList
* An array of Comment objects
*/
public static function GetList(array $p_parameters, $p_order = null,
$p_start = 0, $p_limit = 0, &$p_count, $p_skipCache = false)
{
global $g_ado_db, $PHORUM;
if (!$p_skipCache && CampCache::IsEnabled()) {
$paramsArray['parameters'] = serialize($p_parameters);
$paramsArray['order'] = (is_null($p_order)) ? 'null' : $p_order;
$paramsArray['start'] = $p_start;
$paramsArray['limit'] = $p_limit;
$cacheListObj = new CampCacheList($paramsArray, __METHOD__, self::DEFAULT_TTL);
$articleCommentsList = $cacheListObj->fetchFromCache();
if ($articleCommentsList !== false && is_array($articleCommentsList)) {
return $articleCommentsList;
}
}
$selectClauseObj = new SQLSelectClause();
$countClauseObj = new SQLSelectClause();
$messageTable = $PHORUM['message_table'];
$selectClauseObj->setTable($messageTable);
$countClauseObj->setTable($messageTable);
$articleNumber = null;
$languageId = null;
// sets the where conditions
foreach ($p_parameters as $param) {
$comparisonOperation = self::ProcessListParameters($param);
if (strtolower($comparisonOperation->getLeftOperand()) == 'fk_article_number') {
$articleNumber = $comparisonOperation->getRightOperand();
}
if (strtolower($comparisonOperation->getLeftOperand()) == 'fk_language_id') {
$languageId = $comparisonOperation->getRightOperand();
}
$parameters[] = $comparisonOperation;
}
if (!is_null($articleNumber) && !is_null($languageId)) {
// gets the thread id for the article
$threadId = ArticleComment::GetCommentThreadId($articleNumber, $languageId);
$selectClauseObj->addWhere('thread = '.$threadId);
$countClauseObj->addWhere('thread = '.$threadId);
}
$selectClauseObj->addWhere('message_id != thread');
$selectClauseObj->addWhere('status = '.PHORUM_STATUS_APPROVED);
$countClauseObj->addWhere('message_id != thread');
$countClauseObj->addWhere('status = '.PHORUM_STATUS_APPROVED);
if (!is_array($p_order) || count($p_order) == 0) {
$p_order = array('default'=>'asc');
}
// sets the order condition if any
if (is_array($p_order)) {
$order = ArticleComment::ProcessListOrder($p_order);
// sets the order condition if any
foreach ($order as $orderDesc) {
$orderField = $orderDesc['field'];
$orderDirection = $orderDesc['dir'];
$selectClauseObj->addOrderBy($orderField . ' ' . $orderDirection);
}
}
// sets the limit
$selectClauseObj->setLimit($p_start, $p_limit);
// builds the query and executes it
$selectQuery = $selectClauseObj->buildQuery();
$comments = $g_ado_db->GetAll($selectQuery);
if (is_array($comments)) {
$countClauseObj->addColumn('COUNT(*)');
$countQuery = $countClauseObj->buildQuery();
$p_count = $g_ado_db->GetOne($countQuery);
// builds the array of comment objects
$articleCommentsList = array();
foreach ($comments as $comment) {
$pmObj = new Phorum_message($comment['message_id']);
if ($pmObj->exists()) {
$articleCommentsList[] = $pmObj;
}
}
} else {
$articleCommentsList = array();
$p_count = 0;
}
if (!$p_skipCache && CampCache::IsEnabled()) {
$cacheListObj->storeInCache($articleCommentsList);
}
return $articleCommentsList;
} // fn GetList