1 <?php
  2 /**
  3  * Represents an interface for viewing and adding page comments
  4  * Create one, passing the page discussed to the constructor.  It can then be
  5  * inserted into a template.
  6  * @package cms
  7  * @subpackage comments
  8  */
  9 class PageCommentInterface extends RequestHandler {
 10     static $url_handlers = array(
 11         '$Item!' => '$Item',
 12     );
 13     static $allowed_actions = array(
 14         'PostCommentForm',
 15     );
 16     
 17     protected $controller, $methodName, $page;
 18     
 19     /**
 20      * If this is true, you must be logged in to post a comment 
 21      * (and therefore, you don't need to specify a 'Your name' field unless 
 22      * your name is blank)
 23      * 
 24      * @var bool
 25      */
 26     static $comments_require_login = false;
 27     
 28     /**
 29      * If this is a valid permission code, you must be logged in 
 30      * and have the appropriate permission code on your account before you can 
 31      * post a comment.
 32      * 
 33      * @var string 
 34      */
 35     static $comments_require_permission = "";
 36     
 37     /**
 38      * If this is true it will include the javascript for AJAX 
 39      * commenting. If it is set to false then it will not load
 40      * the files required and it will fall back
 41      * 
 42      * @var bool
 43      */
 44     static $use_ajax_commenting = true;
 45     
 46     /**
 47      * If this is true then we should show the existing comments on 
 48      * the page even when we have disabled the comment form. 
 49      *
 50      * If this is false the form + existing comments will be hidden
 51      * 
 52      * @var bool
 53      * @since 2.4 - Always show them by default
 54      */
 55     static $show_comments_when_disabled = true;
 56     
 57     /**
 58      * Define how you want to order page comments by. By default order by newest
 59      * to oldest. 
 60      * 
 61      * @var String - used as $orderby in DB query
 62      * @since 2.4 
 63      */
 64     static $order_comments_by = "\"Created\" DESC";
 65     
 66     /**
 67      * Required fields for Comment Form
 68      * 
 69      * by menedem    
 70      */
 71     static $required_fields = array();
 72     
 73     /**
 74      * Create a new page comment interface
 75      * @param controller The controller that the interface is used on
 76      * @param methodName The method to return this PageCommentInterface object
 77      * @param page The page that we're commenting on
 78      */
 79     function __construct($controller, $methodName, $page) {
 80         $this->controller = $controller;
 81         $this->methodName = $methodName;
 82         $this->page = $page;
 83         parent::__construct();
 84     }
 85     
 86     function Link() {
 87         return Controller::join_links($this->controller->Link(), $this->methodName);
 88     }
 89     
 90     /**
 91      * See {@link PageCommentInterface::$comments_require_login}
 92      *
 93      * @param boolean state The new state of this static field
 94      */
 95     static function set_comments_require_login($state) {
 96         self::$comments_require_login = (boolean) $state;
 97     }
 98     
 99     /**
100      * See {@link PageCommentInterface::$comments_require_permission}
101      *
102      * @param string permission The permission to check against.
103      */
104     static function set_comments_require_permission($permission) {
105         self::$comments_require_permission = $permission;
106     }
107     
108     /**
109      * See {@link PageCommentInterface::$show_comments_when_disabled}
110      * 
111      * @param bool - show / hide the existing comments when disabled
112      */
113     static function set_show_comments_when_disabled($state) {
114         self::$show_comments_when_disabled = $state;
115     }
116     
117     /**
118      * See {@link PageCommentInterface::$order_comments_by}
119      *
120      * @param String
121      */
122     static function set_order_comments_by($order) {
123         self::$order_comments_by = $order;
124     }
125     
126     /**
127      * See {@link PageCommentInterface::$use_ajax_commenting}
128      *
129      * @param bool
130      */
131     static function set_use_ajax_commenting($state) {
132         self::$use_ajax_commenting = $state;
133     }
134     
135     function forTemplate() {
136         return $this->renderWith('PageCommentInterface');
137     }
138     
139     /**
140      * @return boolean true if the currently logged in user can post a comment,
141      * false if they can't. Users can post comments by default, enforce 
142      * security by using 
143      * @link PageCommentInterface::set_comments_require_login() and 
144      * @link {PageCommentInterface::set_comments_require_permission()}.
145      */
146     static function CanPostComment() {
147         $member = Member::currentUser();
148         if(self::$comments_require_permission && $member && Permission::check(self::$comments_require_permission)) {
149             return true; // Comments require a certain permission, and the user has the correct permission
150         } elseif(self::$comments_require_login && $member && !self::$comments_require_permission) {
151             return true; // Comments only require that a member is logged in
152         } elseif(!self::$comments_require_permission && !self::$comments_require_login) {
153             return true; // Comments don't require anything - anyone can add a comment
154         }
155         
156         return false;
157     }
158     
159     /**
160      * if this page comment form requires users to have a
161      * valid permission code in order to post (used to customize the error 
162      * message).
163      * 
164      * @return bool
165      */
166     function PostingRequiresPermission() {
167         return self::$comments_require_permission;
168     }
169     
170     function Page() {
171         return $this->page;
172     }
173     
174     function PostCommentForm() {
175         if(!$this->page->ProvideComments || !$this->page->allowComments()){
176             return false;
177         }
178         $fields = new FieldSet(
179             new HiddenField("ParentID", "ParentID", $this->page->ID)
180         );
181         
182         $member = Member::currentUser();
183         
184         if((self::$comments_require_login || self::$comments_require_permission) && $member && $member->FirstName) {
185             // note this was a ReadonlyField - which displayed the name in a span as well as the hidden field but
186             // it was not saving correctly. Have changed it to a hidden field. It passes the data correctly but I 
187             // believe the id of the form field is wrong.
188             $fields->push(new ReadonlyField("NameView", _t('PageCommentInterface.YOURNAME', 'Your name'), $member->getName()));
189             $fields->push(new HiddenField("Name", "", $member->getName()));
190         } else {
191             $fields->push(new TextField("Name", _t('PageCommentInterface.YOURNAME', 'Your name')));
192         }
193                 
194         // optional commenter URL
195         $fields->push(new TextField("CommenterURL", _t('PageCommentInterface.COMMENTERURL', "Your website URL")));
196         
197         if(MathSpamProtection::isEnabled()){
198             $fields->push(new TextField("Math", sprintf(_t('PageCommentInterface.SPAMQUESTION', "Spam protection question: %s"), MathSpamProtection::getMathQuestion())));
199         }               
200         
201         $fields->push(new TextareaField("Comment", _t('PageCommentInterface.YOURCOMMENT', "Comments")));
202         
203         $required_fields = self::$required_fields;
204         $siteConfig = SiteConfig::current_site_config();
205         if ($siteConfig->hasMethod('SiteAgreementField') && ($rulesField = $siteConfig->SiteAgreementField())) {
206             $fields->push($rulesField);
207             $required_fields[] = $rulesField->Name();
208         }
209         $validator = new RequiredFields($required_fields);
210         
211         $form = new PageCommentInterface_Form($this, "PostCommentForm", $fields, new FieldSet(
212             new FormAction("postcomment", _t('PageCommentInterface.POST', 'Post'))
213         ), $validator);
214         
215         // Set it so the user gets redirected back down to the form upon form fail
216         $form->setRedirectToFormOnValidationError(true);
217         
218         // Optional Spam Protection.
219         if(class_exists('SpamProtectorManager')) {
220             SpamProtectorManager::update_form($form, null, array('Name' => 'author_name', 'CommenterURL' => 'author_url', 'Comment' => 'post_body'),_t('PageCommentInterface.Captcha','SpamProtection'));
221             self::set_use_ajax_commenting(false);
222         }
223         
224         // Shall We use AJAX?
225         if(self::$use_ajax_commenting) {
226             Requirements::javascript(SAPPHIRE_DIR . '/thirdparty/behaviour/behaviour.js');
227             Requirements::javascript(SAPPHIRE_DIR . '/thirdparty/prototype/prototype.js');
228             Requirements::javascript(THIRDPARTY_DIR . '/scriptaculous/effects.js');
229             Requirements::javascript(CMS_DIR . '/javascript/PageCommentInterface.js');
230         }
231         
232         $this->extend('updatePageCommentForm', $form);
233         
234         // Load the data from Session
235         $form->loadDataFrom(array(
236             "Name" => Cookie::get("PageCommentInterface_Name"),
237             "Comment" => Cookie::get("PageCommentInterface_Comment"),
238             "CommenterURL" => Cookie::get("PageCommentInterface_CommenterURL")  
239         ));
240         
241         return $form;
242     }
243     
244     function Comments() {
245         // Comment limits
246         $limit = array();
247         $limit['start'] = isset($_GET['commentStart']) ? (int)$_GET['commentStart'] : 0;
248         $limit['limit'] = PageComment::$comments_per_page;
249         
250         $spamfilter = isset($_GET['showspam']) ? '' : "AND \"IsSpam\" = 0";
251         $unmoderatedfilter = Permission::check('ADMIN') ? '' : "AND \"NeedsModeration\" = 0";
252         $order = self::$order_comments_by;
253         $comments =  DataObject::get("PageComment", "\"ParentID\" = '" . Convert::raw2sql($this->page->ID) . "' $spamfilter $unmoderatedfilter", $order, "", $limit);
254         
255         if(is_null($comments)) {
256             return;
257         }
258         
259         // This allows us to use the normal 'start' GET variables as well (In the weird circumstance where you have paginated comments AND something else paginated)
260         $comments->setPaginationGetVar('commentStart');
261         
262         return $comments;
263     }
264     
265     function CommentRssLink() {
266         return Director::absoluteBaseURL() . "PageComment/rss?pageid=" . $this->page->ID;
267     }
268     
269     /**
270      * A link to PageComment_Controller.deleteallcomments() which deletes all
271      * comments on a page referenced by the url param pageid
272      */
273     function DeleteAllLink() {
274         if(Permission::check('CMS_ACCESS_CMSMain')) {
275             return Director::absoluteBaseURL() . "PageComment/deleteallcomments?pageid=" . $this->page->ID;
276         }
277     }
278     
279 }
280 
281 /**
282  * @package cms
283  * @subpackage comments
284  */
285 class PageCommentInterface_Form extends Form {
286     function postcomment($data) {
287         // Spam filtering
288         Cookie::set("PageCommentInterface_Name", $data['Name']);
289         Cookie::set("PageCommentInterface_CommenterURL", $data['CommenterURL']);
290         Cookie::set("PageCommentInterface_Comment", $data['Comment']);
291 
292         if(SSAkismet::isEnabled()) {
293             try {
294                 $akismet = new SSAkismet();
295                 
296                 $akismet->setCommentAuthor($data['Name']);
297                 $akismet->setCommentContent($data['Comment']);
298                 
299                 if($akismet->isCommentSpam()) {
300                     if(SSAkismet::getSaveSpam()) {
301                         $comment = Object::create('PageComment');
302                         $this->saveInto($comment);
303                         $comment->setField("IsSpam", true);
304                         $comment->write();
305                     }
306                     echo "<b>"._t('PageCommentInterface_Form.SPAMDETECTED', 'Spam detected!!') . "</b><br /><br />";
307                     printf("If you believe this was in error, please email %s.", ereg_replace("@", " _(at)_", Email::getAdminEmail()));
308                     echo "<br /><br />"._t('PageCommentInterface_Form.MSGYOUPOSTED', 'The message you posted was:'). "<br /><br />";
309                     echo $data['Comment'];
310                     
311                     return;
312                 }
313             } catch (Exception $e) {
314                 // Akismet didn't work, continue without spam check
315             }
316         }
317         
318         //check if spam question was right.
319         if(MathSpamProtection::isEnabled()){
320             if(!MathSpamProtection::correctAnswer($data['Math'])){
321                 if(!Director::is_ajax()) {              
322                     Director::redirectBack();
323                 }
324                 return "spamprotectionfailed"; //used by javascript for checking if the spam question was wrong
325             }
326         }
327         
328         // If commenting can only be done by logged in users, make sure the user is logged in
329         $member = Member::currentUser();
330         if(PageCommentInterface::CanPostComment() && $member) {
331             $this->Fields()->push(new HiddenField("AuthorID", "Author ID", $member->ID));
332         } elseif(!PageCommentInterface::CanPostComment()) {
333             echo "You're not able to post comments to this page. Please ensure you are logged in and have an appropriate permission level.";
334             return;
335         }
336 
337         $comment = Object::create('PageComment');
338         $this->saveInto($comment);
339         
340         // Store the Session ID if needed for Spamprotection
341         if($session = Session::get('mollom_user_session_id')) {
342             $comment->SessionID = $session;
343             Session::clear('mollom_user_session_id');   
344         }
345         $comment->IsSpam = false;
346         $comment->NeedsModeration = PageComment::moderationEnabled();
347         $comment->write();
348         
349         $this->extend('OnAfterPost', $comment, $data);
350         
351         Cookie::set("PageCommentInterface_Comment", '');
352         
353         $moderationMsg = _t('PageCommentInterface_Form.AWAITINGMODERATION', "Your comment has been submitted and is now awaiting moderation.");
354         
355         if(Director::is_ajax()) {
356             if($comment->NeedsModeration){
357                 echo $moderationMsg;
358             } else{
359                 echo $comment->renderWith('PageCommentInterface_singlecomment');
360             }
361         } else {        
362             if($comment->NeedsModeration){
363                 $this->sessionMessage($moderationMsg, 'good');
364             }
365             // since it is not ajax redirect user down to their comment since it has been posted
366             // get the pages url off the comments parent ID.
367             if($comment->ParentID) {
368                 $page = DataObject::get_by_id("Page", $comment->ParentID);
369                 if($page) {
370                     // Redirect to the actual post on the page.
371                     return Director::redirect($page->Link() . '#PageComment_' . $comment->ID);
372                 }
373             }
374 
375             return Director::redirectBack(); // worst case, just go back to the page
376         }
377     }
378 }
379 
380 /**
381  * @package cms
382  * @subpackage comments
383  */
384 class PageCommentInterface_Controller extends ContentController {
385     function __construct() {
386         parent::__construct(null);
387     }
388     
389     function newspamquestion() {
390         if(Director::is_ajax()) {
391             echo Convert::raw2xml(sprintf(_t('PageCommentInterface_Controller.SPAMQUESTION', "Spam protection question: %s"),MathSpamProtection::getMathQuestion()));
392         }
393     }
394 }
395 
396 ?>
397