[Summary view]

Differences Between: [Versions 310 and 401] [Versions 311 and 401] [Versions 39 and 401]

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