Issues in CommentsExtension.php - Fixed Issues - Inspection of "Merge pull request #167 from gordonbanderson/issue..." - silverstripe/silverstripe-comments - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b1bf62...c2fee6 )

by Damian

created 2016-02-15 20:43 UTC

code/extensions/CommentsExtension.php (2 issues)

Labels

Duplication 2

Severity

Informational 2

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

/**
 * Extension to {@link DataObject} to enable tracking comments.
 *
 * @package comments
 */
class CommentsExtension extends DataExtension {
	/**
	 * Default configuration values
	 *
	 * 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.
	 * order_comments_by:           Default sort order.
	 * order_replies_by:            Sort order for replies.
	 * 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.
	 * html_allowed:                Allow for sanitized HTML in comments
	 * use_preview:                 Preview formatted comment (when allowing HTML)
	 * nested_comments:             Enable nested comments
	 * nested_depth:                Max depth of nested comments in levels (where root is 1 depth) 0 means no limit.
	 *
	 * @var array
	 *
	 * @config
	 */
	private static $comments = array(
		'enabled' => true,
		'enabled_cms' => false,
		'require_login' => false,
		'require_login_cms' => false,
		'required_permission' => false,
		'include_js' => true,
		'use_gravatar' => false,
		'gravatar_size' => 80,
		'gravatar_default' => 'identicon',
		'gravatar_rating' => 'g',
		'show_comments_when_disabled' => false,
		'order_comments_by' => '"Created" DESC',
		'order_replies_by' => false,
		'comments_per_page' => 10,
		'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,
		'html_allowed' => false,
		'html_allowed_elements' => array('a', 'img', 'i', 'b'),
		'use_preview' => false,
		'nested_comments' => false,
		'nested_depth' => 2,
	);

	/**
	 * @var array
	 */
	private static $db = array(
		'ProvideComments' => 'Boolean',
		'ModerationRequired' => 'Enum(\'None,Required,NonMembersOnly\',\'None\')',
		'CommentsRequireLogin' => 'Boolean',
	);

	/**
	 * CMS configurable options should default to the config values, but respect
	 * default values specified by the object
	 */
	public function populateDefaults() {
		$defaults = $this->owner->config()->defaults;
		
		// Set if comments should be enabled by default
		if(isset($defaults['ProvideComments'])) {

			$this->owner->ProvideComments = $defaults['ProvideComments'];
		} else {
			$this->owner->ProvideComments = $this->owner->getCommentsOption('enabled') ? 1 : 0;
		}

		// If moderation options should be configurable via the CMS then
		if(isset($defaults['ModerationRequired'])) {
			$this->owner->ModerationRequired = $defaults['ModerationRequired'];
		} elseif($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';
		}

		// Set login required
		if(isset($defaults['CommentsRequireLogin'])) {

			$this->owner->CommentsRequireLogin = $defaults['CommentsRequireLogin'];
		} else {
			$this->owner->CommentsRequireLogin = $this->owner->getCommentsOption('require_login') ? 1 : 0;
		}
	}


	/**
	 * 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
	 *
	 * @param FieldList $fields
	 */
	public function updateSettingsFields(FieldList $fields) {

		$options = FieldGroup::create()->setTitle(_t('CommentsExtension.COMMENTOPTIONS', 'Comments'));

		// 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);
			}
		}
	}

	/**
	 * Get comment moderation rules for this parent
	 *
	 * 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')) {
			return (bool) $this->owner->getField('CommentsRequireLogin');
		} else {
			return (bool) $this->owner->getCommentsOption('require_login');
		}
	}

	/**
	 * 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() {
		$order = $this->owner->getCommentsOption('order_comments_by');
		$comments = CommentList::create($this->ownerBaseClass)
			->forForeignID($this->owner->ID)
			->sort($order);
		$this->owner->extend('updateAllComments', $comments);
		return $comments;
	}

	/**
	 * Returns all comments against this object, with with spam and unmoderated items excluded, for use in the frontend
	 *
	 * @return CommentList
	 */
	public function AllVisibleComments() {
		$list = $this->AllComments();

		// Filter spam comments for non-administrators if configured
		$showSpam = $this->owner->getCommentsOption('frontend_spam') && $this->owner->canModerateComments();
		if(!$showSpam) {
			$list = $list->filter('IsSpam', 0);
		}

		// 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) {
			$list = $list->filter('Moderated', 1);
		}

		$this->owner->extend('updateAllVisibleComments', $list);
		return $list;
	}

	/**
	 * Returns the root level comments, with spam and unmoderated items excluded, for use in the frontend
	 *
	 * @return CommentList
	 */
	public function Comments() {
		$list = $this->AllVisibleComments();

		// If nesting comments, only show root level
		if($this->owner->getCommentsOption('nested_comments')) {
			$list = $list->filter('ParentCommentID', 0);
		}

		$this->owner->extend('updateComments', $list);
		return $list;
	}

	/**
	 * 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();

		// Add pagination
		$list = new PaginatedList($list, Controller::curr()->getRequest());
		$list->setPaginationGetVar('commentsstart' . $this->owner->ID);
		$list->setPageLength($this->owner->getCommentsOption('comments_per_page'));

		$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'
	}

	/**
	 * 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
	 *
	 * @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
	 *
	 * @return boolean
	 */
	public function canModerateComments($member = null) {
		// Deny if not enabled for this object
		if(!$this->owner->CommentsEnabled) return false;

		// Fallback to can-edit
		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() {
		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
		);
	}

	/**
	 * Comments interface for the front end. Includes the CommentAddForm and the composition
	 * of the comments display.
	 *
	 * To customize the html see templates/CommentInterface.ss or extend this function with
	 * your own extension.
	 *
	 * @todo Cleanup the passing of all this configuration based functionality
	 *
	 * @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-entwine/dist/jquery.entwine-dist.js');
			Requirements::javascript(THIRDPARTY_DIR . '/jquery-validate/lib/jquery.form.js');
			Requirements::javascript(COMMENTS_THIRDPARTY . '/jquery-validate/jquery.validate.min.js');
			Requirements::javascript('comments/javascript/CommentsInterface.js');
		}

		$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');
	}

	/**
	 * Returns whether this extension instance is attached to a {@link SiteTree} object
	 *
	 * @return bool
	 */
	public function attachedToSiteTree() {
		$class = $this->ownerBaseClass;

		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
	 *
	 * @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) {
		Requirements::css(COMMENTS_DIR . '/css/cms.css');

		$newComments = $this->owner->AllComments()->filter('Moderated', 0);

		$newGrid = new CommentsGridField(
			'NewComments',
			_t('CommentsAdmin.NewComments', 'New'),
			$newComments,
			CommentsGridFieldConfig::create()
		);

		$approvedComments = $this->owner->AllComments()->filter('Moderated', 1)->filter('IsSpam', 0);

		$approvedGrid = new CommentsGridField(
			'ApprovedComments',
			_t('CommentsAdmin.Comments', 'Approved'),
			$approvedComments,
			CommentsGridFieldConfig::create()
		);

		$spamComments = $this->owner->AllComments()->filter('Moderated', 1)->filter('IsSpam', 1);

		$spamGrid = new CommentsGridField(
			'SpamComments',
			_t('CommentsAdmin.SpamComments', 'Spam'),
			$spamComments,
			CommentsGridFieldConfig::create()
		);

		$newCount = '(' . count($newComments) . ')';
		$approvedCount = '(' . count($approvedComments) . ')';
		$spamCount = '(' . count($spamComments) . ')';

		if($fields->hasTabSet()) {
			$tabs = new TabSet(
				'Comments',
				new Tab('CommentsNewCommentsTab', _t('CommentAdmin.NewComments', 'New') . ' ' . $newCount,
					$newGrid
				),
				new Tab('CommentsCommentsTab', _t('CommentAdmin.Comments', 'Approved') . ' ' . $approvedCount,
					$approvedGrid
				),
				new Tab('CommentsSpamCommentsTab', _t('CommentAdmin.SpamComments', 'Spam') . ' ' . $spamCount,
					$spamGrid
				)
			);
			$fields->addFieldToTab('Root', $tabs);
		} else {
			$fields->push($newGrid);
			$fields->push($approvedGrid);
			$fields->push($spamGrid);
		}
	}

	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);
		}
	}
}


1		<?php
2
3		/**
4		* Extension to {@link DataObject} to enable tracking comments.
5		*
6		* @package comments
7		*/
8		class CommentsExtension extends DataExtension {
9		/**
10		* Default configuration values
11		*
12		* enabled: Allows commenting to be disabled even if the extension is present
13		* enabled_cms: Allows commenting to be enabled or disabled via the CMS
14		* require_login: Boolean, whether a user needs to login (required for required_permission)
15		* require_login_cms: Allows require_login to be set via the CMS
16		* required_permission: Permission (or array of permissions) required to comment
17		* include_js: Enhance operation by ajax behaviour on moderation links (required for use_preview)
18		* use_gravatar: Set to true to show gravatar icons
19		* gravatar_default: Theme for 'not found' gravatar {@see http://gravatar.com/site/implement/images}
20		* gravatar_rating: Gravatar rating (same as the standard default)
21		* show_comments_when_disabled: Show older comments when commenting has been disabled.
22		* order_comments_by: Default sort order.
23		* order_replies_by: Sort order for replies.
24		* comments_holder_id: ID for the comments holder
25		* comment_permalink_prefix: ID prefix for each comment
26		* require_moderation: Require moderation for all comments
27		* require_moderation_cms: Ignore other comment moderation config settings and set via CMS
28		* frontend_moderation: Display unmoderated comments in the frontend, if the user can moderate them.
29		* frontend_spam: Display spam comments in the frontend, if the user can moderate them.
30		* html_allowed: Allow for sanitized HTML in comments
31		* use_preview: Preview formatted comment (when allowing HTML)
32		* nested_comments: Enable nested comments
33		* nested_depth: Max depth of nested comments in levels (where root is 1 depth) 0 means no limit.
34		*
35		* @var array
36		*
37		* @config
38		*/
39		private static $comments = array(
40		'enabled' => true,
41		'enabled_cms' => false,
42		'require_login' => false,
43		'require_login_cms' => false,
44		'required_permission' => false,
45		'include_js' => true,
46		'use_gravatar' => false,
47		'gravatar_size' => 80,
48		'gravatar_default' => 'identicon',
49		'gravatar_rating' => 'g',
50		'show_comments_when_disabled' => false,
51		'order_comments_by' => '"Created" DESC',
52		'order_replies_by' => false,
53		'comments_per_page' => 10,
54		'comments_holder_id' => 'comments-holder',
55		'comment_permalink_prefix' => 'comment-',
56		'require_moderation' => false,
57		'require_moderation_nonmembers' => false,
58		'require_moderation_cms' => false,
59		'frontend_moderation' => false,
60		'frontend_spam' => false,
61		'html_allowed' => false,
62		'html_allowed_elements' => array('a', 'img', 'i', 'b'),
63		'use_preview' => false,
64		'nested_comments' => false,
65		'nested_depth' => 2,
66		);
67
68		/**
69		* @var array
70		*/
71		private static $db = array(
72		'ProvideComments' => 'Boolean',
73		'ModerationRequired' => 'Enum(\'None,Required,NonMembersOnly\',\'None\')',
74		'CommentsRequireLogin' => 'Boolean',
75		);
76
77		/**
78		* CMS configurable options should default to the config values, but respect
79		* default values specified by the object
80		*/
81		public function populateDefaults() {
82		$defaults = $this->owner->config()->defaults;
83
84		// Set if comments should be enabled by default
85	View Code Duplication	if(isset($defaults['ProvideComments'])) {
		0 ignored issues – show Duplication introduced 2015-11-20 23:54 UTC by Report Bug Copy Issue Report Show Similar Issues like this This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
86		$this->owner->ProvideComments = $defaults['ProvideComments'];
87		} else {
88		$this->owner->ProvideComments = $this->owner->getCommentsOption('enabled') ? 1 : 0;
89		}
90
91		// If moderation options should be configurable via the CMS then
92		if(isset($defaults['ModerationRequired'])) {
93		$this->owner->ModerationRequired = $defaults['ModerationRequired'];
94		} elseif($this->owner->getCommentsOption('require_moderation')) {
95		$this->owner->ModerationRequired = 'Required';
96		} elseif($this->owner->getCommentsOption('require_moderation_nonmembers')) {
97		$this->owner->ModerationRequired = 'NonMembersOnly';
98		} else {
99		$this->owner->ModerationRequired = 'None';
100		}
101
102		// Set login required
103	View Code Duplication	if(isset($defaults['CommentsRequireLogin'])) {
		0 ignored issues – show Duplication introduced 2015-11-20 23:54 UTC by Report Bug Copy Issue Report Show Similar Issues like this This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
104		$this->owner->CommentsRequireLogin = $defaults['CommentsRequireLogin'];
105		} else {
106		$this->owner->CommentsRequireLogin = $this->owner->getCommentsOption('require_login') ? 1 : 0;
107		}
108		}
109
110
111		/**
112		* If this extension is applied to a {@link SiteTree} record then
113		* append a Provide Comments checkbox to allow authors to trigger
114		* whether or not to display comments
115		*
116		* @todo Allow customization of other {@link Commenting} configuration
117		*
118		* @param FieldList $fields
119		*/
120		public function updateSettingsFields(FieldList $fields) {
121
122		$options = FieldGroup::create()->setTitle(_t('CommentsExtension.COMMENTOPTIONS', 'Comments'));
123
124		// Check if enabled setting should be cms configurable
125		if($this->owner->getCommentsOption('enabled_cms')) {
126		$options->push(new CheckboxField('ProvideComments', _t('Comment.ALLOWCOMMENTS', 'Allow Comments')));
127		}
128
129		// Check if we should require users to login to comment
130		if($this->owner->getCommentsOption('require_login_cms')) {
131		$options->push(
132		new CheckboxField(
133		'CommentsRequireLogin',
134		_t('Comments.COMMENTSREQUIRELOGIN', 'Require login to comment')
135		)
136		);
137		}
138
139		if($options->FieldList()->count()) {
140		if($fields->hasTabSet()) {
141		$fields->addFieldsToTab('Root.Settings', $options);
142		} else {
143		$fields->push($options);
144		}
145		}
146
147		// Check if moderation should be enabled via cms configurable
148		if($this->owner->getCommentsOption('require_moderation_cms')) {
149		$moderationField = new DropdownField('ModerationRequired', 'Comment Moderation', array(
150		'None' => _t('CommentsExtension.MODERATIONREQUIRED_NONE', 'No moderation required'),
151		'Required' => _t('CommentsExtension.MODERATIONREQUIRED_REQUIRED', 'Moderate all comments'),
152		'NonMembersOnly' => _t(
153		'CommentsExtension.MODERATIONREQUIRED_NONMEMBERSONLY',
154		'Only moderate non-members'
155		),
156		));
157		if($fields->hasTabSet()) {
158		$fields->addFieldsToTab('Root.Settings', $moderationField);
159		} else {
160		$fields->push($moderationField);
161		}
162		}
163		}
164
165		/**
166		* Get comment moderation rules for this parent
167		*
168		* None: No moderation required
169		* Required: All comments
170		* NonMembersOnly: Only anonymous users
171		*
172		* @return string
173		*/
174		public function getModerationRequired() {
175		if($this->owner->getCommentsOption('require_moderation_cms')) {
176		return $this->owner->getField('ModerationRequired');
177		} elseif($this->owner->getCommentsOption('require_moderation')) {
178		return 'Required';
179		} elseif($this->owner->getCommentsOption('require_moderation_nonmembers')) {
180		return 'NonMembersOnly';
181		} else {
182		return 'None';
183		}
184		}
185
186		/**
187		* Determine if users must be logged in to post comments
188		*
189		* @return boolean
190		*/
191		public function getCommentsRequireLogin() {
192		if($this->owner->getCommentsOption('require_login_cms')) {
193		return (bool) $this->owner->getField('CommentsRequireLogin');
194		} else {
195		return (bool) $this->owner->getCommentsOption('require_login');
196		}
197		}
198
199		/**
200		* Returns the RelationList of all comments against this object. Can be used as a data source
201		* for a gridfield with write access.
202		*
203		* @return CommentList
204		*/
205		public function AllComments() {
206		$order = $this->owner->getCommentsOption('order_comments_by');
207		$comments = CommentList::create($this->ownerBaseClass)
208		->forForeignID($this->owner->ID)
209		->sort($order);
210		$this->owner->extend('updateAllComments', $comments);
211		return $comments;
212		}
213
214		/**
215		* Returns all comments against this object, with with spam and unmoderated items excluded, for use in the frontend
216		*
217		* @return CommentList
218		*/
219		public function AllVisibleComments() {
220		$list = $this->AllComments();
221
222		// Filter spam comments for non-administrators if configured
223		$showSpam = $this->owner->getCommentsOption('frontend_spam') && $this->owner->canModerateComments();
224		if(!$showSpam) {
225		$list = $list->filter('IsSpam', 0);
226		}
227
228		// Filter un-moderated comments for non-administrators if moderation is enabled
229		$showUnmoderated = ($this->owner->ModerationRequired === 'None')
230		\|\| ($this->owner->getCommentsOption('frontend_moderation') && $this->owner->canModerateComments());
231		if(!$showUnmoderated) {
232		$list = $list->filter('Moderated', 1);
233		}
234
235		$this->owner->extend('updateAllVisibleComments', $list);
236		return $list;
237		}
238
239		/**
240		* Returns the root level comments, with spam and unmoderated items excluded, for use in the frontend
241		*
242		* @return CommentList
243		*/
244		public function Comments() {
245		$list = $this->AllVisibleComments();
246
247		// If nesting comments, only show root level
248		if($this->owner->getCommentsOption('nested_comments')) {
249		$list = $list->filter('ParentCommentID', 0);
250		}
251
252		$this->owner->extend('updateComments', $list);
253		return $list;
254		}
255
256		/**
257		* Returns a paged list of the root level comments, with spam and unmoderated items excluded,
258		* for use in the frontend
259		*
260		* @return PaginatedList
261		*/
262	View Code Duplication	public function PagedComments() {
263		$list = $this->Comments();
264
265		// Add pagination
266		$list = new PaginatedList($list, Controller::curr()->getRequest());
267		$list->setPaginationGetVar('commentsstart' . $this->owner->ID);
268		$list->setPageLength($this->owner->getCommentsOption('comments_per_page'));
269
270		$this->owner->extend('updatePagedComments', $list);
271		return $list;
272		}
273
274		/**
275		* Check if comments are configured for this page even if they are currently disabled.
276		* Do not include the comments on pages which don't have id's such as security pages
277		*
278		* @deprecated since version 2.0
279		*
280		* @return boolean
281		*/
282		public function getCommentsConfigured() {
283		Deprecation::notice('2.0', 'getCommentsConfigured is deprecated. Use getCommentsEnabled instead');
284		return true; // by virtue of all classes with this extension being 'configured'
285		}
286
287		/**
288		* Determine if comments are enabled for this instance
289		*
290		* @return boolean
291		*/
292		public function getCommentsEnabled() {
293		// Don't display comments form for pseudo-pages (such as the login form)
294		if(!$this->owner->exists()) return false;
295
296		// Determine which flag should be used to determine if this is enabled
297		if($this->owner->getCommentsOption('enabled_cms')) {
298		return $this->owner->ProvideComments;
299		} else {
300		return $this->owner->getCommentsOption('enabled');
301		}
302		}
303
304		/**
305		* Get the HTML ID for the comment holder in the template
306		*
307		* @return string
308		*/
309		public function getCommentHolderID() {
310		return $this->owner->getCommentsOption('comments_holder_id');
311		}
312
313		/**
314		* @deprecated since version 2.0
315		*/
316		public function getPostingRequiresPermission() {
317		Deprecation::notice('2.0', 'Use getPostingRequiredPermission instead');
318		return $this->getPostingRequiredPermission();
319		}
320
321		/**
322		* Permission codes required in order to post (or empty if none required)
323		*
324		* @return string\|array Permission or list of permissions, if required
325		*/
326		public function getPostingRequiredPermission() {
327		return $this->owner->getCommentsOption('required_permission');
328		}
329
330		public function canPost() {
331		Deprecation::notice('2.0', 'Use canPostComment instead');
332		return $this->canPostComment();
333		}
334
335		/**
336		* Determine if a user can post comments on this item
337		*
338		* @param Member $member Member to check
339		*
340		* @return boolean
341		*/
342		public function canPostComment($member = null) {
343		// Deny if not enabled for this object
344		if(!$this->owner->CommentsEnabled) return false;
345
346		// Check if member is required
347		$requireLogin = $this->owner->CommentsRequireLogin;
348		if(!$requireLogin) return true;
349
350		// Check member is logged in
351		$member = $member ?: Member::currentUser();
352		if(!$member) return false;
353
354		// If member required check permissions
355		$requiredPermission = $this->owner->PostingRequiredPermission;
356		if($requiredPermission && !Permission::checkMember($member, $requiredPermission)) return false;
357
358		return true;
359		}
360
361		/**
362		* Determine if this member can moderate comments in the CMS
363		*
364		* @param Member $member
365		*
366		* @return boolean
367		*/
368		public function canModerateComments($member = null) {
369		// Deny if not enabled for this object
370		if(!$this->owner->CommentsEnabled) return false;
371
372		// Fallback to can-edit
373		return $this->owner->canEdit($member);
374		}
375
376		public function getRssLink() {
377		Deprecation::notice('2.0', 'Use getCommentRSSLink instead');
378		return $this->getCommentRSSLink();
379		}
380
381		/**
382		* Gets the RSS link to all comments
383		*
384		* @return string
385		*/
386		public function getCommentRSSLink() {
387		return Controller::join_links(Director::baseURL(), 'CommentingController/rss');
388		}
389
390		public function getRssLinkPage() {
391		Deprecation::notice('2.0', 'Use getCommentRSSLinkPage instead');
392		return $this->getCommentRSSLinkPage();
393		}
394
395		/**
396		* Get the RSS link to all comments on this page
397		*
398		* @return string
399		*/
400		public function getCommentRSSLinkPage() {
401		return Controller::join_links(
402		$this->getCommentRSSLink(), $this->ownerBaseClass, $this->owner->ID
403		);
404		}
405
406		/**
407		* Comments interface for the front end. Includes the CommentAddForm and the composition
408		* of the comments display.
409		*
410		* To customize the html see templates/CommentInterface.ss or extend this function with
411		* your own extension.
412		*
413		* @todo Cleanup the passing of all this configuration based functionality
414		*
415		* @see docs/en/Extending
416		*/
417		public function CommentsForm() {
418		// Check if enabled
419		$enabled = $this->getCommentsEnabled();
420		if($enabled && $this->owner->getCommentsOption('include_js')) {
421		Requirements::javascript(THIRDPARTY_DIR . '/jquery/jquery.js');
422		Requirements::javascript(THIRDPARTY_DIR . '/jquery-entwine/dist/jquery.entwine-dist.js');
423		Requirements::javascript(THIRDPARTY_DIR . '/jquery-validate/lib/jquery.form.js');
424		Requirements::javascript(COMMENTS_THIRDPARTY . '/jquery-validate/jquery.validate.min.js');
425		Requirements::javascript('comments/javascript/CommentsInterface.js');
426		}
427
428		$controller = CommentingController::create();
429		$controller->setOwnerRecord($this->owner);
430		$controller->setBaseClass($this->ownerBaseClass);
431		$controller->setOwnerController(Controller::curr());
432
433		$moderatedSubmitted = Session::get('CommentsModerated');
434		Session::clear('CommentsModerated');
435
436		$form = ($enabled) ? $controller->CommentsForm() : false;
437
438		// a little bit all over the show but to ensure a slightly easier upgrade for users
439		// return back the same variables as previously done in comments
440		return $this
441		->owner
442		->customise(array(
443		'AddCommentForm' => $form,
444		'ModeratedSubmitted' => $moderatedSubmitted,
445		))
446		->renderWith('CommentsInterface');
447		}
448
449		/**
450		* Returns whether this extension instance is attached to a {@link SiteTree} object
451		*
452		* @return bool
453		*/
454		public function attachedToSiteTree() {
455		$class = $this->ownerBaseClass;
456
457		return (is_subclass_of($class, 'SiteTree')) \|\| ($class == 'SiteTree');
458		}
459
460		/**
461		* @deprecated 1.0 Please use {@link CommentsExtension->CommentsForm()}
462		*/
463		public function PageComments() {
464		// This method is very commonly used, don't throw a warning just yet
465		Deprecation::notice('1.0', '$PageComments is deprecated. Please use $CommentsForm');
466		return $this->CommentsForm();
467		}
468
469		/**
470		* Get the commenting option for this object
471		*
472		* This can be overridden in any instance or extension to customise the option available
473		*
474		* @param string $key
475		*
476		* @return mixed Result if the setting is available, or null otherwise
477		*/
478		public function getCommentsOption($key) {
479		$settings = $this->owner // In case singleton is called on the extension directly
480		? $this->owner->config()->comments
481		: Config::inst()->get(__CLASS__, 'comments');
482		$value = null;
483		if(isset($settings[$key])) $value = $settings[$key];
484
485		// To allow other extensions to customise this option
486		if($this->owner) $this->owner->extend('updateCommentsOption', $key, $value);
487		return $value;
488		}
489
490		/**
491		* Add moderation functions to the current fieldlist
492		*
493		* @param FieldList $fields
494		*/
495		protected function updateModerationFields(FieldList $fields) {
496		Requirements::css(COMMENTS_DIR . '/css/cms.css');
497
498		$newComments = $this->owner->AllComments()->filter('Moderated', 0);
499
500		$newGrid = new CommentsGridField(
501		'NewComments',
502		_t('CommentsAdmin.NewComments', 'New'),
503		$newComments,
504		CommentsGridFieldConfig::create()
505		);
506
507		$approvedComments = $this->owner->AllComments()->filter('Moderated', 1)->filter('IsSpam', 0);
508
509		$approvedGrid = new CommentsGridField(
510		'ApprovedComments',
511		_t('CommentsAdmin.Comments', 'Approved'),
512		$approvedComments,
513		CommentsGridFieldConfig::create()
514		);
515
516		$spamComments = $this->owner->AllComments()->filter('Moderated', 1)->filter('IsSpam', 1);
517
518		$spamGrid = new CommentsGridField(
519		'SpamComments',
520		_t('CommentsAdmin.SpamComments', 'Spam'),
521		$spamComments,
522		CommentsGridFieldConfig::create()
523		);
524
525		$newCount = '(' . count($newComments) . ')';
526		$approvedCount = '(' . count($approvedComments) . ')';
527		$spamCount = '(' . count($spamComments) . ')';
528
529		if($fields->hasTabSet()) {
530		$tabs = new TabSet(
531		'Comments',
532		new Tab('CommentsNewCommentsTab', _t('CommentAdmin.NewComments', 'New') . ' ' . $newCount,
533		$newGrid
534		),
535		new Tab('CommentsCommentsTab', _t('CommentAdmin.Comments', 'Approved') . ' ' . $approvedCount,
536		$approvedGrid
537		),
538		new Tab('CommentsSpamCommentsTab', _t('CommentAdmin.SpamComments', 'Spam') . ' ' . $spamCount,
539		$spamGrid
540		)
541		);
542		$fields->addFieldToTab('Root', $tabs);
543		} else {
544		$fields->push($newGrid);
545		$fields->push($approvedGrid);
546		$fields->push($spamGrid);
547		}
548		}
549
550		public function updateCMSFields(FieldList $fields) {
551		// Disable moderation if not permitted
552		if($this->owner->canModerateComments()) {
553		$this->updateModerationFields($fields);
554		}
555
556		// If this isn't a page we should merge the settings into the CMS fields
557		if(!$this->attachedToSiteTree()) {
558		$this->updateSettingsFields($fields);
559		}
560		}
561		}
562

silverstripe / silverstripe-comments

Push — master ( b1bf62...c2fee6 )

code/extensions/CommentsExtension.php (2 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like