comment/lib.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Functions and classes for commenting
  19  *
  20  * @package   core
  21  * @copyright 2010 Dongsheng Cai {@link http://dongsheng.org}
  22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24 defined('MOODLE_INTERNAL') || die();
  25
  26 /**
  27  * Comment is helper class to add/delete comments anywhere in moodle
  28  *
  29  * @package   core
  30  * @category  comment
  31  * @copyright 2010 Dongsheng Cai {@link http://dongsheng.org}
  32  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  33  */
  34 class comment {
  35     /** @var int there may be several comment box in one page so we need a client_id to recognize them */
  36     private $cid;
  37     /** @var string commentarea is used to specify different parts shared the same itemid */
  38     private $commentarea;
  39     /** @var int itemid is used to associate with commenting content */
  40     private $itemid;
  41     /** @var string this html snippet will be used as a template to build comment content */
  42     private $template;
  43     /** @var int The context id for comments */
  44     private $contextid;
  45     /** @var stdClass The context itself */
  46     private $context;
  47     /** @var int The course id for comments */
  48     private $courseid;
  49     /** @var stdClass course module object, only be used to help find pluginname automatically */
  50     private $cm;
  51     /** @var string The component that this comment is for. It is STRONGLY recommended to set this. */
  52     private $component;
  53     /** @var string This is calculated by normalising the component */
  54     private $pluginname;
  55     /** @var string This is calculated by normalising the component */
  56     private $plugintype;
  57     /** @var bool Whether the user has the required capabilities/permissions to view comments. */
  58     private $viewcap = false;
  59     /** @var bool Whether the user has the required capabilities/permissions to post comments. */
  60     private $postcap = false;
  61     /** @var string to customize link text */
  62     private $linktext;
  63     /** @var bool If set to true then comment sections won't be able to be opened and closed instead they will always be visible. */
  64     protected $notoggle = false;
  65     /** @var bool If set to true comments are automatically loaded as soon as the page loads. */
  66     protected $autostart = false;
  67     /** @var bool If set to true the total count of comments is displayed when displaying comments. */
  68     protected $displaytotalcount = false;
  69     /** @var bool If set to true a cancel button will be shown on the form used to submit comments. */
  70     protected $displaycancel = false;
  71     /** @var int The number of comments associated with this comments params */
  72     protected $totalcommentcount = null;
  73
  74     /** @var bool Use non-javascript UI */
  75     private static $nonjs = false;
  76     /** @var int comment itemid used in non-javascript UI */
  77     private static $comment_itemid = null;
  78     /** @var int comment context used in non-javascript UI */
  79     private static $comment_context = null;
  80     /** @var string comment area used in non-javascript UI */
  81     private static $comment_area = null;
  82     /** @var string comment page used in non-javascript UI */
  83     private static $comment_page = null;
  84     /** @var string comment itemid component in non-javascript UI */
  85     private static $comment_component = null;
  86
  87     /**
  88      * Construct function of comment class, initialise
  89      * class members
  90      *
  91      * @param stdClass $options {
  92      *            context => context context to use for the comment [required]
  93      *            component => string which plugin will comment being added to [required]
  94      *            itemid  => int the id of the associated item (forum post, glossary item etc) [required]
  95      *            area    => string comment area
  96      *            cm      => stdClass course module
  97      *            course  => course course object
  98      *            client_id => string an unique id to identify comment area
  99      *            autostart => boolean automatically expend comments
 100      *            showcount => boolean display the number of comments
 101      *            displaycancel => boolean display cancel button
 102      *            notoggle => boolean don't show/hide button
 103      *            linktext => string title of show/hide button
 104      * }
 105      */
 106     public function __construct(stdClass $options) {
 107         $this->viewcap = false;
 108         $this->postcap = false;
 109
 110         // setup client_id
 111         if (!empty($options->client_id)) {
 112             $this->cid = $options->client_id;
 113         } else {
 114             $this->cid = uniqid();
 115         }
 116
 117         // setup context
 118         if (!empty($options->context)) {
 119             $this->context = $options->context;
 120             $this->contextid = $this->context->id;
 121         } else if(!empty($options->contextid)) {
 122             $this->contextid = $options->contextid;
 123             $this->context = context::instance_by_id($this->contextid);
 124         } else {
 125             print_error('invalidcontext');
 126         }
 127
 128         if (!empty($options->component)) {
 129             // set and validate component
 130             $this->set_component($options->component);
 131         } else {
 132             // component cannot be empty
 133             throw new comment_exception('invalidcomponent');
 134         }
 135
 136         // setup course
 137         // course will be used to generate user profile link
 138         if (!empty($options->course)) {
 139             $this->courseid = $options->course->id;
 140         } else if (!empty($options->courseid)) {
 141             $this->courseid = $options->courseid;
 142         } else {
 143             $this->courseid = SITEID;
 144         }
 145
 146         // setup coursemodule
 147         if (!empty($options->cm)) {
 148             $this->cm = $options->cm;
 149         } else {
 150             $this->cm = null;
 151         }
 152
 153         // setup commentarea
 154         if (!empty($options->area)) {
 155             $this->commentarea = $options->area;
 156         }
 157
 158         // setup itemid
 159         if (!empty($options->itemid)) {
 160             $this->itemid = $options->itemid;
 161         } else {
 162             $this->itemid = 0;
 163         }
 164
 165         // setup customized linktext
 166         if (!empty($options->linktext)) {
 167             $this->linktext = $options->linktext;
 168         } else {
 169             $this->linktext = get_string('comments');
 170         }
 171
 172         // setup options for callback functions
 173         $this->comment_param = new stdClass();
 174         $this->comment_param->context     = $this->context;
 175         $this->comment_param->courseid    = $this->courseid;
 176         $this->comment_param->cm          = $this->cm;
 177         $this->comment_param->commentarea = $this->commentarea;
 178         $this->comment_param->itemid      = $this->itemid;
 179
 180         // setup notoggle
 181         if (!empty($options->notoggle)) {
 182             $this->set_notoggle($options->notoggle);
 183         }
 184
 185         // setup notoggle
 186         if (!empty($options->autostart)) {
 187             $this->set_autostart($options->autostart);
 188         }
 189
 190         // setup displaycancel
 191         if (!empty($options->displaycancel)) {
 192             $this->set_displaycancel($options->displaycancel);
 193         }
 194
 195         // setup displaytotalcount
 196         if (!empty($options->showcount)) {
 197             $this->set_displaytotalcount($options->showcount);
 198         }
 199
 200         // setting post and view permissions
 201         $this->check_permissions();
 202
 203         // load template
 204         $this->template = html_writer::start_tag('div', array('class' => 'comment-message'));
 205
 206         $this->template .= html_writer::start_tag('div', array('class' => 'comment-message-meta'));
 207
 208         $this->template .= html_writer::tag('span', '___picture___', array('class' => 'picture'));
 209         $this->template .= html_writer::tag('span', '___name___', array('class' => 'user')) . ' - ';
 210         $this->template .= html_writer::tag('span', '___time___', array('class' => 'time'));
 211
 212         $this->template .= html_writer::end_tag('div'); // .comment-message-meta
 213         $this->template .= html_writer::tag('div', '___content___', array('class' => 'text'));
 214
 215         $this->template .= html_writer::end_tag('div'); // .comment-message
 216
 217         if (!empty($this->plugintype)) {
 218             $this->template = plugin_callback($this->plugintype, $this->pluginname, 'comment', 'template', array($this->comment_param), $this->template);
 219         }
 220
 221         unset($options);
 222     }
 223
 224     /**
 225      * Receive nonjs comment parameters
 226      *
 227      * @param moodle_page $page The page object to initialise comments within
 228      *                          If not provided the global $PAGE is used
 229      */
 230     public static function init(moodle_page $page = null) {
 231         global $PAGE;
 232
 233         if (empty($page)) {
 234             $page = $PAGE;
 235         }
 236         // setup variables for non-js interface
 237         self::$nonjs = optional_param('nonjscomment', '', PARAM_ALPHANUM);
 238         self::$comment_itemid  = optional_param('comment_itemid',  '', PARAM_INT);
 239         self::$comment_context = optional_param('comment_context', '', PARAM_INT);
 240         self::$comment_page    = optional_param('comment_page',    '', PARAM_INT);
 241         self::$comment_area    = optional_param('comment_area',    '', PARAM_AREA);
 242
 243         $page->requires->string_for_js('addcomment', 'moodle');
 244         $page->requires->string_for_js('deletecomment', 'moodle');
 245         $page->requires->string_for_js('comments', 'moodle');
 246         $page->requires->string_for_js('commentsrequirelogin', 'moodle');
 247     }
 248
 249     /**
 250      * Sets the component.
 251      *
 252      * This method shouldn't be public, changing the component once it has been set potentially
 253      * invalidates permission checks.
 254      * A coding_error is now thrown if code attempts to change the component.
 255      *
 256      * @param string $component
 257      */
 258     public function set_component($component) {
 259         if (!empty($this->component) && $this->component !== $component) {
 260             throw new coding_exception('You cannot change the component of a comment once it has been set');
 261         }
 262         $this->component = $component;
 263         list($this->plugintype, $this->pluginname) = core_component::normalize_component($component);
 264     }
 265
 266     /**
 267      * Determines if the user can view the comment.
 268      *
 269      * @param bool $value
 270      */
 271     public function set_view_permission($value) {
 272         $this->viewcap = (bool)$value;
 273     }
 274
 275     /**
 276      * Determines if the user can post a comment
 277      *
 278      * @param bool $value
 279      */
 280     public function set_post_permission($value) {
 281         $this->postcap = (bool)$value;
 282     }
 283
 284     /**
 285      * check posting comments permission
 286      * It will check based on user roles and ask modules
 287      * If you need to check permission by modules, a
 288      * function named $pluginname_check_comment_post must be implemented
 289      */
 290     private function check_permissions() {
 291         $this->postcap = has_capability('moodle/comment:post', $this->context);
 292         $this->viewcap = has_capability('moodle/comment:view', $this->context);
 293         if (!empty($this->plugintype)) {
 294             $permissions = plugin_callback($this->plugintype, $this->pluginname, 'comment', 'permissions', array($this->comment_param), array('post'=>false, 'view'=>false));
 295             $this->postcap = $this->postcap && $permissions['post'];
 296             $this->viewcap = $this->viewcap && $permissions['view'];
 297         }
 298     }
 299
 300     /**
 301      * Gets a link for this page that will work with JS disabled.
 302      *
 303      * @global moodle_page $PAGE
 304      * @param moodle_page $page
 305      * @return moodle_url
 306      */
 307     public function get_nojslink(moodle_page $page = null) {
 308         if ($page === null) {
 309             global $PAGE;
 310             $page = $PAGE;
 311         }
 312
 313         $link = new moodle_url($page->url, array(
 314             'nonjscomment'    => true,
 315             'comment_itemid'  => $this->itemid,
 316             'comment_context' => $this->context->id,
 317             'comment_area'    => $this->commentarea,
 318         ));
 319         $link->remove_params(array('comment_page'));
 320         return $link;
 321     }
 322
 323     /**
 324      * Sets the value of the notoggle option.
 325      *
 326      * If set to true then the user will not be able to expand and collase
 327      * the comment section.
 328      *
 329      * @param bool $newvalue
 330      */
 331     public function set_notoggle($newvalue = true) {
 332         $this->notoggle = (bool)$newvalue;
 333     }
 334
 335     /**
 336      * Sets the value of the autostart option.
 337      *
 338      * If set to true then the comments will be loaded during page load.
 339      * Normally this happens only once the user expands the comment section.
 340      *
 341      * @param bool $newvalue
 342      */
 343     public function set_autostart($newvalue = true) {
 344         $this->autostart = (bool)$newvalue;
 345     }
 346
 347     /**
 348      * Sets the displaycancel option
 349      *
 350      * If set to true then a cancel button will be shown when using the form
 351      * to post comments.
 352      *
 353      * @param bool $newvalue
 354      */
 355     public function set_displaycancel($newvalue = true) {
 356         $this->displaycancel = (bool)$newvalue;
 357     }
 358
 359     /**
 360      * Sets the displaytotalcount option
 361      *
 362      * If set to true then the total number of comments will be displayed
 363      * when printing comments.
 364      *
 365      * @param bool $newvalue
 366      */
 367     public function set_displaytotalcount($newvalue = true) {
 368         $this->displaytotalcount = (bool)$newvalue;
 369     }
 370
 371     /**
 372      * Initialises the JavaScript that enchances the comment API.
 373      *
 374      * @param moodle_page $page The moodle page object that the JavaScript should be
 375      *                          initialised for.
 376      */
 377     public function initialise_javascript(moodle_page $page) {
 378
 379         $options = new stdClass;
 380         $options->client_id   = $this->cid;
 381         $options->commentarea = $this->commentarea;
 382         $options->itemid      = $this->itemid;
 383         $options->page        = 0;
 384         $options->courseid    = $this->courseid;
 385         $options->contextid   = $this->contextid;
 386         $options->component   = $this->component;
 387         $options->notoggle    = $this->notoggle;
 388         $options->autostart   = $this->autostart;
 389
 390         $page->requires->js_init_call('M.core_comment.init', array($options), true);
 391
 392         return true;
 393     }
 394
 395     /**
 396      * Prepare comment code in html
 397      * @param  boolean $return
 398      * @return string|void
 399      */
 400     public function output($return = true) {
 401         global $PAGE, $OUTPUT;
 402         static $template_printed;
 403
 404         $this->initialise_javascript($PAGE);
 405
 406         if (!empty(self::$nonjs)) {
 407             // return non js comments interface
 408             return $this->print_comments(self::$comment_page, $return, true);
 409         }
 410
 411         $html = '';
 412
 413         // print html template
 414         // Javascript will use the template to render new comments
 415         if (empty($template_printed) && $this->can_view()) {
 416             $html .= html_writer::tag('div', $this->template, array('style' => 'display:none', 'id' => 'cmt-tmpl'));
 417             $template_printed = true;
 418         }
 419
 420         if ($this->can_view()) {
 421             // print commenting icon and tooltip
 422             $html .= html_writer::start_tag('div', array('class' => 'mdl-left'));
 423             $html .= html_writer::link($this->get_nojslink($PAGE), get_string('showcommentsnonjs'), array('class' => 'showcommentsnonjs'));
 424
 425             if (!$this->notoggle) {
 426                 // If toggling is enabled (notoggle=false) then print the controls to toggle
 427                 // comments open and closed
 428                 $countstring = '';
 429                 if ($this->displaytotalcount) {
 430                     $countstring = '('.$this->count().')';
 431                 }
 432                 $collapsedimage= 't/collapsed';
 433                 if (right_to_left()) {
 434                     $collapsedimage= 't/collapsed_rtl';
 435                 } else {
 436                     $collapsedimage= 't/collapsed';
 437                 }
 438                 $html .= html_writer::start_tag('a', array('class' => 'comment-link', 'id' => 'comment-link-'.$this->cid, 'href' => '#'));
 439                 $html .= html_writer::empty_tag('img', array('id' => 'comment-img-'.$this->cid, 'src' => $OUTPUT->pix_url($collapsedimage), 'alt' => $this->linktext, 'title' => $this->linktext));
 440                 $html .= html_writer::tag('span', $this->linktext.' '.$countstring, array('id' => 'comment-link-text-'.$this->cid));
 441                 $html .= html_writer::end_tag('a');
 442             }
 443
 444             $html .= html_writer::start_tag('div', array('id' => 'comment-ctrl-'.$this->cid, 'class' => 'comment-ctrl'));
 445
 446             if ($this->autostart) {
 447                 // If autostart has been enabled print the comments list immediatly
 448                 $html .= html_writer::start_tag('ul', array('id' => 'comment-list-'.$this->cid, 'class' => 'comment-list comments-loaded'));
 449                 $html .= html_writer::tag('li', '', array('class' => 'first'));
 450                 $html .= $this->print_comments(0, true, false);
 451                 $html .= html_writer::end_tag('ul'); // .comment-list
 452                 $html .= $this->get_pagination(0);
 453             } else {
 454                 $html .= html_writer::start_tag('ul', array('id' => 'comment-list-'.$this->cid, 'class' => 'comment-list'));
 455                 $html .= html_writer::tag('li', '', array('class' => 'first'));
 456                 $html .= html_writer::end_tag('ul'); // .comment-list
 457                 $html .= html_writer::tag('div', '', array('id' => 'comment-pagination-'.$this->cid, 'class' => 'comment-pagination'));
 458             }
 459
 460             if ($this->can_post()) {
 461                 // print posting textarea
 462                 $html .= html_writer::start_tag('div', array('class' => 'comment-area'));
 463                 $html .= html_writer::start_tag('div', array('class' => 'db'));
 464                 $html .= html_writer::tag('textarea', '', array('name' => 'content', 'rows' => 2, 'cols' => 20, 'id' => 'dlg-content-'.$this->cid));
 465                 $html .= html_writer::end_tag('div'); // .db
 466
 467                 $html .= html_writer::start_tag('div', array('class' => 'fd', 'id' => 'comment-action-'.$this->cid));
 468                 $html .= html_writer::link('#', get_string('savecomment'), array('id' => 'comment-action-post-'.$this->cid));
 469
 470                 if ($this->displaycancel) {
 471                     $html .= html_writer::tag('span', ' | ');
 472                     $html .= html_writer::link('#', get_string('cancel'), array('id' => 'comment-action-cancel-'.$this->cid));
 473                 }
 474
 475                 $html .= html_writer::end_tag('div'); // .fd
 476                 $html .= html_writer::end_tag('div'); // .comment-area
 477                 $html .= html_writer::tag('div', '', array('class' => 'clearer'));
 478             }
 479
 480             $html .= html_writer::end_tag('div'); // .comment-ctrl
 481             $html .= html_writer::end_tag('div'); // .mdl-left
 482         } else {
 483             $html = '';
 484         }
 485
 486         if ($return) {
 487             return $html;
 488         } else {
 489             echo $html;
 490         }
 491     }
 492
 493     /**
 494      * Return matched comments
 495      *
 496      * @param  int $page
 497      * @return array
 498      */
 499     public function get_comments($page = '') {
 500         global $DB, $CFG, $USER, $OUTPUT;
 501         if (!$this->can_view()) {
 502             return false;
 503         }
 504         if (!is_numeric($page)) {
 505             $page = 0;
 506         }
 507         $params = array();
 508         $perpage = (!empty($CFG->commentsperpage))?$CFG->commentsperpage:15;
 509         $start = $page * $perpage;
 510         $ufields = user_picture::fields('u');
 511         $sql = "SELECT $ufields, c.id AS cid, c.content AS ccontent, c.format AS cformat, c.timecreated AS ctimecreated
 512                   FROM {comments} c
 513                   JOIN {user} u ON u.id = c.userid
 514                  WHERE c.contextid = :contextid AND c.commentarea = :commentarea AND c.itemid = :itemid
 515               ORDER BY c.timecreated DESC";
 516         $params['contextid'] = $this->contextid;
 517         $params['commentarea'] = $this->commentarea;
 518         $params['itemid'] = $this->itemid;
 519
 520         $comments = array();
 521         $formatoptions = array('overflowdiv' => true);
 522         $rs = $DB->get_recordset_sql($sql, $params, $start, $perpage);
 523         foreach ($rs as $u) {
 524             $c = new stdClass();
 525             $c->id          = $u->cid;
 526             $c->content     = $u->ccontent;
 527             $c->format      = $u->cformat;
 528             $c->timecreated = $u->ctimecreated;
 529             $c->strftimeformat = get_string('strftimerecent', 'langconfig');
 530             $url = new moodle_url('/user/view.php', array('id'=>$u->id, 'course'=>$this->courseid));
 531             $c->profileurl = $url->out(true);
 532             $c->fullname = fullname($u);
 533             $c->time = userdate($c->timecreated, $c->strftimeformat);
 534             $c->content = format_text($c->content, $c->format, $formatoptions);
 535             $c->avatar = $OUTPUT->user_picture($u, array('size'=>18));
 536             $c->userid = $u->id;
 537
 538             $candelete = $this->can_delete($c->id);
 539             if (($USER->id == $u->id) || !empty($candelete)) {
 540                 $c->delete = true;
 541             }
 542             $comments[] = $c;
 543         }
 544         $rs->close();
 545
 546         if (!empty($this->plugintype)) {
 547             // moodle module will filter comments
 548             $comments = plugin_callback($this->plugintype, $this->pluginname, 'comment', 'display', array($comments, $this->comment_param), $comments);
 549         }
 550
 551         return $comments;
 552     }
 553
 554     /**
 555      * Returns the number of comments associated with the details of this object
 556      *
 557      * @global moodle_database $DB
 558      * @return int
 559      */
 560     public function count() {
 561         global $DB;
 562         if ($this->totalcommentcount === null) {
 563             $this->totalcommentcount = $DB->count_records('comments', array('itemid' => $this->itemid, 'commentarea' => $this->commentarea, 'contextid' => $this->context->id));
 564         }
 565         return $this->totalcommentcount;
 566     }
 567
 568     /**
 569      * Returns HTML to display a pagination bar
 570      *
 571      * @global stdClass $CFG
 572      * @global core_renderer $OUTPUT
 573      * @param int $page
 574      * @return string
 575      */
 576     public function get_pagination($page = 0) {
 577         global $CFG, $OUTPUT;
 578         $count = $this->count();
 579         $perpage = (!empty($CFG->commentsperpage))?$CFG->commentsperpage:15;
 580         $pages = (int)ceil($count/$perpage);
 581         if ($pages == 1 || $pages == 0) {
 582             return html_writer::tag('div', '', array('id' => 'comment-pagination-'.$this->cid, 'class' => 'comment-pagination'));
 583         }
 584         if (!empty(self::$nonjs)) {
 585             // used in non-js interface
 586             return $OUTPUT->paging_bar($count, $page, $perpage, $this->get_nojslink(), 'comment_page');
 587         } else {
 588             // return ajax paging bar
 589             $str = '';
 590             $str .= '<div class="comment-paging" id="comment-pagination-'.$this->cid.'">';
 591             for ($p=0; $p<$pages; $p++) {
 592                 if ($p == $page) {
 593                     $class = 'curpage';
 594                 } else {
 595                     $class = 'pageno';
 596                 }
 597                 $str .= '<a href="#" class="'.$class.'" id="comment-page-'.$this->cid.'-'.$p.'">'.($p+1).'</a> ';
 598             }
 599             $str .= '</div>';
 600         }
 601         return $str;
 602     }
 603
 604     /**
 605      * Add a new comment
 606      *
 607      * @global moodle_database $DB
 608      * @param string $content
 609      * @param int $format
 610      * @return stdClass
 611      */
 612     public function add($content, $format = FORMAT_MOODLE) {
 613         global $CFG, $DB, $USER, $OUTPUT;
 614         if (!$this->can_post()) {
 615             throw new comment_exception('nopermissiontocomment');
 616         }
 617         $now = time();
 618         $newcmt = new stdClass;
 619         $newcmt->contextid    = $this->contextid;
 620         $newcmt->commentarea  = $this->commentarea;
 621         $newcmt->itemid       = $this->itemid;
 622         $newcmt->content      = $content;
 623         $newcmt->format       = $format;
 624         $newcmt->userid       = $USER->id;
 625         $newcmt->timecreated  = $now;
 626
 627         // This callback allow module to modify the content of comment, such as filter or replacement
 628         plugin_callback($this->plugintype, $this->pluginname, 'comment', 'add', array(&$newcmt, $this->comment_param));
 629
 630         $cmt_id = $DB->insert_record('comments', $newcmt);
 631         if (!empty($cmt_id)) {
 632             $newcmt->id = $cmt_id;
 633             $newcmt->strftimeformat = get_string('strftimerecent', 'langconfig');
 634             $newcmt->fullname = fullname($USER);
 635             $url = new moodle_url('/user/view.php', array('id' => $USER->id, 'course' => $this->courseid));
 636             $newcmt->profileurl = $url->out();
 637             $newcmt->content = format_text($newcmt->content, $format, array('overflowdiv'=>true));
 638             $newcmt->avatar = $OUTPUT->user_picture($USER, array('size'=>16));
 639
 640             $commentlist = array($newcmt);
 641
 642             if (!empty($this->plugintype)) {
 643                 // Call the display callback to allow the plugin to format the newly added comment.
 644                 $commentlist = plugin_callback($this->plugintype,
 645                                                $this->pluginname,
 646                                                'comment',
 647                                                'display',
 648                                                array($commentlist, $this->comment_param),
 649                                                $commentlist);
 650                 $newcmt = $commentlist[0];
 651             }
 652             $newcmt->time = userdate($newcmt->timecreated, $newcmt->strftimeformat);
 653
 654             // Trigger comment created event.
 655             if (core_component::is_core_subsystem($this->component)) {
 656                 $eventclassname = '\\core\\event\\' . $this->component . '_comment_created';
 657             } else {
 658                 $eventclassname = '\\' . $this->component . '\\event\comment_created';
 659             }
 660             if (class_exists($eventclassname)) {
 661                 $event = $eventclassname::create(
 662                         array(
 663                             'context' => $this->context,
 664                             'objectid' => $newcmt->id,
 665                             'other' => array(
 666                                 'itemid' => $this->itemid
 667                                 )
 668                             ));
 669                 $event->trigger();
 670             }
 671
 672             return $newcmt;
 673         } else {
 674             throw new comment_exception('dbupdatefailed');
 675         }
 676     }
 677
 678     /**
 679      * delete by context, commentarea and itemid
 680      * @param stdClass|array $param {
 681      *            contextid => int the context in which the comments exist [required]
 682      *            commentarea => string the comment area [optional]
 683      *            itemid => int comment itemid [optional]
 684      * }
 685      * @return boolean
 686      */
 687     public static function delete_comments($param) {
 688         global $DB;
 689         $param = (array)$param;
 690         if (empty($param['contextid'])) {
 691             return false;
 692         }
 693         $DB->delete_records('comments', $param);
 694         return true;
 695     }
 696
 697     /**
 698      * Delete page_comments in whole course, used by course reset
 699      *
 700      * @param stdClass $context course context
 701      */
 702     public static function reset_course_page_comments($context) {
 703         global $DB;
 704         $contexts = array();
 705         $contexts[] = $context->id;
 706         $children = $context->get_child_contexts();
 707         foreach ($children as $c) {
 708             $contexts[] = $c->id;
 709         }
 710         list($ids, $params) = $DB->get_in_or_equal($contexts);
 711         $DB->delete_records_select('comments', "commentarea='page_comments' AND contextid $ids", $params);
 712     }
 713
 714     /**
 715      * Delete a comment
 716      *
 717      * @param  int $commentid
 718      * @return bool
 719      */
 720     public function delete($commentid) {
 721         global $DB, $USER;
 722         $candelete = has_capability('moodle/comment:delete', $this->context);
 723         if (!$comment = $DB->get_record('comments', array('id'=>$commentid))) {
 724             throw new comment_exception('dbupdatefailed');
 725         }
 726         if (!($USER->id == $comment->userid || !empty($candelete))) {
 727             throw new comment_exception('nopermissiontocomment');
 728         }
 729         $DB->delete_records('comments', array('id'=>$commentid));
 730         // Trigger comment delete event.
 731         if (core_component::is_core_subsystem($this->component)) {
 732             $eventclassname = '\\core\\event\\' . $this->component . '_comment_deleted';
 733         } else {
 734             $eventclassname = '\\' . $this->component . '\\event\comment_deleted';
 735         }
 736         if (class_exists($eventclassname)) {
 737             $event = $eventclassname::create(
 738                     array(
 739                         'context' => $this->context,
 740                         'objectid' => $commentid,
 741                         'other' => array(
 742                             'itemid' => $this->itemid
 743                             )
 744                         ));
 745             $event->add_record_snapshot('comments', $comment);
 746             $event->trigger();
 747         }
 748         return true;
 749     }
 750
 751     /**
 752      * Print comments
 753      *
 754      * @param int $page
 755      * @param bool $return return comments list string or print it out
 756      * @param bool $nonjs print nonjs comments list or not?
 757      * @return string|void
 758      */
 759     public function print_comments($page = 0, $return = true, $nonjs = true) {
 760         global $DB, $CFG, $PAGE;
 761
 762         if (!$this->can_view()) {
 763             return '';
 764         }
 765
 766         $html = '';
 767         if (!(self::$comment_itemid == $this->itemid &&
 768             self::$comment_context == $this->context->id &&
 769             self::$comment_area == $this->commentarea)) {
 770             $page = 0;
 771         }
 772         $comments = $this->get_comments($page);
 773
 774         $html = '';
 775         if ($nonjs) {
 776             $html .= html_writer::tag('h3', get_string('comments'));
 777             $html .= html_writer::start_tag('ul', array('id' => 'comment-list-'.$this->cid, 'class' => 'comment-list'));
 778         }
 779         // Reverse the comments array to display them in the correct direction
 780         foreach (array_reverse($comments) as $cmt) {
 781             $html .= html_writer::tag('li', $this->print_comment($cmt, $nonjs), array('id' => 'comment-'.$cmt->id.'-'.$this->cid));
 782         }
 783         if ($nonjs) {
 784             $html .= html_writer::end_tag('ul');
 785             $html .= $this->get_pagination($page);
 786         }
 787         if ($nonjs && $this->can_post()) {
 788             // Form to add comments
 789             $html .= html_writer::start_tag('form', array('method' => 'post', 'action' => new moodle_url('/comment/comment_post.php')));
 790             // Comment parameters
 791             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'contextid', 'value' => $this->contextid));
 792             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'action',    'value' => 'add'));
 793             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'area',      'value' => $this->commentarea));
 794             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'component', 'value' => $this->component));
 795             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'itemid',    'value' => $this->itemid));
 796             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'courseid',  'value' => $this->courseid));
 797             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'sesskey',   'value' => sesskey()));
 798             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'returnurl', 'value' => $PAGE->url));
 799             // Textarea for the actual comment
 800             $html .= html_writer::tag('textarea', '', array('name' => 'content', 'rows' => 2));
 801             // Submit button to add the comment
 802             $html .= html_writer::empty_tag('input', array('type' => 'submit', 'value' => get_string('submit')));
 803             $html .= html_writer::end_tag('form');
 804         }
 805         if ($return) {
 806             return $html;
 807         } else {
 808             echo $html;
 809         }
 810     }
 811
 812     /**
 813      * Returns an array containing comments in HTML format.
 814      *
 815      * @global core_renderer $OUTPUT
 816      * @param stdClass $cmt {
 817      *          id => int comment id
 818      *          content => string comment content
 819      *          format  => int comment text format
 820      *          timecreated => int comment's timecreated
 821      *          profileurl  => string link to user profile
 822      *          fullname    => comment author's full name
 823      *          avatar      => string user's avatar
 824      *          delete      => boolean does user have permission to delete comment?
 825      * }
 826      * @param bool $nonjs
 827      * @return array
 828      */
 829     public function print_comment($cmt, $nonjs = true) {
 830         global $OUTPUT;
 831         $patterns = array();
 832         $replacements = array();
 833
 834         if (!empty($cmt->delete) && empty($nonjs)) {
 835             $deletelink  = html_writer::start_tag('div', array('class'=>'comment-delete'));
 836             $deletelink .= html_writer::start_tag('a', array('href' => '#', 'id' => 'comment-delete-'.$this->cid.'-'.$cmt->id));
 837             $deletelink .= $OUTPUT->pix_icon('t/delete', get_string('delete'));
 838             $deletelink .= html_writer::end_tag('a');
 839             $deletelink .= html_writer::end_tag('div');
 840             $cmt->content = $deletelink . $cmt->content;
 841         }
 842         $patterns[] = '___picture___';
 843         $patterns[] = '___name___';
 844         $patterns[] = '___content___';
 845         $patterns[] = '___time___';
 846         $replacements[] = $cmt->avatar;
 847         $replacements[] = html_writer::link($cmt->profileurl, $cmt->fullname);
 848         $replacements[] = $cmt->content;
 849         $replacements[] = $cmt->time;
 850
 851         // use html template to format a single comment.
 852         return str_replace($patterns, $replacements, $this->template);
 853     }
 854
 855     /**
 856      * Revoke validate callbacks
 857      *
 858      * @param stdClass $params addtionall parameters need to add to callbacks
 859      */
 860     protected function validate($params=array()) {
 861         foreach ($params as $key=>$value) {
 862             $this->comment_param->$key = $value;
 863         }
 864         $validation = plugin_callback($this->plugintype, $this->pluginname, 'comment', 'validate', array($this->comment_param), false);
 865         if (!$validation) {
 866             throw new comment_exception('invalidcommentparam');
 867         }
 868     }
 869
 870     /**
 871      * Returns true if the user is able to view comments
 872      * @return bool
 873      */
 874     public function can_view() {
 875         $this->validate();
 876         return !empty($this->viewcap);
 877     }
 878
 879     /**
 880      * Returns true if the user can add comments against this comment description
 881      * @return bool
 882      */
 883     public function can_post() {
 884         $this->validate();
 885         return isloggedin() && !empty($this->postcap);
 886     }
 887
 888     /**
 889      * Returns true if the user can delete this comment
 890      * @param int $commentid
 891      * @return bool
 892      */
 893     public function can_delete($commentid) {
 894         $this->validate(array('commentid'=>$commentid));
 895         return has_capability('moodle/comment:delete', $this->context);
 896     }
 897
 898     /**
 899      * Returns the component associated with the comment
 900      * @return string
 901      */
 902     public function get_compontent() {
 903         return $this->component;
 904     }
 905
 906     /**
 907      * Returns the context associated with the comment
 908      * @return stdClass
 909      */
 910     public function get_context() {
 911         return $this->context;
 912     }
 913
 914     /**
 915      * Returns the course id associated with the comment
 916      * @return int
 917      */
 918     public function get_courseid() {
 919         return $this->courseid;
 920     }
 921
 922     /**
 923      * Returns the course module associated with the comment
 924      *
 925      * @return stdClass
 926      */
 927     public function get_cm() {
 928         return $this->cm;
 929     }
 930
 931     /**
 932      * Returns the item id associated with the comment
 933      *
 934      * @return int
 935      */
 936     public function get_itemid() {
 937         return $this->itemid;
 938     }
 939
 940     /**
 941      * Returns the comment area associated with the commentarea
 942      *
 943      * @return stdClass
 944      */
 945     public function get_commentarea() {
 946         return $this->commentarea;
 947     }
 948 }
 949
 950 /**
 951  * Comment exception class
 952  *
 953  * @package   core
 954  * @copyright 2010 Dongsheng Cai {@link http://dongsheng.org}
 955  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 956  */
 957 class comment_exception extends moodle_exception {
 958 }