mod/assign/submission/file/locallib.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  * This file contains the definition for the library class for file submission plugin
  19  *
  20  * This class provides all the functionality for the new assign module.
  21  *
  22  * @package assignsubmission_file
  23  * @copyright 2012 NetSpot {@link http://www.netspot.com.au}
  24  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  25  */
  26
  27 /** Include eventslib.php */
  28 require_once($CFG->libdir.'/eventslib.php');
  29
  30 defined('MOODLE_INTERNAL') || die();
  31 /**
  32  * File areas for file submission assignment
  33  */
  34 define('ASSIGNSUBMISSION_FILE_MAXFILES', 20);
  35 define('ASSIGNSUBMISSION_FILE_MAXSUMMARYFILES', 5);
  36 define('ASSIGNSUBMISSION_FILE_FILEAREA', 'submission_files');
  37
  38 /**
  39  * library class for file submission plugin extending submission plugin base class
  40  *
  41  * @package   assignsubmission_file
  42  * @copyright 2012 NetSpot {@link http://www.netspot.com.au}
  43  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  44  */
  45 class assign_submission_file extends assign_submission_plugin {
  46
  47     /**
  48      * Get the name of the file submission plugin
  49      * @return string
  50      */
  51     public function get_name() {
  52         return get_string('file', 'assignsubmission_file');
  53     }
  54
  55     /**
  56      * Get file submission information from the database
  57      *
  58      * @param int $submissionid
  59      * @return mixed
  60      */
  61     private function get_file_submission($submissionid) {
  62         global $DB;
  63         return $DB->get_record('assignsubmission_file', array('submission'=>$submissionid));
  64     }
  65
  66     /**
  67      * Get the default setting for file submission plugin
  68      *
  69      * @param MoodleQuickForm $mform The form to add elements to
  70      * @return void
  71      */
  72     public function get_settings(MoodleQuickForm $mform) {
  73         global $CFG, $COURSE;
  74
  75         $defaultmaxfilesubmissions = $this->get_config('maxfilesubmissions');
  76         $defaultmaxsubmissionsizebytes = $this->get_config('maxsubmissionsizebytes');
  77
  78         $settings = array();
  79         $options = array();
  80         for($i = 1; $i <= ASSIGNSUBMISSION_FILE_MAXFILES; $i++) {
  81             $options[$i] = $i;
  82         }
  83
  84         $mform->addElement('select', 'assignsubmission_file_maxfiles', get_string('maxfilessubmission', 'assignsubmission_file'), $options);
  85         $mform->addHelpButton('assignsubmission_file_maxfiles', 'maxfilessubmission', 'assignsubmission_file');
  86         $mform->setDefault('assignsubmission_file_maxfiles', $defaultmaxfilesubmissions);
  87         $mform->disabledIf('assignsubmission_file_maxfiles', 'assignsubmission_file_enabled', 'eq', 0);
  88
  89         $choices = get_max_upload_sizes($CFG->maxbytes, $COURSE->maxbytes, get_config('assignsubmission_file', 'maxbytes'));
  90
  91         // Remove the option for 0 bytes.
  92         unset($choices[0]);
  93         if ($COURSE->maxbytes == 0) {
  94             $choices = array(0=>get_string('siteuploadlimit', 'assignsubmission_file')) + $choices;
  95         } else {
  96             $choices = array(0=>get_string('courseuploadlimit') . ' (' . display_size($COURSE->maxbytes) . ')') + $choices;
  97         }
  98         $settings[] = array('type' => 'select',
  99                             'name' => 'maxsubmissionsizebytes',
 100                             'description' => get_string('maximumsubmissionsize', 'assignsubmission_file'),
 101                             'options'=> $choices,
 102                             'default'=> $defaultmaxsubmissionsizebytes);
 103
 104         $mform->addElement('select', 'assignsubmission_file_maxsizebytes', get_string('maximumsubmissionsize', 'assignsubmission_file'), $choices);
 105         $mform->addHelpButton('assignsubmission_file_maxsizebytes', 'maximumsubmissionsize', 'assignsubmission_file');
 106         $mform->setDefault('assignsubmission_file_maxsizebytes', $defaultmaxsubmissionsizebytes);
 107         $mform->disabledIf('assignsubmission_file_maxsizebytes', 'assignsubmission_file_enabled', 'eq', 0);
 108     }
 109
 110     /**
 111      * Save the settings for file submission plugin
 112      *
 113      * @param stdClass $data
 114      * @return bool
 115      */
 116     public function save_settings(stdClass $data) {
 117         $this->set_config('maxfilesubmissions', $data->assignsubmission_file_maxfiles);
 118         $this->set_config('maxsubmissionsizebytes', $data->assignsubmission_file_maxsizebytes);
 119         return true;
 120     }
 121
 122     /**
 123      * File format options
 124      *
 125      * @return array
 126      */
 127     private function get_file_options() {
 128         $fileoptions = array('subdirs'=>1,
 129                                 'maxbytes'=>$this->get_config('maxsubmissionsizebytes'),
 130                                 'maxfiles'=>$this->get_config('maxfilesubmissions'),
 131                                 'accepted_types'=>'*',
 132                                 'return_types'=>FILE_INTERNAL);
 133         return $fileoptions;
 134     }
 135
 136     /**
 137      * Add elements to submission form
 138      *
 139      * @param mixed $submission stdClass|null
 140      * @param MoodleQuickForm $mform
 141      * @param stdClass $data
 142      * @return bool
 143      */
 144     public function get_form_elements($submission, MoodleQuickForm $mform, stdClass $data) {
 145
 146         if ($this->get_config('maxfilesubmissions') <= 0) {
 147             return false;
 148         }
 149
 150         $fileoptions = $this->get_file_options();
 151         $submissionid = $submission ? $submission->id : 0;
 152
 153         $data = file_prepare_standard_filemanager($data, 'files', $fileoptions, $this->assignment->get_context(), 'assignsubmission_file', ASSIGNSUBMISSION_FILE_FILEAREA, $submissionid);
 154         $mform->addElement('filemanager', 'files_filemanager', html_writer::tag('span', $this->get_name(),
 155             array('class' => 'accesshide')), null, $fileoptions);
 156
 157         return true;
 158     }
 159
 160     /**
 161      * Count the number of files
 162      *
 163      * @param int $submissionid
 164      * @param string $area
 165      * @return int
 166      */
 167     private function count_files($submissionid, $area) {
 168
 169         $fs = get_file_storage();
 170         $files = $fs->get_area_files($this->assignment->get_context()->id, 'assignsubmission_file', $area, $submissionid, "id", false);
 171
 172         return count($files);
 173     }
 174
 175     /**
 176      * Save the files and trigger plagiarism plugin, if enabled, to scan the uploaded files via events trigger
 177      *
 178      * @param stdClass $submission
 179      * @param stdClass $data
 180      * @return bool
 181      */
 182     public function save(stdClass $submission, stdClass $data) {
 183         global $USER, $DB;
 184
 185         $fileoptions = $this->get_file_options();
 186
 187
 188         $data = file_postupdate_standard_filemanager($data, 'files', $fileoptions, $this->assignment->get_context(), 'assignsubmission_file', ASSIGNSUBMISSION_FILE_FILEAREA, $submission->id);
 189
 190
 191         $filesubmission = $this->get_file_submission($submission->id);
 192
 193         //plagiarism code event trigger when files are uploaded
 194
 195         $fs = get_file_storage();
 196         $files = $fs->get_area_files($this->assignment->get_context()->id, 'assignsubmission_file', ASSIGNSUBMISSION_FILE_FILEAREA, $submission->id, "id", false);
 197         $count = $this->count_files($submission->id, ASSIGNSUBMISSION_FILE_FILEAREA);
 198         // send files to event system
 199         // Let Moodle know that an assessable file was uploaded (eg for plagiarism detection)
 200         $eventdata = new stdClass();
 201         $eventdata->modulename = 'assign';
 202         $eventdata->cmid = $this->assignment->get_course_module()->id;
 203         $eventdata->itemid = $submission->id;
 204         $eventdata->courseid = $this->assignment->get_course()->id;
 205         $eventdata->userid = $USER->id;
 206         if ($count > 1) {
 207             $eventdata->files = $files; // This is depreceated - please use pathnamehashes instead!
 208         }
 209         $eventdata->file = $files; // This is depreceated - please use pathnamehashes instead!
 210         $eventdata->pathnamehashes = array_keys($files);
 211         events_trigger('assessable_file_uploaded', $eventdata);
 212
 213
 214         if ($filesubmission) {
 215             $filesubmission->numfiles = $this->count_files($submission->id, ASSIGNSUBMISSION_FILE_FILEAREA);
 216             return $DB->update_record('assignsubmission_file', $filesubmission);
 217         } else {
 218             $filesubmission = new stdClass();
 219             $filesubmission->numfiles = $this->count_files($submission->id, ASSIGNSUBMISSION_FILE_FILEAREA);
 220             $filesubmission->submission = $submission->id;
 221             $filesubmission->assignment = $this->assignment->get_instance()->id;
 222             return $DB->insert_record('assignsubmission_file', $filesubmission) > 0;
 223         }
 224     }
 225
 226     /**
 227      * Produce a list of files suitable for export that represent this feedback or submission
 228      *
 229      * @param stdClass $submission The submission
 230      * @return array - return an array of files indexed by filename
 231      */
 232     public function get_files(stdClass $submission) {
 233         $result = array();
 234         $fs = get_file_storage();
 235
 236         $files = $fs->get_area_files($this->assignment->get_context()->id, 'assignsubmission_file', ASSIGNSUBMISSION_FILE_FILEAREA, $submission->id, "timemodified", false);
 237
 238         foreach ($files as $file) {
 239             $result[$file->get_filename()] = $file;
 240         }
 241         return $result;
 242     }
 243
 244     /**
 245      * Display the list of files  in the submission status table
 246      *
 247      * @param stdClass $submission
 248      * @param bool $showviewlink Set this to true if the list of files is long
 249      * @return string
 250      */
 251     public function view_summary(stdClass $submission, & $showviewlink) {
 252         $count = $this->count_files($submission->id, ASSIGNSUBMISSION_FILE_FILEAREA);
 253
 254         // show we show a link to view all files for this plugin?
 255         $showviewlink = $count > ASSIGNSUBMISSION_FILE_MAXSUMMARYFILES;
 256         if ($count <= ASSIGNSUBMISSION_FILE_MAXSUMMARYFILES) {
 257             return $this->assignment->render_area_files('assignsubmission_file', ASSIGNSUBMISSION_FILE_FILEAREA, $submission->id);
 258         } else {
 259             return get_string('countfiles', 'assignsubmission_file', $count);
 260         }
 261     }
 262
 263     /**
 264      * No full submission view - the summary contains the list of files and that is the whole submission
 265      *
 266      * @param stdClass $submission
 267      * @return string
 268      */
 269     public function view(stdClass $submission) {
 270         return $this->assignment->render_area_files('assignsubmission_file', ASSIGNSUBMISSION_FILE_FILEAREA, $submission->id);
 271     }
 272
 273
 274
 275     /**
 276      * Return true if this plugin can upgrade an old Moodle 2.2 assignment of this type
 277      * and version.
 278      *
 279      * @param string $type
 280      * @param int $version
 281      * @return bool True if upgrade is possible
 282      */
 283     public function can_upgrade($type, $version) {
 284
 285         $uploadsingletype ='uploadsingle';
 286         $uploadtype ='upload';
 287
 288         if (($type == $uploadsingletype || $type == $uploadtype) && $version >= 2011112900) {
 289             return true;
 290         }
 291         return false;
 292     }
 293
 294
 295     /**
 296      * Upgrade the settings from the old assignment
 297      * to the new plugin based one
 298      *
 299      * @param context $oldcontext - the old assignment context
 300      * @param stdClass $oldassignment - the old assignment data record
 301      * @param string $log record log events here
 302      * @return bool Was it a success? (false will trigger rollback)
 303      */
 304     public function upgrade_settings(context $oldcontext,stdClass $oldassignment, & $log) {
 305         if ($oldassignment->assignmenttype == 'uploadsingle') {
 306             $this->set_config('maxfilesubmissions', 1);
 307             $this->set_config('maxsubmissionsizebytes', $oldassignment->maxbytes);
 308             return true;
 309         }else {
 310
 311             $this->set_config('maxfilesubmissions', $oldassignment->var1);
 312             $this->set_config('maxsubmissionsizebytes', $oldassignment->maxbytes);
 313             return true;
 314         }
 315
 316
 317
 318     }
 319
 320     /**
 321      * Upgrade the submission from the old assignment to the new one
 322      *
 323      * @param context $oldcontext The context of the old assignment
 324      * @param stdClass $oldassignment The data record for the old oldassignment
 325      * @param stdClass $oldsubmission The data record for the old submission
 326      * @param stdClass $submission The data record for the new submission
 327      * @param string $log Record upgrade messages in the log
 328      * @return bool true or false - false will trigger a rollback
 329      */
 330     public function upgrade(context $oldcontext, stdClass $oldassignment, stdClass $oldsubmission, stdClass $submission, & $log) {
 331         global $DB;
 332
 333         $filesubmission = new stdClass();
 334
 335         $filesubmission->numfiles = $oldsubmission->numfiles;
 336         $filesubmission->submission = $submission->id;
 337         $filesubmission->assignment = $this->assignment->get_instance()->id;
 338
 339         if (!$DB->insert_record('assignsubmission_file', $filesubmission) > 0) {
 340             $log .= get_string('couldnotconvertsubmission', 'mod_assign', $submission->userid);
 341             return false;
 342         }
 343
 344
 345
 346
 347         // now copy the area files
 348         $this->assignment->copy_area_files_for_upgrade($oldcontext->id,
 349                                                         'mod_assignment',
 350                                                         'submission',
 351                                                         $oldsubmission->id,
 352                                                         // New file area
 353                                                         $this->assignment->get_context()->id,
 354                                                         'assignsubmission_file',
 355                                                         ASSIGNSUBMISSION_FILE_FILEAREA,
 356                                                         $submission->id);
 357
 358
 359
 360
 361
 362         return true;
 363     }
 364
 365     /**
 366      * The assignment has been deleted - cleanup
 367      *
 368      * @return bool
 369      */
 370     public function delete_instance() {
 371         global $DB;
 372         // will throw exception on failure
 373         $DB->delete_records('assignsubmission_file', array('assignment'=>$this->assignment->get_instance()->id));
 374
 375         return true;
 376     }
 377
 378     /**
 379      * Formatting for log info
 380      *
 381      * @param stdClass $submission The submission
 382      *
 383      * @return string
 384      */
 385     public function format_for_log(stdClass $submission) {
 386         // format the info for each submission plugin add_to_log
 387         $filecount = $this->count_files($submission->id, ASSIGNSUBMISSION_FILE_FILEAREA);
 388         $fileloginfo = '';
 389         $fileloginfo .= ' the number of file(s) : ' . $filecount . " file(s).<br>";
 390
 391         return $fileloginfo;
 392     }
 393
 394     /**
 395      * Return true if there are no submission files
 396      * @param stdClass $submission
 397      */
 398     public function is_empty(stdClass $submission) {
 399         return $this->count_files($submission->id, ASSIGNSUBMISSION_FILE_FILEAREA) == 0;
 400     }
 401
 402     /**
 403      * Get file areas returns a list of areas this plugin stores files
 404      * @return array - An array of fileareas (keys) and descriptions (values)
 405      */
 406     public function get_file_areas() {
 407         return array(ASSIGNSUBMISSION_FILE_FILEAREA=>$this->get_name());
 408     }
 409
 410 }