MDL-59287 calendar_events: Update modules to create all events.
[moodle.git] / mod / feedback / 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/>.
17 /**
18  * Library of functions and constants for module feedback
19  * includes the main-part of feedback-functions
20  *
21  * @package mod_feedback
22  * @copyright Andreas Grabs
23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 /** Include eventslib.php */
29 require_once($CFG->libdir.'/eventslib.php');
30 // Include forms lib.
31 require_once($CFG->libdir.'/formslib.php');
33 define('FEEDBACK_ANONYMOUS_YES', 1);
34 define('FEEDBACK_ANONYMOUS_NO', 2);
35 define('FEEDBACK_MIN_ANONYMOUS_COUNT_IN_GROUP', 2);
36 define('FEEDBACK_DECIMAL', '.');
37 define('FEEDBACK_THOUSAND', ',');
38 define('FEEDBACK_RESETFORM_RESET', 'feedback_reset_data_');
39 define('FEEDBACK_RESETFORM_DROP', 'feedback_drop_feedback_');
40 define('FEEDBACK_MAX_PIX_LENGTH', '400'); //max. Breite des grafischen Balkens in der Auswertung
41 define('FEEDBACK_DEFAULT_PAGE_COUNT', 20);
43 // Event types.
44 define('FEEDBACK_EVENT_TYPE_OPEN', 'open');
45 define('FEEDBACK_EVENT_TYPE_CLOSE', 'close');
47 /**
48  * Returns all other caps used in module.
49  *
50  * @return array
51  */
52 function feedback_get_extra_capabilities() {
53     return array('moodle/site:accessallgroups');
54 }
56 /**
57  * @uses FEATURE_GROUPS
58  * @uses FEATURE_GROUPINGS
59  * @uses FEATURE_MOD_INTRO
60  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
61  * @uses FEATURE_GRADE_HAS_GRADE
62  * @uses FEATURE_GRADE_OUTCOMES
63  * @param string $feature FEATURE_xx constant for requested feature
64  * @return mixed True if module supports feature, null if doesn't know
65  */
66 function feedback_supports($feature) {
67     switch($feature) {
68         case FEATURE_GROUPS:                  return true;
69         case FEATURE_GROUPINGS:               return true;
70         case FEATURE_MOD_INTRO:               return true;
71         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
72         case FEATURE_COMPLETION_HAS_RULES:    return true;
73         case FEATURE_GRADE_HAS_GRADE:         return false;
74         case FEATURE_GRADE_OUTCOMES:          return false;
75         case FEATURE_BACKUP_MOODLE2:          return true;
76         case FEATURE_SHOW_DESCRIPTION:        return true;
78         default: return null;
79     }
80 }
82 /**
83  * this will create a new instance and return the id number
84  * of the new instance.
85  *
86  * @global object
87  * @param object $feedback the object given by mod_feedback_mod_form
88  * @return int
89  */
90 function feedback_add_instance($feedback) {
91     global $DB;
93     $feedback->timemodified = time();
94     $feedback->id = '';
96     if (empty($feedback->site_after_submit)) {
97         $feedback->site_after_submit = '';
98     }
100     //saving the feedback in db
101     $feedbackid = $DB->insert_record("feedback", $feedback);
103     $feedback->id = $feedbackid;
105     feedback_set_events($feedback);
107     if (!isset($feedback->coursemodule)) {
108         $cm = get_coursemodule_from_id('feedback', $feedback->id);
109         $feedback->coursemodule = $cm->id;
110     }
111     $context = context_module::instance($feedback->coursemodule);
113     if (!empty($feedback->completionexpected)) {
114         \core_completion\api::update_completion_date_event($feedback->coursemodule, 'feedback', $feedback->id,
115                 $feedback->completionexpected);
116     }
118     $editoroptions = feedback_get_editor_options();
120     // process the custom wysiwyg editor in page_after_submit
121     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
122         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
123                                                     'mod_feedback', 'page_after_submit',
124                                                     0, $editoroptions,
125                                                     $feedback->page_after_submit_editor['text']);
127         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
128     }
129     $DB->update_record('feedback', $feedback);
131     return $feedbackid;
134 /**
135  * this will update a given instance
136  *
137  * @global object
138  * @param object $feedback the object given by mod_feedback_mod_form
139  * @return boolean
140  */
141 function feedback_update_instance($feedback) {
142     global $DB;
144     $feedback->timemodified = time();
145     $feedback->id = $feedback->instance;
147     if (empty($feedback->site_after_submit)) {
148         $feedback->site_after_submit = '';
149     }
151     //save the feedback into the db
152     $DB->update_record("feedback", $feedback);
154     //create or update the new events
155     feedback_set_events($feedback);
156     $completionexpected = (!empty($feedback->completionexpected)) ? $feedback->completionexpected : null;
157     \core_completion\api::update_completion_date_event($feedback->coursemodule, 'feedback', $feedback->id, $completionexpected);
159     $context = context_module::instance($feedback->coursemodule);
161     $editoroptions = feedback_get_editor_options();
163     // process the custom wysiwyg editor in page_after_submit
164     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
165         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
166                                                     'mod_feedback', 'page_after_submit',
167                                                     0, $editoroptions,
168                                                     $feedback->page_after_submit_editor['text']);
170         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
171     }
172     $DB->update_record('feedback', $feedback);
174     return true;
177 /**
178  * Serves the files included in feedback items like label. Implements needed access control ;-)
179  *
180  * There are two situations in general where the files will be sent.
181  * 1) filearea = item, 2) filearea = template
182  *
183  * @package  mod_feedback
184  * @category files
185  * @param stdClass $course course object
186  * @param stdClass $cm course module object
187  * @param stdClass $context context object
188  * @param string $filearea file area
189  * @param array $args extra arguments
190  * @param bool $forcedownload whether or not force download
191  * @param array $options additional options affecting the file serving
192  * @return bool false if file not found, does not return if found - justsend the file
193  */
194 function feedback_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
195     global $CFG, $DB;
197     if ($filearea === 'item' or $filearea === 'template') {
198         $itemid = (int)array_shift($args);
199         //get the item what includes the file
200         if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
201             return false;
202         }
203         $feedbackid = $item->feedback;
204         $templateid = $item->template;
205     }
207     if ($filearea === 'page_after_submit' or $filearea === 'item') {
208         if (! $feedback = $DB->get_record("feedback", array("id"=>$cm->instance))) {
209             return false;
210         }
212         $feedbackid = $feedback->id;
214         //if the filearea is "item" so we check the permissions like view/complete the feedback
215         $canload = false;
216         //first check whether the user has the complete capability
217         if (has_capability('mod/feedback:complete', $context)) {
218             $canload = true;
219         }
221         //now we check whether the user has the view capability
222         if (has_capability('mod/feedback:view', $context)) {
223             $canload = true;
224         }
226         //if the feedback is on frontpage and anonymous and the fullanonymous is allowed
227         //so the file can be loaded too.
228         if (isset($CFG->feedback_allowfullanonymous)
229                     AND $CFG->feedback_allowfullanonymous
230                     AND $course->id == SITEID
231                     AND $feedback->anonymous == FEEDBACK_ANONYMOUS_YES ) {
232             $canload = true;
233         }
235         if (!$canload) {
236             return false;
237         }
238     } else if ($filearea === 'template') { //now we check files in templates
239         if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
240             return false;
241         }
243         //if the file is not public so the capability edititems has to be there
244         if (!$template->ispublic) {
245             if (!has_capability('mod/feedback:edititems', $context)) {
246                 return false;
247             }
248         } else { //on public templates, at least the user has to be logged in
249             if (!isloggedin()) {
250                 return false;
251             }
252         }
253     } else {
254         return false;
255     }
257     if ($context->contextlevel == CONTEXT_MODULE) {
258         if ($filearea !== 'item' and $filearea !== 'page_after_submit') {
259             return false;
260         }
261     }
263     if ($context->contextlevel == CONTEXT_COURSE || $context->contextlevel == CONTEXT_SYSTEM) {
264         if ($filearea !== 'template') {
265             return false;
266         }
267     }
269     $relativepath = implode('/', $args);
270     if ($filearea === 'page_after_submit') {
271         $fullpath = "/{$context->id}/mod_feedback/$filearea/$relativepath";
272     } else {
273         $fullpath = "/{$context->id}/mod_feedback/$filearea/{$item->id}/$relativepath";
274     }
276     $fs = get_file_storage();
278     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
279         return false;
280     }
282     // finally send the file
283     send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
285     return false;
288 /**
289  * this will delete a given instance.
290  * all referenced data also will be deleted
291  *
292  * @global object
293  * @param int $id the instanceid of feedback
294  * @return boolean
295  */
296 function feedback_delete_instance($id) {
297     global $DB;
299     //get all referenced items
300     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
302     //deleting all referenced items and values
303     if (is_array($feedbackitems)) {
304         foreach ($feedbackitems as $feedbackitem) {
305             $DB->delete_records("feedback_value", array("item"=>$feedbackitem->id));
306             $DB->delete_records("feedback_valuetmp", array("item"=>$feedbackitem->id));
307         }
308         if ($delitems = $DB->get_records("feedback_item", array("feedback"=>$id))) {
309             foreach ($delitems as $delitem) {
310                 feedback_delete_item($delitem->id, false);
311             }
312         }
313     }
315     //deleting the completeds
316     $DB->delete_records("feedback_completed", array("feedback"=>$id));
318     //deleting the unfinished completeds
319     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
321     //deleting old events
322     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
323     return $DB->delete_records("feedback", array("id"=>$id));
326 /**
327  * Return a small object with summary information about what a
328  * user has done with a given particular instance of this module
329  * Used for user activity reports.
330  * $return->time = the time they did it
331  * $return->info = a short text description
332  *
333  * @param stdClass $course
334  * @param stdClass $user
335  * @param cm_info|stdClass $mod
336  * @param stdClass $feedback
337  * @return stdClass
338  */
339 function feedback_user_outline($course, $user, $mod, $feedback) {
340     global $DB;
341     $outline = (object)['info' => '', 'time' => 0];
342     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
343         // Do not disclose any user info if feedback is anonymous.
344         return $outline;
345     }
346     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
347         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
348     $status = null;
349     $context = context_module::instance($mod->id);
350     if ($completed = $DB->get_record('feedback_completed', $params)) {
351         // User has completed feedback.
352         $outline->info = get_string('completed', 'feedback');
353         $outline->time = $completed->timemodified;
354     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
355         // User has started but not completed feedback.
356         $outline->info = get_string('started', 'feedback');
357         $outline->time = $completedtmp->timemodified;
358     } else if (has_capability('mod/feedback:complete', $context, $user)) {
359         // User has not started feedback but has capability to do so.
360         $outline->info = get_string('not_started', 'feedback');
361     }
363     return $outline;
366 /**
367  * Returns all users who has completed a specified feedback since a given time
368  * many thanks to Manolescu Dorel, who contributed these two functions
369  *
370  * @global object
371  * @global object
372  * @global object
373  * @global object
374  * @uses CONTEXT_MODULE
375  * @param array $activities Passed by reference
376  * @param int $index Passed by reference
377  * @param int $timemodified Timestamp
378  * @param int $courseid
379  * @param int $cmid
380  * @param int $userid
381  * @param int $groupid
382  * @return void
383  */
384 function feedback_get_recent_mod_activity(&$activities, &$index,
385                                           $timemodified, $courseid,
386                                           $cmid, $userid="", $groupid="") {
388     global $CFG, $COURSE, $USER, $DB;
390     if ($COURSE->id == $courseid) {
391         $course = $COURSE;
392     } else {
393         $course = $DB->get_record('course', array('id'=>$courseid));
394     }
396     $modinfo = get_fast_modinfo($course);
398     $cm = $modinfo->cms[$cmid];
400     $sqlargs = array();
402     $userfields = user_picture::fields('u', null, 'useridagain');
403     $sql = " SELECT fk . * , fc . * , $userfields
404                 FROM {feedback_completed} fc
405                     JOIN {feedback} fk ON fk.id = fc.feedback
406                     JOIN {user} u ON u.id = fc.userid ";
408     if ($groupid) {
409         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
410     }
412     $sql .= " WHERE fc.timemodified > ?
413                 AND fk.id = ?
414                 AND fc.anonymous_response = ?";
415     $sqlargs[] = $timemodified;
416     $sqlargs[] = $cm->instance;
417     $sqlargs[] = FEEDBACK_ANONYMOUS_NO;
419     if ($userid) {
420         $sql .= " AND u.id = ? ";
421         $sqlargs[] = $userid;
422     }
424     if ($groupid) {
425         $sql .= " AND gm.groupid = ? ";
426         $sqlargs[] = $groupid;
427     }
429     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
430         return;
431     }
433     $cm_context = context_module::instance($cm->id);
435     if (!has_capability('mod/feedback:view', $cm_context)) {
436         return;
437     }
439     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
440     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cm_context);
441     $groupmode       = groups_get_activity_groupmode($cm, $course);
443     $aname = format_string($cm->name, true);
444     foreach ($feedbackitems as $feedbackitem) {
445         if ($feedbackitem->userid != $USER->id) {
447             if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
448                 $usersgroups = groups_get_all_groups($course->id,
449                                                      $feedbackitem->userid,
450                                                      $cm->groupingid);
451                 if (!is_array($usersgroups)) {
452                     continue;
453                 }
454                 $usersgroups = array_keys($usersgroups);
455                 $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
456                 if (empty($intersect)) {
457                     continue;
458                 }
459             }
460         }
462         $tmpactivity = new stdClass();
464         $tmpactivity->type      = 'feedback';
465         $tmpactivity->cmid      = $cm->id;
466         $tmpactivity->name      = $aname;
467         $tmpactivity->sectionnum= $cm->sectionnum;
468         $tmpactivity->timestamp = $feedbackitem->timemodified;
470         $tmpactivity->content = new stdClass();
471         $tmpactivity->content->feedbackid = $feedbackitem->id;
472         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
474         $tmpactivity->user = user_picture::unalias($feedbackitem, null, 'useridagain');
475         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
477         $activities[$index++] = $tmpactivity;
478     }
480     return;
483 /**
484  * Prints all users who has completed a specified feedback since a given time
485  * many thanks to Manolescu Dorel, who contributed these two functions
486  *
487  * @global object
488  * @param object $activity
489  * @param int $courseid
490  * @param string $detail
491  * @param array $modnames
492  * @return void Output is echo'd
493  */
494 function feedback_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
495     global $CFG, $OUTPUT;
497     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
499     echo "<tr><td class=\"userpicture\" valign=\"top\">";
500     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
501     echo "</td><td>";
503     if ($detail) {
504         $modname = $modnames[$activity->type];
505         echo '<div class="title">';
506         echo $OUTPUT->image_icon('icon', $modname, $activity->type);
507         echo "<a href=\"$CFG->wwwroot/mod/feedback/view.php?id={$activity->cmid}\">{$activity->name}</a>";
508         echo '</div>';
509     }
511     echo '<div class="title">';
512     echo '</div>';
514     echo '<div class="user">';
515     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&amp;course=$courseid\">"
516          ."{$activity->user->fullname}</a> - ".userdate($activity->timestamp);
517     echo '</div>';
519     echo "</td></tr></table>";
521     return;
524 /**
525  * Obtains the automatic completion state for this feedback based on the condition
526  * in feedback settings.
527  *
528  * @param object $course Course
529  * @param object $cm Course-module
530  * @param int $userid User ID
531  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
532  * @return bool True if completed, false if not, $type if conditions not set.
533  */
534 function feedback_get_completion_state($course, $cm, $userid, $type) {
535     global $CFG, $DB;
537     // Get feedback details
538     $feedback = $DB->get_record('feedback', array('id'=>$cm->instance), '*', MUST_EXIST);
540     // If completion option is enabled, evaluate it and return true/false
541     if ($feedback->completionsubmit) {
542         $params = array('userid'=>$userid, 'feedback'=>$feedback->id);
543         return $DB->record_exists('feedback_completed', $params);
544     } else {
545         // Completion option is not enabled so just return $type
546         return $type;
547     }
550 /**
551  * Print a detailed representation of what a  user has done with
552  * a given particular instance of this module, for user activity reports.
553  *
554  * @param stdClass $course
555  * @param stdClass $user
556  * @param cm_info|stdClass $mod
557  * @param stdClass $feedback
558  */
559 function feedback_user_complete($course, $user, $mod, $feedback) {
560     global $DB;
561     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
562         // Do not disclose any user info if feedback is anonymous.
563         return;
564     }
565     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
566         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
567     $url = $status = null;
568     $context = context_module::instance($mod->id);
569     if ($completed = $DB->get_record('feedback_completed', $params)) {
570         // User has completed feedback.
571         if (has_capability('mod/feedback:viewreports', $context)) {
572             $url = new moodle_url('/mod/feedback/show_entries.php',
573                 ['id' => $mod->id, 'userid' => $user->id,
574                     'showcompleted' => $completed->id]);
575         }
576         $status = get_string('completedon', 'feedback', userdate($completed->timemodified));
577     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
578         // User has started but not completed feedback.
579         $status = get_string('startedon', 'feedback', userdate($completedtmp->timemodified));
580     } else if (has_capability('mod/feedback:complete', $context, $user)) {
581         // User has not started feedback but has capability to do so.
582         $status = get_string('not_started', 'feedback');
583     }
585     if ($url && $status) {
586         echo html_writer::link($url, $status);
587     } else if ($status) {
588         echo html_writer::div($status);
589     }
592 /**
593  * @return bool true
594  */
595 function feedback_cron () {
596     return true;
599 /**
600  * @return bool false
601  */
602 function feedback_scale_used ($feedbackid, $scaleid) {
603     return false;
606 /**
607  * Checks if scale is being used by any instance of feedback
608  *
609  * This is used to find out if scale used anywhere
610  * @param $scaleid int
611  * @return boolean True if the scale is used by any assignment
612  */
613 function feedback_scale_used_anywhere($scaleid) {
614     return false;
617 /**
618  * List the actions that correspond to a view of this module.
619  * This is used by the participation report.
620  *
621  * Note: This is not used by new logging system. Event with
622  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
623  *       be considered as view action.
624  *
625  * @return array
626  */
627 function feedback_get_view_actions() {
628     return array('view', 'view all');
631 /**
632  * List the actions that correspond to a post of this module.
633  * This is used by the participation report.
634  *
635  * Note: This is not used by new logging system. Event with
636  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
637  *       will be considered as post action.
638  *
639  * @return array
640  */
641 function feedback_get_post_actions() {
642     return array('submit');
645 /**
646  * This function is used by the reset_course_userdata function in moodlelib.
647  * This function will remove all responses from the specified feedback
648  * and clean up any related data.
649  *
650  * @global object
651  * @global object
652  * @uses FEEDBACK_RESETFORM_RESET
653  * @uses FEEDBACK_RESETFORM_DROP
654  * @param object $data the data submitted from the reset course.
655  * @return array status array
656  */
657 function feedback_reset_userdata($data) {
658     global $CFG, $DB;
660     $resetfeedbacks = array();
661     $dropfeedbacks = array();
662     $status = array();
663     $componentstr = get_string('modulenameplural', 'feedback');
665     //get the relevant entries from $data
666     foreach ($data as $key => $value) {
667         switch(true) {
668             case substr($key, 0, strlen(FEEDBACK_RESETFORM_RESET)) == FEEDBACK_RESETFORM_RESET:
669                 if ($value == 1) {
670                     $templist = explode('_', $key);
671                     if (isset($templist[3])) {
672                         $resetfeedbacks[] = intval($templist[3]);
673                     }
674                 }
675             break;
676             case substr($key, 0, strlen(FEEDBACK_RESETFORM_DROP)) == FEEDBACK_RESETFORM_DROP:
677                 if ($value == 1) {
678                     $templist = explode('_', $key);
679                     if (isset($templist[3])) {
680                         $dropfeedbacks[] = intval($templist[3]);
681                     }
682                 }
683             break;
684         }
685     }
687     //reset the selected feedbacks
688     foreach ($resetfeedbacks as $id) {
689         $feedback = $DB->get_record('feedback', array('id'=>$id));
690         feedback_delete_all_completeds($feedback);
691         $status[] = array('component'=>$componentstr.':'.$feedback->name,
692                         'item'=>get_string('resetting_data', 'feedback'),
693                         'error'=>false);
694     }
696     // Updating dates - shift may be negative too.
697     if ($data->timeshift) {
698         $shifterror = !shift_course_mod_dates('feedback', array('timeopen', 'timeclose'), $data->timeshift, $data->courseid);
699         $status[] = array('component' => $componentstr, 'item' => get_string('datechanged'), 'error' => $shifterror);
700     }
702     return $status;
705 /**
706  * Called by course/reset.php
707  *
708  * @global object
709  * @uses FEEDBACK_RESETFORM_RESET
710  * @param object $mform form passed by reference
711  */
712 function feedback_reset_course_form_definition(&$mform) {
713     global $COURSE, $DB;
715     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
717     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')) {
718         return;
719     }
721     $mform->addElement('static', 'hint', get_string('resetting_data', 'feedback'));
722     foreach ($feedbacks as $feedback) {
723         $mform->addElement('checkbox', FEEDBACK_RESETFORM_RESET.$feedback->id, $feedback->name);
724     }
727 /**
728  * Course reset form defaults.
729  *
730  * @global object
731  * @uses FEEDBACK_RESETFORM_RESET
732  * @param object $course
733  */
734 function feedback_reset_course_form_defaults($course) {
735     global $DB;
737     $return = array();
738     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
739         return;
740     }
741     foreach ($feedbacks as $feedback) {
742         $return[FEEDBACK_RESETFORM_RESET.$feedback->id] = true;
743     }
744     return $return;
747 /**
748  * Called by course/reset.php and shows the formdata by coursereset.
749  * it prints checkboxes for each feedback available at the given course
750  * there are two checkboxes:
751  * 1) delete userdata and keep the feedback
752  * 2) delete userdata and drop the feedback
753  *
754  * @global object
755  * @uses FEEDBACK_RESETFORM_RESET
756  * @uses FEEDBACK_RESETFORM_DROP
757  * @param object $course
758  * @return void
759  */
760 function feedback_reset_course_form($course) {
761     global $DB, $OUTPUT;
763     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
764     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
765         return;
766     }
768     foreach ($feedbacks as $feedback) {
769         echo '<p>';
770         echo get_string('name', 'feedback').': '.$feedback->name.'<br />';
771         echo html_writer::checkbox(FEEDBACK_RESETFORM_RESET.$feedback->id,
772                                 1, true,
773                                 get_string('resetting_data', 'feedback'));
774         echo '<br />';
775         echo html_writer::checkbox(FEEDBACK_RESETFORM_DROP.$feedback->id,
776                                 1, false,
777                                 get_string('drop_feedback', 'feedback'));
778         echo '</p>';
779     }
782 /**
783  * This gets an array with default options for the editor
784  *
785  * @return array the options
786  */
787 function feedback_get_editor_options() {
788     return array('maxfiles' => EDITOR_UNLIMITED_FILES,
789                 'trusttext'=>true);
792 /**
793  * This creates new events given as timeopen and closeopen by $feedback.
794  *
795  * @global object
796  * @param object $feedback
797  * @return void
798  */
799 function feedback_set_events($feedback) {
800     global $DB, $CFG;
802     // Include calendar/lib.php.
803     require_once($CFG->dirroot.'/calendar/lib.php');
805     // Get CMID if not sent as part of $feedback.
806     if (!isset($feedback->coursemodule)) {
807         $cm = get_coursemodule_from_instance('feedback', $feedback->id, $feedback->course);
808         $feedback->coursemodule = $cm->id;
809     }
811     // Feedback start calendar events.
812     $eventid = $DB->get_field('event', 'id',
813             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => FEEDBACK_EVENT_TYPE_OPEN));
815     if (isset($feedback->timeopen) && $feedback->timeopen > 0) {
816         $event = new stdClass();
817         $event->eventtype    = FEEDBACK_EVENT_TYPE_OPEN;
818         $event->type         = empty($feedback->timeclose) ? CALENDAR_EVENT_TYPE_ACTION : CALENDAR_EVENT_TYPE_STANDARD;
819         $event->name         = get_string('calendarstart', 'feedback', $feedback->name);
820         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
821         $event->timestart    = $feedback->timeopen;
822         $event->timesort     = $feedback->timeopen;
823         $event->visible      = instance_is_visible('feedback', $feedback);
824         $event->timeduration = 0;
825         if ($eventid) {
826             // Calendar event exists so update it.
827             $event->id = $eventid;
828             $calendarevent = calendar_event::load($event->id);
829             $calendarevent->update($event);
830         } else {
831             // Event doesn't exist so create one.
832             $event->courseid     = $feedback->course;
833             $event->groupid      = 0;
834             $event->userid       = 0;
835             $event->modulename   = 'feedback';
836             $event->instance     = $feedback->id;
837             $event->eventtype    = FEEDBACK_EVENT_TYPE_OPEN;
838             calendar_event::create($event);
839         }
840     } else if ($eventid) {
841         // Calendar event is on longer needed.
842         $calendarevent = calendar_event::load($eventid);
843         $calendarevent->delete();
844     }
846     // Feedback close calendar events.
847     $eventid = $DB->get_field('event', 'id',
848             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => FEEDBACK_EVENT_TYPE_CLOSE));
850     if (isset($feedback->timeclose) && $feedback->timeclose > 0) {
851         $event = new stdClass();
852         $event->type         = CALENDAR_EVENT_TYPE_ACTION;
853         $event->eventtype    = FEEDBACK_EVENT_TYPE_CLOSE;
854         $event->name         = get_string('calendarend', 'feedback', $feedback->name);
855         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
856         $event->timestart    = $feedback->timeclose;
857         $event->timesort     = $feedback->timeclose;
858         $event->visible      = instance_is_visible('feedback', $feedback);
859         $event->timeduration = 0;
860         if ($eventid) {
861             // Calendar event exists so update it.
862             $event->id = $eventid;
863             $calendarevent = calendar_event::load($event->id);
864             $calendarevent->update($event);
865         } else {
866             // Event doesn't exist so create one.
867             $event->courseid     = $feedback->course;
868             $event->groupid      = 0;
869             $event->userid       = 0;
870             $event->modulename   = 'feedback';
871             $event->instance     = $feedback->id;
872             calendar_event::create($event);
873         }
874     } else if ($eventid) {
875         // Calendar event is on longer needed.
876         $calendarevent = calendar_event::load($eventid);
877         $calendarevent->delete();
878     }
881 /**
882  * This standard function will check all instances of this module
883  * and make sure there are up-to-date events created for each of them.
884  * If courseid = 0, then every feedback event in the site is checked, else
885  * only feedback events belonging to the course specified are checked.
886  * This function is used, in its new format, by restore_refresh_events()
887  *
888  * @param int $courseid
889  * @param int|stdClass $instance Feedback module instance or ID.
890  * @param int|stdClass $cm Course module object or ID (not used in this module).
891  * @return bool
892  */
893 function feedback_refresh_events($courseid = 0, $instance = null, $cm = null) {
894     global $DB;
896     // If we have instance information then we can just update the one event instead of updating all events.
897     if (isset($instance)) {
898         if (!is_object($instance)) {
899             $instance = $DB->get_record('feedback', array('id' => $instance), '*', MUST_EXIST);
900         }
901         feedback_set_events($instance);
902         return true;
903     }
905     if ($courseid) {
906         if (! $feedbacks = $DB->get_records("feedback", array("course" => $courseid))) {
907             return true;
908         }
909     } else {
910         if (! $feedbacks = $DB->get_records("feedback")) {
911             return true;
912         }
913     }
915     foreach ($feedbacks as $feedback) {
916         feedback_set_events($feedback);
917     }
918     return true;
921 /**
922  * this function is called by {@link feedback_delete_userdata()}
923  * it drops the feedback-instance from the course_module table
924  *
925  * @global object
926  * @param int $id the id from the coursemodule
927  * @return boolean
928  */
929 function feedback_delete_course_module($id) {
930     global $DB;
932     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
933         return true;
934     }
935     return $DB->delete_records('course_modules', array('id'=>$cm->id));
940 ////////////////////////////////////////////////
941 //functions to handle capabilities
942 ////////////////////////////////////////////////
944 /**
945  * returns the context-id related to the given coursemodule-id
946  *
947  * @deprecated since 3.1
948  * @staticvar object $context
949  * @param int $cmid the coursemodule-id
950  * @return object $context
951  */
952 function feedback_get_context($cmid) {
953     debugging('Function feedback_get_context() is deprecated because it was not used.',
954             DEBUG_DEVELOPER);
955     static $context;
957     if (isset($context)) {
958         return $context;
959     }
961     $context = context_module::instance($cmid);
962     return $context;
965 /**
966  *  returns true if the current role is faked by switching role feature
967  *
968  * @global object
969  * @return boolean
970  */
971 function feedback_check_is_switchrole() {
972     global $USER;
973     if (isset($USER->switchrole) AND
974             is_array($USER->switchrole) AND
975             count($USER->switchrole) > 0) {
977         return true;
978     }
979     return false;
982 /**
983  * count users which have not completed the feedback
984  *
985  * @global object
986  * @uses CONTEXT_MODULE
987  * @param cm_info $cm Course-module object
988  * @param int $group single groupid
989  * @param string $sort
990  * @param int $startpage
991  * @param int $pagecount
992  * @param bool $includestatus to return if the user started or not the feedback among the complete user record
993  * @return array array of user ids or user objects when $includestatus set to true
994  */
995 function feedback_get_incomplete_users(cm_info $cm,
996                                        $group = false,
997                                        $sort = '',
998                                        $startpage = false,
999                                        $pagecount = false,
1000                                        $includestatus = false) {
1002     global $DB;
1004     $context = context_module::instance($cm->id);
1006     //first get all user who can complete this feedback
1007     $cap = 'mod/feedback:complete';
1008     $allnames = get_all_user_name_fields(true, 'u');
1009     $fields = 'u.id, ' . $allnames . ', u.picture, u.email, u.imagealt';
1010     if (!$allusers = get_users_by_capability($context,
1011                                             $cap,
1012                                             $fields,
1013                                             $sort,
1014                                             '',
1015                                             '',
1016                                             $group,
1017                                             '',
1018                                             true)) {
1019         return false;
1020     }
1021     // Filter users that are not in the correct group/grouping.
1022     $info = new \core_availability\info_module($cm);
1023     $allusersrecords = $info->filter_user_list($allusers);
1025     $allusers = array_keys($allusersrecords);
1027     //now get all completeds
1028     $params = array('feedback'=>$cm->instance);
1029     if ($completedusers = $DB->get_records_menu('feedback_completed', $params, '', 'id, userid')) {
1030         // Now strike all completedusers from allusers.
1031         $allusers = array_diff($allusers, $completedusers);
1032     }
1034     //for paging I use array_slice()
1035     if ($startpage !== false AND $pagecount !== false) {
1036         $allusers = array_slice($allusers, $startpage, $pagecount);
1037     }
1039     // Check if we should return the full users objects.
1040     if ($includestatus) {
1041         $userrecords = [];
1042         $startedusers = $DB->get_records_menu('feedback_completedtmp', ['feedback' => $cm->instance], '', 'id, userid');
1043         $startedusers = array_flip($startedusers);
1044         foreach ($allusers as $userid) {
1045             $allusersrecords[$userid]->feedbackstarted = isset($startedusers[$userid]);
1046             $userrecords[] = $allusersrecords[$userid];
1047         }
1048         return $userrecords;
1049     } else {    // Return just user ids.
1050         return $allusers;
1051     }
1054 /**
1055  * count users which have not completed the feedback
1056  *
1057  * @global object
1058  * @param object $cm
1059  * @param int $group single groupid
1060  * @return int count of userrecords
1061  */
1062 function feedback_count_incomplete_users($cm, $group = false) {
1063     if ($allusers = feedback_get_incomplete_users($cm, $group)) {
1064         return count($allusers);
1065     }
1066     return 0;
1069 /**
1070  * count users which have completed a feedback
1071  *
1072  * @global object
1073  * @uses FEEDBACK_ANONYMOUS_NO
1074  * @param object $cm
1075  * @param int $group single groupid
1076  * @return int count of userrecords
1077  */
1078 function feedback_count_complete_users($cm, $group = false) {
1079     global $DB;
1081     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
1083     $fromgroup = '';
1084     $wheregroup = '';
1085     if ($group) {
1086         $fromgroup = ', {groups_members} g';
1087         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
1088         $params[] = $group;
1089     }
1091     $sql = 'SELECT COUNT(u.id) FROM {user} u, {feedback_completed} c'.$fromgroup.'
1092               WHERE anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
1093               '.$wheregroup;
1095     return $DB->count_records_sql($sql, $params);
1099 /**
1100  * get users which have completed a feedback
1101  *
1102  * @global object
1103  * @uses CONTEXT_MODULE
1104  * @uses FEEDBACK_ANONYMOUS_NO
1105  * @param object $cm
1106  * @param int $group single groupid
1107  * @param string $where a sql where condition (must end with " AND ")
1108  * @param array parameters used in $where
1109  * @param string $sort a table field
1110  * @param int $startpage
1111  * @param int $pagecount
1112  * @return object the userrecords
1113  */
1114 function feedback_get_complete_users($cm,
1115                                      $group = false,
1116                                      $where = '',
1117                                      array $params = null,
1118                                      $sort = '',
1119                                      $startpage = false,
1120                                      $pagecount = false) {
1122     global $DB;
1124     $context = context_module::instance($cm->id);
1126     $params = (array)$params;
1128     $params['anon'] = FEEDBACK_ANONYMOUS_NO;
1129     $params['instance'] = $cm->instance;
1131     $fromgroup = '';
1132     $wheregroup = '';
1133     if ($group) {
1134         $fromgroup = ', {groups_members} g';
1135         $wheregroup = ' AND g.groupid = :group AND g.userid = c.userid';
1136         $params['group'] = $group;
1137     }
1139     if ($sort) {
1140         $sortsql = ' ORDER BY '.$sort;
1141     } else {
1142         $sortsql = '';
1143     }
1145     $ufields = user_picture::fields('u');
1146     $sql = 'SELECT DISTINCT '.$ufields.', c.timemodified as completed_timemodified
1147             FROM {user} u, {feedback_completed} c '.$fromgroup.'
1148             WHERE '.$where.' anonymous_response = :anon
1149                 AND u.id = c.userid
1150                 AND c.feedback = :instance
1151               '.$wheregroup.$sortsql;
1153     if ($startpage === false OR $pagecount === false) {
1154         $startpage = false;
1155         $pagecount = false;
1156     }
1157     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
1160 /**
1161  * get users which have the viewreports-capability
1162  *
1163  * @uses CONTEXT_MODULE
1164  * @param int $cmid
1165  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1166  * @return object the userrecords
1167  */
1168 function feedback_get_viewreports_users($cmid, $groups = false) {
1170     $context = context_module::instance($cmid);
1172     //description of the call below:
1173     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1174     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1175     return get_users_by_capability($context,
1176                             'mod/feedback:viewreports',
1177                             '',
1178                             'lastname',
1179                             '',
1180                             '',
1181                             $groups,
1182                             '',
1183                             false);
1186 /**
1187  * get users which have the receivemail-capability
1188  *
1189  * @uses CONTEXT_MODULE
1190  * @param int $cmid
1191  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1192  * @return object the userrecords
1193  */
1194 function feedback_get_receivemail_users($cmid, $groups = false) {
1196     $context = context_module::instance($cmid);
1198     //description of the call below:
1199     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1200     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1201     return get_users_by_capability($context,
1202                             'mod/feedback:receivemail',
1203                             '',
1204                             'lastname',
1205                             '',
1206                             '',
1207                             $groups,
1208                             '',
1209                             false);
1212 ////////////////////////////////////////////////
1213 //functions to handle the templates
1214 ////////////////////////////////////////////////
1215 ////////////////////////////////////////////////
1217 /**
1218  * creates a new template-record.
1219  *
1220  * @global object
1221  * @param int $courseid
1222  * @param string $name the name of template shown in the templatelist
1223  * @param int $ispublic 0:privat 1:public
1224  * @return int the new templateid
1225  */
1226 function feedback_create_template($courseid, $name, $ispublic = 0) {
1227     global $DB;
1229     $templ = new stdClass();
1230     $templ->course   = ($ispublic ? 0 : $courseid);
1231     $templ->name     = $name;
1232     $templ->ispublic = $ispublic;
1234     $templid = $DB->insert_record('feedback_template', $templ);
1235     return $DB->get_record('feedback_template', array('id'=>$templid));
1238 /**
1239  * creates new template items.
1240  * all items will be copied and the attribute feedback will be set to 0
1241  * and the attribute template will be set to the new templateid
1242  *
1243  * @global object
1244  * @uses CONTEXT_MODULE
1245  * @uses CONTEXT_COURSE
1246  * @param object $feedback
1247  * @param string $name the name of template shown in the templatelist
1248  * @param int $ispublic 0:privat 1:public
1249  * @return boolean
1250  */
1251 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
1252     global $DB;
1253     $fs = get_file_storage();
1255     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1256         return false;
1257     }
1259     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
1260         return false;
1261     }
1263     //files in the template_item are in the context of the current course or
1264     //if the template is public the files are in the system context
1265     //files in the feedback_item are in the feedback_context of the feedback
1266     if ($ispublic) {
1267         $s_context = context_system::instance();
1268     } else {
1269         $s_context = context_course::instance($newtempl->course);
1270     }
1271     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1272     $f_context = context_module::instance($cm->id);
1274     //create items of this new template
1275     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1276     //we also store a mapping of all items array(oldid => newid)
1277     $dependitemsmap = array();
1278     $itembackup = array();
1279     foreach ($feedbackitems as $item) {
1281         $t_item = clone($item);
1283         unset($t_item->id);
1284         $t_item->feedback = 0;
1285         $t_item->template     = $newtempl->id;
1286         $t_item->id = $DB->insert_record('feedback_item', $t_item);
1287         //copy all included files to the feedback_template filearea
1288         $itemfiles = $fs->get_area_files($f_context->id,
1289                                     'mod_feedback',
1290                                     'item',
1291                                     $item->id,
1292                                     "id",
1293                                     false);
1294         if ($itemfiles) {
1295             foreach ($itemfiles as $ifile) {
1296                 $file_record = new stdClass();
1297                 $file_record->contextid = $s_context->id;
1298                 $file_record->component = 'mod_feedback';
1299                 $file_record->filearea = 'template';
1300                 $file_record->itemid = $t_item->id;
1301                 $fs->create_file_from_storedfile($file_record, $ifile);
1302             }
1303         }
1305         $itembackup[$item->id] = $t_item->id;
1306         if ($t_item->dependitem) {
1307             $dependitemsmap[$t_item->id] = $t_item->dependitem;
1308         }
1310     }
1312     //remapping the dependency
1313     foreach ($dependitemsmap as $key => $dependitem) {
1314         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1315         $newitem->dependitem = $itembackup[$newitem->dependitem];
1316         $DB->update_record('feedback_item', $newitem);
1317     }
1319     return true;
1322 /**
1323  * deletes all feedback_items related to the given template id
1324  *
1325  * @global object
1326  * @uses CONTEXT_COURSE
1327  * @param object $template the template
1328  * @return void
1329  */
1330 function feedback_delete_template($template) {
1331     global $DB;
1333     //deleting the files from the item is done by feedback_delete_item
1334     if ($t_items = $DB->get_records("feedback_item", array("template"=>$template->id))) {
1335         foreach ($t_items as $t_item) {
1336             feedback_delete_item($t_item->id, false, $template);
1337         }
1338     }
1339     $DB->delete_records("feedback_template", array("id"=>$template->id));
1342 /**
1343  * creates new feedback_item-records from template.
1344  * if $deleteold is set true so the existing items of the given feedback will be deleted
1345  * if $deleteold is set false so the new items will be appanded to the old items
1346  *
1347  * @global object
1348  * @uses CONTEXT_COURSE
1349  * @uses CONTEXT_MODULE
1350  * @param object $feedback
1351  * @param int $templateid
1352  * @param boolean $deleteold
1353  */
1354 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1355     global $DB, $CFG;
1357     require_once($CFG->libdir.'/completionlib.php');
1359     $fs = get_file_storage();
1361     if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
1362         return false;
1363     }
1364     //get all templateitems
1365     if (!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1366         return false;
1367     }
1369     //files in the template_item are in the context of the current course
1370     //files in the feedback_item are in the feedback_context of the feedback
1371     if ($template->ispublic) {
1372         $s_context = context_system::instance();
1373     } else {
1374         $s_context = context_course::instance($feedback->course);
1375     }
1376     $course = $DB->get_record('course', array('id'=>$feedback->course));
1377     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1378     $f_context = context_module::instance($cm->id);
1380     //if deleteold then delete all old items before
1381     //get all items
1382     if ($deleteold) {
1383         if ($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1384             //delete all items of this feedback
1385             foreach ($feedbackitems as $item) {
1386                 feedback_delete_item($item->id, false);
1387             }
1389             $params = array('feedback'=>$feedback->id);
1390             if ($completeds = $DB->get_records('feedback_completed', $params)) {
1391                 $completion = new completion_info($course);
1392                 foreach ($completeds as $completed) {
1393                     $DB->delete_records('feedback_completed', array('id' => $completed->id));
1394                     // Update completion state
1395                     if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC &&
1396                             $feedback->completionsubmit) {
1397                         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1398                     }
1399                 }
1400             }
1401             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1402         }
1403         $positionoffset = 0;
1404     } else {
1405         //if the old items are kept the new items will be appended
1406         //therefor the new position has an offset
1407         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1408     }
1410     //create items of this new template
1411     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1412     //we also store a mapping of all items array(oldid => newid)
1413     $dependitemsmap = array();
1414     $itembackup = array();
1415     foreach ($templitems as $t_item) {
1416         $item = clone($t_item);
1417         unset($item->id);
1418         $item->feedback = $feedback->id;
1419         $item->template = 0;
1420         $item->position = $item->position + $positionoffset;
1422         $item->id = $DB->insert_record('feedback_item', $item);
1424         //moving the files to the new item
1425         $templatefiles = $fs->get_area_files($s_context->id,
1426                                         'mod_feedback',
1427                                         'template',
1428                                         $t_item->id,
1429                                         "id",
1430                                         false);
1431         if ($templatefiles) {
1432             foreach ($templatefiles as $tfile) {
1433                 $file_record = new stdClass();
1434                 $file_record->contextid = $f_context->id;
1435                 $file_record->component = 'mod_feedback';
1436                 $file_record->filearea = 'item';
1437                 $file_record->itemid = $item->id;
1438                 $fs->create_file_from_storedfile($file_record, $tfile);
1439             }
1440         }
1442         $itembackup[$t_item->id] = $item->id;
1443         if ($item->dependitem) {
1444             $dependitemsmap[$item->id] = $item->dependitem;
1445         }
1446     }
1448     //remapping the dependency
1449     foreach ($dependitemsmap as $key => $dependitem) {
1450         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1451         $newitem->dependitem = $itembackup[$newitem->dependitem];
1452         $DB->update_record('feedback_item', $newitem);
1453     }
1456 /**
1457  * get the list of available templates.
1458  * if the $onlyown param is set true so only templates from own course will be served
1459  * this is important for droping templates
1460  *
1461  * @global object
1462  * @param object $course
1463  * @param string $onlyownorpublic
1464  * @return array the template recordsets
1465  */
1466 function feedback_get_template_list($course, $onlyownorpublic = '') {
1467     global $DB, $CFG;
1469     switch($onlyownorpublic) {
1470         case '':
1471             $templates = $DB->get_records_select('feedback_template',
1472                                                  'course = ? OR ispublic = 1',
1473                                                  array($course->id),
1474                                                  'name');
1475             break;
1476         case 'own':
1477             $templates = $DB->get_records('feedback_template',
1478                                           array('course'=>$course->id),
1479                                           'name');
1480             break;
1481         case 'public':
1482             $templates = $DB->get_records('feedback_template', array('ispublic'=>1), 'name');
1483             break;
1484     }
1485     return $templates;
1488 ////////////////////////////////////////////////
1489 //Handling der Items
1490 ////////////////////////////////////////////////
1491 ////////////////////////////////////////////////
1493 /**
1494  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1495  *
1496  * @param string $typ
1497  * @return feedback_item_base the instance of itemclass
1498  */
1499 function feedback_get_item_class($typ) {
1500     global $CFG;
1502     //get the class of item-typ
1503     $itemclass = 'feedback_item_'.$typ;
1504     //get the instance of item-class
1505     if (!class_exists($itemclass)) {
1506         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1507     }
1508     return new $itemclass();
1511 /**
1512  * load the available item plugins from given subdirectory of $CFG->dirroot
1513  * the default is "mod/feedback/item"
1514  *
1515  * @global object
1516  * @param string $dir the subdir
1517  * @return array pluginnames as string
1518  */
1519 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1520     global $CFG;
1521     $names = get_list_of_plugins($dir);
1522     $ret_names = array();
1524     foreach ($names as $name) {
1525         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1526         if (class_exists('feedback_item_'.$name)) {
1527             $ret_names[] = $name;
1528         }
1529     }
1530     return $ret_names;
1533 /**
1534  * load the available item plugins to use as dropdown-options
1535  *
1536  * @global object
1537  * @return array pluginnames as string
1538  */
1539 function feedback_load_feedback_items_options() {
1540     global $CFG;
1542     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1544     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1545         return array();
1546     }
1548     foreach ($feedback_names as $fn) {
1549         $feedback_options[$fn] = get_string($fn, 'feedback');
1550     }
1551     asort($feedback_options);
1552     return $feedback_options;
1555 /**
1556  * load the available items for the depend item dropdown list shown in the edit_item form
1557  *
1558  * @global object
1559  * @param object $feedback
1560  * @param object $item the item of the edit_item form
1561  * @return array all items except the item $item, labels and pagebreaks
1562  */
1563 function feedback_get_depend_candidates_for_item($feedback, $item) {
1564     global $DB;
1565     //all items for dependitem
1566     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1567     $params = array($feedback->id);
1568     if (isset($item->id) AND $item->id) {
1569         $where .= ' AND id != ?';
1570         $params[] = $item->id;
1571     }
1572     $dependitems = array(0 => get_string('choose'));
1573     $feedbackitems = $DB->get_records_select_menu('feedback_item',
1574                                                   $where,
1575                                                   $params,
1576                                                   'position',
1577                                                   'id, label');
1579     if (!$feedbackitems) {
1580         return $dependitems;
1581     }
1582     //adding the choose-option
1583     foreach ($feedbackitems as $key => $val) {
1584         if (trim(strval($val)) !== '') {
1585             $dependitems[$key] = format_string($val);
1586         }
1587     }
1588     return $dependitems;
1591 /**
1592  * creates a new item-record
1593  *
1594  * @deprecated since 3.1
1595  * @param object $data the data from edit_item_form
1596  * @return int the new itemid
1597  */
1598 function feedback_create_item($data) {
1599     debugging('Function feedback_create_item() is deprecated because it was not used.',
1600             DEBUG_DEVELOPER);
1601     global $DB;
1603     $item = new stdClass();
1604     $item->feedback = $data->feedbackid;
1606     $item->template=0;
1607     if (isset($data->templateid)) {
1608             $item->template = intval($data->templateid);
1609     }
1611     $itemname = trim($data->itemname);
1612     $item->name = ($itemname ? $data->itemname : get_string('no_itemname', 'feedback'));
1614     if (!empty($data->itemlabel)) {
1615         $item->label = trim($data->itemlabel);
1616     } else {
1617         $item->label = get_string('no_itemlabel', 'feedback');
1618     }
1620     $itemobj = feedback_get_item_class($data->typ);
1621     $item->presentation = ''; //the date comes from postupdate() of the itemobj
1623     $item->hasvalue = $itemobj->get_hasvalue();
1625     $item->typ = $data->typ;
1626     $item->position = $data->position;
1628     $item->required=0;
1629     if (!empty($data->required)) {
1630         $item->required = $data->required;
1631     }
1633     $item->id = $DB->insert_record('feedback_item', $item);
1635     //move all itemdata to the data
1636     $data->id = $item->id;
1637     $data->feedback = $item->feedback;
1638     $data->name = $item->name;
1639     $data->label = $item->label;
1640     $data->required = $item->required;
1641     return $itemobj->postupdate($data);
1644 /**
1645  * save the changes of a given item.
1646  *
1647  * @global object
1648  * @param object $item
1649  * @return boolean
1650  */
1651 function feedback_update_item($item) {
1652     global $DB;
1653     return $DB->update_record("feedback_item", $item);
1656 /**
1657  * deletes an item and also deletes all related values
1658  *
1659  * @global object
1660  * @uses CONTEXT_MODULE
1661  * @param int $itemid
1662  * @param boolean $renumber should the kept items renumbered Yes/No
1663  * @param object $template if the template is given so the items are bound to it
1664  * @return void
1665  */
1666 function feedback_delete_item($itemid, $renumber = true, $template = false) {
1667     global $DB;
1669     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1671     //deleting the files from the item
1672     $fs = get_file_storage();
1674     if ($template) {
1675         if ($template->ispublic) {
1676             $context = context_system::instance();
1677         } else {
1678             $context = context_course::instance($template->course);
1679         }
1680         $templatefiles = $fs->get_area_files($context->id,
1681                                     'mod_feedback',
1682                                     'template',
1683                                     $item->id,
1684                                     "id",
1685                                     false);
1687         if ($templatefiles) {
1688             $fs->delete_area_files($context->id, 'mod_feedback', 'template', $item->id);
1689         }
1690     } else {
1691         if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1692             return false;
1693         }
1694         $context = context_module::instance($cm->id);
1696         $itemfiles = $fs->get_area_files($context->id,
1697                                     'mod_feedback',
1698                                     'item',
1699                                     $item->id,
1700                                     "id", false);
1702         if ($itemfiles) {
1703             $fs->delete_area_files($context->id, 'mod_feedback', 'item', $item->id);
1704         }
1705     }
1707     $DB->delete_records("feedback_value", array("item"=>$itemid));
1708     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1710     //remove all depends
1711     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1712     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1714     $DB->delete_records("feedback_item", array("id"=>$itemid));
1715     if ($renumber) {
1716         feedback_renumber_items($item->feedback);
1717     }
1720 /**
1721  * deletes all items of the given feedbackid
1722  *
1723  * @global object
1724  * @param int $feedbackid
1725  * @return void
1726  */
1727 function feedback_delete_all_items($feedbackid) {
1728     global $DB, $CFG;
1729     require_once($CFG->libdir.'/completionlib.php');
1731     if (!$feedback = $DB->get_record('feedback', array('id'=>$feedbackid))) {
1732         return false;
1733     }
1735     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
1736         return false;
1737     }
1739     if (!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
1740         return false;
1741     }
1743     if (!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1744         return;
1745     }
1746     foreach ($items as $item) {
1747         feedback_delete_item($item->id, false);
1748     }
1749     if ($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1750         $completion = new completion_info($course);
1751         foreach ($completeds as $completed) {
1752             $DB->delete_records('feedback_completed', array('id' => $completed->id));
1753             // Update completion state
1754             if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC &&
1755                     $feedback->completionsubmit) {
1756                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1757             }
1758         }
1759     }
1761     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1765 /**
1766  * this function toggled the item-attribute required (yes/no)
1767  *
1768  * @global object
1769  * @param object $item
1770  * @return boolean
1771  */
1772 function feedback_switch_item_required($item) {
1773     global $DB, $CFG;
1775     $itemobj = feedback_get_item_class($item->typ);
1777     if ($itemobj->can_switch_require()) {
1778         $new_require_val = (int)!(bool)$item->required;
1779         $params = array('id'=>$item->id);
1780         $DB->set_field('feedback_item', 'required', $new_require_val, $params);
1781     }
1782     return true;
1785 /**
1786  * renumbers all items of the given feedbackid
1787  *
1788  * @global object
1789  * @param int $feedbackid
1790  * @return void
1791  */
1792 function feedback_renumber_items($feedbackid) {
1793     global $DB;
1795     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1796     $pos = 1;
1797     if ($items) {
1798         foreach ($items as $item) {
1799             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1800             $pos++;
1801         }
1802     }
1805 /**
1806  * this decreases the position of the given item
1807  *
1808  * @global object
1809  * @param object $item
1810  * @return bool
1811  */
1812 function feedback_moveup_item($item) {
1813     global $DB;
1815     if ($item->position == 1) {
1816         return true;
1817     }
1819     $params = array('feedback'=>$item->feedback);
1820     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1821         return false;
1822     }
1824     $itembefore = null;
1825     foreach ($items as $i) {
1826         if ($i->id == $item->id) {
1827             if (is_null($itembefore)) {
1828                 return true;
1829             }
1830             $itembefore->position = $item->position;
1831             $item->position--;
1832             feedback_update_item($itembefore);
1833             feedback_update_item($item);
1834             feedback_renumber_items($item->feedback);
1835             return true;
1836         }
1837         $itembefore = $i;
1838     }
1839     return false;
1842 /**
1843  * this increased the position of the given item
1844  *
1845  * @global object
1846  * @param object $item
1847  * @return bool
1848  */
1849 function feedback_movedown_item($item) {
1850     global $DB;
1852     $params = array('feedback'=>$item->feedback);
1853     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1854         return false;
1855     }
1857     $movedownitem = null;
1858     foreach ($items as $i) {
1859         if (!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1860             $movedownitem->position = $i->position;
1861             $i->position--;
1862             feedback_update_item($movedownitem);
1863             feedback_update_item($i);
1864             feedback_renumber_items($item->feedback);
1865             return true;
1866         }
1867         $movedownitem = $i;
1868     }
1869     return false;
1872 /**
1873  * here the position of the given item will be set to the value in $pos
1874  *
1875  * @global object
1876  * @param object $moveitem
1877  * @param int $pos
1878  * @return boolean
1879  */
1880 function feedback_move_item($moveitem, $pos) {
1881     global $DB;
1883     $params = array('feedback'=>$moveitem->feedback);
1884     if (!$allitems = $DB->get_records('feedback_item', $params, 'position')) {
1885         return false;
1886     }
1887     if (is_array($allitems)) {
1888         $index = 1;
1889         foreach ($allitems as $item) {
1890             if ($index == $pos) {
1891                 $index++;
1892             }
1893             if ($item->id == $moveitem->id) {
1894                 $moveitem->position = $pos;
1895                 feedback_update_item($moveitem);
1896                 continue;
1897             }
1898             $item->position = $index;
1899             feedback_update_item($item);
1900             $index++;
1901         }
1902         return true;
1903     }
1904     return false;
1907 /**
1908  * prints the given item as a preview.
1909  * each item-class has an own print_item_preview function implemented.
1910  *
1911  * @deprecated since Moodle 3.1
1912  * @global object
1913  * @param object $item the item what we want to print out
1914  * @return void
1915  */
1916 function feedback_print_item_preview($item) {
1917     debugging('Function feedback_print_item_preview() is deprecated and does nothing. '
1918             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
1921 /**
1922  * prints the given item in the completion form.
1923  * each item-class has an own print_item_complete function implemented.
1924  *
1925  * @deprecated since Moodle 3.1
1926  * @param object $item the item what we want to print out
1927  * @param mixed $value the value
1928  * @param boolean $highlightrequire if this set true and the value are false on completing so the item will be highlighted
1929  * @return void
1930  */
1931 function feedback_print_item_complete($item, $value = false, $highlightrequire = false) {
1932     debugging('Function feedback_print_item_complete() is deprecated and does nothing. '
1933             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
1936 /**
1937  * prints the given item in the show entries page.
1938  * each item-class has an own print_item_show_value function implemented.
1939  *
1940  * @deprecated since Moodle 3.1
1941  * @param object $item the item what we want to print out
1942  * @param mixed $value
1943  * @return void
1944  */
1945 function feedback_print_item_show_value($item, $value = false) {
1946     debugging('Function feedback_print_item_show_value() is deprecated and does nothing. '
1947             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
1950 /**
1951  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1952  * the values are not saved permanently until the user click on save button
1953  *
1954  * @global object
1955  * @param object $feedbackcompleted
1956  * @return object temporary saved completed-record
1957  */
1958 function feedback_set_tmp_values($feedbackcompleted) {
1959     global $DB;
1961     //first we create a completedtmp
1962     $tmpcpl = new stdClass();
1963     foreach ($feedbackcompleted as $key => $value) {
1964         $tmpcpl->{$key} = $value;
1965     }
1966     unset($tmpcpl->id);
1967     $tmpcpl->timemodified = time();
1968     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1969     //get all values of original-completed
1970     if (!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1971         return;
1972     }
1973     foreach ($values as $value) {
1974         unset($value->id);
1975         $value->completed = $tmpcpl->id;
1976         $DB->insert_record('feedback_valuetmp', $value);
1977     }
1978     return $tmpcpl;
1981 /**
1982  * this saves the temporary saved values permanently
1983  *
1984  * @global object
1985  * @param object $feedbackcompletedtmp the temporary completed
1986  * @param object $feedbackcompleted the target completed
1987  * @return int the id of the completed
1988  */
1989 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted) {
1990     global $DB;
1992     $tmpcplid = $feedbackcompletedtmp->id;
1993     if ($feedbackcompleted) {
1994         //first drop all existing values
1995         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1996         //update the current completed
1997         $feedbackcompleted->timemodified = time();
1998         $DB->update_record('feedback_completed', $feedbackcompleted);
1999     } else {
2000         $feedbackcompleted = clone($feedbackcompletedtmp);
2001         $feedbackcompleted->id = '';
2002         $feedbackcompleted->timemodified = time();
2003         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
2004     }
2006     $allitems = $DB->get_records('feedback_item', array('feedback' => $feedbackcompleted->feedback));
2008     //save all the new values from feedback_valuetmp
2009     //get all values of tmp-completed
2010     $params = array('completed'=>$feedbackcompletedtmp->id);
2011     $values = $DB->get_records('feedback_valuetmp', $params);
2012     foreach ($values as $value) {
2013         //check if there are depend items
2014         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
2015         if ($item->dependitem > 0 && isset($allitems[$item->dependitem])) {
2016             $check = feedback_compare_item_value($tmpcplid,
2017                                         $allitems[$item->dependitem],
2018                                         $item->dependvalue,
2019                                         true);
2020         } else {
2021             $check = true;
2022         }
2023         if ($check) {
2024             unset($value->id);
2025             $value->completed = $feedbackcompleted->id;
2026             $DB->insert_record('feedback_value', $value);
2027         }
2028     }
2029     //drop all the tmpvalues
2030     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
2031     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
2033     // Trigger event for the delete action we performed.
2034     $cm = get_coursemodule_from_instance('feedback', $feedbackcompleted->feedback);
2035     $event = \mod_feedback\event\response_submitted::create_from_record($feedbackcompleted, $cm);
2036     $event->trigger();
2037     return $feedbackcompleted->id;
2041 /**
2042  * deletes the given temporary completed and all related temporary values
2043  *
2044  * @deprecated since Moodle 3.1
2045  *
2046  * @param int $tmpcplid
2047  * @return void
2048  */
2049 function feedback_delete_completedtmp($tmpcplid) {
2050     global $DB;
2052     debugging('Function feedback_delete_completedtmp() is deprecated because it is no longer used',
2053             DEBUG_DEVELOPER);
2055     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
2056     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
2059 ////////////////////////////////////////////////
2060 ////////////////////////////////////////////////
2061 ////////////////////////////////////////////////
2062 //functions to handle the pagebreaks
2063 ////////////////////////////////////////////////
2065 /**
2066  * this creates a pagebreak.
2067  * a pagebreak is a special kind of item
2068  *
2069  * @global object
2070  * @param int $feedbackid
2071  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
2072  */
2073 function feedback_create_pagebreak($feedbackid) {
2074     global $DB;
2076     //check if there already is a pagebreak on the last position
2077     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
2078     if ($lastposition == feedback_get_last_break_position($feedbackid)) {
2079         return false;
2080     }
2082     $item = new stdClass();
2083     $item->feedback = $feedbackid;
2085     $item->template=0;
2087     $item->name = '';
2089     $item->presentation = '';
2090     $item->hasvalue = 0;
2092     $item->typ = 'pagebreak';
2093     $item->position = $lastposition + 1;
2095     $item->required=0;
2097     return $DB->insert_record('feedback_item', $item);
2100 /**
2101  * get all positions of pagebreaks in the given feedback
2102  *
2103  * @global object
2104  * @param int $feedbackid
2105  * @return array all ordered pagebreak positions
2106  */
2107 function feedback_get_all_break_positions($feedbackid) {
2108     global $DB;
2110     $params = array('typ'=>'pagebreak', 'feedback'=>$feedbackid);
2111     $allbreaks = $DB->get_records_menu('feedback_item', $params, 'position', 'id, position');
2112     if (!$allbreaks) {
2113         return false;
2114     }
2115     return array_values($allbreaks);
2118 /**
2119  * get the position of the last pagebreak
2120  *
2121  * @param int $feedbackid
2122  * @return int the position of the last pagebreak
2123  */
2124 function feedback_get_last_break_position($feedbackid) {
2125     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2126         return false;
2127     }
2128     return $allbreaks[count($allbreaks) - 1];
2131 /**
2132  * this returns the position where the user can continue the completing.
2133  *
2134  * @deprecated since Moodle 3.1
2135  * @global object
2136  * @global object
2137  * @global object
2138  * @param int $feedbackid
2139  * @param int $courseid
2140  * @param string $guestid this id will be saved temporary and is unique
2141  * @return int the position to continue
2142  */
2143 function feedback_get_page_to_continue($feedbackid, $courseid = false, $guestid = false) {
2144     global $CFG, $USER, $DB;
2146     debugging('Function feedback_get_page_to_continue() is deprecated and since it is '
2147             . 'no longer used in mod_feedback', DEBUG_DEVELOPER);
2149     //is there any break?
2151     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2152         return false;
2153     }
2155     $params = array();
2156     if ($courseid) {
2157         $courseselect = "AND fv.course_id = :courseid";
2158         $params['courseid'] = $courseid;
2159     } else {
2160         $courseselect = '';
2161     }
2163     if ($guestid) {
2164         $userselect = "AND fc.guestid = :guestid";
2165         $usergroup = "GROUP BY fc.guestid";
2166         $params['guestid'] = $guestid;
2167     } else {
2168         $userselect = "AND fc.userid = :userid";
2169         $usergroup = "GROUP BY fc.userid";
2170         $params['userid'] = $USER->id;
2171     }
2173     $sql =  "SELECT MAX(fi.position)
2174                FROM {feedback_completedtmp} fc, {feedback_valuetmp} fv, {feedback_item} fi
2175               WHERE fc.id = fv.completed
2176                     $userselect
2177                     AND fc.feedback = :feedbackid
2178                     $courseselect
2179                     AND fi.id = fv.item
2180          $usergroup";
2181     $params['feedbackid'] = $feedbackid;
2183     $lastpos = $DB->get_field_sql($sql, $params);
2185     //the index of found pagebreak is the searched pagenumber
2186     foreach ($allbreaks as $pagenr => $br) {
2187         if ($lastpos < $br) {
2188             return $pagenr;
2189         }
2190     }
2191     return count($allbreaks);
2194 ////////////////////////////////////////////////
2195 ////////////////////////////////////////////////
2196 ////////////////////////////////////////////////
2197 //functions to handle the values
2198 ////////////////////////////////////////////////
2200 /**
2201  * cleans the userinput while submitting the form.
2202  *
2203  * @deprecated since Moodle 3.1
2204  * @param mixed $value
2205  * @return mixed
2206  */
2207 function feedback_clean_input_value($item, $value) {
2208     debugging('Function feedback_clean_input_value() is deprecated and does nothing. '
2209             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
2212 /**
2213  * this saves the values of an completed.
2214  * if the param $tmp is set true so the values are saved temporary in table feedback_valuetmp.
2215  * if there is already a completed and the userid is set so the values are updated.
2216  * on all other things new value records will be created.
2217  *
2218  * @deprecated since Moodle 3.1
2219  *
2220  * @param int $usrid
2221  * @param boolean $tmp
2222  * @return mixed false on error or the completeid
2223  */
2224 function feedback_save_values($usrid, $tmp = false) {
2225     global $DB;
2227     debugging('Function feedback_save_values() was deprecated because it did not have '.
2228             'enough arguments, was not suitable for non-temporary table and was taking '.
2229             'data directly from input', DEBUG_DEVELOPER);
2231     $completedid = optional_param('completedid', 0, PARAM_INT);
2232     $tmpstr = $tmp ? 'tmp' : '';
2233     $time = time();
2234     $timemodified = mktime(0, 0, 0, date('m', $time), date('d', $time), date('Y', $time));
2236     if ($usrid == 0) {
2237         return feedback_create_values($usrid, $timemodified, $tmp);
2238     }
2239     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2240     if (!$completed) {
2241         return feedback_create_values($usrid, $timemodified, $tmp);
2242     } else {
2243         $completed->timemodified = $timemodified;
2244         return feedback_update_values($completed, $tmp);
2245     }
2248 /**
2249  * this saves the values from anonymous user such as guest on the main-site
2250  *
2251  * @deprecated since Moodle 3.1
2252  *
2253  * @param string $guestid the unique guestidentifier
2254  * @return mixed false on error or the completeid
2255  */
2256 function feedback_save_guest_values($guestid) {
2257     global $DB;
2259     debugging('Function feedback_save_guest_values() was deprecated because it did not have '.
2260             'enough arguments, was not suitable for non-temporary table and was taking '.
2261             'data directly from input', DEBUG_DEVELOPER);
2263     $completedid = optional_param('completedid', false, PARAM_INT);
2265     $timemodified = time();
2266     if (!$completed = $DB->get_record('feedback_completedtmp', array('id'=>$completedid))) {
2267         return feedback_create_values(0, $timemodified, true, $guestid);
2268     } else {
2269         $completed->timemodified = $timemodified;
2270         return feedback_update_values($completed, true);
2271     }
2274 /**
2275  * get the value from the given item related to the given completed.
2276  * the value can come as temporary or as permanently value. the deciding is done by $tmp
2277  *
2278  * @global object
2279  * @param int $completeid
2280  * @param int $itemid
2281  * @param boolean $tmp
2282  * @return mixed the value, the type depends on plugin-definition
2283  */
2284 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
2285     global $DB;
2287     $tmpstr = $tmp ? 'tmp' : '';
2288     $params = array('completed'=>$completedid, 'item'=>$itemid);
2289     return $DB->get_field('feedback_value'.$tmpstr, 'value', $params);
2292 /**
2293  * compares the value of the itemid related to the completedid with the dependvalue.
2294  * this is used if a depend item is set.
2295  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
2296  *
2297  * @param int $completedid
2298  * @param stdClass|int $item
2299  * @param mixed $dependvalue
2300  * @param bool $tmp
2301  * @return bool
2302  */
2303 function feedback_compare_item_value($completedid, $item, $dependvalue, $tmp = false) {
2304     global $DB;
2306     if (is_int($item)) {
2307         $item = $DB->get_record('feedback_item', array('id' => $item));
2308     }
2310     $dbvalue = feedback_get_item_value($completedid, $item->id, $tmp);
2312     $itemobj = feedback_get_item_class($item->typ);
2313     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
2316 /**
2317  * this function checks the correctness of values.
2318  * the rules for this are implemented in the class of each item.
2319  * it can be the required attribute or the value self e.g. numeric.
2320  * the params first/lastitem are given to determine the visible range between pagebreaks.
2321  *
2322  * @global object
2323  * @param int $firstitem the position of firstitem for checking
2324  * @param int $lastitem the position of lastitem for checking
2325  * @return boolean
2326  */
2327 function feedback_check_values($firstitem, $lastitem) {
2328     debugging('Function feedback_check_values() is deprecated and does nothing. '
2329             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
2330     return true;
2333 /**
2334  * this function create a complete-record and the related value-records.
2335  * depending on the $tmp (true/false) the values are saved temporary or permanently
2336  *
2337  * @deprecated since Moodle 3.1
2338  *
2339  * @param int $userid
2340  * @param int $timemodified
2341  * @param boolean $tmp
2342  * @param string $guestid a unique identifier to save temporary data
2343  * @return mixed false on error or the completedid
2344  */
2345 function feedback_create_values($usrid, $timemodified, $tmp = false, $guestid = false) {
2346     global $DB;
2348     debugging('Function feedback_create_values() was deprecated because it did not have '.
2349             'enough arguments, was not suitable for non-temporary table and was taking '.
2350             'data directly from input', DEBUG_DEVELOPER);
2352     $tmpstr = $tmp ? 'tmp' : '';
2353     //first we create a new completed record
2354     $completed = new stdClass();
2355     $completed->feedback           = $feedbackid;
2356     $completed->userid             = $usrid;
2357     $completed->guestid            = $guestid;
2358     $completed->timemodified       = $timemodified;
2359     $completed->anonymous_response = $anonymous_response;
2361     $completedid = $DB->insert_record('feedback_completed'.$tmpstr, $completed);
2363     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2365     //the keys are in the form like abc_xxx
2366     //with explode we make an array with(abc, xxx) and (abc=typ und xxx=itemnr)
2368     //get the items of the feedback
2369     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2370         return false;
2371     }
2372     foreach ($allitems as $item) {
2373         if (!$item->hasvalue) {
2374             continue;
2375         }
2376         //get the class of item-typ
2377         $itemobj = feedback_get_item_class($item->typ);
2379         $keyname = $item->typ.'_'.$item->id;
2381         if ($item->typ === 'multichoice') {
2382             $itemvalue = optional_param_array($keyname, null, PARAM_INT);
2383         } else {
2384             $itemvalue = optional_param($keyname, null, PARAM_NOTAGS);
2385         }
2387         if (is_null($itemvalue)) {
2388             continue;
2389         }
2391         $value = new stdClass();
2392         $value->item = $item->id;
2393         $value->completed = $completed->id;
2394         $value->course_id = $courseid;
2396         //the kind of values can be absolutely different
2397         //so we run create_value directly by the item-class
2398         $value->value = $itemobj->create_value($itemvalue);
2399         $DB->insert_record('feedback_value'.$tmpstr, $value);
2400     }
2401     return $completed->id;
2404 /**
2405  * this function updates a complete-record and the related value-records.
2406  * depending on the $tmp (true/false) the values are saved temporary or permanently
2407  *
2408  * @global object
2409  * @param object $completed
2410  * @param boolean $tmp
2411  * @return int the completedid
2412  */
2413 function feedback_update_values($completed, $tmp = false) {
2414     global $DB;
2416     debugging('Function feedback_update_values() was deprecated because it did not have '.
2417             'enough arguments, was not suitable for non-temporary table and was taking '.
2418             'data directly from input', DEBUG_DEVELOPER);
2420     $courseid = optional_param('courseid', false, PARAM_INT);
2421     $tmpstr = $tmp ? 'tmp' : '';
2423     $DB->update_record('feedback_completed'.$tmpstr, $completed);
2424     //get the values of this completed
2425     $values = $DB->get_records('feedback_value'.$tmpstr, array('completed'=>$completed->id));
2427     //get the items of the feedback
2428     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2429         return false;
2430     }
2431     foreach ($allitems as $item) {
2432         if (!$item->hasvalue) {
2433             continue;
2434         }
2435         //get the class of item-typ
2436         $itemobj = feedback_get_item_class($item->typ);
2438         $keyname = $item->typ.'_'.$item->id;
2440         if ($item->typ === 'multichoice') {
2441             $itemvalue = optional_param_array($keyname, null, PARAM_INT);
2442         } else {
2443             $itemvalue = optional_param($keyname, null, PARAM_NOTAGS);
2444         }
2446         //is the itemvalue set (could be a subset of items because pagebreak)?
2447         if (is_null($itemvalue)) {
2448             continue;
2449         }
2451         $newvalue = new stdClass();
2452         $newvalue->item = $item->id;
2453         $newvalue->completed = $completed->id;
2454         $newvalue->course_id = $courseid;
2456         //the kind of values can be absolutely different
2457         //so we run create_value directly by the item-class
2458         $newvalue->value = $itemobj->create_value($itemvalue);
2460         //check, if we have to create or update the value
2461         $exist = false;
2462         foreach ($values as $value) {
2463             if ($value->item == $newvalue->item) {
2464                 $newvalue->id = $value->id;
2465                 $exist = true;
2466                 break;
2467             }
2468         }
2469         if ($exist) {
2470             $DB->update_record('feedback_value'.$tmpstr, $newvalue);
2471         } else {
2472             $DB->insert_record('feedback_value'.$tmpstr, $newvalue);
2473         }
2474     }
2476     return $completed->id;
2479 /**
2480  * get the values of an item depending on the given groupid.
2481  * if the feedback is anonymous so the values are shuffled
2482  *
2483  * @global object
2484  * @global object
2485  * @param object $item
2486  * @param int $groupid
2487  * @param int $courseid
2488  * @param bool $ignore_empty if this is set true so empty values are not delivered
2489  * @return array the value-records
2490  */
2491 function feedback_get_group_values($item,
2492                                    $groupid = false,
2493                                    $courseid = false,
2494                                    $ignore_empty = false) {
2496     global $CFG, $DB;
2498     //if the groupid is given?
2499     if (intval($groupid) > 0) {
2500         $params = array();
2501         if ($ignore_empty) {
2502             $value = $DB->sql_compare_text('fbv.value');
2503             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2504             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2505         } else {
2506             $ignore_empty_select = "";
2507         }
2509         $query = 'SELECT fbv .  *
2510                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2511                    WHERE fbv.item = :itemid
2512                          AND fbv.completed = fbc.id
2513                          AND fbc.userid = gm.userid
2514                          '.$ignore_empty_select.'
2515                          AND gm.groupid = :groupid
2516                 ORDER BY fbc.timemodified';
2517         $params += array('itemid' => $item->id, 'groupid' => $groupid);
2518         $values = $DB->get_records_sql($query, $params);
2520     } else {
2521         $params = array();
2522         if ($ignore_empty) {
2523             $value = $DB->sql_compare_text('value');
2524             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2525             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2526         } else {
2527             $ignore_empty_select = "";
2528         }
2530         if ($courseid) {
2531             $select = "item = :itemid AND course_id = :courseid ".$ignore_empty_select;
2532             $params += array('itemid' => $item->id, 'courseid' => $courseid);
2533             $values = $DB->get_records_select('feedback_value', $select, $params);
2534         } else {
2535             $select = "item = :itemid ".$ignore_empty_select;
2536             $params += array('itemid' => $item->id);
2537             $values = $DB->get_records_select('feedback_value', $select, $params);
2538         }
2539     }
2540     $params = array('id'=>$item->feedback);
2541     if ($DB->get_field('feedback', 'anonymous', $params) == FEEDBACK_ANONYMOUS_YES) {
2542         if (is_array($values)) {
2543             shuffle($values);
2544         }
2545     }
2546     return $values;
2549 /**
2550  * check for multiple_submit = false.
2551  * if the feedback is global so the courseid must be given
2552  *
2553  * @global object
2554  * @global object
2555  * @param int $feedbackid
2556  * @param int $courseid
2557  * @return boolean true if the feedback already is submitted otherwise false
2558  */
2559 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2560     global $USER, $DB;
2562     if (!isloggedin() || isguestuser()) {
2563         return false;
2564     }
2566     $params = array('userid' => $USER->id, 'feedback' => $feedbackid);
2567     if ($courseid) {
2568         $params['courseid'] = $courseid;
2569     }
2570     return $DB->record_exists('feedback_completed', $params);
2573 /**
2574  * if the completion of a feedback will be continued eg.
2575  * by pagebreak or by multiple submit so the complete must be found.
2576  * if the param $tmp is set true so all things are related to temporary completeds
2577  *
2578  * @deprecated since Moodle 3.1
2579  * @param int $feedbackid
2580  * @param boolean $tmp
2581  * @param int $courseid
2582  * @param string $guestid
2583  * @return int the id of the found completed
2584  */
2585 function feedback_get_current_completed($feedbackid,
2586                                         $tmp = false,
2587                                         $courseid = false,
2588                                         $guestid = false) {
2590     debugging('Function feedback_get_current_completed() is deprecated. Please use either '.
2591             'feedback_get_current_completed_tmp() or feedback_get_last_completed()',
2592             DEBUG_DEVELOPER);
2594     global $USER, $CFG, $DB;
2596     $tmpstr = $tmp ? 'tmp' : '';
2598     if (!$courseid) {
2599         if ($guestid) {
2600             $params = array('feedback'=>$feedbackid, 'guestid'=>$guestid);
2601             return $DB->get_record('feedback_completed'.$tmpstr, $params);
2602         } else {
2603             $params = array('feedback'=>$feedbackid, 'userid'=>$USER->id);
2604             return $DB->get_record('feedback_completed'.$tmpstr, $params);
2605         }
2606     }
2608     $params = array();
2610     if ($guestid) {
2611         $userselect = "AND fc.guestid = :guestid";
2612         $params['guestid'] = $guestid;
2613     } else {
2614         $userselect = "AND fc.userid = :userid";
2615         $params['userid'] = $USER->id;
2616     }
2617     //if courseid is set the feedback is global.
2618     //there can be more than one completed on one feedback
2619     $sql =  "SELECT DISTINCT fc.*
2620                FROM {feedback_value{$tmpstr}} fv, {feedback_completed{$tmpstr}} fc
2621               WHERE fv.course_id = :courseid
2622                     AND fv.completed = fc.id
2623                     $userselect
2624                     AND fc.feedback = :feedbackid";
2625     $params['courseid']   = intval($courseid);
2626     $params['feedbackid'] = $feedbackid;
2628     if (!$sqlresult = $DB->get_records_sql($sql, $params)) {
2629         return false;
2630     }
2631     foreach ($sqlresult as $r) {
2632         return $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$r->id));
2633     }
2636 /**
2637  * get the completeds depending on the given groupid.
2638  *
2639  * @global object
2640  * @global object
2641  * @param object $feedback
2642  * @param int $groupid
2643  * @param int $courseid
2644  * @return mixed array of found completeds otherwise false
2645  */
2646 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2647     global $CFG, $DB;
2649     if (intval($groupid) > 0) {
2650         $query = "SELECT fbc.*
2651                     FROM {feedback_completed} fbc, {groups_members} gm
2652                    WHERE fbc.feedback = ?
2653                          AND gm.groupid = ?
2654                          AND fbc.userid = gm.userid";
2655         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2656             return $values;
2657         } else {
2658             return false;
2659         }
2660     } else {
2661         if ($courseid) {
2662             $query = "SELECT DISTINCT fbc.*
2663                         FROM {feedback_completed} fbc, {feedback_value} fbv
2664                         WHERE fbc.id = fbv.completed
2665                             AND fbc.feedback = ?
2666                             AND fbv.course_id = ?
2667                         ORDER BY random_response";
2668             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2669                 return $values;
2670             } else {
2671                 return false;
2672             }
2673         } else {
2674             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2675                 return $values;
2676             } else {
2677                 return false;
2678             }
2679         }
2680     }
2683 /**
2684  * get the count of completeds depending on the given groupid.
2685  *
2686  * @global object
2687  * @global object
2688  * @param object $feedback
2689  * @param int $groupid
2690  * @param int $courseid
2691  * @return mixed count of completeds or false
2692  */
2693 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2694     global $CFG, $DB;
2696     if ($courseid > 0 AND !$groupid <= 0) {
2697         $sql = "SELECT id, COUNT(item) AS ci
2698                   FROM {feedback_value}
2699                  WHERE course_id  = ?
2700               GROUP BY item ORDER BY ci DESC";
2701         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2702             $foundrecs = array_values($foundrecs);
2703             return $foundrecs[0]->ci;
2704         }
2705         return false;
2706     }
2707     if ($values = feedback_get_completeds_group($feedback, $groupid)) {
2708         return count($values);
2709     } else {
2710         return false;
2711     }
2714 /**
2715  * deletes all completed-recordsets from a feedback.
2716  * all related data such as values also will be deleted
2717  *
2718  * @param stdClass|int $feedback
2719  * @param stdClass|cm_info $cm
2720  * @param stdClass $course
2721  * @return void
2722  */
2723 function feedback_delete_all_completeds($feedback, $cm = null, $course = null) {
2724     global $DB;
2726     if (is_int($feedback)) {
2727         $feedback = $DB->get_record('feedback', array('id' => $feedback));
2728     }
2730     if (!$completeds = $DB->get_records('feedback_completed', array('feedback' => $feedback->id))) {
2731         return;
2732     }
2734     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2735         return false;
2736     }
2738     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2739         return false;
2740     }
2742     foreach ($completeds as $completed) {
2743         feedback_delete_completed($completed, $feedback, $cm, $course);
2744     }
2747 /**
2748  * deletes a completed given by completedid.
2749  * all related data such values or tracking data also will be deleted
2750  *
2751  * @param int|stdClass $completed
2752  * @param stdClass $feedback
2753  * @param stdClass|cm_info $cm
2754  * @param stdClass $course
2755  * @return boolean
2756  */
2757 function feedback_delete_completed($completed, $feedback = null, $cm = null, $course = null) {
2758     global $DB, $CFG;
2759     require_once($CFG->libdir.'/completionlib.php');
2761     if (!isset($completed->id)) {
2762         if (!$completed = $DB->get_record('feedback_completed', array('id' => $completed))) {
2763             return false;
2764         }
2765     }
2767     if (!$feedback && !($feedback = $DB->get_record('feedback', array('id' => $completed->feedback)))) {
2768         return false;
2769     }
2771     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2772         return false;
2773     }
2775     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2776         return false;
2777     }
2779     //first we delete all related values
2780     $DB->delete_records('feedback_value', array('completed' => $completed->id));
2782     // Delete the completed record.
2783     $return = $DB->delete_records('feedback_completed', array('id' => $completed->id));
2785     // Update completion state
2786     $completion = new completion_info($course);
2787     if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC && $feedback->completionsubmit) {
2788         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
2789     }
2790     // Trigger event for the delete action we performed.
2791     $event = \mod_feedback\event\response_deleted::create_from_record($completed, $cm, $feedback);
2792     $event->trigger();
2794     return $return;
2797 ////////////////////////////////////////////////
2798 ////////////////////////////////////////////////
2799 ////////////////////////////////////////////////
2800 //functions to handle sitecourse mapping
2801 ////////////////////////////////////////////////
2803 /**
2804  * checks if the course and the feedback is in the table feedback_sitecourse_map.
2805  *
2806  * @deprecated since 3.1
2807  * @param int $feedbackid
2808  * @param int $courseid
2809  * @return int the count of records
2810  */
2811 function feedback_is_course_in_sitecourse_map($feedbackid, $courseid) {
2812     debugging('Function feedback_is_course_in_sitecourse_map() is deprecated because it was not used.',
2813             DEBUG_DEVELOPER);
2814     global $DB;
2815     $params = array('feedbackid'=>$feedbackid, 'courseid'=>$courseid);
2816     return $DB->count_records('feedback_sitecourse_map', $params);
2819 /**
2820  * checks if the feedback is in the table feedback_sitecourse_map.
2821  *
2822  * @deprecated since 3.1
2823  * @param int $feedbackid
2824  * @return boolean
2825  */
2826 function feedback_is_feedback_in_sitecourse_map($feedbackid) {
2827     debugging('Function feedback_is_feedback_in_sitecourse_map() is deprecated because it was not used.',
2828             DEBUG_DEVELOPER);
2829     global $DB;
2830     return $DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$feedbackid));
2833 /**
2834  * gets the feedbacks from table feedback_sitecourse_map.
2835  * this is used to show the global feedbacks on the feedback block
2836  * all feedbacks with the following criteria will be selected:<br />
2837  *
2838  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2839  * 2) all feedbacks which not are listed in sitecoursemap
2840  *
2841  * @global object
2842  * @param int $courseid
2843  * @return array the feedback-records
2844  */
2845 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2846     global $DB;
2848     //first get all feedbacks listed in sitecourse_map with named courseid
2849     $sql = "SELECT f.id AS id,
2850                    cm.id AS cmid,
2851                    f.name AS name,
2852                    f.timeopen AS timeopen,
2853                    f.timeclose AS timeclose
2854             FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2855             WHERE f.id = cm.instance
2856                    AND f.course = '".SITEID."'
2857                    AND m.id = cm.module
2858                    AND m.name = 'feedback'
2859                    AND sm.courseid = ?
2860                    AND sm.feedbackid = f.id";
2862     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2863         $feedbacks1 = array();
2864     }
2866     //second get all feedbacks not listed in sitecourse_map
2867     $feedbacks2 = array();
2868     $sql = "SELECT f.id AS id,
2869                    cm.id AS cmid,
2870                    f.name AS name,
2871                    f.timeopen AS timeopen,
2872                    f.timeclose AS timeclose
2873             FROM {feedback} f, {course_modules} cm, {modules} m
2874             WHERE f.id = cm.instance
2875                    AND f.course = '".SITEID."'
2876                    AND m.id = cm.module
2877                    AND m.name = 'feedback'";
2878     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2879         $allfeedbacks = array();
2880     }
2881     foreach ($allfeedbacks as $a) {
2882         if (!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2883             $feedbacks2[] = $a;
2884         }
2885     }
2887     $feedbacks = array_merge($feedbacks1, $feedbacks2);
2888     $modinfo = get_fast_modinfo(SITEID);
2889     return array_filter($feedbacks, function($f) use ($modinfo) {
2890         return ($cm = $modinfo->get_cm($f->cmid)) && $cm->uservisible;
2891     });
2895 /**
2896  * Gets the courses from table feedback_sitecourse_map
2897  *
2898  * @param int $feedbackid
2899  * @return array the course-records
2900  */
2901 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2902     global $DB;
2904     $sql = "SELECT c.id, c.fullname, c.shortname
2905               FROM {feedback_sitecourse_map} f, {course} c
2906              WHERE c.id = f.courseid
2907                    AND f.feedbackid = ?
2908           ORDER BY c.fullname";
2910     return $DB->get_records_sql($sql, array($feedbackid));
2914 /**
2915  * Updates the course mapping for the feedback
2916  *
2917  * @param stdClass $feedback
2918  * @param array $courses array of course ids
2919  */
2920 function feedback_update_sitecourse_map($feedback, $courses) {
2921     global $DB;
2922     if (empty($courses)) {
2923         $courses = array();
2924     }
2925     $currentmapping = $DB->get_fieldset_select('feedback_sitecourse_map', 'courseid', 'feedbackid=?', array($feedback->id));
2926     foreach (array_diff($courses, $currentmapping) as $courseid) {
2927         $DB->insert_record('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2928     }
2929     foreach (array_diff($currentmapping, $courses) as $courseid) {
2930         $DB->delete_records('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2931     }
2932     // TODO MDL-53574 add events.
2935 /**
2936  * removes non existing courses or feedbacks from sitecourse_map.
2937  * it shouldn't be called all too often
2938  * a good place for it could be the mapcourse.php or unmapcourse.php
2939  *
2940  * @deprecated since 3.1
2941  * @global object
2942  * @return void
2943  */
2944 function feedback_clean_up_sitecourse_map() {
2945     global $DB;
2946     debugging('Function feedback_clean_up_sitecourse_map() is deprecated because it was not used.',
2947             DEBUG_DEVELOPER);
2949     $maps = $DB->get_records('feedback_sitecourse_map');
2950     foreach ($maps as $map) {
2951         if (!$DB->get_record('course', array('id'=>$map->courseid))) {
2952             $params = array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid);
2953             $DB->delete_records('feedback_sitecourse_map', $params);
2954             continue;
2955         }
2956         if (!$DB->get_record('feedback', array('id'=>$map->feedbackid))) {
2957             $params = array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid);
2958             $DB->delete_records('feedback_sitecourse_map', $params);
2959             continue;
2960         }
2962     }
2965 ////////////////////////////////////////////////
2966 ////////////////////////////////////////////////
2967 ////////////////////////////////////////////////
2968 //not relatable functions
2969 ////////////////////////////////////////////////
2971 /**
2972  * prints the option items of a selection-input item (dropdownlist).
2973  * @deprecated since 3.1
2974  * @param int $startval the first value of the list
2975  * @param int $endval the last value of the list
2976  * @param int $selectval which item should be selected
2977  * @param int $interval the stepsize from the first to the last value
2978  * @return void
2979  */
2980 function feedback_print_numeric_option_list($startval, $endval, $selectval = '', $interval = 1) {
2981     debugging('Function feedback_print_numeric_option_list() is deprecated because it was not used.',
2982             DEBUG_DEVELOPER);
2983     for ($i = $startval; $i <= $endval; $i += $interval) {
2984         if ($selectval == ($i)) {
2985             $selected = 'selected="selected"';
2986         } else {
2987             $selected = '';
2988         }
2989         echo '<option '.$selected.'>'.$i.'</option>';
2990     }
2993 /**
2994  * sends an email to the teachers of the course where the given feedback is placed.
2995  *
2996  * @global object
2997  * @global object
2998  * @uses FEEDBACK_ANONYMOUS_NO
2999  * @uses FORMAT_PLAIN
3000  * @param object $cm the coursemodule-record
3001  * @param object $feedback
3002  * @param object $course
3003  * @param stdClass|int $user
3004  * @param stdClass $completed record from feedback_completed if known
3005  * @return void
3006  */
3007 function feedback_send_email($cm, $feedback, $course, $user, $completed = null) {
3008     global $CFG, $DB;
3010     if ($feedback->email_notification == 0) {  // No need to do anything
3011         return;
3012     }
3014     if (is_int($user)) {
3015         $user = $DB->get_record('user', array('id' => $user));
3016     }
3018     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
3019         $groupmode =  $cm->groupmode;
3020     } else {
3021         $groupmode = $course->groupmode;
3022     }
3024     if ($groupmode == SEPARATEGROUPS) {
3025         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
3026                                                FROM {groups} g, {groups_members} m
3027                                               WHERE g.courseid = ?
3028                                                     AND g.id = m.groupid
3029                                                     AND m.userid = ?
3030                                            ORDER BY name ASC", array($course->id, $user->id));
3031         $groups = array_values($groups);
3033         $teachers = feedback_get_receivemail_users($cm->id, $groups);
3034     } else {
3035         $teachers = feedback_get_receivemail_users($cm->id);
3036     }
3038     if ($teachers) {
3040         $strfeedbacks = get_string('modulenameplural', 'feedback');
3041         $strfeedback  = get_string('modulename', 'feedback');
3043         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
3044             $printusername = fullname($user);
3045         } else {
3046             $printusername = get_string('anonymous_user', 'feedback');
3047         }
3049         foreach ($teachers as $teacher) {
3050             $info = new stdClass();
3051             $info->username = $printusername;
3052             $info->feedback = format_string($feedback->name, true);
3053             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?'.
3054                             'id='.$cm->id.'&'.
3055                             'userid=' . $user->id;
3056             if ($completed) {
3057                 $info->url .= '&showcompleted=' . $completed->id;
3058                 if ($feedback->course == SITEID) {
3059                     // Course where feedback was completed (for site feedbacks only).
3060                     $info->url .= '&courseid=' . $completed->courseid;
3061                 }
3062             }
3064             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
3066             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
3067             $posttext = feedback_send_email_text($info, $course);
3069             if ($teacher->mailformat == 1) {
3070                 $posthtml = feedback_send_email_html($info, $course, $cm);
3071             } else {
3072                 $posthtml = '';
3073             }
3075             if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
3076                 $eventdata = new \core\message\message();
3077                 $eventdata->courseid         = $course->id;
3078                 $eventdata->name             = 'submission';
3079                 $eventdata->component        = 'mod_feedback';
3080                 $eventdata->userfrom         = $user;
3081                 $eventdata->userto           = $teacher;
3082                 $eventdata->subject          = $postsubject;
3083                 $eventdata->fullmessage      = $posttext;
3084                 $eventdata->fullmessageformat = FORMAT_PLAIN;
3085                 $eventdata->fullmessagehtml  = $posthtml;
3086                 $eventdata->smallmessage     = '';
3087                 $eventdata->courseid         = $course->id;
3088                 $eventdata->contexturl       = $info->url;
3089                 $eventdata->contexturlname   = $info->feedback;
3090                 message_send($eventdata);
3091             } else {
3092                 $eventdata = new \core\message\message();
3093                 $eventdata->courseid         = $course->id;
3094                 $eventdata->name             = 'submission';
3095                 $eventdata->component        = 'mod_feedback';
3096                 $eventdata->userfrom         = $teacher;
3097                 $eventdata->userto           = $teacher;
3098                 $eventdata->subject          = $postsubject;
3099                 $eventdata->fullmessage      = $posttext;
3100                 $eventdata->fullmessageformat = FORMAT_PLAIN;
3101                 $eventdata->fullmessagehtml  = $posthtml;
3102                 $eventdata->smallmessage     = '';
3103                 $eventdata->courseid         = $course->id;
3104                 $eventdata->contexturl       = $info->url;
3105                 $eventdata->contexturlname   = $info->feedback;
3106                 message_send($eventdata);
3107             }
3108         }
3109     }
3112 /**
3113  * sends an email to the teachers of the course where the given feedback is placed.
3114  *
3115  * @global object
3116  * @uses FORMAT_PLAIN
3117  * @param object $cm the coursemodule-record
3118  * @param object $feedback
3119  * @param object $course
3120  * @return void
3121  */
3122 function feedback_send_email_anonym($cm, $feedback, $course) {
3123     global $CFG;
3125     if ($feedback->email_notification == 0) { // No need to do anything
3126         return;
3127     }
3129     $teachers = feedback_get_receivemail_users($cm->id);
3131     if ($teachers) {
3133         $strfeedbacks = get_string('modulenameplural', 'feedback');
3134         $strfeedback  = get_string('modulename', 'feedback');
3135         $printusername = get_string('anonymous_user', 'feedback');
3137         foreach ($teachers as $teacher) {
3138             $info = new stdClass();
3139             $info->username = $printusername;
3140             $info->feedback = format_string($feedback->name, true);
3141             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?id=' . $cm->id;
3143             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
3145             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
3146             $posttext = feedback_send_email_text($info, $course);
3148             if ($teacher->mailformat == 1) {
3149                 $posthtml = feedback_send_email_html($info, $course, $cm);
3150             } else {
3151                 $posthtml = '';
3152             }
3154             $eventdata = new \core\message\message();
3155             $eventdata->courseid         = $course->id;
3156             $eventdata->name             = 'submission';
3157             $eventdata->component        = 'mod_feedback';
3158             $eventdata->userfrom         = $teacher;
3159             $eventdata->userto           = $teacher;
3160             $eventdata->subject          = $postsubject;
3161             $eventdata->fullmessage      = $posttext;
3162             $eventdata->fullmessageformat = FORMAT_PLAIN;
3163             $eventdata->fullmessagehtml  = $posthtml;
3164             $eventdata->smallmessage     = '';
3165             $eventdata->courseid         = $course->id;
3166             $eventdata->contexturl       = $info->url;
3167             $eventdata->contexturlname   = $info->feedback;
3168             message_send($eventdata);
3169         }
3170     }
3173 /**
3174  * send the text-part of the email
3175  *
3176  * @param object $info includes some infos about the feedback you want to send
3177  * @param object $course
3178  * @return string the text you want to post
3179  */
3180 function feedback_send_email_text($info, $course) {
3181     $coursecontext = context_course::instance($course->id);
3182     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
3183     $posttext  = $courseshortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
3184                     $info->feedback."\n";
3185     $posttext .= '---------------------------------------------------------------------'."\n";
3186     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
3187     $posttext .= '---------------------------------------------------------------------'."\n";
3188     return $posttext;
3192 /**
3193  * send the html-part of the email
3194  *
3195  * @global object
3196  * @param object $info includes some infos about the feedback you want to send
3197  * @param object $course
3198  * @return string the text you want to post
3199  */
3200 function feedback_send_email_html($info, $course, $cm) {
3201     global $CFG;
3202     $coursecontext = context_course::instance($course->id);
3203     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
3204     $course_url = $CFG->wwwroot.'/course/view.php?id='.$course->id;
3205     $feedback_all_url = $CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id;
3206     $feedback_url = $CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id;
3208     $posthtml = '<p><font face="sans-serif">'.
3209             '<a href="'.$course_url.'">'.$courseshortname.'</a> ->'.
3210             '<a href="'.$feedback_all_url.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
3211             '<a href="'.$feedback_url.'">'.$info->feedback.'</a></font></p>';
3212     $posthtml .= '<hr /><font face="sans-serif">';
3213     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
3214     $posthtml .= '</font><hr />';
3215     return $posthtml;
3218 /**
3219  * @param string $url
3220  * @return string
3221  */
3222 function feedback_encode_target_url($url) {
3223     if (strpos($url, '?')) {
3224         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
3225         return $part1 . '?' . htmlentities($part2);
3226     } else {
3227         return $url;
3228     }
3231 /**
3232  * Adds module specific settings to the settings block
3233  *
3234  * @param settings_navigation $settings The settings navigation object
3235  * @param navigation_node $feedbacknode The node to add module settings to
3236  */
3237 function feedback_extend_settings_navigation(settings_navigation $settings,
3238                                              navigation_node $feedbacknode) {
3240     global $PAGE;
3242     if (!$context = context_module::instance($PAGE->cm->id, IGNORE_MISSING)) {
3243         print_error('badcontext');
3244     }
3246     if (has_capability('mod/feedback:edititems', $context)) {
3247         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
3249         $questionnode->add(get_string('edit_items', 'feedback'),
3250                     new moodle_url('/mod/feedback/edit.php',
3251                                     array('id' => $PAGE->cm->id,
3252                                           'do_show' => 'edit')));
3254         $questionnode->add(get_string('export_questions', 'feedback'),
3255                     new moodle_url('/mod/feedback/export.php',
3256                                     array('id' => $PAGE->cm->id,
3257                                           'action' => 'exportfile')));
3259         $questionnode->add(get_string('import_questions', 'feedback'),
3260                     new moodle_url('/mod/feedback/import.php',
3261                                     array('id' => $PAGE->cm->id)));
3263         $questionnode->add(get_string('templates', 'feedback'),
3264                     new moodle_url('/mod/feedback/edit.php',
3265                                     array('id' => $PAGE->cm->id,
3266                                           'do_show' => 'templates')));
3267     }
3269     if (has_capability('mod/feedback:mapcourse', $context) && $PAGE->course->id == SITEID) {
3270         $feedbacknode->add(get_string('mappedcourses', 'feedback'),
3271                     new moodle_url('/mod/feedback/mapcourse.php',
3272                                     array('id' => $PAGE->cm->id)));
3273     }
3275     if (has_capability('mod/feedback:viewreports', $context)) {
3276         $feedback = $PAGE->activityrecord;
3277         if ($feedback->course == SITEID) {
3278             $feedbacknode->add(get_string('analysis', 'feedback'),
3279                     new moodle_url('/mod/feedback/analysis_course.php',
3280                                     array('id' => $PAGE->cm->id)));
3281         } else {
3282             $feedbacknode->add(get_string('analysis', 'feedback'),
3283                     new moodle_url('/mod/feedback/analysis.php',
3284                                     array('id' => $PAGE->cm->id)));
3285         }
3287         $feedbacknode->add(get_string('show_entries', 'feedback'),
3288                     new moodle_url('/mod/feedback/show_entries.php',
3289                                     array('id' => $PAGE->cm->id)));
3291         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO AND $feedback->course != SITEID) {
3292             $feedbacknode->add(get_string('show_nonrespondents', 'feedback'),
3293                         new moodle_url('/mod/feedback/show_nonrespondents.php',
3294                                         array('id' => $PAGE->cm->id)));
3295         }
3296     }
3299 function feedback_init_feedback_session() {
3300     //initialize the feedback-Session - not nice at all!!
3301     global $SESSION;
3302     if (!empty($SESSION)) {
3303         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
3304             $SESSION->feedback = new stdClass();
3305         }
3306     }
3309 /**
3310  * Return a list of page types
3311  * @param string $pagetype current page type
3312  * @param stdClass $parentcontext Block's parent context
3313  * @param stdClass $currentcontext Current context of block
3314  */
3315 function feedback_page_type_list($pagetype, $parentcontext, $currentcontext) {
3316     $module_pagetype = array('mod-feedback-*'=>get_string('page-mod-feedback-x', 'feedback'));
3317     return $module_pagetype;
3320 /**
3321  * Move save the items of the given $feedback in the order of $itemlist.
3322  * @param string $itemlist a comma separated list with item ids
3323  * @param stdClass $feedback
3324  * @return bool true if success
3325  */
3326 function feedback_ajax_saveitemorder($itemlist, $feedback) {
3327     global $DB;
3329     $result = true;
3330     $position = 0;
3331     foreach ($itemlist as $itemid) {
3332         $position++;
3333         $result = $result && $DB->set_field('feedback_item',
3334                                             'position',
3335                                             $position,
3336                                             array('id'=>$itemid, 'feedback'=>$feedback->id));
3337     }
3338     return $result;
3341 /**
3342  * Checks if current user is able to view feedback on this course.
3343  *
3344  * @param stdClass $feedback
3345  * @param context_module $context
3346  * @param int $courseid
3347  * @return bool
3348  */
3349 function feedback_can_view_analysis($feedback, $context, $courseid = false) {
3350     if (has_capability('mod/feedback:viewreports', $context)) {
3351         return true;
3352     }
3354     if (intval($feedback->publish_stats) != 1 ||
3355             !has_capability('mod/feedback:viewanalysepage', $context)) {
3356         return false;
3357     }
3359     if (!isloggedin() || isguestuser()) {
3360         // There is no tracking for the guests, assume that they can view analysis if condition above is satisfied.
3361         return $feedback->course == SITEID;
3362     }
3364     return feedback_is_already_submitted($feedback->id, $courseid);
3367 /**
3368  * Get icon mapping for font-awesome.
3369  */
3370 function mod_feedback_get_fontawesome_icon_map() {
3371     return [
3372         'mod_feedback:required' => 'fa-exclamation-circle',
3373         'mod_feedback:notrequired' => 'fa-question-circle-o',
3374     ];
3377 /**
3378  * Check if the module has any update that affects the current user since a given time.
3379  *
3380  * @param  cm_info $cm course module data
3381  * @param  int $from the time to check updates from
3382  * @param  array $filter if we need to check only specific updates
3383  * @return stdClass an object with the different type of areas indicating if they were updated or not
3384  * @since Moodle 3.3
3385  */
3386 function feedback_check_updates_since(cm_info $cm, $from, $filter = array()) {
3387     global $DB, $USER, $CFG;
3389     $updates = course_check_module_updates_since($cm, $from, array(), $filter);
3391     // Check for new attempts.
3392     $updates->attemptsfinished = (object) array('updated' => false);
3393     $updates->attemptsunfinished = (object) array('updated' => false);
3394     $select = 'feedback = ? AND userid = ? AND timemodified > ?';
3395     $params = array($cm->instance, $USER->id, $from);
3397     $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
3398     if (!empty($attemptsfinished)) {
3399         $updates->attemptsfinished->updated = true;
3400         $updates->attemptsfinished->itemids = array_keys($attemptsfinished);
3401     }
3402     $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
3403     if (!empty($attemptsunfinished)) {
3404         $updates->attemptsunfinished->updated = true;
3405         $updates->attemptsunfinished->itemids = array_keys($attemptsunfinished);
3406     }
3408     // Now, teachers should see other students updates.
3409     if (has_capability('mod/feedback:viewreports', $cm->context)) {
3410         $select = 'feedback = ? AND timemodified > ?';
3411         $params = array($cm->instance, $from);
3413         if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
3414             $groupusers = array_keys(groups_get_activity_shared_group_members($cm));
3415             if (empty($groupusers)) {
3416                 return $updates;
3417             }
3418             list($insql, $inparams) = $DB->get_in_or_equal($groupusers);
3419             $select .= ' AND userid ' . $insql;
3420             $params = array_merge($params, $inparams);
3421         }
3423         $updates->userattemptsfinished = (object) array('updated' => false);
3424         $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
3425         if (!empty($attemptsfinished)) {
3426             $updates->userattemptsfinished->updated = true;
3427             $updates->userattemptsfinished->itemids = array_keys($attemptsfinished);
3428         }
3430         $updates->userattemptsunfinished = (object) array('updated' => false);
3431         $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
3432         if (!empty($attemptsunfinished)) {
3433             $updates->userattemptsunfinished->updated = true;
3434             $updates->userattemptsunfinished->itemids = array_keys($attemptsunfinished);
3435         }
3436     }
3438     return $updates;
3441 /**
3442  * The event is only visible anywhere if the user can submit feedback.
3443  *
3444  * @param calendar_event $event
3445  * @return bool Returns true if the event is visible to the current user, false otherwise.
3446  */
3447 function mod_feedback_core_calendar_is_event_visible(calendar_event $event) {
3448     global $DB;
3450     $cm = get_fast_modinfo($event->courseid)->instances['feedback'][$event->instance];
3451     $feedbackcompletion = new mod_feedback_completion(null, $cm, 0);
3453     // The event is only visible if the user can submit it.
3454     return $feedbackcompletion->can_complete();
3457 /**
3458  * This function receives a calendar event and returns the action associated with it, or null if there is none.
3459  *
3460  * This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
3461  * is not displayed on the block.
3462  *
3463  * @param calendar_event $event
3464  * @param \core_calendar\action_factory $factory
3465  * @return \core_calendar\local\event\entities\action_interface|null
3466  */
3467 function mod_feedback_core_calendar_provide_event_action(calendar_event $event,
3468                                                          \core_calendar\action_factory $factory) {
3470     $cm = get_fast_modinfo($event->courseid)->instances['feedback'][$event->instance];
3471     $feedbackcompletion = new mod_feedback_completion(null, $cm, 0);
3473     if (!empty($cm->customdata['timeclose']) && $cm->customdata['timeclose'] < time()) {
3474         // Feedback is already closed, do not display it even if it was never submitted.
3475         return null;
3476     }
3478     // The feedback is actionable if it does not have timeopen or timeopen is in the past.
3479     $actionable = $feedbackcompletion->is_open();
3481     if ($actionable && $feedbackcompletion->is_already_submitted()) {
3482         // There is no need to display anything if the user has already submitted the feedback.
3483         return null;
3484     }
3486     return $factory->create_instance(
3487         get_string('answerquestions', 'feedback'),
3488         new \moodle_url('/mod/feedback/view.php', ['id' => $cm->id]),
3489         1,
3490         $actionable
3491     );
3494 /**
3495  * Add a get_coursemodule_info function in case any feedback type wants to add 'extra' information
3496  * for the course (see resource).
3497  *
3498  * Given a course_module object, this function returns any "extra" information that may be needed
3499  * when printing this activity in a course listing.  See get_array_of_activities() in course/lib.php.
3500  *
3501  * @param stdClass $coursemodule The coursemodule object (record).
3502  * @return cached_cm_info An object on information that the courses
3503  *                        will know about (most noticeably, an icon).
3504  */
3505 function feedback_get_coursemodule_info($coursemodule) {
3506     global $DB;
3508     $dbparams = ['id' => $coursemodule->instance];
3509     $fields = 'id, name, intro, introformat, completionsubmit, timeopen, timeclose, anonymous';
3510     if (!$feedback = $DB->get_record('feedback', $dbparams, $fields)) {
3511         return false;
3512     }
3514     $result = new cached_cm_info();
3515     $result->name = $feedback->name;
3517     if ($coursemodule->showdescription) {
3518         // Convert intro to html. Do not filter cached version, filters run at display time.
3519         $result->content = format_module_intro('feedback', $feedback, $coursemodule->id, false);
3520     }
3522     // Populate the custom completion rules as key => value pairs, but only if the completion mode is 'automatic'.
3523     if ($coursemodule->completion == COMPLETION_TRACKING_AUTOMATIC) {
3524         $result->customdata['customcompletionrules']['completionsubmit'] = $feedback->completionsubmit;
3525     }
3526     // Populate some other values that can be used in calendar or on dashboard.
3527     if ($feedback->timeopen) {
3528         $result->customdata['timeopen'] = $feedback->timeopen;
3529     }
3530     if ($feedback->timeclose) {
3531         $result->customdata['timeclose'] = $feedback->timeclose;
3532     }
3533     if ($feedback->anonymous) {
3534         $result->customdata['anonymous'] = $feedback->anonymous;
3535     }
3537     return $result;
3540 /**
3541  * Callback which returns human-readable strings describing the active completion custom rules for the module instance.
3542  *
3543  * @param cm_info|stdClass $cm object with fields ->completion and ->customdata['customcompletionrules']
3544  * @return array $descriptions the array of descriptions for the custom rules.
3545  */
3546 function mod_feedback_get_completion_active_rule_descriptions($cm) {
3547     // Values will be present in cm_info, and we assume these are up to date.
3548     if (empty($cm->customdata['customcompletionrules'])
3549         || $cm->completion != COMPLETION_TRACKING_AUTOMATIC) {
3550         return [];
3551     }
3553     $descriptions = [];
3554     foreach ($cm->customdata['customcompletionrules'] as $key => $val) {
3555         switch ($key) {
3556             case 'completionsubmit':
3557                 if (empty($val)) {
3558                     continue;
3559                 }
3560                 $descriptions[] = get_string('completionsubmit', 'feedback');
3561                 break;
3562             default:
3563                 break;
3564         }
3565     }
3566     return $descriptions;