[Summary view] [Print] [Text view]

   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   * A Handler to process replies to forum posts.
  19   *
  20   * @package    mod_forum
  21   * @subpackage core_message
  22   * @copyright  2014 Andrew Nicols
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  namespace mod_forum\message\inbound;
  27  
  28  defined('MOODLE_INTERNAL') || die();
  29  
  30  require_once($CFG->dirroot . '/mod/forum/lib.php');
  31  require_once($CFG->dirroot . '/repository/lib.php');
  32  
  33  /**
  34   * A Handler to process replies to forum posts.
  35   *
  36   * @copyright  2014 Andrew Nicols
  37   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  38   */
  39  class reply_handler extends \core\message\inbound\handler {
  40  
  41      /**
  42       * Return a description for the current handler.
  43       *
  44       * @return string
  45       */
  46      public function get_description() {
  47          return get_string('reply_handler', 'mod_forum');
  48      }
  49  
  50      /**
  51       * Return a short name for the current handler.
  52       * This appears in the admin pages as a human-readable name.
  53       *
  54       * @return string
  55       */
  56      public function get_name() {
  57          return get_string('reply_handler_name', 'mod_forum');
  58      }
  59  
  60      /**
  61       * Process a message received and validated by the Inbound Message processor.
  62       *
  63       * @throws \core\message\inbound\processing_failed_exception
  64       * @param \stdClass $messagedata The Inbound Message record
  65       * @param \stdClass $messagedata The message data packet
  66       * @return bool Whether the message was successfully processed.
  67       */
  68      public function process_message(\stdClass $record, \stdClass $messagedata) {
  69          global $DB, $USER;
  70  
  71          // Load the post being replied to.
  72          $post = $DB->get_record('forum_posts', array('id' => $record->datavalue));
  73          if (!$post) {
  74              mtrace("--> Unable to find a post matching with id {$record->datavalue}");
  75              return false;
  76          }
  77  
  78          // Load the discussion that this post is in.
  79          $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion));
  80          if (!$post) {
  81              mtrace("--> Unable to find the discussion for post {$record->datavalue}");
  82              return false;
  83          }
  84  
  85          // Load the other required data.
  86          $forum = $DB->get_record('forum', array('id' => $discussion->forum));
  87          $course = $DB->get_record('course', array('id' => $forum->course));
  88          $cm = get_fast_modinfo($course->id)->instances['forum'][$forum->id];
  89          $modcontext = \context_module::instance($cm->id);
  90          $usercontext = \context_user::instance($USER->id);
  91  
  92          // Make sure user can post in this discussion.
  93          $canpost = true;
  94          if (!forum_user_can_post($forum, $discussion, $USER, $cm, $course, $modcontext)) {
  95              $canpost = false;
  96          }
  97  
  98          if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
  99              $groupmode = $cm->groupmode;
 100          } else {
 101              $groupmode = $course->groupmode;
 102          }
 103          if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $modcontext)) {
 104              if ($discussion->groupid == -1) {
 105                  $canpost = false;
 106              } else {
 107                  if (!groups_is_member($discussion->groupid)) {
 108                      $canpost = false;
 109                  }
 110              }
 111          }
 112  
 113          if (!$canpost) {
 114              $data = new \stdClass();
 115              $data->forum = $forum;
 116              throw new \core\message\inbound\processing_failed_exception('messageinboundnopostforum', 'mod_forum', $data);
 117          }
 118  
 119          // And check the availability.
 120          if (!\core_availability\info_module::is_user_visible($cm, $USER, true)) {
 121              $data = new \stdClass();
 122              $data->forum = $forum;
 123              throw new \core\message\inbound\processing_failed_exception('messageinboundforumhidden', 'mod_forum', $data);
 124          }
 125  
 126          // Before we add this we must check that the user will not exceed the blocking threshold.
 127          // This should result in an appropriate reply.
 128          $thresholdwarning = forum_check_throttling($forum, $cm);
 129          if (!empty($thresholdwarning) && !$thresholdwarning->canpost) {
 130              $data = new \stdClass();
 131              $data->forum = $forum;
 132              $data->message = get_string($thresholdwarning->errorcode, $thresholdwarning->module, $thresholdwarning->additional);
 133              throw new \core\message\inbound\processing_failed_exception('messageinboundthresholdhit', 'mod_forum', $data);
 134          }
 135  
 136          $addpost = new \stdClass();
 137          $addpost->course       = $course->id;
 138          $addpost->forum        = $forum->id;
 139          $addpost->discussion   = $discussion->id;
 140          $addpost->modified     = $messagedata->timestamp;
 141          $addpost->subject      = clean_param($messagedata->envelope->subject, PARAM_TEXT);
 142          $addpost->parent       = $post->id;
 143          $addpost->itemid       = file_get_unused_draft_itemid();
 144  
 145          if (!empty($messagedata->html)) {
 146              $addpost->message = $messagedata->html;
 147              $addpost->messageformat = FORMAT_HTML;
 148          } else {
 149              $addpost->message = $messagedata->plain;
 150              $addpost->messageformat = FORMAT_PLAIN;
 151          }
 152  
 153          // We don't trust text coming from e-mail.
 154          $addpost->messagetrust = false;
 155  
 156          // Add attachments to the post.
 157          if (!empty($messagedata->attachments['attachment']) && count($messagedata->attachments['attachment'])) {
 158              $attachmentcount = count($messagedata->attachments['attachment']);
 159              if (empty($forum->maxattachments) || $forum->maxbytes == 1 ||
 160                      !has_capability('mod/forum:createattachment', $modcontext)) {
 161                  // Attachments are not allowed.
 162                  mtrace("--> User does not have permission to attach files in this forum. Rejecting e-mail.");
 163  
 164                  $data = new \stdClass();
 165                  $data->forum = $forum;
 166                  $data->attachmentcount = $attachmentcount;
 167                  throw new \core\message\inbound\processing_failed_exception('messageinboundattachmentdisallowed', 'mod_forum', $data);
 168              }
 169  
 170              if ($forum->maxattachments < $attachmentcount) {
 171                  // Too many attachments.
 172                  mtrace("--> User attached {$attachmentcount} files when only {$forum->maxattachments} where allowed. "
 173                       . " Rejecting e-mail.");
 174  
 175                  $data = new \stdClass();
 176                  $data->forum = $forum;
 177                  $data->attachmentcount = $attachmentcount;
 178                  throw new \core\message\inbound\processing_failed_exception('messageinboundfilecountexceeded', 'mod_forum', $data);
 179              }
 180  
 181              $filesize = 0;
 182              $addpost->attachments  = file_get_unused_draft_itemid();
 183              foreach ($messagedata->attachments['attachment'] as $attachment) {
 184                  mtrace("--> Processing {$attachment->filename} as an attachment.");
 185                  $this->process_attachment('*', $usercontext, $addpost->attachments, $attachment);
 186                  $filesize += $attachment->filesize;
 187              }
 188  
 189              if ($forum->maxbytes < $filesize) {
 190                  // Too many attachments.
 191                  mtrace("--> User attached {$filesize} bytes of files when only {$forum->maxbytes} where allowed. "
 192                       . "Rejecting e-mail.");
 193                  $data = new \stdClass();
 194                  $data->forum = $forum;
 195                  $data->maxbytes = display_size($forum->maxbytes);
 196                  $data->filesize = display_size($filesize);
 197                  throw new \core\message\inbound\processing_failed_exception('messageinboundfilesizeexceeded', 'mod_forum', $data);
 198              }
 199          }
 200  
 201          // Process any files in the message itself.
 202          if (!empty($messagedata->attachments['inline'])) {
 203              foreach ($messagedata->attachments['inline'] as $attachment) {
 204                  mtrace("--> Processing {$attachment->filename} as an inline attachment.");
 205                  $this->process_attachment('*', $usercontext, $addpost->itemid, $attachment);
 206  
 207                  // Convert the contentid link in the message.
 208                  $draftfile = \moodle_url::make_draftfile_url($addpost->itemid, '/', $attachment->filename);
 209                  $addpost->message = preg_replace('/cid:' . $attachment->contentid . '/', $draftfile, $addpost->message);
 210              }
 211          }
 212  
 213          // Insert the message content now.
 214          $addpost->id = forum_add_new_post($addpost, true);
 215  
 216          // Log the new post creation.
 217          $params = array(
 218              'context' => $modcontext,
 219              'objectid' => $addpost->id,
 220              'other' => array(
 221                  'discussionid'  => $discussion->id,
 222                  'forumid'       => $forum->id,
 223                  'forumtype'     => $forum->type,
 224              )
 225          );
 226          $event = \mod_forum\event\post_created::create($params);
 227          $event->add_record_snapshot('forum_posts', $addpost);
 228          $event->add_record_snapshot('forum_discussions', $discussion);
 229          $event->trigger();
 230  
 231          mtrace("--> Created a post {$addpost->id} in {$discussion->id}.");
 232          return $addpost;
 233      }
 234  
 235      /**
 236       * Process attachments included in a message.
 237       *
 238       * @param string[] $acceptedtypes String The mimetypes of the acceptable attachment types.
 239       * @param \context_user $context context_user The context of the user creating this attachment.
 240       * @param int $itemid int The itemid to store this attachment under.
 241       * @param \stdClass $attachment stdClass The Attachment data to store.
 242       * @return \stored_file
 243       */
 244      protected function process_attachment($acceptedtypes, \context_user $context, $itemid, \stdClass $attachment) {
 245          global $USER, $CFG;
 246  
 247          // Create the file record.
 248          $record = new \stdClass();
 249          $record->filearea   = 'draft';
 250          $record->component  = 'user';
 251  
 252          $record->itemid     = $itemid;
 253          $record->license    = $CFG->sitedefaultlicense;
 254          $record->author     = fullname($USER);
 255          $record->contextid  = $context->id;
 256          $record->userid     = $USER->id;
 257  
 258          // All files sent by e-mail should have a flat structure.
 259          $record->filepath   = '/';
 260  
 261          $record->filename = $attachment->filename;
 262  
 263          mtrace("--> Attaching {$record->filename} to " .
 264                 "/{$record->contextid}/{$record->component}/{$record->filearea}/" .
 265                 "{$record->itemid}{$record->filepath}{$record->filename}");
 266  
 267          $fs = get_file_storage();
 268          return $fs->create_file_from_string($record, $attachment->content);
 269      }
 270  
 271  
 272      /**
 273       * Return the content of any success notification to be sent.
 274       * Both an HTML and Plain Text variant must be provided.
 275       *
 276       * @param \stdClass $messagedata The message data.
 277       * @param \stdClass $handlerresult The record for the newly created post.
 278       * @return \stdClass with keys `html` and `plain`.
 279       */
 280      public function get_success_message(\stdClass $messagedata, $handlerresult) {
 281          $a = new \stdClass();
 282          $a->subject = $handlerresult->subject;
 283          $discussionurl = new \moodle_url('/mod/forum/discuss.php', array('d' => $handlerresult->discussion));
 284          $a->discussionurl = $discussionurl->out();
 285  
 286          $message = new \stdClass();
 287          $message->plain = get_string('postbymailsuccess', 'mod_forum', $a);
 288          $message->html = get_string('postbymailsuccess_html', 'mod_forum', $a);
 289          return $message;
 290      }
 291  
 292  }