d242b1973ddf58aa260c18c96feae767a1c488fc
[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     $editoroptions = feedback_get_editor_options();
115     // process the custom wysiwyg editor in page_after_submit
116     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
117         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
118                                                     'mod_feedback', 'page_after_submit',
119                                                     0, $editoroptions,
120                                                     $feedback->page_after_submit_editor['text']);
122         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
123     }
124     $DB->update_record('feedback', $feedback);
126     return $feedbackid;
129 /**
130  * this will update a given instance
131  *
132  * @global object
133  * @param object $feedback the object given by mod_feedback_mod_form
134  * @return boolean
135  */
136 function feedback_update_instance($feedback) {
137     global $DB;
139     $feedback->timemodified = time();
140     $feedback->id = $feedback->instance;
142     if (empty($feedback->site_after_submit)) {
143         $feedback->site_after_submit = '';
144     }
146     //save the feedback into the db
147     $DB->update_record("feedback", $feedback);
149     //create or update the new events
150     feedback_set_events($feedback);
152     $context = context_module::instance($feedback->coursemodule);
154     $editoroptions = feedback_get_editor_options();
156     // process the custom wysiwyg editor in page_after_submit
157     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
158         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
159                                                     'mod_feedback', 'page_after_submit',
160                                                     0, $editoroptions,
161                                                     $feedback->page_after_submit_editor['text']);
163         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
164     }
165     $DB->update_record('feedback', $feedback);
167     return true;
170 /**
171  * Serves the files included in feedback items like label. Implements needed access control ;-)
172  *
173  * There are two situations in general where the files will be sent.
174  * 1) filearea = item, 2) filearea = template
175  *
176  * @package  mod_feedback
177  * @category files
178  * @param stdClass $course course object
179  * @param stdClass $cm course module object
180  * @param stdClass $context context object
181  * @param string $filearea file area
182  * @param array $args extra arguments
183  * @param bool $forcedownload whether or not force download
184  * @param array $options additional options affecting the file serving
185  * @return bool false if file not found, does not return if found - justsend the file
186  */
187 function feedback_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
188     global $CFG, $DB;
190     if ($filearea === 'item' or $filearea === 'template') {
191         $itemid = (int)array_shift($args);
192         //get the item what includes the file
193         if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
194             return false;
195         }
196         $feedbackid = $item->feedback;
197         $templateid = $item->template;
198     }
200     if ($filearea === 'page_after_submit' or $filearea === 'item') {
201         if (! $feedback = $DB->get_record("feedback", array("id"=>$cm->instance))) {
202             return false;
203         }
205         $feedbackid = $feedback->id;
207         //if the filearea is "item" so we check the permissions like view/complete the feedback
208         $canload = false;
209         //first check whether the user has the complete capability
210         if (has_capability('mod/feedback:complete', $context)) {
211             $canload = true;
212         }
214         //now we check whether the user has the view capability
215         if (has_capability('mod/feedback:view', $context)) {
216             $canload = true;
217         }
219         //if the feedback is on frontpage and anonymous and the fullanonymous is allowed
220         //so the file can be loaded too.
221         if (isset($CFG->feedback_allowfullanonymous)
222                     AND $CFG->feedback_allowfullanonymous
223                     AND $course->id == SITEID
224                     AND $feedback->anonymous == FEEDBACK_ANONYMOUS_YES ) {
225             $canload = true;
226         }
228         if (!$canload) {
229             return false;
230         }
231     } else if ($filearea === 'template') { //now we check files in templates
232         if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
233             return false;
234         }
236         //if the file is not public so the capability edititems has to be there
237         if (!$template->ispublic) {
238             if (!has_capability('mod/feedback:edititems', $context)) {
239                 return false;
240             }
241         } else { //on public templates, at least the user has to be logged in
242             if (!isloggedin()) {
243                 return false;
244             }
245         }
246     } else {
247         return false;
248     }
250     if ($context->contextlevel == CONTEXT_MODULE) {
251         if ($filearea !== 'item' and $filearea !== 'page_after_submit') {
252             return false;
253         }
254     }
256     if ($context->contextlevel == CONTEXT_COURSE || $context->contextlevel == CONTEXT_SYSTEM) {
257         if ($filearea !== 'template') {
258             return false;
259         }
260     }
262     $relativepath = implode('/', $args);
263     if ($filearea === 'page_after_submit') {
264         $fullpath = "/{$context->id}/mod_feedback/$filearea/$relativepath";
265     } else {
266         $fullpath = "/{$context->id}/mod_feedback/$filearea/{$item->id}/$relativepath";
267     }
269     $fs = get_file_storage();
271     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
272         return false;
273     }
275     // finally send the file
276     send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
278     return false;
281 /**
282  * this will delete a given instance.
283  * all referenced data also will be deleted
284  *
285  * @global object
286  * @param int $id the instanceid of feedback
287  * @return boolean
288  */
289 function feedback_delete_instance($id) {
290     global $DB;
292     //get all referenced items
293     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
295     //deleting all referenced items and values
296     if (is_array($feedbackitems)) {
297         foreach ($feedbackitems as $feedbackitem) {
298             $DB->delete_records("feedback_value", array("item"=>$feedbackitem->id));
299             $DB->delete_records("feedback_valuetmp", array("item"=>$feedbackitem->id));
300         }
301         if ($delitems = $DB->get_records("feedback_item", array("feedback"=>$id))) {
302             foreach ($delitems as $delitem) {
303                 feedback_delete_item($delitem->id, false);
304             }
305         }
306     }
308     //deleting the completeds
309     $DB->delete_records("feedback_completed", array("feedback"=>$id));
311     //deleting the unfinished completeds
312     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
314     //deleting old events
315     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
316     return $DB->delete_records("feedback", array("id"=>$id));
319 /**
320  * Return a small object with summary information about what a
321  * user has done with a given particular instance of this module
322  * Used for user activity reports.
323  * $return->time = the time they did it
324  * $return->info = a short text description
325  *
326  * @param stdClass $course
327  * @param stdClass $user
328  * @param cm_info|stdClass $mod
329  * @param stdClass $feedback
330  * @return stdClass
331  */
332 function feedback_user_outline($course, $user, $mod, $feedback) {
333     global $DB;
334     $outline = (object)['info' => '', 'time' => 0];
335     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
336         // Do not disclose any user info if feedback is anonymous.
337         return $outline;
338     }
339     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
340         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
341     $status = null;
342     $context = context_module::instance($mod->id);
343     if ($completed = $DB->get_record('feedback_completed', $params)) {
344         // User has completed feedback.
345         $outline->info = get_string('completed', 'feedback');
346         $outline->time = $completed->timemodified;
347     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
348         // User has started but not completed feedback.
349         $outline->info = get_string('started', 'feedback');
350         $outline->time = $completedtmp->timemodified;
351     } else if (has_capability('mod/feedback:complete', $context, $user)) {
352         // User has not started feedback but has capability to do so.
353         $outline->info = get_string('not_started', 'feedback');
354     }
356     return $outline;
359 /**
360  * Returns all users who has completed a specified feedback since a given time
361  * many thanks to Manolescu Dorel, who contributed these two functions
362  *
363  * @global object
364  * @global object
365  * @global object
366  * @global object
367  * @uses CONTEXT_MODULE
368  * @param array $activities Passed by reference
369  * @param int $index Passed by reference
370  * @param int $timemodified Timestamp
371  * @param int $courseid
372  * @param int $cmid
373  * @param int $userid
374  * @param int $groupid
375  * @return void
376  */
377 function feedback_get_recent_mod_activity(&$activities, &$index,
378                                           $timemodified, $courseid,
379                                           $cmid, $userid="", $groupid="") {
381     global $CFG, $COURSE, $USER, $DB;
383     if ($COURSE->id == $courseid) {
384         $course = $COURSE;
385     } else {
386         $course = $DB->get_record('course', array('id'=>$courseid));
387     }
389     $modinfo = get_fast_modinfo($course);
391     $cm = $modinfo->cms[$cmid];
393     $sqlargs = array();
395     $userfields = user_picture::fields('u', null, 'useridagain');
396     $sql = " SELECT fk . * , fc . * , $userfields
397                 FROM {feedback_completed} fc
398                     JOIN {feedback} fk ON fk.id = fc.feedback
399                     JOIN {user} u ON u.id = fc.userid ";
401     if ($groupid) {
402         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
403     }
405     $sql .= " WHERE fc.timemodified > ?
406                 AND fk.id = ?
407                 AND fc.anonymous_response = ?";
408     $sqlargs[] = $timemodified;
409     $sqlargs[] = $cm->instance;
410     $sqlargs[] = FEEDBACK_ANONYMOUS_NO;
412     if ($userid) {
413         $sql .= " AND u.id = ? ";
414         $sqlargs[] = $userid;
415     }
417     if ($groupid) {
418         $sql .= " AND gm.groupid = ? ";
419         $sqlargs[] = $groupid;
420     }
422     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
423         return;
424     }
426     $cm_context = context_module::instance($cm->id);
428     if (!has_capability('mod/feedback:view', $cm_context)) {
429         return;
430     }
432     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
433     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cm_context);
434     $groupmode       = groups_get_activity_groupmode($cm, $course);
436     $aname = format_string($cm->name, true);
437     foreach ($feedbackitems as $feedbackitem) {
438         if ($feedbackitem->userid != $USER->id) {
440             if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
441                 $usersgroups = groups_get_all_groups($course->id,
442                                                      $feedbackitem->userid,
443                                                      $cm->groupingid);
444                 if (!is_array($usersgroups)) {
445                     continue;
446                 }
447                 $usersgroups = array_keys($usersgroups);
448                 $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
449                 if (empty($intersect)) {
450                     continue;
451                 }
452             }
453         }
455         $tmpactivity = new stdClass();
457         $tmpactivity->type      = 'feedback';
458         $tmpactivity->cmid      = $cm->id;
459         $tmpactivity->name      = $aname;
460         $tmpactivity->sectionnum= $cm->sectionnum;
461         $tmpactivity->timestamp = $feedbackitem->timemodified;
463         $tmpactivity->content = new stdClass();
464         $tmpactivity->content->feedbackid = $feedbackitem->id;
465         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
467         $tmpactivity->user = user_picture::unalias($feedbackitem, null, 'useridagain');
468         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
470         $activities[$index++] = $tmpactivity;
471     }
473     return;
476 /**
477  * Prints all users who has completed a specified feedback since a given time
478  * many thanks to Manolescu Dorel, who contributed these two functions
479  *
480  * @global object
481  * @param object $activity
482  * @param int $courseid
483  * @param string $detail
484  * @param array $modnames
485  * @return void Output is echo'd
486  */
487 function feedback_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
488     global $CFG, $OUTPUT;
490     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
492     echo "<tr><td class=\"userpicture\" valign=\"top\">";
493     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
494     echo "</td><td>";
496     if ($detail) {
497         $modname = $modnames[$activity->type];
498         echo '<div class="title">';
499         echo $OUTPUT->image_icon('icon', $modname, $activity->type);
500         echo "<a href=\"$CFG->wwwroot/mod/feedback/view.php?id={$activity->cmid}\">{$activity->name}</a>";
501         echo '</div>';
502     }
504     echo '<div class="title">';
505     echo '</div>';
507     echo '<div class="user">';
508     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&amp;course=$courseid\">"
509          ."{$activity->user->fullname}</a> - ".userdate($activity->timestamp);
510     echo '</div>';
512     echo "</td></tr></table>";
514     return;
517 /**
518  * Obtains the automatic completion state for this feedback based on the condition
519  * in feedback settings.
520  *
521  * @param object $course Course
522  * @param object $cm Course-module
523  * @param int $userid User ID
524  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
525  * @return bool True if completed, false if not, $type if conditions not set.
526  */
527 function feedback_get_completion_state($course, $cm, $userid, $type) {
528     global $CFG, $DB;
530     // Get feedback details
531     $feedback = $DB->get_record('feedback', array('id'=>$cm->instance), '*', MUST_EXIST);
533     // If completion option is enabled, evaluate it and return true/false
534     if ($feedback->completionsubmit) {
535         $params = array('userid'=>$userid, 'feedback'=>$feedback->id);
536         return $DB->record_exists('feedback_completed', $params);
537     } else {
538         // Completion option is not enabled so just return $type
539         return $type;
540     }
543 /**
544  * Print a detailed representation of what a  user has done with
545  * a given particular instance of this module, for user activity reports.
546  *
547  * @param stdClass $course
548  * @param stdClass $user
549  * @param cm_info|stdClass $mod
550  * @param stdClass $feedback
551  */
552 function feedback_user_complete($course, $user, $mod, $feedback) {
553     global $DB;
554     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
555         // Do not disclose any user info if feedback is anonymous.
556         return;
557     }
558     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
559         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
560     $url = $status = null;
561     $context = context_module::instance($mod->id);
562     if ($completed = $DB->get_record('feedback_completed', $params)) {
563         // User has completed feedback.
564         if (has_capability('mod/feedback:viewreports', $context)) {
565             $url = new moodle_url('/mod/feedback/show_entries.php',
566                 ['id' => $mod->id, 'userid' => $user->id,
567                     'showcompleted' => $completed->id]);
568         }
569         $status = get_string('completedon', 'feedback', userdate($completed->timemodified));
570     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
571         // User has started but not completed feedback.
572         $status = get_string('startedon', 'feedback', userdate($completedtmp->timemodified));
573     } else if (has_capability('mod/feedback:complete', $context, $user)) {
574         // User has not started feedback but has capability to do so.
575         $status = get_string('not_started', 'feedback');
576     }
578     if ($url && $status) {
579         echo html_writer::link($url, $status);
580     } else if ($status) {
581         echo html_writer::div($status);
582     }
585 /**
586  * @return bool true
587  */
588 function feedback_cron () {
589     return true;
592 /**
593  * @return bool false
594  */
595 function feedback_scale_used ($feedbackid, $scaleid) {
596     return false;
599 /**
600  * Checks if scale is being used by any instance of feedback
601  *
602  * This is used to find out if scale used anywhere
603  * @param $scaleid int
604  * @return boolean True if the scale is used by any assignment
605  */
606 function feedback_scale_used_anywhere($scaleid) {
607     return false;
610 /**
611  * List the actions that correspond to a view of this module.
612  * This is used by the participation report.
613  *
614  * Note: This is not used by new logging system. Event with
615  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
616  *       be considered as view action.
617  *
618  * @return array
619  */
620 function feedback_get_view_actions() {
621     return array('view', 'view all');
624 /**
625  * List the actions that correspond to a post of this module.
626  * This is used by the participation report.
627  *
628  * Note: This is not used by new logging system. Event with
629  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
630  *       will be considered as post action.
631  *
632  * @return array
633  */
634 function feedback_get_post_actions() {
635     return array('submit');
638 /**
639  * This function is used by the reset_course_userdata function in moodlelib.
640  * This function will remove all responses from the specified feedback
641  * and clean up any related data.
642  *
643  * @global object
644  * @global object
645  * @uses FEEDBACK_RESETFORM_RESET
646  * @uses FEEDBACK_RESETFORM_DROP
647  * @param object $data the data submitted from the reset course.
648  * @return array status array
649  */
650 function feedback_reset_userdata($data) {
651     global $CFG, $DB;
653     $resetfeedbacks = array();
654     $dropfeedbacks = array();
655     $status = array();
656     $componentstr = get_string('modulenameplural', 'feedback');
658     //get the relevant entries from $data
659     foreach ($data as $key => $value) {
660         switch(true) {
661             case substr($key, 0, strlen(FEEDBACK_RESETFORM_RESET)) == FEEDBACK_RESETFORM_RESET:
662                 if ($value == 1) {
663                     $templist = explode('_', $key);
664                     if (isset($templist[3])) {
665                         $resetfeedbacks[] = intval($templist[3]);
666                     }
667                 }
668             break;
669             case substr($key, 0, strlen(FEEDBACK_RESETFORM_DROP)) == FEEDBACK_RESETFORM_DROP:
670                 if ($value == 1) {
671                     $templist = explode('_', $key);
672                     if (isset($templist[3])) {
673                         $dropfeedbacks[] = intval($templist[3]);
674                     }
675                 }
676             break;
677         }
678     }
680     //reset the selected feedbacks
681     foreach ($resetfeedbacks as $id) {
682         $feedback = $DB->get_record('feedback', array('id'=>$id));
683         feedback_delete_all_completeds($feedback);
684         $status[] = array('component'=>$componentstr.':'.$feedback->name,
685                         'item'=>get_string('resetting_data', 'feedback'),
686                         'error'=>false);
687     }
689     // Updating dates - shift may be negative too.
690     if ($data->timeshift) {
691         $shifterror = !shift_course_mod_dates('feedback', array('timeopen', 'timeclose'), $data->timeshift, $data->courseid);
692         $status[] = array('component' => $componentstr, 'item' => get_string('datechanged'), 'error' => $shifterror);
693     }
695     return $status;
698 /**
699  * Called by course/reset.php
700  *
701  * @global object
702  * @uses FEEDBACK_RESETFORM_RESET
703  * @param object $mform form passed by reference
704  */
705 function feedback_reset_course_form_definition(&$mform) {
706     global $COURSE, $DB;
708     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
710     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')) {
711         return;
712     }
714     $mform->addElement('static', 'hint', get_string('resetting_data', 'feedback'));
715     foreach ($feedbacks as $feedback) {
716         $mform->addElement('checkbox', FEEDBACK_RESETFORM_RESET.$feedback->id, $feedback->name);
717     }
720 /**
721  * Course reset form defaults.
722  *
723  * @global object
724  * @uses FEEDBACK_RESETFORM_RESET
725  * @param object $course
726  */
727 function feedback_reset_course_form_defaults($course) {
728     global $DB;
730     $return = array();
731     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
732         return;
733     }
734     foreach ($feedbacks as $feedback) {
735         $return[FEEDBACK_RESETFORM_RESET.$feedback->id] = true;
736     }
737     return $return;
740 /**
741  * Called by course/reset.php and shows the formdata by coursereset.
742  * it prints checkboxes for each feedback available at the given course
743  * there are two checkboxes:
744  * 1) delete userdata and keep the feedback
745  * 2) delete userdata and drop the feedback
746  *
747  * @global object
748  * @uses FEEDBACK_RESETFORM_RESET
749  * @uses FEEDBACK_RESETFORM_DROP
750  * @param object $course
751  * @return void
752  */
753 function feedback_reset_course_form($course) {
754     global $DB, $OUTPUT;
756     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
757     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
758         return;
759     }
761     foreach ($feedbacks as $feedback) {
762         echo '<p>';
763         echo get_string('name', 'feedback').': '.$feedback->name.'<br />';
764         echo html_writer::checkbox(FEEDBACK_RESETFORM_RESET.$feedback->id,
765                                 1, true,
766                                 get_string('resetting_data', 'feedback'));
767         echo '<br />';
768         echo html_writer::checkbox(FEEDBACK_RESETFORM_DROP.$feedback->id,
769                                 1, false,
770                                 get_string('drop_feedback', 'feedback'));
771         echo '</p>';
772     }
775 /**
776  * This gets an array with default options for the editor
777  *
778  * @return array the options
779  */
780 function feedback_get_editor_options() {
781     return array('maxfiles' => EDITOR_UNLIMITED_FILES,
782                 'trusttext'=>true);
785 /**
786  * This creates new events given as timeopen and closeopen by $feedback.
787  *
788  * @global object
789  * @param object $feedback
790  * @return void
791  */
792 function feedback_set_events($feedback) {
793     global $DB, $CFG;
795     // Include calendar/lib.php.
796     require_once($CFG->dirroot.'/calendar/lib.php');
798     // Get CMID if not sent as part of $feedback.
799     if (!isset($feedback->coursemodule)) {
800         $cm = get_coursemodule_from_instance('feedback', $feedback->id, $feedback->course);
801         $feedback->coursemodule = $cm->id;
802     }
804     // Feedback start calendar events.
805     $eventid = $DB->get_field('event', 'id',
806             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => FEEDBACK_EVENT_TYPE_OPEN));
808     if (isset($feedback->timeopen) && $feedback->timeopen > 0) {
809         $event = new stdClass();
810         $event->eventtype    = FEEDBACK_EVENT_TYPE_OPEN;
811         $event->type         = empty($feedback->timeclose) ? CALENDAR_EVENT_TYPE_ACTION : CALENDAR_EVENT_TYPE_STANDARD;
812         $event->name         = get_string('calendarstart', 'feedback', $feedback->name);
813         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
814         $event->timestart    = $feedback->timeopen;
815         $event->timesort     = $feedback->timeopen;
816         $event->visible      = instance_is_visible('feedback', $feedback);
817         $event->timeduration = 0;
818         if ($eventid) {
819             // Calendar event exists so update it.
820             $event->id = $eventid;
821             $calendarevent = calendar_event::load($event->id);
822             $calendarevent->update($event);
823         } else {
824             // Event doesn't exist so create one.
825             $event->courseid     = $feedback->course;
826             $event->groupid      = 0;
827             $event->userid       = 0;
828             $event->modulename   = 'feedback';
829             $event->instance     = $feedback->id;
830             $event->eventtype    = FEEDBACK_EVENT_TYPE_OPEN;
831             calendar_event::create($event);
832         }
833     } else if ($eventid) {
834         // Calendar event is on longer needed.
835         $calendarevent = calendar_event::load($eventid);
836         $calendarevent->delete();
837     }
839     // Feedback close calendar events.
840     $eventid = $DB->get_field('event', 'id',
841             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => FEEDBACK_EVENT_TYPE_CLOSE));
843     if (isset($feedback->timeclose) && $feedback->timeclose > 0) {
844         $event = new stdClass();
845         $event->type         = CALENDAR_EVENT_TYPE_ACTION;
846         $event->eventtype    = FEEDBACK_EVENT_TYPE_CLOSE;
847         $event->name         = get_string('calendarend', 'feedback', $feedback->name);
848         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
849         $event->timestart    = $feedback->timeclose;
850         $event->timesort     = $feedback->timeclose;
851         $event->visible      = instance_is_visible('feedback', $feedback);
852         $event->timeduration = 0;
853         if ($eventid) {
854             // Calendar event exists so update it.
855             $event->id = $eventid;
856             $calendarevent = calendar_event::load($event->id);
857             $calendarevent->update($event);
858         } else {
859             // Event doesn't exist so create one.
860             $event->courseid     = $feedback->course;
861             $event->groupid      = 0;
862             $event->userid       = 0;
863             $event->modulename   = 'feedback';
864             $event->instance     = $feedback->id;
865             calendar_event::create($event);
866         }
867     } else if ($eventid) {
868         // Calendar event is on longer needed.
869         $calendarevent = calendar_event::load($eventid);
870         $calendarevent->delete();
871     }
874 /**
875  * This standard function will check all instances of this module
876  * and make sure there are up-to-date events created for each of them.
877  * If courseid = 0, then every feedback event in the site is checked, else
878  * only feedback events belonging to the course specified are checked.
879  * This function is used, in its new format, by restore_refresh_events()
880  *
881  * @param int $courseid
882  * @return bool
883  */
884 function feedback_refresh_events($courseid = 0) {
885     global $DB;
887     if ($courseid) {
888         if (! $feedbacks = $DB->get_records("feedback", array("course" => $courseid))) {
889             return true;
890         }
891     } else {
892         if (! $feedbacks = $DB->get_records("feedback")) {
893             return true;
894         }
895     }
897     foreach ($feedbacks as $feedback) {
898         feedback_set_events($feedback);
899     }
900     return true;
903 /**
904  * this function is called by {@link feedback_delete_userdata()}
905  * it drops the feedback-instance from the course_module table
906  *
907  * @global object
908  * @param int $id the id from the coursemodule
909  * @return boolean
910  */
911 function feedback_delete_course_module($id) {
912     global $DB;
914     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
915         return true;
916     }
917     return $DB->delete_records('course_modules', array('id'=>$cm->id));
922 ////////////////////////////////////////////////
923 //functions to handle capabilities
924 ////////////////////////////////////////////////
926 /**
927  * returns the context-id related to the given coursemodule-id
928  *
929  * @deprecated since 3.1
930  * @staticvar object $context
931  * @param int $cmid the coursemodule-id
932  * @return object $context
933  */
934 function feedback_get_context($cmid) {
935     debugging('Function feedback_get_context() is deprecated because it was not used.',
936             DEBUG_DEVELOPER);
937     static $context;
939     if (isset($context)) {
940         return $context;
941     }
943     $context = context_module::instance($cmid);
944     return $context;
947 /**
948  *  returns true if the current role is faked by switching role feature
949  *
950  * @global object
951  * @return boolean
952  */
953 function feedback_check_is_switchrole() {
954     global $USER;
955     if (isset($USER->switchrole) AND
956             is_array($USER->switchrole) AND
957             count($USER->switchrole) > 0) {
959         return true;
960     }
961     return false;
964 /**
965  * count users which have not completed the feedback
966  *
967  * @global object
968  * @uses CONTEXT_MODULE
969  * @param cm_info $cm Course-module object
970  * @param int $group single groupid
971  * @param string $sort
972  * @param int $startpage
973  * @param int $pagecount
974  * @param bool $includestatus to return if the user started or not the feedback among the complete user record
975  * @return array array of user ids or user objects when $includestatus set to true
976  */
977 function feedback_get_incomplete_users(cm_info $cm,
978                                        $group = false,
979                                        $sort = '',
980                                        $startpage = false,
981                                        $pagecount = false,
982                                        $includestatus = false) {
984     global $DB;
986     $context = context_module::instance($cm->id);
988     //first get all user who can complete this feedback
989     $cap = 'mod/feedback:complete';
990     $allnames = get_all_user_name_fields(true, 'u');
991     $fields = 'u.id, ' . $allnames . ', u.picture, u.email, u.imagealt';
992     if (!$allusers = get_users_by_capability($context,
993                                             $cap,
994                                             $fields,
995                                             $sort,
996                                             '',
997                                             '',
998                                             $group,
999                                             '',
1000                                             true)) {
1001         return false;
1002     }
1003     // Filter users that are not in the correct group/grouping.
1004     $info = new \core_availability\info_module($cm);
1005     $allusersrecords = $info->filter_user_list($allusers);
1007     $allusers = array_keys($allusersrecords);
1009     //now get all completeds
1010     $params = array('feedback'=>$cm->instance);
1011     if ($completedusers = $DB->get_records_menu('feedback_completed', $params, '', 'id, userid')) {
1012         // Now strike all completedusers from allusers.
1013         $allusers = array_diff($allusers, $completedusers);
1014     }
1016     //for paging I use array_slice()
1017     if ($startpage !== false AND $pagecount !== false) {
1018         $allusers = array_slice($allusers, $startpage, $pagecount);
1019     }
1021     // Check if we should return the full users objects.
1022     if ($includestatus) {
1023         $userrecords = [];
1024         $startedusers = $DB->get_records_menu('feedback_completedtmp', ['feedback' => $cm->instance], '', 'id, userid');
1025         $startedusers = array_flip($startedusers);
1026         foreach ($allusers as $userid) {
1027             $allusersrecords[$userid]->feedbackstarted = isset($startedusers[$userid]);
1028             $userrecords[] = $allusersrecords[$userid];
1029         }
1030         return $userrecords;
1031     } else {    // Return just user ids.
1032         return $allusers;
1033     }
1036 /**
1037  * count users which have not completed the feedback
1038  *
1039  * @global object
1040  * @param object $cm
1041  * @param int $group single groupid
1042  * @return int count of userrecords
1043  */
1044 function feedback_count_incomplete_users($cm, $group = false) {
1045     if ($allusers = feedback_get_incomplete_users($cm, $group)) {
1046         return count($allusers);
1047     }
1048     return 0;
1051 /**
1052  * count users which have completed a feedback
1053  *
1054  * @global object
1055  * @uses FEEDBACK_ANONYMOUS_NO
1056  * @param object $cm
1057  * @param int $group single groupid
1058  * @return int count of userrecords
1059  */
1060 function feedback_count_complete_users($cm, $group = false) {
1061     global $DB;
1063     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
1065     $fromgroup = '';
1066     $wheregroup = '';
1067     if ($group) {
1068         $fromgroup = ', {groups_members} g';
1069         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
1070         $params[] = $group;
1071     }
1073     $sql = 'SELECT COUNT(u.id) FROM {user} u, {feedback_completed} c'.$fromgroup.'
1074               WHERE anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
1075               '.$wheregroup;
1077     return $DB->count_records_sql($sql, $params);
1081 /**
1082  * get users which have completed a feedback
1083  *
1084  * @global object
1085  * @uses CONTEXT_MODULE
1086  * @uses FEEDBACK_ANONYMOUS_NO
1087  * @param object $cm
1088  * @param int $group single groupid
1089  * @param string $where a sql where condition (must end with " AND ")
1090  * @param array parameters used in $where
1091  * @param string $sort a table field
1092  * @param int $startpage
1093  * @param int $pagecount
1094  * @return object the userrecords
1095  */
1096 function feedback_get_complete_users($cm,
1097                                      $group = false,
1098                                      $where = '',
1099                                      array $params = null,
1100                                      $sort = '',
1101                                      $startpage = false,
1102                                      $pagecount = false) {
1104     global $DB;
1106     $context = context_module::instance($cm->id);
1108     $params = (array)$params;
1110     $params['anon'] = FEEDBACK_ANONYMOUS_NO;
1111     $params['instance'] = $cm->instance;
1113     $fromgroup = '';
1114     $wheregroup = '';
1115     if ($group) {
1116         $fromgroup = ', {groups_members} g';
1117         $wheregroup = ' AND g.groupid = :group AND g.userid = c.userid';
1118         $params['group'] = $group;
1119     }
1121     if ($sort) {
1122         $sortsql = ' ORDER BY '.$sort;
1123     } else {
1124         $sortsql = '';
1125     }
1127     $ufields = user_picture::fields('u');
1128     $sql = 'SELECT DISTINCT '.$ufields.', c.timemodified as completed_timemodified
1129             FROM {user} u, {feedback_completed} c '.$fromgroup.'
1130             WHERE '.$where.' anonymous_response = :anon
1131                 AND u.id = c.userid
1132                 AND c.feedback = :instance
1133               '.$wheregroup.$sortsql;
1135     if ($startpage === false OR $pagecount === false) {
1136         $startpage = false;
1137         $pagecount = false;
1138     }
1139     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
1142 /**
1143  * get users which have the viewreports-capability
1144  *
1145  * @uses CONTEXT_MODULE
1146  * @param int $cmid
1147  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1148  * @return object the userrecords
1149  */
1150 function feedback_get_viewreports_users($cmid, $groups = false) {
1152     $context = context_module::instance($cmid);
1154     //description of the call below:
1155     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1156     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1157     return get_users_by_capability($context,
1158                             'mod/feedback:viewreports',
1159                             '',
1160                             'lastname',
1161                             '',
1162                             '',
1163                             $groups,
1164                             '',
1165                             false);
1168 /**
1169  * get users which have the receivemail-capability
1170  *
1171  * @uses CONTEXT_MODULE
1172  * @param int $cmid
1173  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1174  * @return object the userrecords
1175  */
1176 function feedback_get_receivemail_users($cmid, $groups = false) {
1178     $context = context_module::instance($cmid);
1180     //description of the call below:
1181     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1182     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1183     return get_users_by_capability($context,
1184                             'mod/feedback:receivemail',
1185                             '',
1186                             'lastname',
1187                             '',
1188                             '',
1189                             $groups,
1190                             '',
1191                             false);
1194 ////////////////////////////////////////////////
1195 //functions to handle the templates
1196 ////////////////////////////////////////////////
1197 ////////////////////////////////////////////////
1199 /**
1200  * creates a new template-record.
1201  *
1202  * @global object
1203  * @param int $courseid
1204  * @param string $name the name of template shown in the templatelist
1205  * @param int $ispublic 0:privat 1:public
1206  * @return int the new templateid
1207  */
1208 function feedback_create_template($courseid, $name, $ispublic = 0) {
1209     global $DB;
1211     $templ = new stdClass();
1212     $templ->course   = ($ispublic ? 0 : $courseid);
1213     $templ->name     = $name;
1214     $templ->ispublic = $ispublic;
1216     $templid = $DB->insert_record('feedback_template', $templ);
1217     return $DB->get_record('feedback_template', array('id'=>$templid));
1220 /**
1221  * creates new template items.
1222  * all items will be copied and the attribute feedback will be set to 0
1223  * and the attribute template will be set to the new templateid
1224  *
1225  * @global object
1226  * @uses CONTEXT_MODULE
1227  * @uses CONTEXT_COURSE
1228  * @param object $feedback
1229  * @param string $name the name of template shown in the templatelist
1230  * @param int $ispublic 0:privat 1:public
1231  * @return boolean
1232  */
1233 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
1234     global $DB;
1235     $fs = get_file_storage();
1237     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1238         return false;
1239     }
1241     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
1242         return false;
1243     }
1245     //files in the template_item are in the context of the current course or
1246     //if the template is public the files are in the system context
1247     //files in the feedback_item are in the feedback_context of the feedback
1248     if ($ispublic) {
1249         $s_context = context_system::instance();
1250     } else {
1251         $s_context = context_course::instance($newtempl->course);
1252     }
1253     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1254     $f_context = context_module::instance($cm->id);
1256     //create items of this new template
1257     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1258     //we also store a mapping of all items array(oldid => newid)
1259     $dependitemsmap = array();
1260     $itembackup = array();
1261     foreach ($feedbackitems as $item) {
1263         $t_item = clone($item);
1265         unset($t_item->id);
1266         $t_item->feedback = 0;
1267         $t_item->template     = $newtempl->id;
1268         $t_item->id = $DB->insert_record('feedback_item', $t_item);
1269         //copy all included files to the feedback_template filearea
1270         $itemfiles = $fs->get_area_files($f_context->id,
1271                                     'mod_feedback',
1272                                     'item',
1273                                     $item->id,
1274                                     "id",
1275                                     false);
1276         if ($itemfiles) {
1277             foreach ($itemfiles as $ifile) {
1278                 $file_record = new stdClass();
1279                 $file_record->contextid = $s_context->id;
1280                 $file_record->component = 'mod_feedback';
1281                 $file_record->filearea = 'template';
1282                 $file_record->itemid = $t_item->id;
1283                 $fs->create_file_from_storedfile($file_record, $ifile);
1284             }
1285         }
1287         $itembackup[$item->id] = $t_item->id;
1288         if ($t_item->dependitem) {
1289             $dependitemsmap[$t_item->id] = $t_item->dependitem;
1290         }
1292     }
1294     //remapping the dependency
1295     foreach ($dependitemsmap as $key => $dependitem) {
1296         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1297         $newitem->dependitem = $itembackup[$newitem->dependitem];
1298         $DB->update_record('feedback_item', $newitem);
1299     }
1301     return true;
1304 /**
1305  * deletes all feedback_items related to the given template id
1306  *
1307  * @global object
1308  * @uses CONTEXT_COURSE
1309  * @param object $template the template
1310  * @return void
1311  */
1312 function feedback_delete_template($template) {
1313     global $DB;
1315     //deleting the files from the item is done by feedback_delete_item
1316     if ($t_items = $DB->get_records("feedback_item", array("template"=>$template->id))) {
1317         foreach ($t_items as $t_item) {
1318             feedback_delete_item($t_item->id, false, $template);
1319         }
1320     }
1321     $DB->delete_records("feedback_template", array("id"=>$template->id));
1324 /**
1325  * creates new feedback_item-records from template.
1326  * if $deleteold is set true so the existing items of the given feedback will be deleted
1327  * if $deleteold is set false so the new items will be appanded to the old items
1328  *
1329  * @global object
1330  * @uses CONTEXT_COURSE
1331  * @uses CONTEXT_MODULE
1332  * @param object $feedback
1333  * @param int $templateid
1334  * @param boolean $deleteold
1335  */
1336 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1337     global $DB, $CFG;
1339     require_once($CFG->libdir.'/completionlib.php');
1341     $fs = get_file_storage();
1343     if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
1344         return false;
1345     }
1346     //get all templateitems
1347     if (!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1348         return false;
1349     }
1351     //files in the template_item are in the context of the current course
1352     //files in the feedback_item are in the feedback_context of the feedback
1353     if ($template->ispublic) {
1354         $s_context = context_system::instance();
1355     } else {
1356         $s_context = context_course::instance($feedback->course);
1357     }
1358     $course = $DB->get_record('course', array('id'=>$feedback->course));
1359     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1360     $f_context = context_module::instance($cm->id);
1362     //if deleteold then delete all old items before
1363     //get all items
1364     if ($deleteold) {
1365         if ($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1366             //delete all items of this feedback
1367             foreach ($feedbackitems as $item) {
1368                 feedback_delete_item($item->id, false);
1369             }
1371             $params = array('feedback'=>$feedback->id);
1372             if ($completeds = $DB->get_records('feedback_completed', $params)) {
1373                 $completion = new completion_info($course);
1374                 foreach ($completeds as $completed) {
1375                     $DB->delete_records('feedback_completed', array('id' => $completed->id));
1376                     // Update completion state
1377                     if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC &&
1378                             $feedback->completionsubmit) {
1379                         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1380                     }
1381                 }
1382             }
1383             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1384         }
1385         $positionoffset = 0;
1386     } else {
1387         //if the old items are kept the new items will be appended
1388         //therefor the new position has an offset
1389         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1390     }
1392     //create items of this new template
1393     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1394     //we also store a mapping of all items array(oldid => newid)
1395     $dependitemsmap = array();
1396     $itembackup = array();
1397     foreach ($templitems as $t_item) {
1398         $item = clone($t_item);
1399         unset($item->id);
1400         $item->feedback = $feedback->id;
1401         $item->template = 0;
1402         $item->position = $item->position + $positionoffset;
1404         $item->id = $DB->insert_record('feedback_item', $item);
1406         //moving the files to the new item
1407         $templatefiles = $fs->get_area_files($s_context->id,
1408                                         'mod_feedback',
1409                                         'template',
1410                                         $t_item->id,
1411                                         "id",
1412                                         false);
1413         if ($templatefiles) {
1414             foreach ($templatefiles as $tfile) {
1415                 $file_record = new stdClass();
1416                 $file_record->contextid = $f_context->id;
1417                 $file_record->component = 'mod_feedback';
1418                 $file_record->filearea = 'item';
1419                 $file_record->itemid = $item->id;
1420                 $fs->create_file_from_storedfile($file_record, $tfile);
1421             }
1422         }
1424         $itembackup[$t_item->id] = $item->id;
1425         if ($item->dependitem) {
1426             $dependitemsmap[$item->id] = $item->dependitem;
1427         }
1428     }
1430     //remapping the dependency
1431     foreach ($dependitemsmap as $key => $dependitem) {
1432         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1433         $newitem->dependitem = $itembackup[$newitem->dependitem];
1434         $DB->update_record('feedback_item', $newitem);
1435     }
1438 /**
1439  * get the list of available templates.
1440  * if the $onlyown param is set true so only templates from own course will be served
1441  * this is important for droping templates
1442  *
1443  * @global object
1444  * @param object $course
1445  * @param string $onlyownorpublic
1446  * @return array the template recordsets
1447  */
1448 function feedback_get_template_list($course, $onlyownorpublic = '') {
1449     global $DB, $CFG;
1451     switch($onlyownorpublic) {
1452         case '':
1453             $templates = $DB->get_records_select('feedback_template',
1454                                                  'course = ? OR ispublic = 1',
1455                                                  array($course->id),
1456                                                  'name');
1457             break;
1458         case 'own':
1459             $templates = $DB->get_records('feedback_template',
1460                                           array('course'=>$course->id),
1461                                           'name');
1462             break;
1463         case 'public':
1464             $templates = $DB->get_records('feedback_template', array('ispublic'=>1), 'name');
1465             break;
1466     }
1467     return $templates;
1470 ////////////////////////////////////////////////
1471 //Handling der Items
1472 ////////////////////////////////////////////////
1473 ////////////////////////////////////////////////
1475 /**
1476  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1477  *
1478  * @param string $typ
1479  * @return feedback_item_base the instance of itemclass
1480  */
1481 function feedback_get_item_class($typ) {
1482     global $CFG;
1484     //get the class of item-typ
1485     $itemclass = 'feedback_item_'.$typ;
1486     //get the instance of item-class
1487     if (!class_exists($itemclass)) {
1488         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1489     }
1490     return new $itemclass();
1493 /**
1494  * load the available item plugins from given subdirectory of $CFG->dirroot
1495  * the default is "mod/feedback/item"
1496  *
1497  * @global object
1498  * @param string $dir the subdir
1499  * @return array pluginnames as string
1500  */
1501 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1502     global $CFG;
1503     $names = get_list_of_plugins($dir);
1504     $ret_names = array();
1506     foreach ($names as $name) {
1507         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1508         if (class_exists('feedback_item_'.$name)) {
1509             $ret_names[] = $name;
1510         }
1511     }
1512     return $ret_names;
1515 /**
1516  * load the available item plugins to use as dropdown-options
1517  *
1518  * @global object
1519  * @return array pluginnames as string
1520  */
1521 function feedback_load_feedback_items_options() {
1522     global $CFG;
1524     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1526     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1527         return array();
1528     }
1530     foreach ($feedback_names as $fn) {
1531         $feedback_options[$fn] = get_string($fn, 'feedback');
1532     }
1533     asort($feedback_options);
1534     return $feedback_options;
1537 /**
1538  * load the available items for the depend item dropdown list shown in the edit_item form
1539  *
1540  * @global object
1541  * @param object $feedback
1542  * @param object $item the item of the edit_item form
1543  * @return array all items except the item $item, labels and pagebreaks
1544  */
1545 function feedback_get_depend_candidates_for_item($feedback, $item) {
1546     global $DB;
1547     //all items for dependitem
1548     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1549     $params = array($feedback->id);
1550     if (isset($item->id) AND $item->id) {
1551         $where .= ' AND id != ?';
1552         $params[] = $item->id;
1553     }
1554     $dependitems = array(0 => get_string('choose'));
1555     $feedbackitems = $DB->get_records_select_menu('feedback_item',
1556                                                   $where,
1557                                                   $params,
1558                                                   'position',
1559                                                   'id, label');
1561     if (!$feedbackitems) {
1562         return $dependitems;
1563     }
1564     //adding the choose-option
1565     foreach ($feedbackitems as $key => $val) {
1566         if (trim(strval($val)) !== '') {
1567             $dependitems[$key] = format_string($val);
1568         }
1569     }
1570     return $dependitems;
1573 /**
1574  * creates a new item-record
1575  *
1576  * @deprecated since 3.1
1577  * @param object $data the data from edit_item_form
1578  * @return int the new itemid
1579  */
1580 function feedback_create_item($data) {
1581     debugging('Function feedback_create_item() is deprecated because it was not used.',
1582             DEBUG_DEVELOPER);
1583     global $DB;
1585     $item = new stdClass();
1586     $item->feedback = $data->feedbackid;
1588     $item->template=0;
1589     if (isset($data->templateid)) {
1590             $item->template = intval($data->templateid);
1591     }
1593     $itemname = trim($data->itemname);
1594     $item->name = ($itemname ? $data->itemname : get_string('no_itemname', 'feedback'));
1596     if (!empty($data->itemlabel)) {
1597         $item->label = trim($data->itemlabel);
1598     } else {
1599         $item->label = get_string('no_itemlabel', 'feedback');
1600     }
1602     $itemobj = feedback_get_item_class($data->typ);
1603     $item->presentation = ''; //the date comes from postupdate() of the itemobj
1605     $item->hasvalue = $itemobj->get_hasvalue();
1607     $item->typ = $data->typ;
1608     $item->position = $data->position;
1610     $item->required=0;
1611     if (!empty($data->required)) {
1612         $item->required = $data->required;
1613     }
1615     $item->id = $DB->insert_record('feedback_item', $item);
1617     //move all itemdata to the data
1618     $data->id = $item->id;
1619     $data->feedback = $item->feedback;
1620     $data->name = $item->name;
1621     $data->label = $item->label;
1622     $data->required = $item->required;
1623     return $itemobj->postupdate($data);
1626 /**
1627  * save the changes of a given item.
1628  *
1629  * @global object
1630  * @param object $item
1631  * @return boolean
1632  */
1633 function feedback_update_item($item) {
1634     global $DB;
1635     return $DB->update_record("feedback_item", $item);
1638 /**
1639  * deletes an item and also deletes all related values
1640  *
1641  * @global object
1642  * @uses CONTEXT_MODULE
1643  * @param int $itemid
1644  * @param boolean $renumber should the kept items renumbered Yes/No
1645  * @param object $template if the template is given so the items are bound to it
1646  * @return void
1647  */
1648 function feedback_delete_item($itemid, $renumber = true, $template = false) {
1649     global $DB;
1651     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1653     //deleting the files from the item
1654     $fs = get_file_storage();
1656     if ($template) {
1657         if ($template->ispublic) {
1658             $context = context_system::instance();
1659         } else {
1660             $context = context_course::instance($template->course);
1661         }
1662         $templatefiles = $fs->get_area_files($context->id,
1663                                     'mod_feedback',
1664                                     'template',
1665                                     $item->id,
1666                                     "id",
1667                                     false);
1669         if ($templatefiles) {
1670             $fs->delete_area_files($context->id, 'mod_feedback', 'template', $item->id);
1671         }
1672     } else {
1673         if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1674             return false;
1675         }
1676         $context = context_module::instance($cm->id);
1678         $itemfiles = $fs->get_area_files($context->id,
1679                                     'mod_feedback',
1680                                     'item',
1681                                     $item->id,
1682                                     "id", false);
1684         if ($itemfiles) {
1685             $fs->delete_area_files($context->id, 'mod_feedback', 'item', $item->id);
1686         }
1687     }
1689     $DB->delete_records("feedback_value", array("item"=>$itemid));
1690     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1692     //remove all depends
1693     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1694     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1696     $DB->delete_records("feedback_item", array("id"=>$itemid));
1697     if ($renumber) {
1698         feedback_renumber_items($item->feedback);
1699     }
1702 /**
1703  * deletes all items of the given feedbackid
1704  *
1705  * @global object
1706  * @param int $feedbackid
1707  * @return void
1708  */
1709 function feedback_delete_all_items($feedbackid) {
1710     global $DB, $CFG;
1711     require_once($CFG->libdir.'/completionlib.php');
1713     if (!$feedback = $DB->get_record('feedback', array('id'=>$feedbackid))) {
1714         return false;
1715     }
1717     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
1718         return false;
1719     }
1721     if (!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
1722         return false;
1723     }
1725     if (!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1726         return;
1727     }
1728     foreach ($items as $item) {
1729         feedback_delete_item($item->id, false);
1730     }
1731     if ($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1732         $completion = new completion_info($course);
1733         foreach ($completeds as $completed) {
1734             $DB->delete_records('feedback_completed', array('id' => $completed->id));
1735             // Update completion state
1736             if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC &&
1737                     $feedback->completionsubmit) {
1738                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1739             }
1740         }
1741     }
1743     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1747 /**
1748  * this function toggled the item-attribute required (yes/no)
1749  *
1750  * @global object
1751  * @param object $item
1752  * @return boolean
1753  */
1754 function feedback_switch_item_required($item) {
1755     global $DB, $CFG;
1757     $itemobj = feedback_get_item_class($item->typ);
1759     if ($itemobj->can_switch_require()) {
1760         $new_require_val = (int)!(bool)$item->required;
1761         $params = array('id'=>$item->id);
1762         $DB->set_field('feedback_item', 'required', $new_require_val, $params);
1763     }
1764     return true;
1767 /**
1768  * renumbers all items of the given feedbackid
1769  *
1770  * @global object
1771  * @param int $feedbackid
1772  * @return void
1773  */
1774 function feedback_renumber_items($feedbackid) {
1775     global $DB;
1777     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1778     $pos = 1;
1779     if ($items) {
1780         foreach ($items as $item) {
1781             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1782             $pos++;
1783         }
1784     }
1787 /**
1788  * this decreases the position of the given item
1789  *
1790  * @global object
1791  * @param object $item
1792  * @return bool
1793  */
1794 function feedback_moveup_item($item) {
1795     global $DB;
1797     if ($item->position == 1) {
1798         return true;
1799     }
1801     $params = array('feedback'=>$item->feedback);
1802     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1803         return false;
1804     }
1806     $itembefore = null;
1807     foreach ($items as $i) {
1808         if ($i->id == $item->id) {
1809             if (is_null($itembefore)) {
1810                 return true;
1811             }
1812             $itembefore->position = $item->position;
1813             $item->position--;
1814             feedback_update_item($itembefore);
1815             feedback_update_item($item);
1816             feedback_renumber_items($item->feedback);
1817             return true;
1818         }
1819         $itembefore = $i;
1820     }
1821     return false;
1824 /**
1825  * this increased the position of the given item
1826  *
1827  * @global object
1828  * @param object $item
1829  * @return bool
1830  */
1831 function feedback_movedown_item($item) {
1832     global $DB;
1834     $params = array('feedback'=>$item->feedback);
1835     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1836         return false;
1837     }
1839     $movedownitem = null;
1840     foreach ($items as $i) {
1841         if (!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1842             $movedownitem->position = $i->position;
1843             $i->position--;
1844             feedback_update_item($movedownitem);
1845             feedback_update_item($i);
1846             feedback_renumber_items($item->feedback);
1847             return true;
1848         }
1849         $movedownitem = $i;
1850     }
1851     return false;
1854 /**
1855  * here the position of the given item will be set to the value in $pos
1856  *
1857  * @global object
1858  * @param object $moveitem
1859  * @param int $pos
1860  * @return boolean
1861  */
1862 function feedback_move_item($moveitem, $pos) {
1863     global $DB;
1865     $params = array('feedback'=>$moveitem->feedback);
1866     if (!$allitems = $DB->get_records('feedback_item', $params, 'position')) {
1867         return false;
1868     }
1869     if (is_array($allitems)) {
1870         $index = 1;
1871         foreach ($allitems as $item) {
1872             if ($index == $pos) {
1873                 $index++;
1874             }
1875             if ($item->id == $moveitem->id) {
1876                 $moveitem->position = $pos;
1877                 feedback_update_item($moveitem);
1878                 continue;
1879             }
1880             $item->position = $index;
1881             feedback_update_item($item);
1882             $index++;
1883         }
1884         return true;
1885     }
1886     return false;
1889 /**
1890  * prints the given item as a preview.
1891  * each item-class has an own print_item_preview function implemented.
1892  *
1893  * @deprecated since Moodle 3.1
1894  * @global object
1895  * @param object $item the item what we want to print out
1896  * @return void
1897  */
1898 function feedback_print_item_preview($item) {
1899     debugging('Function feedback_print_item_preview() is deprecated and does nothing. '
1900             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
1903 /**
1904  * prints the given item in the completion form.
1905  * each item-class has an own print_item_complete function implemented.
1906  *
1907  * @deprecated since Moodle 3.1
1908  * @param object $item the item what we want to print out
1909  * @param mixed $value the value
1910  * @param boolean $highlightrequire if this set true and the value are false on completing so the item will be highlighted
1911  * @return void
1912  */
1913 function feedback_print_item_complete($item, $value = false, $highlightrequire = false) {
1914     debugging('Function feedback_print_item_complete() is deprecated and does nothing. '
1915             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
1918 /**
1919  * prints the given item in the show entries page.
1920  * each item-class has an own print_item_show_value function implemented.
1921  *
1922  * @deprecated since Moodle 3.1
1923  * @param object $item the item what we want to print out
1924  * @param mixed $value
1925  * @return void
1926  */
1927 function feedback_print_item_show_value($item, $value = false) {
1928     debugging('Function feedback_print_item_show_value() is deprecated and does nothing. '
1929             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
1932 /**
1933  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1934  * the values are not saved permanently until the user click on save button
1935  *
1936  * @global object
1937  * @param object $feedbackcompleted
1938  * @return object temporary saved completed-record
1939  */
1940 function feedback_set_tmp_values($feedbackcompleted) {
1941     global $DB;
1943     //first we create a completedtmp
1944     $tmpcpl = new stdClass();
1945     foreach ($feedbackcompleted as $key => $value) {
1946         $tmpcpl->{$key} = $value;
1947     }
1948     unset($tmpcpl->id);
1949     $tmpcpl->timemodified = time();
1950     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1951     //get all values of original-completed
1952     if (!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1953         return;
1954     }
1955     foreach ($values as $value) {
1956         unset($value->id);
1957         $value->completed = $tmpcpl->id;
1958         $DB->insert_record('feedback_valuetmp', $value);
1959     }
1960     return $tmpcpl;
1963 /**
1964  * this saves the temporary saved values permanently
1965  *
1966  * @global object
1967  * @param object $feedbackcompletedtmp the temporary completed
1968  * @param object $feedbackcompleted the target completed
1969  * @return int the id of the completed
1970  */
1971 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted) {
1972     global $DB;
1974     $tmpcplid = $feedbackcompletedtmp->id;
1975     if ($feedbackcompleted) {
1976         //first drop all existing values
1977         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1978         //update the current completed
1979         $feedbackcompleted->timemodified = time();
1980         $DB->update_record('feedback_completed', $feedbackcompleted);
1981     } else {
1982         $feedbackcompleted = clone($feedbackcompletedtmp);
1983         $feedbackcompleted->id = '';
1984         $feedbackcompleted->timemodified = time();
1985         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
1986     }
1988     $allitems = $DB->get_records('feedback_item', array('feedback' => $feedbackcompleted->feedback));
1990     //save all the new values from feedback_valuetmp
1991     //get all values of tmp-completed
1992     $params = array('completed'=>$feedbackcompletedtmp->id);
1993     $values = $DB->get_records('feedback_valuetmp', $params);
1994     foreach ($values as $value) {
1995         //check if there are depend items
1996         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
1997         if ($item->dependitem > 0 && isset($allitems[$item->dependitem])) {
1998             $check = feedback_compare_item_value($tmpcplid,
1999                                         $allitems[$item->dependitem],
2000                                         $item->dependvalue,
2001                                         true);
2002         } else {
2003             $check = true;
2004         }
2005         if ($check) {
2006             unset($value->id);
2007             $value->completed = $feedbackcompleted->id;
2008             $DB->insert_record('feedback_value', $value);
2009         }
2010     }
2011     //drop all the tmpvalues
2012     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
2013     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
2015     // Trigger event for the delete action we performed.
2016     $cm = get_coursemodule_from_instance('feedback', $feedbackcompleted->feedback);
2017     $event = \mod_feedback\event\response_submitted::create_from_record($feedbackcompleted, $cm);
2018     $event->trigger();
2019     return $feedbackcompleted->id;
2023 /**
2024  * deletes the given temporary completed and all related temporary values
2025  *
2026  * @deprecated since Moodle 3.1
2027  *
2028  * @param int $tmpcplid
2029  * @return void
2030  */
2031 function feedback_delete_completedtmp($tmpcplid) {
2032     global $DB;
2034     debugging('Function feedback_delete_completedtmp() is deprecated because it is no longer used',
2035             DEBUG_DEVELOPER);
2037     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
2038     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
2041 ////////////////////////////////////////////////
2042 ////////////////////////////////////////////////
2043 ////////////////////////////////////////////////
2044 //functions to handle the pagebreaks
2045 ////////////////////////////////////////////////
2047 /**
2048  * this creates a pagebreak.
2049  * a pagebreak is a special kind of item
2050  *
2051  * @global object
2052  * @param int $feedbackid
2053  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
2054  */
2055 function feedback_create_pagebreak($feedbackid) {
2056     global $DB;
2058     //check if there already is a pagebreak on the last position
2059     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
2060     if ($lastposition == feedback_get_last_break_position($feedbackid)) {
2061         return false;
2062     }
2064     $item = new stdClass();
2065     $item->feedback = $feedbackid;
2067     $item->template=0;
2069     $item->name = '';
2071     $item->presentation = '';
2072     $item->hasvalue = 0;
2074     $item->typ = 'pagebreak';
2075     $item->position = $lastposition + 1;
2077     $item->required=0;
2079     return $DB->insert_record('feedback_item', $item);
2082 /**
2083  * get all positions of pagebreaks in the given feedback
2084  *
2085  * @global object
2086  * @param int $feedbackid
2087  * @return array all ordered pagebreak positions
2088  */
2089 function feedback_get_all_break_positions($feedbackid) {
2090     global $DB;
2092     $params = array('typ'=>'pagebreak', 'feedback'=>$feedbackid);
2093     $allbreaks = $DB->get_records_menu('feedback_item', $params, 'position', 'id, position');
2094     if (!$allbreaks) {
2095         return false;
2096     }
2097     return array_values($allbreaks);
2100 /**
2101  * get the position of the last pagebreak
2102  *
2103  * @param int $feedbackid
2104  * @return int the position of the last pagebreak
2105  */
2106 function feedback_get_last_break_position($feedbackid) {
2107     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2108         return false;
2109     }
2110     return $allbreaks[count($allbreaks) - 1];
2113 /**
2114  * this returns the position where the user can continue the completing.
2115  *
2116  * @deprecated since Moodle 3.1
2117  * @global object
2118  * @global object
2119  * @global object
2120  * @param int $feedbackid
2121  * @param int $courseid
2122  * @param string $guestid this id will be saved temporary and is unique
2123  * @return int the position to continue
2124  */
2125 function feedback_get_page_to_continue($feedbackid, $courseid = false, $guestid = false) {
2126     global $CFG, $USER, $DB;
2128     debugging('Function feedback_get_page_to_continue() is deprecated and since it is '
2129             . 'no longer used in mod_feedback', DEBUG_DEVELOPER);
2131     //is there any break?
2133     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2134         return false;
2135     }
2137     $params = array();
2138     if ($courseid) {
2139         $courseselect = "AND fv.course_id = :courseid";
2140         $params['courseid'] = $courseid;
2141     } else {
2142         $courseselect = '';
2143     }
2145     if ($guestid) {
2146         $userselect = "AND fc.guestid = :guestid";
2147         $usergroup = "GROUP BY fc.guestid";
2148         $params['guestid'] = $guestid;
2149     } else {
2150         $userselect = "AND fc.userid = :userid";
2151         $usergroup = "GROUP BY fc.userid";
2152         $params['userid'] = $USER->id;
2153     }
2155     $sql =  "SELECT MAX(fi.position)
2156                FROM {feedback_completedtmp} fc, {feedback_valuetmp} fv, {feedback_item} fi
2157               WHERE fc.id = fv.completed
2158                     $userselect
2159                     AND fc.feedback = :feedbackid
2160                     $courseselect
2161                     AND fi.id = fv.item
2162          $usergroup";
2163     $params['feedbackid'] = $feedbackid;
2165     $lastpos = $DB->get_field_sql($sql, $params);
2167     //the index of found pagebreak is the searched pagenumber
2168     foreach ($allbreaks as $pagenr => $br) {
2169         if ($lastpos < $br) {
2170             return $pagenr;
2171         }
2172     }
2173     return count($allbreaks);
2176 ////////////////////////////////////////////////
2177 ////////////////////////////////////////////////
2178 ////////////////////////////////////////////////
2179 //functions to handle the values
2180 ////////////////////////////////////////////////
2182 /**
2183  * cleans the userinput while submitting the form.
2184  *
2185  * @deprecated since Moodle 3.1
2186  * @param mixed $value
2187  * @return mixed
2188  */
2189 function feedback_clean_input_value($item, $value) {
2190     debugging('Function feedback_clean_input_value() is deprecated and does nothing. '
2191             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
2194 /**
2195  * this saves the values of an completed.
2196  * if the param $tmp is set true so the values are saved temporary in table feedback_valuetmp.
2197  * if there is already a completed and the userid is set so the values are updated.
2198  * on all other things new value records will be created.
2199  *
2200  * @deprecated since Moodle 3.1
2201  *
2202  * @param int $usrid
2203  * @param boolean $tmp
2204  * @return mixed false on error or the completeid
2205  */
2206 function feedback_save_values($usrid, $tmp = false) {
2207     global $DB;
2209     debugging('Function feedback_save_values() was deprecated because it did not have '.
2210             'enough arguments, was not suitable for non-temporary table and was taking '.
2211             'data directly from input', DEBUG_DEVELOPER);
2213     $completedid = optional_param('completedid', 0, PARAM_INT);
2214     $tmpstr = $tmp ? 'tmp' : '';
2215     $time = time();
2216     $timemodified = mktime(0, 0, 0, date('m', $time), date('d', $time), date('Y', $time));
2218     if ($usrid == 0) {
2219         return feedback_create_values($usrid, $timemodified, $tmp);
2220     }
2221     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2222     if (!$completed) {
2223         return feedback_create_values($usrid, $timemodified, $tmp);
2224     } else {
2225         $completed->timemodified = $timemodified;
2226         return feedback_update_values($completed, $tmp);
2227     }
2230 /**
2231  * this saves the values from anonymous user such as guest on the main-site
2232  *
2233  * @deprecated since Moodle 3.1
2234  *
2235  * @param string $guestid the unique guestidentifier
2236  * @return mixed false on error or the completeid
2237  */
2238 function feedback_save_guest_values($guestid) {
2239     global $DB;
2241     debugging('Function feedback_save_guest_values() was deprecated because it did not have '.
2242             'enough arguments, was not suitable for non-temporary table and was taking '.
2243             'data directly from input', DEBUG_DEVELOPER);
2245     $completedid = optional_param('completedid', false, PARAM_INT);
2247     $timemodified = time();
2248     if (!$completed = $DB->get_record('feedback_completedtmp', array('id'=>$completedid))) {
2249         return feedback_create_values(0, $timemodified, true, $guestid);
2250     } else {
2251         $completed->timemodified = $timemodified;
2252         return feedback_update_values($completed, true);
2253     }
2256 /**
2257  * get the value from the given item related to the given completed.
2258  * the value can come as temporary or as permanently value. the deciding is done by $tmp
2259  *
2260  * @global object
2261  * @param int $completeid
2262  * @param int $itemid
2263  * @param boolean $tmp
2264  * @return mixed the value, the type depends on plugin-definition
2265  */
2266 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
2267     global $DB;
2269     $tmpstr = $tmp ? 'tmp' : '';
2270     $params = array('completed'=>$completedid, 'item'=>$itemid);
2271     return $DB->get_field('feedback_value'.$tmpstr, 'value', $params);
2274 /**
2275  * compares the value of the itemid related to the completedid with the dependvalue.
2276  * this is used if a depend item is set.
2277  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
2278  *
2279  * @param int $completedid
2280  * @param stdClass|int $item
2281  * @param mixed $dependvalue
2282  * @param bool $tmp
2283  * @return bool
2284  */
2285 function feedback_compare_item_value($completedid, $item, $dependvalue, $tmp = false) {
2286     global $DB;
2288     if (is_int($item)) {
2289         $item = $DB->get_record('feedback_item', array('id' => $item));
2290     }
2292     $dbvalue = feedback_get_item_value($completedid, $item->id, $tmp);
2294     $itemobj = feedback_get_item_class($item->typ);
2295     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
2298 /**
2299  * this function checks the correctness of values.
2300  * the rules for this are implemented in the class of each item.
2301  * it can be the required attribute or the value self e.g. numeric.
2302  * the params first/lastitem are given to determine the visible range between pagebreaks.
2303  *
2304  * @global object
2305  * @param int $firstitem the position of firstitem for checking
2306  * @param int $lastitem the position of lastitem for checking
2307  * @return boolean
2308  */
2309 function feedback_check_values($firstitem, $lastitem) {
2310     debugging('Function feedback_check_values() is deprecated and does nothing. '
2311             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
2312     return true;
2315 /**
2316  * this function create a complete-record and the related value-records.
2317  * depending on the $tmp (true/false) the values are saved temporary or permanently
2318  *
2319  * @deprecated since Moodle 3.1
2320  *
2321  * @param int $userid
2322  * @param int $timemodified
2323  * @param boolean $tmp
2324  * @param string $guestid a unique identifier to save temporary data
2325  * @return mixed false on error or the completedid
2326  */
2327 function feedback_create_values($usrid, $timemodified, $tmp = false, $guestid = false) {
2328     global $DB;
2330     debugging('Function feedback_create_values() was deprecated because it did not have '.
2331             'enough arguments, was not suitable for non-temporary table and was taking '.
2332             'data directly from input', DEBUG_DEVELOPER);
2334     $tmpstr = $tmp ? 'tmp' : '';
2335     //first we create a new completed record
2336     $completed = new stdClass();
2337     $completed->feedback           = $feedbackid;
2338     $completed->userid             = $usrid;
2339     $completed->guestid            = $guestid;
2340     $completed->timemodified       = $timemodified;
2341     $completed->anonymous_response = $anonymous_response;
2343     $completedid = $DB->insert_record('feedback_completed'.$tmpstr, $completed);
2345     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2347     //the keys are in the form like abc_xxx
2348     //with explode we make an array with(abc, xxx) and (abc=typ und xxx=itemnr)
2350     //get the items of the feedback
2351     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2352         return false;
2353     }
2354     foreach ($allitems as $item) {
2355         if (!$item->hasvalue) {
2356             continue;
2357         }
2358         //get the class of item-typ
2359         $itemobj = feedback_get_item_class($item->typ);
2361         $keyname = $item->typ.'_'.$item->id;
2363         if ($item->typ === 'multichoice') {
2364             $itemvalue = optional_param_array($keyname, null, PARAM_INT);
2365         } else {
2366             $itemvalue = optional_param($keyname, null, PARAM_NOTAGS);
2367         }
2369         if (is_null($itemvalue)) {
2370             continue;
2371         }
2373         $value = new stdClass();
2374         $value->item = $item->id;
2375         $value->completed = $completed->id;
2376         $value->course_id = $courseid;
2378         //the kind of values can be absolutely different
2379         //so we run create_value directly by the item-class
2380         $value->value = $itemobj->create_value($itemvalue);
2381         $DB->insert_record('feedback_value'.$tmpstr, $value);
2382     }
2383     return $completed->id;
2386 /**
2387  * this function updates a complete-record and the related value-records.
2388  * depending on the $tmp (true/false) the values are saved temporary or permanently
2389  *
2390  * @global object
2391  * @param object $completed
2392  * @param boolean $tmp
2393  * @return int the completedid
2394  */
2395 function feedback_update_values($completed, $tmp = false) {
2396     global $DB;
2398     debugging('Function feedback_update_values() was deprecated because it did not have '.
2399             'enough arguments, was not suitable for non-temporary table and was taking '.
2400             'data directly from input', DEBUG_DEVELOPER);
2402     $courseid = optional_param('courseid', false, PARAM_INT);
2403     $tmpstr = $tmp ? 'tmp' : '';
2405     $DB->update_record('feedback_completed'.$tmpstr, $completed);
2406     //get the values of this completed
2407     $values = $DB->get_records('feedback_value'.$tmpstr, array('completed'=>$completed->id));
2409     //get the items of the feedback
2410     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2411         return false;
2412     }
2413     foreach ($allitems as $item) {
2414         if (!$item->hasvalue) {
2415             continue;
2416         }
2417         //get the class of item-typ
2418         $itemobj = feedback_get_item_class($item->typ);
2420         $keyname = $item->typ.'_'.$item->id;
2422         if ($item->typ === 'multichoice') {
2423             $itemvalue = optional_param_array($keyname, null, PARAM_INT);
2424         } else {
2425             $itemvalue = optional_param($keyname, null, PARAM_NOTAGS);
2426         }
2428         //is the itemvalue set (could be a subset of items because pagebreak)?
2429         if (is_null($itemvalue)) {
2430             continue;
2431         }
2433         $newvalue = new stdClass();
2434         $newvalue->item = $item->id;
2435         $newvalue->completed = $completed->id;
2436         $newvalue->course_id = $courseid;
2438         //the kind of values can be absolutely different
2439         //so we run create_value directly by the item-class
2440         $newvalue->value = $itemobj->create_value($itemvalue);
2442         //check, if we have to create or update the value
2443         $exist = false;
2444         foreach ($values as $value) {
2445             if ($value->item == $newvalue->item) {
2446                 $newvalue->id = $value->id;
2447                 $exist = true;
2448                 break;
2449             }
2450         }
2451         if ($exist) {
2452             $DB->update_record('feedback_value'.$tmpstr, $newvalue);
2453         } else {
2454             $DB->insert_record('feedback_value'.$tmpstr, $newvalue);
2455         }
2456     }
2458     return $completed->id;
2461 /**
2462  * get the values of an item depending on the given groupid.
2463  * if the feedback is anonymous so the values are shuffled
2464  *
2465  * @global object
2466  * @global object
2467  * @param object $item
2468  * @param int $groupid
2469  * @param int $courseid
2470  * @param bool $ignore_empty if this is set true so empty values are not delivered
2471  * @return array the value-records
2472  */
2473 function feedback_get_group_values($item,
2474                                    $groupid = false,
2475                                    $courseid = false,
2476                                    $ignore_empty = false) {
2478     global $CFG, $DB;
2480     //if the groupid is given?
2481     if (intval($groupid) > 0) {
2482         $params = array();
2483         if ($ignore_empty) {
2484             $value = $DB->sql_compare_text('fbv.value');
2485             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2486             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2487         } else {
2488             $ignore_empty_select = "";
2489         }
2491         $query = 'SELECT fbv .  *
2492                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2493                    WHERE fbv.item = :itemid
2494                          AND fbv.completed = fbc.id
2495                          AND fbc.userid = gm.userid
2496                          '.$ignore_empty_select.'
2497                          AND gm.groupid = :groupid
2498                 ORDER BY fbc.timemodified';
2499         $params += array('itemid' => $item->id, 'groupid' => $groupid);
2500         $values = $DB->get_records_sql($query, $params);
2502     } else {
2503         $params = array();
2504         if ($ignore_empty) {
2505             $value = $DB->sql_compare_text('value');
2506             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2507             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2508         } else {
2509             $ignore_empty_select = "";
2510         }
2512         if ($courseid) {
2513             $select = "item = :itemid AND course_id = :courseid ".$ignore_empty_select;
2514             $params += array('itemid' => $item->id, 'courseid' => $courseid);
2515             $values = $DB->get_records_select('feedback_value', $select, $params);
2516         } else {
2517             $select = "item = :itemid ".$ignore_empty_select;
2518             $params += array('itemid' => $item->id);
2519             $values = $DB->get_records_select('feedback_value', $select, $params);
2520         }
2521     }
2522     $params = array('id'=>$item->feedback);
2523     if ($DB->get_field('feedback', 'anonymous', $params) == FEEDBACK_ANONYMOUS_YES) {
2524         if (is_array($values)) {
2525             shuffle($values);
2526         }
2527     }
2528     return $values;
2531 /**
2532  * check for multiple_submit = false.
2533  * if the feedback is global so the courseid must be given
2534  *
2535  * @global object
2536  * @global object
2537  * @param int $feedbackid
2538  * @param int $courseid
2539  * @return boolean true if the feedback already is submitted otherwise false
2540  */
2541 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2542     global $USER, $DB;
2544     if (!isloggedin() || isguestuser()) {
2545         return false;
2546     }
2548     $params = array('userid' => $USER->id, 'feedback' => $feedbackid);
2549     if ($courseid) {
2550         $params['courseid'] = $courseid;
2551     }
2552     return $DB->record_exists('feedback_completed', $params);
2555 /**
2556  * if the completion of a feedback will be continued eg.
2557  * by pagebreak or by multiple submit so the complete must be found.
2558  * if the param $tmp is set true so all things are related to temporary completeds
2559  *
2560  * @deprecated since Moodle 3.1
2561  * @param int $feedbackid
2562  * @param boolean $tmp
2563  * @param int $courseid
2564  * @param string $guestid
2565  * @return int the id of the found completed
2566  */
2567 function feedback_get_current_completed($feedbackid,
2568                                         $tmp = false,
2569                                         $courseid = false,
2570                                         $guestid = false) {
2572     debugging('Function feedback_get_current_completed() is deprecated. Please use either '.
2573             'feedback_get_current_completed_tmp() or feedback_get_last_completed()',
2574             DEBUG_DEVELOPER);
2576     global $USER, $CFG, $DB;
2578     $tmpstr = $tmp ? 'tmp' : '';
2580     if (!$courseid) {
2581         if ($guestid) {
2582             $params = array('feedback'=>$feedbackid, 'guestid'=>$guestid);
2583             return $DB->get_record('feedback_completed'.$tmpstr, $params);
2584         } else {
2585             $params = array('feedback'=>$feedbackid, 'userid'=>$USER->id);
2586             return $DB->get_record('feedback_completed'.$tmpstr, $params);
2587         }
2588     }
2590     $params = array();
2592     if ($guestid) {
2593         $userselect = "AND fc.guestid = :guestid";
2594         $params['guestid'] = $guestid;
2595     } else {
2596         $userselect = "AND fc.userid = :userid";
2597         $params['userid'] = $USER->id;
2598     }
2599     //if courseid is set the feedback is global.
2600     //there can be more than one completed on one feedback
2601     $sql =  "SELECT DISTINCT fc.*
2602                FROM {feedback_value{$tmpstr}} fv, {feedback_completed{$tmpstr}} fc
2603               WHERE fv.course_id = :courseid
2604                     AND fv.completed = fc.id
2605                     $userselect
2606                     AND fc.feedback = :feedbackid";
2607     $params['courseid']   = intval($courseid);
2608     $params['feedbackid'] = $feedbackid;
2610     if (!$sqlresult = $DB->get_records_sql($sql, $params)) {
2611         return false;
2612     }
2613     foreach ($sqlresult as $r) {
2614         return $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$r->id));
2615     }
2618 /**
2619  * get the completeds depending on the given groupid.
2620  *
2621  * @global object
2622  * @global object
2623  * @param object $feedback
2624  * @param int $groupid
2625  * @param int $courseid
2626  * @return mixed array of found completeds otherwise false
2627  */
2628 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2629     global $CFG, $DB;
2631     if (intval($groupid) > 0) {
2632         $query = "SELECT fbc.*
2633                     FROM {feedback_completed} fbc, {groups_members} gm
2634                    WHERE fbc.feedback = ?
2635                          AND gm.groupid = ?
2636                          AND fbc.userid = gm.userid";
2637         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2638             return $values;
2639         } else {
2640             return false;
2641         }
2642     } else {
2643         if ($courseid) {
2644             $query = "SELECT DISTINCT fbc.*
2645                         FROM {feedback_completed} fbc, {feedback_value} fbv
2646                         WHERE fbc.id = fbv.completed
2647                             AND fbc.feedback = ?
2648                             AND fbv.course_id = ?
2649                         ORDER BY random_response";
2650             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2651                 return $values;
2652             } else {
2653                 return false;
2654             }
2655         } else {
2656             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2657                 return $values;
2658             } else {
2659                 return false;
2660             }
2661         }
2662     }
2665 /**
2666  * get the count of completeds depending on the given groupid.
2667  *
2668  * @global object
2669  * @global object
2670  * @param object $feedback
2671  * @param int $groupid
2672  * @param int $courseid
2673  * @return mixed count of completeds or false
2674  */
2675 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2676     global $CFG, $DB;
2678     if ($courseid > 0 AND !$groupid <= 0) {
2679         $sql = "SELECT id, COUNT(item) AS ci
2680                   FROM {feedback_value}
2681                  WHERE course_id  = ?
2682               GROUP BY item ORDER BY ci DESC";
2683         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2684             $foundrecs = array_values($foundrecs);
2685             return $foundrecs[0]->ci;
2686         }
2687         return false;
2688     }
2689     if ($values = feedback_get_completeds_group($feedback, $groupid)) {
2690         return count($values);
2691     } else {
2692         return false;
2693     }
2696 /**
2697  * deletes all completed-recordsets from a feedback.
2698  * all related data such as values also will be deleted
2699  *
2700  * @param stdClass|int $feedback
2701  * @param stdClass|cm_info $cm
2702  * @param stdClass $course
2703  * @return void
2704  */
2705 function feedback_delete_all_completeds($feedback, $cm = null, $course = null) {
2706     global $DB;
2708     if (is_int($feedback)) {
2709         $feedback = $DB->get_record('feedback', array('id' => $feedback));
2710     }
2712     if (!$completeds = $DB->get_records('feedback_completed', array('feedback' => $feedback->id))) {
2713         return;
2714     }
2716     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2717         return false;
2718     }
2720     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2721         return false;
2722     }
2724     foreach ($completeds as $completed) {
2725         feedback_delete_completed($completed, $feedback, $cm, $course);
2726     }
2729 /**
2730  * deletes a completed given by completedid.
2731  * all related data such values or tracking data also will be deleted
2732  *
2733  * @param int|stdClass $completed
2734  * @param stdClass $feedback
2735  * @param stdClass|cm_info $cm
2736  * @param stdClass $course
2737  * @return boolean
2738  */
2739 function feedback_delete_completed($completed, $feedback = null, $cm = null, $course = null) {
2740     global $DB, $CFG;
2741     require_once($CFG->libdir.'/completionlib.php');
2743     if (!isset($completed->id)) {
2744         if (!$completed = $DB->get_record('feedback_completed', array('id' => $completed))) {
2745             return false;
2746         }
2747     }
2749     if (!$feedback && !($feedback = $DB->get_record('feedback', array('id' => $completed->feedback)))) {
2750         return false;
2751     }
2753     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2754         return false;
2755     }
2757     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2758         return false;
2759     }
2761     //first we delete all related values
2762     $DB->delete_records('feedback_value', array('completed' => $completed->id));
2764     // Delete the completed record.
2765     $return = $DB->delete_records('feedback_completed', array('id' => $completed->id));
2767     // Update completion state
2768     $completion = new completion_info($course);
2769     if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC && $feedback->completionsubmit) {
2770         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
2771     }
2772     // Trigger event for the delete action we performed.
2773     $event = \mod_feedback\event\response_deleted::create_from_record($completed, $cm, $feedback);
2774     $event->trigger();
2776     return $return;
2779 ////////////////////////////////////////////////
2780 ////////////////////////////////////////////////
2781 ////////////////////////////////////////////////
2782 //functions to handle sitecourse mapping
2783 ////////////////////////////////////////////////
2785 /**
2786  * checks if the course and the feedback is in the table feedback_sitecourse_map.
2787  *
2788  * @deprecated since 3.1
2789  * @param int $feedbackid
2790  * @param int $courseid
2791  * @return int the count of records
2792  */
2793 function feedback_is_course_in_sitecourse_map($feedbackid, $courseid) {
2794     debugging('Function feedback_is_course_in_sitecourse_map() is deprecated because it was not used.',
2795             DEBUG_DEVELOPER);
2796     global $DB;
2797     $params = array('feedbackid'=>$feedbackid, 'courseid'=>$courseid);
2798     return $DB->count_records('feedback_sitecourse_map', $params);
2801 /**
2802  * checks if the feedback is in the table feedback_sitecourse_map.
2803  *
2804  * @deprecated since 3.1
2805  * @param int $feedbackid
2806  * @return boolean
2807  */
2808 function feedback_is_feedback_in_sitecourse_map($feedbackid) {
2809     debugging('Function feedback_is_feedback_in_sitecourse_map() is deprecated because it was not used.',
2810             DEBUG_DEVELOPER);
2811     global $DB;
2812     return $DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$feedbackid));
2815 /**
2816  * gets the feedbacks from table feedback_sitecourse_map.
2817  * this is used to show the global feedbacks on the feedback block
2818  * all feedbacks with the following criteria will be selected:<br />
2819  *
2820  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2821  * 2) all feedbacks which not are listed in sitecoursemap
2822  *
2823  * @global object
2824  * @param int $courseid
2825  * @return array the feedback-records
2826  */
2827 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2828     global $DB;
2830     //first get all feedbacks listed in sitecourse_map with named courseid
2831     $sql = "SELECT f.id AS id,
2832                    cm.id AS cmid,
2833                    f.name AS name,
2834                    f.timeopen AS timeopen,
2835                    f.timeclose AS timeclose
2836             FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2837             WHERE f.id = cm.instance
2838                    AND f.course = '".SITEID."'
2839                    AND m.id = cm.module
2840                    AND m.name = 'feedback'
2841                    AND sm.courseid = ?
2842                    AND sm.feedbackid = f.id";
2844     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2845         $feedbacks1 = array();
2846     }
2848     //second get all feedbacks not listed in sitecourse_map
2849     $feedbacks2 = array();
2850     $sql = "SELECT f.id AS id,
2851                    cm.id AS cmid,
2852                    f.name AS name,
2853                    f.timeopen AS timeopen,
2854                    f.timeclose AS timeclose
2855             FROM {feedback} f, {course_modules} cm, {modules} m
2856             WHERE f.id = cm.instance
2857                    AND f.course = '".SITEID."'
2858                    AND m.id = cm.module
2859                    AND m.name = 'feedback'";
2860     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2861         $allfeedbacks = array();
2862     }
2863     foreach ($allfeedbacks as $a) {
2864         if (!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2865             $feedbacks2[] = $a;
2866         }
2867     }
2869     $feedbacks = array_merge($feedbacks1, $feedbacks2);
2870     $modinfo = get_fast_modinfo(SITEID);
2871     return array_filter($feedbacks, function($f) use ($modinfo) {
2872         return ($cm = $modinfo->get_cm($f->cmid)) && $cm->uservisible;
2873     });
2877 /**
2878  * Gets the courses from table feedback_sitecourse_map
2879  *
2880  * @param int $feedbackid
2881  * @return array the course-records
2882  */
2883 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2884     global $DB;
2886     $sql = "SELECT c.id, c.fullname, c.shortname
2887               FROM {feedback_sitecourse_map} f, {course} c
2888              WHERE c.id = f.courseid
2889                    AND f.feedbackid = ?
2890           ORDER BY c.fullname";
2892     return $DB->get_records_sql($sql, array($feedbackid));
2896 /**
2897  * Updates the course mapping for the feedback
2898  *
2899  * @param stdClass $feedback
2900  * @param array $courses array of course ids
2901  */
2902 function feedback_update_sitecourse_map($feedback, $courses) {
2903     global $DB;
2904     if (empty($courses)) {
2905         $courses = array();
2906     }
2907     $currentmapping = $DB->get_fieldset_select('feedback_sitecourse_map', 'courseid', 'feedbackid=?', array($feedback->id));
2908     foreach (array_diff($courses, $currentmapping) as $courseid) {
2909         $DB->insert_record('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2910     }
2911     foreach (array_diff($currentmapping, $courses) as $courseid) {
2912         $DB->delete_records('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2913     }
2914     // TODO MDL-53574 add events.
2917 /**
2918  * removes non existing courses or feedbacks from sitecourse_map.
2919  * it shouldn't be called all too often
2920  * a good place for it could be the mapcourse.php or unmapcourse.php
2921  *
2922  * @deprecated since 3.1
2923  * @global object
2924  * @return void
2925  */
2926 function feedback_clean_up_sitecourse_map() {
2927     global $DB;
2928     debugging('Function feedback_clean_up_sitecourse_map() is deprecated because it was not used.',
2929             DEBUG_DEVELOPER);
2931     $maps = $DB->get_records('feedback_sitecourse_map');
2932     foreach ($maps as $map) {
2933         if (!$DB->get_record('course', array('id'=>$map->courseid))) {
2934             $params = array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid);
2935             $DB->delete_records('feedback_sitecourse_map', $params);
2936             continue;
2937         }
2938         if (!$DB->get_record('feedback', array('id'=>$map->feedbackid))) {
2939             $params = array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid);
2940             $DB->delete_records('feedback_sitecourse_map', $params);
2941             continue;
2942         }
2944     }
2947 ////////////////////////////////////////////////
2948 ////////////////////////////////////////////////
2949 ////////////////////////////////////////////////
2950 //not relatable functions
2951 ////////////////////////////////////////////////
2953 /**
2954  * prints the option items of a selection-input item (dropdownlist).
2955  * @deprecated since 3.1
2956  * @param int $startval the first value of the list
2957  * @param int $endval the last value of the list
2958  * @param int $selectval which item should be selected
2959  * @param int $interval the stepsize from the first to the last value
2960  * @return void
2961  */
2962 function feedback_print_numeric_option_list($startval, $endval, $selectval = '', $interval = 1) {
2963     debugging('Function feedback_print_numeric_option_list() is deprecated because it was not used.',
2964             DEBUG_DEVELOPER);
2965     for ($i = $startval; $i <= $endval; $i += $interval) {
2966         if ($selectval == ($i)) {
2967             $selected = 'selected="selected"';
2968         } else {
2969             $selected = '';
2970         }
2971         echo '<option '.$selected.'>'.$i.'</option>';
2972     }
2975 /**
2976  * sends an email to the teachers of the course where the given feedback is placed.
2977  *
2978  * @global object
2979  * @global object
2980  * @uses FEEDBACK_ANONYMOUS_NO
2981  * @uses FORMAT_PLAIN
2982  * @param object $cm the coursemodule-record
2983  * @param object $feedback
2984  * @param object $course
2985  * @param stdClass|int $user
2986  * @param stdClass $completed record from feedback_completed if known
2987  * @return void
2988  */
2989 function feedback_send_email($cm, $feedback, $course, $user, $completed = null) {
2990     global $CFG, $DB;
2992     if ($feedback->email_notification == 0) {  // No need to do anything
2993         return;
2994     }
2996     if (is_int($user)) {
2997         $user = $DB->get_record('user', array('id' => $user));
2998     }
3000     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
3001         $groupmode =  $cm->groupmode;
3002     } else {
3003         $groupmode = $course->groupmode;
3004     }
3006     if ($groupmode == SEPARATEGROUPS) {
3007         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
3008                                                FROM {groups} g, {groups_members} m
3009                                               WHERE g.courseid = ?
3010                                                     AND g.id = m.groupid
3011                                                     AND m.userid = ?
3012                                            ORDER BY name ASC", array($course->id, $user->id));
3013         $groups = array_values($groups);
3015         $teachers = feedback_get_receivemail_users($cm->id, $groups);
3016     } else {
3017         $teachers = feedback_get_receivemail_users($cm->id);
3018     }
3020     if ($teachers) {
3022         $strfeedbacks = get_string('modulenameplural', 'feedback');
3023         $strfeedback  = get_string('modulename', 'feedback');
3025         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
3026             $printusername = fullname($user);
3027         } else {
3028             $printusername = get_string('anonymous_user', 'feedback');
3029         }
3031         foreach ($teachers as $teacher) {
3032             $info = new stdClass();
3033             $info->username = $printusername;
3034             $info->feedback = format_string($feedback->name, true);
3035             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?'.
3036                             'id='.$cm->id.'&'.
3037                             'userid=' . $user->id;
3038             if ($completed) {
3039                 $info->url .= '&showcompleted=' . $completed->id;
3040                 if ($feedback->course == SITEID) {
3041                     // Course where feedback was completed (for site feedbacks only).
3042                     $info->url .= '&courseid=' . $completed->courseid;
3043                 }
3044             }
3046             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
3048             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
3049             $posttext = feedback_send_email_text($info, $course);
3051             if ($teacher->mailformat == 1) {
3052                 $posthtml = feedback_send_email_html($info, $course, $cm);
3053             } else {
3054                 $posthtml = '';
3055             }
3057             if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
3058                 $eventdata = new \core\message\message();
3059                 $eventdata->courseid         = $course->id;
3060                 $eventdata->name             = 'submission';
3061                 $eventdata->component        = 'mod_feedback';
3062                 $eventdata->userfrom         = $user;
3063                 $eventdata->userto           = $teacher;
3064                 $eventdata->subject          = $postsubject;
3065                 $eventdata->fullmessage      = $posttext;
3066                 $eventdata->fullmessageformat = FORMAT_PLAIN;
3067                 $eventdata->fullmessagehtml  = $posthtml;
3068                 $eventdata->smallmessage     = '';
3069                 $eventdata->courseid         = $course->id;
3070                 $eventdata->contexturl       = $info->url;
3071                 $eventdata->contexturlname   = $info->feedback;
3072                 message_send($eventdata);
3073             } else {
3074                 $eventdata = new \core\message\message();
3075                 $eventdata->courseid         = $course->id;
3076                 $eventdata->name             = 'submission';
3077                 $eventdata->component        = 'mod_feedback';
3078                 $eventdata->userfrom         = $teacher;
3079                 $eventdata->userto           = $teacher;
3080                 $eventdata->subject          = $postsubject;
3081                 $eventdata->fullmessage      = $posttext;
3082                 $eventdata->fullmessageformat = FORMAT_PLAIN;
3083                 $eventdata->fullmessagehtml  = $posthtml;
3084                 $eventdata->smallmessage     = '';
3085                 $eventdata->courseid         = $course->id;
3086                 $eventdata->contexturl       = $info->url;
3087                 $eventdata->contexturlname   = $info->feedback;
3088                 message_send($eventdata);
3089             }
3090         }
3091     }
3094 /**
3095  * sends an email to the teachers of the course where the given feedback is placed.
3096  *
3097  * @global object
3098  * @uses FORMAT_PLAIN
3099  * @param object $cm the coursemodule-record
3100  * @param object $feedback
3101  * @param object $course
3102  * @return void
3103  */
3104 function feedback_send_email_anonym($cm, $feedback, $course) {
3105     global $CFG;
3107     if ($feedback->email_notification == 0) { // No need to do anything
3108         return;
3109     }
3111     $teachers = feedback_get_receivemail_users($cm->id);
3113     if ($teachers) {
3115         $strfeedbacks = get_string('modulenameplural', 'feedback');
3116         $strfeedback  = get_string('modulename', 'feedback');
3117         $printusername = get_string('anonymous_user', 'feedback');
3119         foreach ($teachers as $teacher) {
3120             $info = new stdClass();
3121             $info->username = $printusername;
3122             $info->feedback = format_string($feedback->name, true);
3123             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?id=' . $cm->id;
3125             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
3127             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
3128             $posttext = feedback_send_email_text($info, $course);
3130             if ($teacher->mailformat == 1) {
3131                 $posthtml = feedback_send_email_html($info, $course, $cm);
3132             } else {
3133                 $posthtml = '';
3134             }
3136             $eventdata = new \core\message\message();
3137             $eventdata->courseid         = $course->id;
3138             $eventdata->name             = 'submission';
3139             $eventdata->component        = 'mod_feedback';
3140             $eventdata->userfrom         = $teacher;
3141             $eventdata->userto           = $teacher;
3142             $eventdata->subject          = $postsubject;
3143             $eventdata->fullmessage      = $posttext;
3144             $eventdata->fullmessageformat = FORMAT_PLAIN;
3145             $eventdata->fullmessagehtml  = $posthtml;
3146             $eventdata->smallmessage     = '';
3147             $eventdata->courseid         = $course->id;
3148             $eventdata->contexturl       = $info->url;
3149             $eventdata->contexturlname   = $info->feedback;
3150             message_send($eventdata);
3151         }
3152     }
3155 /**
3156  * send the text-part of the email
3157  *
3158  * @param object $info includes some infos about the feedback you want to send
3159  * @param object $course
3160  * @return string the text you want to post
3161  */
3162 function feedback_send_email_text($info, $course) {
3163     $coursecontext = context_course::instance($course->id);
3164     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
3165     $posttext  = $courseshortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
3166                     $info->feedback."\n";
3167     $posttext .= '---------------------------------------------------------------------'."\n";
3168     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
3169     $posttext .= '---------------------------------------------------------------------'."\n";
3170     return $posttext;
3174 /**
3175  * send the html-part of the email
3176  *
3177  * @global object
3178  * @param object $info includes some infos about the feedback you want to send
3179  * @param object $course
3180  * @return string the text you want to post
3181  */
3182 function feedback_send_email_html($info, $course, $cm) {
3183     global $CFG;
3184     $coursecontext = context_course::instance($course->id);
3185     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
3186     $course_url = $CFG->wwwroot.'/course/view.php?id='.$course->id;
3187     $feedback_all_url = $CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id;
3188     $feedback_url = $CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id;
3190     $posthtml = '<p><font face="sans-serif">'.
3191             '<a href="'.$course_url.'">'.$courseshortname.'</a> ->'.
3192             '<a href="'.$feedback_all_url.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
3193             '<a href="'.$feedback_url.'">'.$info->feedback.'</a></font></p>';
3194     $posthtml .= '<hr /><font face="sans-serif">';
3195     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
3196     $posthtml .= '</font><hr />';
3197     return $posthtml;
3200 /**
3201  * @param string $url
3202  * @return string
3203  */
3204 function feedback_encode_target_url($url) {
3205     if (strpos($url, '?')) {
3206         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
3207         return $part1 . '?' . htmlentities($part2);
3208     } else {
3209         return $url;
3210     }
3213 /**
3214  * Adds module specific settings to the settings block
3215  *
3216  * @param settings_navigation $settings The settings navigation object
3217  * @param navigation_node $feedbacknode The node to add module settings to
3218  */
3219 function feedback_extend_settings_navigation(settings_navigation $settings,
3220                                              navigation_node $feedbacknode) {
3222     global $PAGE;
3224     if (!$context = context_module::instance($PAGE->cm->id, IGNORE_MISSING)) {
3225         print_error('badcontext');
3226     }
3228     if (has_capability('mod/feedback:edititems', $context)) {
3229         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
3231         $questionnode->add(get_string('edit_items', 'feedback'),
3232                     new moodle_url('/mod/feedback/edit.php',
3233                                     array('id' => $PAGE->cm->id,
3234                                           'do_show' => 'edit')));
3236         $questionnode->add(get_string('export_questions', 'feedback'),
3237                     new moodle_url('/mod/feedback/export.php',
3238                                     array('id' => $PAGE->cm->id,
3239                                           'action' => 'exportfile')));
3241         $questionnode->add(get_string('import_questions', 'feedback'),
3242                     new moodle_url('/mod/feedback/import.php',
3243                                     array('id' => $PAGE->cm->id)));
3245         $questionnode->add(get_string('templates', 'feedback'),
3246                     new moodle_url('/mod/feedback/edit.php',
3247                                     array('id' => $PAGE->cm->id,
3248                                           'do_show' => 'templates')));
3249     }
3251     if (has_capability('mod/feedback:mapcourse', $context) && $PAGE->course->id == SITEID) {
3252         $feedbacknode->add(get_string('mappedcourses', 'feedback'),
3253                     new moodle_url('/mod/feedback/mapcourse.php',
3254                                     array('id' => $PAGE->cm->id)));
3255     }
3257     if (has_capability('mod/feedback:viewreports', $context)) {
3258         $feedback = $PAGE->activityrecord;
3259         if ($feedback->course == SITEID) {
3260             $feedbacknode->add(get_string('analysis', 'feedback'),
3261                     new moodle_url('/mod/feedback/analysis_course.php',
3262                                     array('id' => $PAGE->cm->id)));
3263         } else {
3264             $feedbacknode->add(get_string('analysis', 'feedback'),
3265                     new moodle_url('/mod/feedback/analysis.php',
3266                                     array('id' => $PAGE->cm->id)));
3267         }
3269         $feedbacknode->add(get_string('show_entries', 'feedback'),
3270                     new moodle_url('/mod/feedback/show_entries.php',
3271                                     array('id' => $PAGE->cm->id)));
3273         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO AND $feedback->course != SITEID) {
3274             $feedbacknode->add(get_string('show_nonrespondents', 'feedback'),
3275                         new moodle_url('/mod/feedback/show_nonrespondents.php',
3276                                         array('id' => $PAGE->cm->id)));
3277         }
3278     }
3281 function feedback_init_feedback_session() {
3282     //initialize the feedback-Session - not nice at all!!
3283     global $SESSION;
3284     if (!empty($SESSION)) {
3285         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
3286             $SESSION->feedback = new stdClass();
3287         }
3288     }
3291 /**
3292  * Return a list of page types
3293  * @param string $pagetype current page type
3294  * @param stdClass $parentcontext Block's parent context
3295  * @param stdClass $currentcontext Current context of block
3296  */
3297 function feedback_page_type_list($pagetype, $parentcontext, $currentcontext) {
3298     $module_pagetype = array('mod-feedback-*'=>get_string('page-mod-feedback-x', 'feedback'));
3299     return $module_pagetype;
3302 /**
3303  * Move save the items of the given $feedback in the order of $itemlist.
3304  * @param string $itemlist a comma separated list with item ids
3305  * @param stdClass $feedback
3306  * @return bool true if success
3307  */
3308 function feedback_ajax_saveitemorder($itemlist, $feedback) {
3309     global $DB;
3311     $result = true;
3312     $position = 0;
3313     foreach ($itemlist as $itemid) {
3314         $position++;
3315         $result = $result && $DB->set_field('feedback_item',
3316                                             'position',
3317                                             $position,
3318                                             array('id'=>$itemid, 'feedback'=>$feedback->id));
3319     }
3320     return $result;
3323 /**
3324  * Checks if current user is able to view feedback on this course.
3325  *
3326  * @param stdClass $feedback
3327  * @param context_module $context
3328  * @param int $courseid
3329  * @return bool
3330  */
3331 function feedback_can_view_analysis($feedback, $context, $courseid = false) {
3332     if (has_capability('mod/feedback:viewreports', $context)) {
3333         return true;
3334     }
3336     if (intval($feedback->publish_stats) != 1 ||
3337             !has_capability('mod/feedback:viewanalysepage', $context)) {
3338         return false;
3339     }
3341     if (!isloggedin() || isguestuser()) {
3342         // There is no tracking for the guests, assume that they can view analysis if condition above is satisfied.
3343         return $feedback->course == SITEID;
3344     }
3346     return feedback_is_already_submitted($feedback->id, $courseid);
3349 /**
3350  * Get icon mapping for font-awesome.
3351  */
3352 function mod_feedback_get_fontawesome_icon_map() {
3353     return [
3354         'mod_feedback:required' => 'fa-exclamation-circle',
3355         'mod_feedback:notrequired' => 'fa-question-circle-o',
3356     ];
3359 /**
3360  * Check if the module has any update that affects the current user since a given time.
3361  *
3362  * @param  cm_info $cm course module data
3363  * @param  int $from the time to check updates from
3364  * @param  array $filter if we need to check only specific updates
3365  * @return stdClass an object with the different type of areas indicating if they were updated or not
3366  * @since Moodle 3.3
3367  */
3368 function feedback_check_updates_since(cm_info $cm, $from, $filter = array()) {
3369     global $DB, $USER, $CFG;
3371     $updates = course_check_module_updates_since($cm, $from, array(), $filter);
3373     // Check for new attempts.
3374     $updates->attemptsfinished = (object) array('updated' => false);
3375     $updates->attemptsunfinished = (object) array('updated' => false);
3376     $select = 'feedback = ? AND userid = ? AND timemodified > ?';
3377     $params = array($cm->instance, $USER->id, $from);
3379     $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
3380     if (!empty($attemptsfinished)) {
3381         $updates->attemptsfinished->updated = true;
3382         $updates->attemptsfinished->itemids = array_keys($attemptsfinished);
3383     }
3384     $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
3385     if (!empty($attemptsunfinished)) {
3386         $updates->attemptsunfinished->updated = true;
3387         $updates->attemptsunfinished->itemids = array_keys($attemptsunfinished);
3388     }
3390     // Now, teachers should see other students updates.
3391     if (has_capability('mod/feedback:viewreports', $cm->context)) {
3392         $select = 'feedback = ? AND timemodified > ?';
3393         $params = array($cm->instance, $from);
3395         if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
3396             $groupusers = array_keys(groups_get_activity_shared_group_members($cm));
3397             if (empty($groupusers)) {
3398                 return $updates;
3399             }
3400             list($insql, $inparams) = $DB->get_in_or_equal($groupusers);
3401             $select .= ' AND userid ' . $insql;
3402             $params = array_merge($params, $inparams);
3403         }
3405         $updates->userattemptsfinished = (object) array('updated' => false);
3406         $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
3407         if (!empty($attemptsfinished)) {
3408             $updates->userattemptsfinished->updated = true;
3409             $updates->userattemptsfinished->itemids = array_keys($attemptsfinished);
3410         }
3412         $updates->userattemptsunfinished = (object) array('updated' => false);
3413         $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
3414         if (!empty($attemptsunfinished)) {
3415             $updates->userattemptsunfinished->updated = true;
3416             $updates->userattemptsunfinished->itemids = array_keys($attemptsunfinished);
3417         }
3418     }
3420     return $updates;
3423 /**
3424  * The event is only visible anywhere if the user can submit feedback.
3425  *
3426  * @param calendar_event $event
3427  * @return bool Returns true if the event is visible to the current user, false otherwise.
3428  */
3429 function mod_feedback_core_calendar_is_event_visible(calendar_event $event) {
3430     global $DB;
3432     $cm = get_fast_modinfo($event->courseid)->instances['feedback'][$event->instance];
3433     $feedbackcompletion = new mod_feedback_completion(null, $cm, 0);
3435     // The event is only visible if the user can submit it.
3436     return $feedbackcompletion->can_complete();
3439 /**
3440  * This function receives a calendar event and returns the action associated with it, or null if there is none.
3441  *
3442  * This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
3443  * is not displayed on the block.
3444  *
3445  * @param calendar_event $event
3446  * @param \core_calendar\action_factory $factory
3447  * @return \core_calendar\local\event\entities\action_interface|null
3448  */
3449 function mod_feedback_core_calendar_provide_event_action(calendar_event $event,
3450                                                          \core_calendar\action_factory $factory) {
3452     $cm = get_fast_modinfo($event->courseid)->instances['feedback'][$event->instance];
3453     $feedbackcompletion = new mod_feedback_completion(null, $cm, 0);
3455     if (!empty($cm->customdata['timeclose']) && $cm->customdata['timeclose'] < time()) {
3456         // Feedback is already closed, do not display it even if it was never submitted.
3457         return null;
3458     }
3460     // The feedback is actionable if it does not have timeopen or timeopen is in the past.
3461     $actionable = $feedbackcompletion->is_open();
3463     if ($actionable && $feedbackcompletion->is_already_submitted()) {
3464         // There is no need to display anything if the user has already submitted the feedback.
3465         return null;
3466     }
3468     return $factory->create_instance(
3469         get_string('answerquestions', 'feedback'),
3470         new \moodle_url('/mod/feedback/view.php', ['id' => $cm->id]),
3471         1,
3472         $actionable
3473     );
3476 /**
3477  * Add a get_coursemodule_info function in case any feedback type wants to add 'extra' information
3478  * for the course (see resource).
3479  *
3480  * Given a course_module object, this function returns any "extra" information that may be needed
3481  * when printing this activity in a course listing.  See get_array_of_activities() in course/lib.php.
3482  *
3483  * @param stdClass $coursemodule The coursemodule object (record).
3484  * @return cached_cm_info An object on information that the courses
3485  *                        will know about (most noticeably, an icon).
3486  */
3487 function feedback_get_coursemodule_info($coursemodule) {
3488     global $DB;
3490     $dbparams = ['id' => $coursemodule->instance];
3491     $fields = 'id, name, intro, introformat, completionsubmit, timeopen, timeclose, anonymous';
3492     if (!$feedback = $DB->get_record('feedback', $dbparams, $fields)) {
3493         return false;
3494     }
3496     $result = new cached_cm_info();
3497     $result->name = $feedback->name;
3499     if ($coursemodule->showdescription) {
3500         // Convert intro to html. Do not filter cached version, filters run at display time.
3501         $result->content = format_module_intro('feedback', $feedback, $coursemodule->id, false);
3502     }
3504     // Populate the custom completion rules as key => value pairs, but only if the completion mode is 'automatic'.
3505     if ($coursemodule->completion == COMPLETION_TRACKING_AUTOMATIC) {
3506         $result->customdata['customcompletionrules']['completionsubmit'] = $feedback->completionsubmit;
3507     }
3508     // Populate some other values that can be used in calendar or on dashboard.
3509     if ($feedback->timeopen) {
3510         $result->customdata['timeopen'] = $feedback->timeopen;
3511     }
3512     if ($feedback->timeclose) {
3513         $result->customdata['timeclose'] = $feedback->timeclose;
3514     }
3515     if ($feedback->anonymous) {
3516         $result->customdata['anonymous'] = $feedback->anonymous;
3517     }
3519     return $result;
3522 /**
3523  * Callback which returns human-readable strings describing the active completion custom rules for the module instance.
3524  *
3525  * @param cm_info|stdClass $cm object with fields ->completion and ->customdata['customcompletionrules']
3526  * @return array $descriptions the array of descriptions for the custom rules.
3527  */
3528 function mod_feedback_get_completion_active_rule_descriptions($cm) {
3529     // Values will be present in cm_info, and we assume these are up to date.
3530     if (empty($cm->customdata['customcompletionrules'])
3531         || $cm->completion != COMPLETION_TRACKING_AUTOMATIC) {
3532         return [];
3533     }
3535     $descriptions = [];
3536     foreach ($cm->customdata['customcompletionrules'] as $key => $val) {
3537         switch ($key) {
3538             case 'completionsubmit':
3539                 if (empty($val)) {
3540                     continue;
3541                 }
3542                 $descriptions[] = get_string('completionsubmit', 'feedback');
3543                 break;
3544             default:
3545                 break;
3546         }
3547     }
3548     return $descriptions;