silverstripe-comments/code/extensions/CommentsExtension.php

526 lines
16 KiB
PHP
Raw Normal View History

<?php
/**
* Extension to {@link DataObject} to enable tracking comments.
*
* @package comments
*/
class CommentsExtension extends DataExtension {
/**
* Default configuration values
2015-04-13 05:41:18 +02:00
*
* enabled: Allows commenting to be disabled even if the extension is present
* enabled_cms: Allows commenting to be enabled or disabled via the CMS
* require_login: Boolean, whether a user needs to login (required for required_permission)
* require_login_cms: Allows require_login to be set via the CMS
* required_permission: Permission (or array of permissions) required to comment
* include_js: Enhance operation by ajax behaviour on moderation links (required for use_preview)
* use_gravatar: Set to true to show gravatar icons
* gravatar_default: Theme for 'not found' gravatar {@see http://gravatar.com/site/implement/images}
* gravatar_rating: Gravatar rating (same as the standard default)
* show_comments_when_disabled: Show older comments when commenting has been disabled.
* comments_holder_id: ID for the comments holder
* comment_permalink_prefix: ID prefix for each comment
* require_moderation: Require moderation for all comments
* require_moderation_cms: Ignore other comment moderation config settings and set via CMS
* frontend_moderation: Display unmoderated comments in the frontend, if the user can moderate them.
* frontend_spam: Display spam comments in the frontend, if the user can moderate them.
2015-04-13 05:41:18 +02:00
* html_allowed: Allow for sanitized HTML in comments
* use_preview: Preview formatted comment (when allowing HTML)
*
* @var array
*
* @config
*/
private static $comments = array(
2015-04-13 05:41:18 +02:00
'enabled' => true,
'enabled_cms' => false,
'require_login' => false,
'require_login_cms' => false,
'required_permission' => false,
2015-04-13 05:41:18 +02:00
'include_js' => true,
'use_gravatar' => false,
'gravatar_size' => 80,
'gravatar_default' => 'identicon',
2015-04-13 05:41:18 +02:00
'gravatar_rating' => 'g',
'show_comments_when_disabled' => false,
2015-04-13 05:41:18 +02:00
'order_comments_by' => '"Created" DESC',
'comments_per_page' => 10,
2015-04-13 05:41:18 +02:00
'comments_holder_id' => 'comments-holder',
'comment_permalink_prefix' => 'comment-',
'require_moderation' => false,
'require_moderation_nonmembers' => false,
'require_moderation_cms' => false,
'frontend_moderation' => false,
'frontend_spam' => false,
2015-04-13 05:41:18 +02:00
'html_allowed' => false,
'html_allowed_elements' => array('a', 'img', 'i', 'b'),
2015-04-13 05:41:18 +02:00
'use_preview' => false,
);
2015-04-13 05:41:18 +02:00
/**
* @var array
*/
private static $db = array(
'ProvideComments' => 'Boolean',
2015-04-13 05:41:18 +02:00
'ModerationRequired' => 'Enum(\'None,Required,NonMembersOnly\',\'None\')',
'CommentsRequireLogin' => 'Boolean',
);
/**
* CMS configurable options should default to the config values
*/
public function populateDefaults() {
// Set if comments should be enabled by default
$this->owner->ProvideComments = $this->owner->getCommentsOption('enabled') ? 1 : 0;
2015-04-13 05:41:18 +02:00
// If moderation options should be configurable via the CMS then
if($this->owner->getCommentsOption('require_moderation')) {
$this->owner->ModerationRequired = 'Required';
} elseif($this->owner->getCommentsOption('require_moderation_nonmembers')) {
$this->owner->ModerationRequired = 'NonMembersOnly';
} else {
$this->owner->ModerationRequired = 'None';
}
$this->owner->CommentsRequireLogin = $this->owner->getCommentsOption('require_login') ? 1 : 0;
}
2015-04-13 05:41:18 +02:00
/**
* If this extension is applied to a {@link SiteTree} record then
* append a Provide Comments checkbox to allow authors to trigger
* whether or not to display comments
*
* @todo Allow customization of other {@link Commenting} configuration
*
2015-04-13 05:41:18 +02:00
* @param FieldList $fields
*/
public function updateSettingsFields(FieldList $fields) {
$options = FieldGroup::create()->setTitle(_t('CommentsExtension.COMMENTOPTIONS', 'Comments'));
2015-04-13 05:41:18 +02:00
// Check if enabled setting should be cms configurable
if($this->owner->getCommentsOption('enabled_cms')) {
$options->push(new CheckboxField('ProvideComments', _t('Comment.ALLOWCOMMENTS', 'Allow Comments')));
}
// Check if we should require users to login to comment
if($this->owner->getCommentsOption('require_login_cms')) {
$options->push(
new CheckboxField(
'CommentsRequireLogin',
_t('Comments.COMMENTSREQUIRELOGIN', 'Require login to comment')
)
);
}
if($options->FieldList()->count()) {
if($fields->hasTabSet()) {
$fields->addFieldsToTab('Root.Settings', $options);
} else {
$fields->push($options);
}
}
// Check if moderation should be enabled via cms configurable
if($this->owner->getCommentsOption('require_moderation_cms')) {
$moderationField = new DropdownField('ModerationRequired', 'Comment Moderation', array(
'None' => _t('CommentsExtension.MODERATIONREQUIRED_NONE', 'No moderation required'),
'Required' => _t('CommentsExtension.MODERATIONREQUIRED_REQUIRED', 'Moderate all comments'),
'NonMembersOnly' => _t(
'CommentsExtension.MODERATIONREQUIRED_NONMEMBERSONLY',
'Only moderate non-members'
),
));
if($fields->hasTabSet()) {
$fields->addFieldsToTab('Root.Settings', $moderationField);
} else {
$fields->push($moderationField);
}
}
}
/**
* Returns the RelationList of all comments against this object. Can be used as a data source
* for a gridfield with write access.
*
* @return CommentList
*/
public function AllComments() {
$comments = CommentList::create($this->ownerBaseClass)->forForeignID($this->owner->ID);
$this->owner->extend('updateAllComments', $comments);
return $comments;
}
public function getComments() {
2015-04-13 05:41:18 +02:00
// TODO: find out why this is being triggered when combined with blog
// Deprecation::notice('2.0', 'Use PagedComments to get paged comments');
return $this->PagedComments();
}
/**
* Get comment moderation rules for this parent
*
2015-04-13 05:41:18 +02:00
* None: No moderation required
* Required: All comments
* NonMembersOnly: Only anonymous users
*
* @return string
*/
public function getModerationRequired() {
if($this->owner->getCommentsOption('require_moderation_cms')) {
return $this->owner->getField('ModerationRequired');
} elseif($this->owner->getCommentsOption('require_moderation')) {
return 'Required';
} elseif($this->owner->getCommentsOption('require_moderation_nonmembers')) {
return 'NonMembersOnly';
} else {
return 'None';
}
}
/**
* Determine if users must be logged in to post comments
*
* @return boolean
*/
public function getCommentsRequireLogin() {
if($this->owner->getCommentsOption('require_login_cms')) {
2015-04-13 05:41:18 +02:00
return (bool) $this->owner->getField('CommentsRequireLogin');
} else {
2015-04-13 05:41:18 +02:00
return (bool) $this->owner->getCommentsOption('require_login');
}
}
/**
* Returns the root level comments, with spam and unmoderated items excluded, for use in the frontend
*
* @return CommentList
*/
public function Comments() {
// Get all non-spam comments
$order = $this->owner->getCommentsOption('order_comments_by');
$list = $this
->AllComments()
->sort($order);
// Filter spam comments for non-administrators if configured
$showSpam = $this->owner->getCommentsOption('frontend_spam') && $this->owner->canModerateComments();
if(!$showSpam) {
$list = $list->filter('IsSpam', 0);
}
2015-04-13 05:41:18 +02:00
// Filter un-moderated comments for non-administrators if moderation is enabled
$showUnmoderated = ($this->owner->ModerationRequired === 'None')
|| ($this->owner->getCommentsOption('frontend_moderation') && $this->owner->canModerateComments());
if(!$showUnmoderated) {
2015-04-13 05:41:18 +02:00
$list = $list->filter('Moderated', 1);
}
$this->owner->extend('updateComments', $list);
return $list;
}
2012-07-22 03:44:30 +02:00
/**
* Returns a paged list of the root level comments, with spam and unmoderated items excluded,
* for use in the frontend
*
* @return PaginatedList
*/
public function PagedComments() {
$list = $this->Comments();
2015-04-13 05:41:18 +02:00
// Add pagination
$list = new PaginatedList($list, Controller::curr()->getRequest());
2015-04-13 05:41:18 +02:00
$list->setPaginationGetVar('commentsstart' . $this->owner->ID);
$list->setPageLength($this->owner->getCommentsOption('comments_per_page'));
2012-07-22 03:44:30 +02:00
$this->owner->extend('updatePagedComments', $list);
return $list;
}
/**
* Check if comments are configured for this page even if they are currently disabled.
* Do not include the comments on pages which don't have id's such as security pages
*
* @deprecated since version 2.0
*
* @return boolean
*/
public function getCommentsConfigured() {
Deprecation::notice('2.0', 'getCommentsConfigured is deprecated. Use getCommentsEnabled instead');
return true; // by virtue of all classes with this extension being 'configured'
}
2012-07-22 03:44:30 +02:00
/**
* Determine if comments are enabled for this instance
*
* @return boolean
*/
public function getCommentsEnabled() {
// Don't display comments form for pseudo-pages (such as the login form)
if(!$this->owner->exists()) return false;
// Determine which flag should be used to determine if this is enabled
if($this->owner->getCommentsOption('enabled_cms')) {
return $this->owner->ProvideComments;
} else {
return $this->owner->getCommentsOption('enabled');
}
}
/**
* Get the HTML ID for the comment holder in the template
*
* @return string
*/
public function getCommentHolderID() {
return $this->owner->getCommentsOption('comments_holder_id');
}
/**
* @deprecated since version 2.0
*/
public function getPostingRequiresPermission() {
Deprecation::notice('2.0', 'Use getPostingRequiredPermission instead');
return $this->getPostingRequiredPermission();
}
/**
* Permission codes required in order to post (or empty if none required)
*
* @return string|array Permission or list of permissions, if required
*/
public function getPostingRequiredPermission() {
return $this->owner->getCommentsOption('required_permission');
}
public function canPost() {
Deprecation::notice('2.0', 'Use canPostComment instead');
return $this->canPostComment();
}
/**
* Determine if a user can post comments on this item
*
* @param Member $member Member to check
2015-04-13 05:41:18 +02:00
*
* @return boolean
*/
public function canPostComment($member = null) {
// Deny if not enabled for this object
if(!$this->owner->CommentsEnabled) return false;
// Check if member is required
$requireLogin = $this->owner->CommentsRequireLogin;
if(!$requireLogin) return true;
// Check member is logged in
$member = $member ?: Member::currentUser();
if(!$member) return false;
// If member required check permissions
$requiredPermission = $this->owner->PostingRequiredPermission;
if($requiredPermission && !Permission::checkMember($member, $requiredPermission)) return false;
return true;
}
/**
* Determine if this member can moderate comments in the CMS
*
* @param Member $member
2015-04-13 05:41:18 +02:00
*
* @return boolean
*/
public function canModerateComments($member = null) {
return $this->owner->canEdit($member);
}
public function getRssLink() {
Deprecation::notice('2.0', 'Use getCommentRSSLink instead');
return $this->getCommentRSSLink();
}
/**
* Gets the RSS link to all comments
*
* @return string
*/
public function getCommentRSSLink() {
2015-04-13 05:41:18 +02:00
return Controller::join_links(Director::baseURL(), 'CommentingController/rss');
}
public function getRssLinkPage() {
Deprecation::notice('2.0', 'Use getCommentRSSLinkPage instead');
return $this->getCommentRSSLinkPage();
}
/**
* Get the RSS link to all comments on this page
*
* @return string
*/
public function getCommentRSSLinkPage() {
return Controller::join_links(
$this->getCommentRSSLink(), $this->ownerBaseClass, $this->owner->ID
);
}
2015-04-13 05:41:18 +02:00
/**
* Comments interface for the front end. Includes the CommentAddForm and the composition
2015-04-13 05:41:18 +02:00
* of the comments display.
*
* To customize the html see templates/CommentInterface.ss or extend this function with
* your own extension.
*
2012-07-22 03:44:30 +02:00
* @todo Cleanup the passing of all this configuration based functionality
*
2015-04-13 05:41:18 +02:00
* @see docs/en/Extending
*/
public function CommentsForm() {
// Check if enabled
$enabled = $this->getCommentsEnabled();
if($enabled && $this->owner->getCommentsOption('include_js')) {
Requirements::javascript(THIRDPARTY_DIR . '/jquery/jquery.js');
Requirements::javascript(THIRDPARTY_DIR . '/jquery-validate/lib/jquery.form.js');
Requirements::javascript(THIRDPARTY_DIR . '/jquery-validate/jquery.validate.pack.js');
Requirements::javascript('comments/javascript/CommentsInterface.js');
}
2015-04-13 05:41:18 +02:00
$controller = CommentingController::create();
$controller->setOwnerRecord($this->owner);
$controller->setBaseClass($this->ownerBaseClass);
$controller->setOwnerController(Controller::curr());
$moderatedSubmitted = Session::get('CommentsModerated');
Session::clear('CommentsModerated');
$form = ($enabled) ? $controller->CommentsForm() : false;
// a little bit all over the show but to ensure a slightly easier upgrade for users
// return back the same variables as previously done in comments
return $this
->owner
->customise(array(
'AddCommentForm' => $form,
'ModeratedSubmitted' => $moderatedSubmitted,
))
->renderWith('CommentsInterface');
}
2015-04-13 05:41:18 +02:00
/**
* Returns whether this extension instance is attached to a {@link SiteTree} object
*
* @return bool
*/
public function attachedToSiteTree() {
$class = $this->ownerBaseClass;
2015-04-13 05:41:18 +02:00
return (is_subclass_of($class, 'SiteTree')) || ($class == 'SiteTree');
}
/**
* @deprecated 1.0 Please use {@link CommentsExtension->CommentsForm()}
*/
public function PageComments() {
// This method is very commonly used, don't throw a warning just yet
Deprecation::notice('1.0', '$PageComments is deprecated. Please use $CommentsForm');
return $this->CommentsForm();
}
/**
* Get the commenting option for this object
*
* This can be overridden in any instance or extension to customise the option available
*
* @param string $key
2015-04-13 05:41:18 +02:00
*
* @return mixed Result if the setting is available, or null otherwise
*/
public function getCommentsOption($key) {
$settings = $this->owner // In case singleton is called on the extension directly
? $this->owner->config()->comments
: Config::inst()->get(__CLASS__, 'comments');
$value = null;
if(isset($settings[$key])) $value = $settings[$key];
// To allow other extensions to customise this option
if($this->owner) $this->owner->extend('updateCommentsOption', $key, $value);
return $value;
}
/**
* Add moderation functions to the current fieldlist
*
* @param FieldList $fields
*/
protected function updateModerationFields(FieldList $fields) {
$commentsConfig = CommentsGridFieldConfig::create();
2015-04-13 05:41:18 +02:00
$newComments = $this->owner->AllComments()->filter('Moderated', 0);
$newGrid = new GridField(
'NewComments',
2015-04-16 04:40:16 +02:00
_t('CommentsAdmin.NewComments', 'New'),
2015-04-13 05:41:18 +02:00
$newComments,
$commentsConfig
);
$approvedComments = $this->owner->AllComments()->filter('Moderated', 1)->filter('IsSpam', 0);
$approvedGrid = new GridField(
'ApprovedComments',
2015-04-16 04:40:16 +02:00
_t('CommentsAdmin.Comments', 'Approved'),
2015-04-13 05:41:18 +02:00
$approvedComments,
$commentsConfig
);
2015-04-13 05:41:18 +02:00
$spamComments = $this->owner->AllComments()->filter('Moderated', 1)->filter('IsSpam', 1);
$spamGrid = new GridField(
'SpamComments',
_t('CommentsAdmin.SpamComments', 'Spam'),
$spamComments,
$commentsConfig
);
2015-04-13 05:41:18 +02:00
$newCount = '(' . count($newComments) . ')';
$approvedCount = '(' . count($approvedComments) . ')';
$spamCount = '(' . count($spamComments) . ')';
if($fields->hasTabSet()) {
2015-04-13 05:41:18 +02:00
$tabs = new TabSet(
'Comments',
2015-04-16 04:40:16 +02:00
new Tab('CommentsNewCommentsTab', _t('CommentAdmin.NewComments', 'New') . ' ' . $newCount,
2015-04-13 05:41:18 +02:00
$newGrid
),
2015-04-16 04:40:16 +02:00
new Tab('CommentsCommentsTab', _t('CommentAdmin.Comments', 'Approved') . ' ' . $approvedCount,
2015-04-13 05:41:18 +02:00
$approvedGrid
),
2015-04-13 05:41:18 +02:00
new Tab('CommentsSpamCommentsTab', _t('CommentAdmin.SpamComments', 'Spam') . ' ' . $spamCount,
$spamGrid
)
);
2015-04-13 05:41:18 +02:00
$fields->addFieldToTab('Root', $tabs);
} else {
2015-04-13 05:41:18 +02:00
$fields->push($newGrid);
$fields->push($approvedGrid);
$fields->push($spamGrid);
}
}
2015-04-13 05:41:18 +02:00
public function updateCMSFields(FieldList $fields) {
// Disable moderation if not permitted
if($this->owner->canModerateComments()) {
$this->updateModerationFields($fields);
}
// If this isn't a page we should merge the settings into the CMS fields
if(!$this->attachedToSiteTree()) {
$this->updateSettingsFields($fields);
}
}
}