MDL-57961 course: change wording of module availability
[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 /**
44  * Returns all other caps used in module.
45  *
46  * @return array
47  */
48 function feedback_get_extra_capabilities() {
49     return array('moodle/site:accessallgroups');
50 }
52 /**
53  * @uses FEATURE_GROUPS
54  * @uses FEATURE_GROUPINGS
55  * @uses FEATURE_MOD_INTRO
56  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
57  * @uses FEATURE_GRADE_HAS_GRADE
58  * @uses FEATURE_GRADE_OUTCOMES
59  * @param string $feature FEATURE_xx constant for requested feature
60  * @return mixed True if module supports feature, null if doesn't know
61  */
62 function feedback_supports($feature) {
63     switch($feature) {
64         case FEATURE_GROUPS:                  return true;
65         case FEATURE_GROUPINGS:               return true;
66         case FEATURE_MOD_INTRO:               return true;
67         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
68         case FEATURE_COMPLETION_HAS_RULES:    return true;
69         case FEATURE_GRADE_HAS_GRADE:         return false;
70         case FEATURE_GRADE_OUTCOMES:          return false;
71         case FEATURE_BACKUP_MOODLE2:          return true;
72         case FEATURE_SHOW_DESCRIPTION:        return true;
74         default: return null;
75     }
76 }
78 /**
79  * this will create a new instance and return the id number
80  * of the new instance.
81  *
82  * @global object
83  * @param object $feedback the object given by mod_feedback_mod_form
84  * @return int
85  */
86 function feedback_add_instance($feedback) {
87     global $DB;
89     $feedback->timemodified = time();
90     $feedback->id = '';
92     if (empty($feedback->site_after_submit)) {
93         $feedback->site_after_submit = '';
94     }
96     //saving the feedback in db
97     $feedbackid = $DB->insert_record("feedback", $feedback);
99     $feedback->id = $feedbackid;
101     feedback_set_events($feedback);
103     if (!isset($feedback->coursemodule)) {
104         $cm = get_coursemodule_from_id('feedback', $feedback->id);
105         $feedback->coursemodule = $cm->id;
106     }
107     $context = context_module::instance($feedback->coursemodule);
109     $editoroptions = feedback_get_editor_options();
111     // process the custom wysiwyg editor in page_after_submit
112     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
113         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
114                                                     'mod_feedback', 'page_after_submit',
115                                                     0, $editoroptions,
116                                                     $feedback->page_after_submit_editor['text']);
118         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
119     }
120     $DB->update_record('feedback', $feedback);
122     return $feedbackid;
125 /**
126  * this will update a given instance
127  *
128  * @global object
129  * @param object $feedback the object given by mod_feedback_mod_form
130  * @return boolean
131  */
132 function feedback_update_instance($feedback) {
133     global $DB;
135     $feedback->timemodified = time();
136     $feedback->id = $feedback->instance;
138     if (empty($feedback->site_after_submit)) {
139         $feedback->site_after_submit = '';
140     }
142     //save the feedback into the db
143     $DB->update_record("feedback", $feedback);
145     //create or update the new events
146     feedback_set_events($feedback);
148     $context = context_module::instance($feedback->coursemodule);
150     $editoroptions = feedback_get_editor_options();
152     // process the custom wysiwyg editor in page_after_submit
153     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
154         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
155                                                     'mod_feedback', 'page_after_submit',
156                                                     0, $editoroptions,
157                                                     $feedback->page_after_submit_editor['text']);
159         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
160     }
161     $DB->update_record('feedback', $feedback);
163     return true;
166 /**
167  * Serves the files included in feedback items like label. Implements needed access control ;-)
168  *
169  * There are two situations in general where the files will be sent.
170  * 1) filearea = item, 2) filearea = template
171  *
172  * @package  mod_feedback
173  * @category files
174  * @param stdClass $course course object
175  * @param stdClass $cm course module object
176  * @param stdClass $context context object
177  * @param string $filearea file area
178  * @param array $args extra arguments
179  * @param bool $forcedownload whether or not force download
180  * @param array $options additional options affecting the file serving
181  * @return bool false if file not found, does not return if found - justsend the file
182  */
183 function feedback_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
184     global $CFG, $DB;
186     if ($filearea === 'item' or $filearea === 'template') {
187         $itemid = (int)array_shift($args);
188         //get the item what includes the file
189         if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
190             return false;
191         }
192         $feedbackid = $item->feedback;
193         $templateid = $item->template;
194     }
196     if ($filearea === 'page_after_submit' or $filearea === 'item') {
197         if (! $feedback = $DB->get_record("feedback", array("id"=>$cm->instance))) {
198             return false;
199         }
201         $feedbackid = $feedback->id;
203         //if the filearea is "item" so we check the permissions like view/complete the feedback
204         $canload = false;
205         //first check whether the user has the complete capability
206         if (has_capability('mod/feedback:complete', $context)) {
207             $canload = true;
208         }
210         //now we check whether the user has the view capability
211         if (has_capability('mod/feedback:view', $context)) {
212             $canload = true;
213         }
215         //if the feedback is on frontpage and anonymous and the fullanonymous is allowed
216         //so the file can be loaded too.
217         if (isset($CFG->feedback_allowfullanonymous)
218                     AND $CFG->feedback_allowfullanonymous
219                     AND $course->id == SITEID
220                     AND $feedback->anonymous == FEEDBACK_ANONYMOUS_YES ) {
221             $canload = true;
222         }
224         if (!$canload) {
225             return false;
226         }
227     } else if ($filearea === 'template') { //now we check files in templates
228         if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
229             return false;
230         }
232         //if the file is not public so the capability edititems has to be there
233         if (!$template->ispublic) {
234             if (!has_capability('mod/feedback:edititems', $context)) {
235                 return false;
236             }
237         } else { //on public templates, at least the user has to be logged in
238             if (!isloggedin()) {
239                 return false;
240             }
241         }
242     } else {
243         return false;
244     }
246     if ($context->contextlevel == CONTEXT_MODULE) {
247         if ($filearea !== 'item' and $filearea !== 'page_after_submit') {
248             return false;
249         }
250     }
252     if ($context->contextlevel == CONTEXT_COURSE || $context->contextlevel == CONTEXT_SYSTEM) {
253         if ($filearea !== 'template') {
254             return false;
255         }
256     }
258     $relativepath = implode('/', $args);
259     if ($filearea === 'page_after_submit') {
260         $fullpath = "/{$context->id}/mod_feedback/$filearea/$relativepath";
261     } else {
262         $fullpath = "/{$context->id}/mod_feedback/$filearea/{$item->id}/$relativepath";
263     }
265     $fs = get_file_storage();
267     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
268         return false;
269     }
271     // finally send the file
272     send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
274     return false;
277 /**
278  * this will delete a given instance.
279  * all referenced data also will be deleted
280  *
281  * @global object
282  * @param int $id the instanceid of feedback
283  * @return boolean
284  */
285 function feedback_delete_instance($id) {
286     global $DB;
288     //get all referenced items
289     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
291     //deleting all referenced items and values
292     if (is_array($feedbackitems)) {
293         foreach ($feedbackitems as $feedbackitem) {
294             $DB->delete_records("feedback_value", array("item"=>$feedbackitem->id));
295             $DB->delete_records("feedback_valuetmp", array("item"=>$feedbackitem->id));
296         }
297         if ($delitems = $DB->get_records("feedback_item", array("feedback"=>$id))) {
298             foreach ($delitems as $delitem) {
299                 feedback_delete_item($delitem->id, false);
300             }
301         }
302     }
304     //deleting the completeds
305     $DB->delete_records("feedback_completed", array("feedback"=>$id));
307     //deleting the unfinished completeds
308     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
310     //deleting old events
311     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
312     return $DB->delete_records("feedback", array("id"=>$id));
315 /**
316  * Return a small object with summary information about what a
317  * user has done with a given particular instance of this module
318  * Used for user activity reports.
319  * $return->time = the time they did it
320  * $return->info = a short text description
321  *
322  * @param stdClass $course
323  * @param stdClass $user
324  * @param cm_info|stdClass $mod
325  * @param stdClass $feedback
326  * @return stdClass
327  */
328 function feedback_user_outline($course, $user, $mod, $feedback) {
329     global $DB;
330     $outline = (object)['info' => '', 'time' => 0];
331     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
332         // Do not disclose any user info if feedback is anonymous.
333         return $outline;
334     }
335     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
336         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
337     $status = null;
338     $context = context_module::instance($mod->id);
339     if ($completed = $DB->get_record('feedback_completed', $params)) {
340         // User has completed feedback.
341         $outline->info = get_string('completed', 'feedback');
342         $outline->time = $completed->timemodified;
343     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
344         // User has started but not completed feedback.
345         $outline->info = get_string('started', 'feedback');
346         $outline->time = $completedtmp->timemodified;
347     } else if (has_capability('mod/feedback:complete', $context, $user)) {
348         // User has not started feedback but has capability to do so.
349         $outline->info = get_string('not_started', 'feedback');
350     }
352     return $outline;
355 /**
356  * Returns all users who has completed a specified feedback since a given time
357  * many thanks to Manolescu Dorel, who contributed these two functions
358  *
359  * @global object
360  * @global object
361  * @global object
362  * @global object
363  * @uses CONTEXT_MODULE
364  * @param array $activities Passed by reference
365  * @param int $index Passed by reference
366  * @param int $timemodified Timestamp
367  * @param int $courseid
368  * @param int $cmid
369  * @param int $userid
370  * @param int $groupid
371  * @return void
372  */
373 function feedback_get_recent_mod_activity(&$activities, &$index,
374                                           $timemodified, $courseid,
375                                           $cmid, $userid="", $groupid="") {
377     global $CFG, $COURSE, $USER, $DB;
379     if ($COURSE->id == $courseid) {
380         $course = $COURSE;
381     } else {
382         $course = $DB->get_record('course', array('id'=>$courseid));
383     }
385     $modinfo = get_fast_modinfo($course);
387     $cm = $modinfo->cms[$cmid];
389     $sqlargs = array();
391     $userfields = user_picture::fields('u', null, 'useridagain');
392     $sql = " SELECT fk . * , fc . * , $userfields
393                 FROM {feedback_completed} fc
394                     JOIN {feedback} fk ON fk.id = fc.feedback
395                     JOIN {user} u ON u.id = fc.userid ";
397     if ($groupid) {
398         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
399     }
401     $sql .= " WHERE fc.timemodified > ?
402                 AND fk.id = ?
403                 AND fc.anonymous_response = ?";
404     $sqlargs[] = $timemodified;
405     $sqlargs[] = $cm->instance;
406     $sqlargs[] = FEEDBACK_ANONYMOUS_NO;
408     if ($userid) {
409         $sql .= " AND u.id = ? ";
410         $sqlargs[] = $userid;
411     }
413     if ($groupid) {
414         $sql .= " AND gm.groupid = ? ";
415         $sqlargs[] = $groupid;
416     }
418     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
419         return;
420     }
422     $cm_context = context_module::instance($cm->id);
424     if (!has_capability('mod/feedback:view', $cm_context)) {
425         return;
426     }
428     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
429     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cm_context);
430     $groupmode       = groups_get_activity_groupmode($cm, $course);
432     $aname = format_string($cm->name, true);
433     foreach ($feedbackitems as $feedbackitem) {
434         if ($feedbackitem->userid != $USER->id) {
436             if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
437                 $usersgroups = groups_get_all_groups($course->id,
438                                                      $feedbackitem->userid,
439                                                      $cm->groupingid);
440                 if (!is_array($usersgroups)) {
441                     continue;
442                 }
443                 $usersgroups = array_keys($usersgroups);
444                 $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
445                 if (empty($intersect)) {
446                     continue;
447                 }
448             }
449         }
451         $tmpactivity = new stdClass();
453         $tmpactivity->type      = 'feedback';
454         $tmpactivity->cmid      = $cm->id;
455         $tmpactivity->name      = $aname;
456         $tmpactivity->sectionnum= $cm->sectionnum;
457         $tmpactivity->timestamp = $feedbackitem->timemodified;
459         $tmpactivity->content = new stdClass();
460         $tmpactivity->content->feedbackid = $feedbackitem->id;
461         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
463         $tmpactivity->user = user_picture::unalias($feedbackitem, null, 'useridagain');
464         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
466         $activities[$index++] = $tmpactivity;
467     }
469     return;
472 /**
473  * Prints all users who has completed a specified feedback since a given time
474  * many thanks to Manolescu Dorel, who contributed these two functions
475  *
476  * @global object
477  * @param object $activity
478  * @param int $courseid
479  * @param string $detail
480  * @param array $modnames
481  * @return void Output is echo'd
482  */
483 function feedback_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
484     global $CFG, $OUTPUT;
486     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
488     echo "<tr><td class=\"userpicture\" valign=\"top\">";
489     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
490     echo "</td><td>";
492     if ($detail) {
493         $modname = $modnames[$activity->type];
494         echo '<div class="title">';
495         echo $OUTPUT->image_icon('icon', $modname, $activity->type);
496         echo "<a href=\"$CFG->wwwroot/mod/feedback/view.php?id={$activity->cmid}\">{$activity->name}</a>";
497         echo '</div>';
498     }
500     echo '<div class="title">';
501     echo '</div>';
503     echo '<div class="user">';
504     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&amp;course=$courseid\">"
505          ."{$activity->user->fullname}</a> - ".userdate($activity->timestamp);
506     echo '</div>';
508     echo "</td></tr></table>";
510     return;
513 /**
514  * Obtains the automatic completion state for this feedback based on the condition
515  * in feedback settings.
516  *
517  * @param object $course Course
518  * @param object $cm Course-module
519  * @param int $userid User ID
520  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
521  * @return bool True if completed, false if not, $type if conditions not set.
522  */
523 function feedback_get_completion_state($course, $cm, $userid, $type) {
524     global $CFG, $DB;
526     // Get feedback details
527     $feedback = $DB->get_record('feedback', array('id'=>$cm->instance), '*', MUST_EXIST);
529     // If completion option is enabled, evaluate it and return true/false
530     if ($feedback->completionsubmit) {
531         $params = array('userid'=>$userid, 'feedback'=>$feedback->id);
532         return $DB->record_exists('feedback_completed', $params);
533     } else {
534         // Completion option is not enabled so just return $type
535         return $type;
536     }
539 /**
540  * Print a detailed representation of what a  user has done with
541  * a given particular instance of this module, for user activity reports.
542  *
543  * @param stdClass $course
544  * @param stdClass $user
545  * @param cm_info|stdClass $mod
546  * @param stdClass $feedback
547  */
548 function feedback_user_complete($course, $user, $mod, $feedback) {
549     global $DB;
550     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
551         // Do not disclose any user info if feedback is anonymous.
552         return;
553     }
554     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
555         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
556     $url = $status = null;
557     $context = context_module::instance($mod->id);
558     if ($completed = $DB->get_record('feedback_completed', $params)) {
559         // User has completed feedback.
560         if (has_capability('mod/feedback:viewreports', $context)) {
561             $url = new moodle_url('/mod/feedback/show_entries.php',
562                 ['id' => $mod->id, 'userid' => $user->id,
563                     'showcompleted' => $completed->id]);
564         }
565         $status = get_string('completedon', 'feedback', userdate($completed->timemodified));
566     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
567         // User has started but not completed feedback.
568         $status = get_string('startedon', 'feedback', userdate($completedtmp->timemodified));
569     } else if (has_capability('mod/feedback:complete', $context, $user)) {
570         // User has not started feedback but has capability to do so.
571         $status = get_string('not_started', 'feedback');
572     }
574     if ($url && $status) {
575         echo html_writer::link($url, $status);
576     } else if ($status) {
577         echo html_writer::div($status);
578     }
581 /**
582  * @return bool true
583  */
584 function feedback_cron () {
585     return true;
588 /**
589  * @return bool false
590  */
591 function feedback_scale_used ($feedbackid, $scaleid) {
592     return false;
595 /**
596  * Checks if scale is being used by any instance of feedback
597  *
598  * This is used to find out if scale used anywhere
599  * @param $scaleid int
600  * @return boolean True if the scale is used by any assignment
601  */
602 function feedback_scale_used_anywhere($scaleid) {
603     return false;
606 /**
607  * List the actions that correspond to a view of this module.
608  * This is used by the participation report.
609  *
610  * Note: This is not used by new logging system. Event with
611  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
612  *       be considered as view action.
613  *
614  * @return array
615  */
616 function feedback_get_view_actions() {
617     return array('view', 'view all');
620 /**
621  * List the actions that correspond to a post of this module.
622  * This is used by the participation report.
623  *
624  * Note: This is not used by new logging system. Event with
625  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
626  *       will be considered as post action.
627  *
628  * @return array
629  */
630 function feedback_get_post_actions() {
631     return array('submit');
634 /**
635  * This function is used by the reset_course_userdata function in moodlelib.
636  * This function will remove all responses from the specified feedback
637  * and clean up any related data.
638  *
639  * @global object
640  * @global object
641  * @uses FEEDBACK_RESETFORM_RESET
642  * @uses FEEDBACK_RESETFORM_DROP
643  * @param object $data the data submitted from the reset course.
644  * @return array status array
645  */
646 function feedback_reset_userdata($data) {
647     global $CFG, $DB;
649     $resetfeedbacks = array();
650     $dropfeedbacks = array();
651     $status = array();
652     $componentstr = get_string('modulenameplural', 'feedback');
654     //get the relevant entries from $data
655     foreach ($data as $key => $value) {
656         switch(true) {
657             case substr($key, 0, strlen(FEEDBACK_RESETFORM_RESET)) == FEEDBACK_RESETFORM_RESET:
658                 if ($value == 1) {
659                     $templist = explode('_', $key);
660                     if (isset($templist[3])) {
661                         $resetfeedbacks[] = intval($templist[3]);
662                     }
663                 }
664             break;
665             case substr($key, 0, strlen(FEEDBACK_RESETFORM_DROP)) == FEEDBACK_RESETFORM_DROP:
666                 if ($value == 1) {
667                     $templist = explode('_', $key);
668                     if (isset($templist[3])) {
669                         $dropfeedbacks[] = intval($templist[3]);
670                     }
671                 }
672             break;
673         }
674     }
676     //reset the selected feedbacks
677     foreach ($resetfeedbacks as $id) {
678         $feedback = $DB->get_record('feedback', array('id'=>$id));
679         feedback_delete_all_completeds($feedback);
680         $status[] = array('component'=>$componentstr.':'.$feedback->name,
681                         'item'=>get_string('resetting_data', 'feedback'),
682                         'error'=>false);
683     }
685     // Updating dates - shift may be negative too.
686     if ($data->timeshift) {
687         $shifterror = !shift_course_mod_dates('feedback', array('timeopen', 'timeclose'), $data->timeshift, $data->courseid);
688         $status[] = array('component' => $componentstr, 'item' => get_string('datechanged'), 'error' => $shifterror);
689     }
691     return $status;
694 /**
695  * Called by course/reset.php
696  *
697  * @global object
698  * @uses FEEDBACK_RESETFORM_RESET
699  * @param object $mform form passed by reference
700  */
701 function feedback_reset_course_form_definition(&$mform) {
702     global $COURSE, $DB;
704     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
706     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')) {
707         return;
708     }
710     $mform->addElement('static', 'hint', get_string('resetting_data', 'feedback'));
711     foreach ($feedbacks as $feedback) {
712         $mform->addElement('checkbox', FEEDBACK_RESETFORM_RESET.$feedback->id, $feedback->name);
713     }
716 /**
717  * Course reset form defaults.
718  *
719  * @global object
720  * @uses FEEDBACK_RESETFORM_RESET
721  * @param object $course
722  */
723 function feedback_reset_course_form_defaults($course) {
724     global $DB;
726     $return = array();
727     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
728         return;
729     }
730     foreach ($feedbacks as $feedback) {
731         $return[FEEDBACK_RESETFORM_RESET.$feedback->id] = true;
732     }
733     return $return;
736 /**
737  * Called by course/reset.php and shows the formdata by coursereset.
738  * it prints checkboxes for each feedback available at the given course
739  * there are two checkboxes:
740  * 1) delete userdata and keep the feedback
741  * 2) delete userdata and drop the feedback
742  *
743  * @global object
744  * @uses FEEDBACK_RESETFORM_RESET
745  * @uses FEEDBACK_RESETFORM_DROP
746  * @param object $course
747  * @return void
748  */
749 function feedback_reset_course_form($course) {
750     global $DB, $OUTPUT;
752     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
753     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
754         return;
755     }
757     foreach ($feedbacks as $feedback) {
758         echo '<p>';
759         echo get_string('name', 'feedback').': '.$feedback->name.'<br />';
760         echo html_writer::checkbox(FEEDBACK_RESETFORM_RESET.$feedback->id,
761                                 1, true,
762                                 get_string('resetting_data', 'feedback'));
763         echo '<br />';
764         echo html_writer::checkbox(FEEDBACK_RESETFORM_DROP.$feedback->id,
765                                 1, false,
766                                 get_string('drop_feedback', 'feedback'));
767         echo '</p>';
768     }
771 /**
772  * This gets an array with default options for the editor
773  *
774  * @return array the options
775  */
776 function feedback_get_editor_options() {
777     return array('maxfiles' => EDITOR_UNLIMITED_FILES,
778                 'trusttext'=>true);
781 /**
782  * This creates new events given as timeopen and closeopen by $feedback.
783  *
784  * @global object
785  * @param object $feedback
786  * @return void
787  */
788 function feedback_set_events($feedback) {
789     global $DB, $CFG;
791     // Include calendar/lib.php.
792     require_once($CFG->dirroot.'/calendar/lib.php');
794     // Get CMID if not sent as part of $feedback.
795     if (!isset($feedback->coursemodule)) {
796         $cm = get_coursemodule_from_instance('feedback', $feedback->id, $feedback->course);
797         $feedback->coursemodule = $cm->id;
798     }
800     // Feedback start calendar events.
801     $eventid = $DB->get_field('event', 'id',
802             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => 'open'));
804     if (isset($feedback->timeopen) && $feedback->timeopen > 0) {
805         $event = new stdClass();
806         $event->name         = get_string('calendarstart', 'feedback', $feedback->name);
807         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
808         $event->timestart    = $feedback->timeopen;
809         $event->visible      = instance_is_visible('feedback', $feedback);
810         $event->timeduration = 0;
811         if ($eventid) {
812             // Calendar event exists so update it.
813             $event->id = $eventid;
814             $calendarevent = calendar_event::load($event->id);
815             $calendarevent->update($event);
816         } else {
817             // Event doesn't exist so create one.
818             $event->courseid     = $feedback->course;
819             $event->groupid      = 0;
820             $event->userid       = 0;
821             $event->modulename   = 'feedback';
822             $event->instance     = $feedback->id;
823             $event->eventtype    = 'open';
824             calendar_event::create($event);
825         }
826     } else if ($eventid) {
827         // Calendar event is on longer needed.
828         $calendarevent = calendar_event::load($eventid);
829         $calendarevent->delete();
830     }
832     // Feedback close calendar events.
833     $eventid = $DB->get_field('event', 'id',
834             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => 'close'));
836     if (isset($feedback->timeclose) && $feedback->timeclose > 0) {
837         $event = new stdClass();
838         $event->name         = get_string('calendarend', 'feedback', $feedback->name);
839         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
840         $event->timestart    = $feedback->timeclose;
841         $event->visible      = instance_is_visible('feedback', $feedback);
842         $event->timeduration = 0;
843         if ($eventid) {
844             // Calendar event exists so update it.
845             $event->id = $eventid;
846             $calendarevent = calendar_event::load($event->id);
847             $calendarevent->update($event);
848         } else {
849             // Event doesn't exist so create one.
850             $event->courseid     = $feedback->course;
851             $event->groupid      = 0;
852             $event->userid       = 0;
853             $event->modulename   = 'feedback';
854             $event->instance     = $feedback->id;
855             $event->eventtype    = 'close';
856             calendar_event::create($event);
857         }
858     } else if ($eventid) {
859         // Calendar event is on longer needed.
860         $calendarevent = calendar_event::load($eventid);
861         $calendarevent->delete();
862     }
865 /**
866  * This standard function will check all instances of this module
867  * and make sure there are up-to-date events created for each of them.
868  * If courseid = 0, then every feedback event in the site is checked, else
869  * only feedback events belonging to the course specified are checked.
870  * This function is used, in its new format, by restore_refresh_events()
871  *
872  * @param int $courseid
873  * @return bool
874  */
875 function feedback_refresh_events($courseid = 0) {
876     global $DB;
878     if ($courseid) {
879         if (! $feedbacks = $DB->get_records("feedback", array("course" => $courseid))) {
880             return true;
881         }
882     } else {
883         if (! $feedbacks = $DB->get_records("feedback")) {
884             return true;
885         }
886     }
888     foreach ($feedbacks as $feedback) {
889         feedback_set_events($feedback);
890     }
891     return true;
894 /**
895  * this function is called by {@link feedback_delete_userdata()}
896  * it drops the feedback-instance from the course_module table
897  *
898  * @global object
899  * @param int $id the id from the coursemodule
900  * @return boolean
901  */
902 function feedback_delete_course_module($id) {
903     global $DB;
905     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
906         return true;
907     }
908     return $DB->delete_records('course_modules', array('id'=>$cm->id));
913 ////////////////////////////////////////////////
914 //functions to handle capabilities
915 ////////////////////////////////////////////////
917 /**
918  * returns the context-id related to the given coursemodule-id
919  *
920  * @deprecated since 3.1
921  * @staticvar object $context
922  * @param int $cmid the coursemodule-id
923  * @return object $context
924  */
925 function feedback_get_context($cmid) {
926     debugging('Function feedback_get_context() is deprecated because it was not used.',
927             DEBUG_DEVELOPER);
928     static $context;
930     if (isset($context)) {
931         return $context;
932     }
934     $context = context_module::instance($cmid);
935     return $context;
938 /**
939  *  returns true if the current role is faked by switching role feature
940  *
941  * @global object
942  * @return boolean
943  */
944 function feedback_check_is_switchrole() {
945     global $USER;
946     if (isset($USER->switchrole) AND
947             is_array($USER->switchrole) AND
948             count($USER->switchrole) > 0) {
950         return true;
951     }
952     return false;
955 /**
956  * count users which have not completed the feedback
957  *
958  * @global object
959  * @uses CONTEXT_MODULE
960  * @param cm_info $cm Course-module object
961  * @param int $group single groupid
962  * @param string $sort
963  * @param int $startpage
964  * @param int $pagecount
965  * @return object the userrecords
966  */
967 function feedback_get_incomplete_users(cm_info $cm,
968                                        $group = false,
969                                        $sort = '',
970                                        $startpage = false,
971                                        $pagecount = false) {
973     global $DB;
975     $context = context_module::instance($cm->id);
977     //first get all user who can complete this feedback
978     $cap = 'mod/feedback:complete';
979     $fields = 'u.id, u.username';
980     if (!$allusers = get_users_by_capability($context,
981                                             $cap,
982                                             $fields,
983                                             $sort,
984                                             '',
985                                             '',
986                                             $group,
987                                             '',
988                                             true)) {
989         return false;
990     }
991     // Filter users that are not in the correct group/grouping.
992     $info = new \core_availability\info_module($cm);
993     $allusers = $info->filter_user_list($allusers);
995     $allusers = array_keys($allusers);
997     //now get all completeds
998     $params = array('feedback'=>$cm->instance);
999     if (!$completedusers = $DB->get_records_menu('feedback_completed', $params, '', 'id, userid')) {
1000         return $allusers;
1001     }
1003     //now strike all completedusers from allusers
1004     $allusers = array_diff($allusers, $completedusers);
1006     //for paging I use array_slice()
1007     if ($startpage !== false AND $pagecount !== false) {
1008         $allusers = array_slice($allusers, $startpage, $pagecount);
1009     }
1011     return $allusers;
1014 /**
1015  * count users which have not completed the feedback
1016  *
1017  * @global object
1018  * @param object $cm
1019  * @param int $group single groupid
1020  * @return int count of userrecords
1021  */
1022 function feedback_count_incomplete_users($cm, $group = false) {
1023     if ($allusers = feedback_get_incomplete_users($cm, $group)) {
1024         return count($allusers);
1025     }
1026     return 0;
1029 /**
1030  * count users which have completed a feedback
1031  *
1032  * @global object
1033  * @uses FEEDBACK_ANONYMOUS_NO
1034  * @param object $cm
1035  * @param int $group single groupid
1036  * @return int count of userrecords
1037  */
1038 function feedback_count_complete_users($cm, $group = false) {
1039     global $DB;
1041     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
1043     $fromgroup = '';
1044     $wheregroup = '';
1045     if ($group) {
1046         $fromgroup = ', {groups_members} g';
1047         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
1048         $params[] = $group;
1049     }
1051     $sql = 'SELECT COUNT(u.id) FROM {user} u, {feedback_completed} c'.$fromgroup.'
1052               WHERE anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
1053               '.$wheregroup;
1055     return $DB->count_records_sql($sql, $params);
1059 /**
1060  * get users which have completed a feedback
1061  *
1062  * @global object
1063  * @uses CONTEXT_MODULE
1064  * @uses FEEDBACK_ANONYMOUS_NO
1065  * @param object $cm
1066  * @param int $group single groupid
1067  * @param string $where a sql where condition (must end with " AND ")
1068  * @param array parameters used in $where
1069  * @param string $sort a table field
1070  * @param int $startpage
1071  * @param int $pagecount
1072  * @return object the userrecords
1073  */
1074 function feedback_get_complete_users($cm,
1075                                      $group = false,
1076                                      $where = '',
1077                                      array $params = null,
1078                                      $sort = '',
1079                                      $startpage = false,
1080                                      $pagecount = false) {
1082     global $DB;
1084     $context = context_module::instance($cm->id);
1086     $params = (array)$params;
1088     $params['anon'] = FEEDBACK_ANONYMOUS_NO;
1089     $params['instance'] = $cm->instance;
1091     $fromgroup = '';
1092     $wheregroup = '';
1093     if ($group) {
1094         $fromgroup = ', {groups_members} g';
1095         $wheregroup = ' AND g.groupid = :group AND g.userid = c.userid';
1096         $params['group'] = $group;
1097     }
1099     if ($sort) {
1100         $sortsql = ' ORDER BY '.$sort;
1101     } else {
1102         $sortsql = '';
1103     }
1105     $ufields = user_picture::fields('u');
1106     $sql = 'SELECT DISTINCT '.$ufields.', c.timemodified as completed_timemodified
1107             FROM {user} u, {feedback_completed} c '.$fromgroup.'
1108             WHERE '.$where.' anonymous_response = :anon
1109                 AND u.id = c.userid
1110                 AND c.feedback = :instance
1111               '.$wheregroup.$sortsql;
1113     if ($startpage === false OR $pagecount === false) {
1114         $startpage = false;
1115         $pagecount = false;
1116     }
1117     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
1120 /**
1121  * get users which have the viewreports-capability
1122  *
1123  * @uses CONTEXT_MODULE
1124  * @param int $cmid
1125  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1126  * @return object the userrecords
1127  */
1128 function feedback_get_viewreports_users($cmid, $groups = false) {
1130     $context = context_module::instance($cmid);
1132     //description of the call below:
1133     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1134     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1135     return get_users_by_capability($context,
1136                             'mod/feedback:viewreports',
1137                             '',
1138                             'lastname',
1139                             '',
1140                             '',
1141                             $groups,
1142                             '',
1143                             false);
1146 /**
1147  * get users which have the receivemail-capability
1148  *
1149  * @uses CONTEXT_MODULE
1150  * @param int $cmid
1151  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1152  * @return object the userrecords
1153  */
1154 function feedback_get_receivemail_users($cmid, $groups = false) {
1156     $context = context_module::instance($cmid);
1158     //description of the call below:
1159     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1160     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1161     return get_users_by_capability($context,
1162                             'mod/feedback:receivemail',
1163                             '',
1164                             'lastname',
1165                             '',
1166                             '',
1167                             $groups,
1168                             '',
1169                             false);
1172 ////////////////////////////////////////////////
1173 //functions to handle the templates
1174 ////////////////////////////////////////////////
1175 ////////////////////////////////////////////////
1177 /**
1178  * creates a new template-record.
1179  *
1180  * @global object
1181  * @param int $courseid
1182  * @param string $name the name of template shown in the templatelist
1183  * @param int $ispublic 0:privat 1:public
1184  * @return int the new templateid
1185  */
1186 function feedback_create_template($courseid, $name, $ispublic = 0) {
1187     global $DB;
1189     $templ = new stdClass();
1190     $templ->course   = ($ispublic ? 0 : $courseid);
1191     $templ->name     = $name;
1192     $templ->ispublic = $ispublic;
1194     $templid = $DB->insert_record('feedback_template', $templ);
1195     return $DB->get_record('feedback_template', array('id'=>$templid));
1198 /**
1199  * creates new template items.
1200  * all items will be copied and the attribute feedback will be set to 0
1201  * and the attribute template will be set to the new templateid
1202  *
1203  * @global object
1204  * @uses CONTEXT_MODULE
1205  * @uses CONTEXT_COURSE
1206  * @param object $feedback
1207  * @param string $name the name of template shown in the templatelist
1208  * @param int $ispublic 0:privat 1:public
1209  * @return boolean
1210  */
1211 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
1212     global $DB;
1213     $fs = get_file_storage();
1215     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1216         return false;
1217     }
1219     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
1220         return false;
1221     }
1223     //files in the template_item are in the context of the current course or
1224     //if the template is public the files are in the system context
1225     //files in the feedback_item are in the feedback_context of the feedback
1226     if ($ispublic) {
1227         $s_context = context_system::instance();
1228     } else {
1229         $s_context = context_course::instance($newtempl->course);
1230     }
1231     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1232     $f_context = context_module::instance($cm->id);
1234     //create items of this new template
1235     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1236     //we also store a mapping of all items array(oldid => newid)
1237     $dependitemsmap = array();
1238     $itembackup = array();
1239     foreach ($feedbackitems as $item) {
1241         $t_item = clone($item);
1243         unset($t_item->id);
1244         $t_item->feedback = 0;
1245         $t_item->template     = $newtempl->id;
1246         $t_item->id = $DB->insert_record('feedback_item', $t_item);
1247         //copy all included files to the feedback_template filearea
1248         $itemfiles = $fs->get_area_files($f_context->id,
1249                                     'mod_feedback',
1250                                     'item',
1251                                     $item->id,
1252                                     "id",
1253                                     false);
1254         if ($itemfiles) {
1255             foreach ($itemfiles as $ifile) {
1256                 $file_record = new stdClass();
1257                 $file_record->contextid = $s_context->id;
1258                 $file_record->component = 'mod_feedback';
1259                 $file_record->filearea = 'template';
1260                 $file_record->itemid = $t_item->id;
1261                 $fs->create_file_from_storedfile($file_record, $ifile);
1262             }
1263         }
1265         $itembackup[$item->id] = $t_item->id;
1266         if ($t_item->dependitem) {
1267             $dependitemsmap[$t_item->id] = $t_item->dependitem;
1268         }
1270     }
1272     //remapping the dependency
1273     foreach ($dependitemsmap as $key => $dependitem) {
1274         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1275         $newitem->dependitem = $itembackup[$newitem->dependitem];
1276         $DB->update_record('feedback_item', $newitem);
1277     }
1279     return true;
1282 /**
1283  * deletes all feedback_items related to the given template id
1284  *
1285  * @global object
1286  * @uses CONTEXT_COURSE
1287  * @param object $template the template
1288  * @return void
1289  */
1290 function feedback_delete_template($template) {
1291     global $DB;
1293     //deleting the files from the item is done by feedback_delete_item
1294     if ($t_items = $DB->get_records("feedback_item", array("template"=>$template->id))) {
1295         foreach ($t_items as $t_item) {
1296             feedback_delete_item($t_item->id, false, $template);
1297         }
1298     }
1299     $DB->delete_records("feedback_template", array("id"=>$template->id));
1302 /**
1303  * creates new feedback_item-records from template.
1304  * if $deleteold is set true so the existing items of the given feedback will be deleted
1305  * if $deleteold is set false so the new items will be appanded to the old items
1306  *
1307  * @global object
1308  * @uses CONTEXT_COURSE
1309  * @uses CONTEXT_MODULE
1310  * @param object $feedback
1311  * @param int $templateid
1312  * @param boolean $deleteold
1313  */
1314 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1315     global $DB, $CFG;
1317     require_once($CFG->libdir.'/completionlib.php');
1319     $fs = get_file_storage();
1321     if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
1322         return false;
1323     }
1324     //get all templateitems
1325     if (!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1326         return false;
1327     }
1329     //files in the template_item are in the context of the current course
1330     //files in the feedback_item are in the feedback_context of the feedback
1331     if ($template->ispublic) {
1332         $s_context = context_system::instance();
1333     } else {
1334         $s_context = context_course::instance($feedback->course);
1335     }
1336     $course = $DB->get_record('course', array('id'=>$feedback->course));
1337     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1338     $f_context = context_module::instance($cm->id);
1340     //if deleteold then delete all old items before
1341     //get all items
1342     if ($deleteold) {
1343         if ($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1344             //delete all items of this feedback
1345             foreach ($feedbackitems as $item) {
1346                 feedback_delete_item($item->id, false);
1347             }
1349             $params = array('feedback'=>$feedback->id);
1350             if ($completeds = $DB->get_records('feedback_completed', $params)) {
1351                 $completion = new completion_info($course);
1352                 foreach ($completeds as $completed) {
1353                     // Update completion state
1354                     if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
1355                         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1356                     }
1357                     $DB->delete_records('feedback_completed', array('id'=>$completed->id));
1358                 }
1359             }
1360             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1361         }
1362         $positionoffset = 0;
1363     } else {
1364         //if the old items are kept the new items will be appended
1365         //therefor the new position has an offset
1366         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1367     }
1369     //create items of this new template
1370     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1371     //we also store a mapping of all items array(oldid => newid)
1372     $dependitemsmap = array();
1373     $itembackup = array();
1374     foreach ($templitems as $t_item) {
1375         $item = clone($t_item);
1376         unset($item->id);
1377         $item->feedback = $feedback->id;
1378         $item->template = 0;
1379         $item->position = $item->position + $positionoffset;
1381         $item->id = $DB->insert_record('feedback_item', $item);
1383         //moving the files to the new item
1384         $templatefiles = $fs->get_area_files($s_context->id,
1385                                         'mod_feedback',
1386                                         'template',
1387                                         $t_item->id,
1388                                         "id",
1389                                         false);
1390         if ($templatefiles) {
1391             foreach ($templatefiles as $tfile) {
1392                 $file_record = new stdClass();
1393                 $file_record->contextid = $f_context->id;
1394                 $file_record->component = 'mod_feedback';
1395                 $file_record->filearea = 'item';
1396                 $file_record->itemid = $item->id;
1397                 $fs->create_file_from_storedfile($file_record, $tfile);
1398             }
1399         }
1401         $itembackup[$t_item->id] = $item->id;
1402         if ($item->dependitem) {
1403             $dependitemsmap[$item->id] = $item->dependitem;
1404         }
1405     }
1407     //remapping the dependency
1408     foreach ($dependitemsmap as $key => $dependitem) {
1409         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1410         $newitem->dependitem = $itembackup[$newitem->dependitem];
1411         $DB->update_record('feedback_item', $newitem);
1412     }
1415 /**
1416  * get the list of available templates.
1417  * if the $onlyown param is set true so only templates from own course will be served
1418  * this is important for droping templates
1419  *
1420  * @global object
1421  * @param object $course
1422  * @param string $onlyownorpublic
1423  * @return array the template recordsets
1424  */
1425 function feedback_get_template_list($course, $onlyownorpublic = '') {
1426     global $DB, $CFG;
1428     switch($onlyownorpublic) {
1429         case '':
1430             $templates = $DB->get_records_select('feedback_template',
1431                                                  'course = ? OR ispublic = 1',
1432                                                  array($course->id),
1433                                                  'name');
1434             break;
1435         case 'own':
1436             $templates = $DB->get_records('feedback_template',
1437                                           array('course'=>$course->id),
1438                                           'name');
1439             break;
1440         case 'public':
1441             $templates = $DB->get_records('feedback_template', array('ispublic'=>1), 'name');
1442             break;
1443     }
1444     return $templates;
1447 ////////////////////////////////////////////////
1448 //Handling der Items
1449 ////////////////////////////////////////////////
1450 ////////////////////////////////////////////////
1452 /**
1453  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1454  *
1455  * @param string $typ
1456  * @return feedback_item_base the instance of itemclass
1457  */
1458 function feedback_get_item_class($typ) {
1459     global $CFG;
1461     //get the class of item-typ
1462     $itemclass = 'feedback_item_'.$typ;
1463     //get the instance of item-class
1464     if (!class_exists($itemclass)) {
1465         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1466     }
1467     return new $itemclass();
1470 /**
1471  * load the available item plugins from given subdirectory of $CFG->dirroot
1472  * the default is "mod/feedback/item"
1473  *
1474  * @global object
1475  * @param string $dir the subdir
1476  * @return array pluginnames as string
1477  */
1478 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1479     global $CFG;
1480     $names = get_list_of_plugins($dir);
1481     $ret_names = array();
1483     foreach ($names as $name) {
1484         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1485         if (class_exists('feedback_item_'.$name)) {
1486             $ret_names[] = $name;
1487         }
1488     }
1489     return $ret_names;
1492 /**
1493  * load the available item plugins to use as dropdown-options
1494  *
1495  * @global object
1496  * @return array pluginnames as string
1497  */
1498 function feedback_load_feedback_items_options() {
1499     global $CFG;
1501     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1503     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1504         return array();
1505     }
1507     foreach ($feedback_names as $fn) {
1508         $feedback_options[$fn] = get_string($fn, 'feedback');
1509     }
1510     asort($feedback_options);
1511     return $feedback_options;
1514 /**
1515  * load the available items for the depend item dropdown list shown in the edit_item form
1516  *
1517  * @global object
1518  * @param object $feedback
1519  * @param object $item the item of the edit_item form
1520  * @return array all items except the item $item, labels and pagebreaks
1521  */
1522 function feedback_get_depend_candidates_for_item($feedback, $item) {
1523     global $DB;
1524     //all items for dependitem
1525     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1526     $params = array($feedback->id);
1527     if (isset($item->id) AND $item->id) {
1528         $where .= ' AND id != ?';
1529         $params[] = $item->id;
1530     }
1531     $dependitems = array(0 => get_string('choose'));
1532     $feedbackitems = $DB->get_records_select_menu('feedback_item',
1533                                                   $where,
1534                                                   $params,
1535                                                   'position',
1536                                                   'id, label');
1538     if (!$feedbackitems) {
1539         return $dependitems;
1540     }
1541     //adding the choose-option
1542     foreach ($feedbackitems as $key => $val) {
1543         if (trim(strval($val)) !== '') {
1544             $dependitems[$key] = format_string($val);
1545         }
1546     }
1547     return $dependitems;
1550 /**
1551  * creates a new item-record
1552  *
1553  * @deprecated since 3.1
1554  * @param object $data the data from edit_item_form
1555  * @return int the new itemid
1556  */
1557 function feedback_create_item($data) {
1558     debugging('Function feedback_create_item() is deprecated because it was not used.',
1559             DEBUG_DEVELOPER);
1560     global $DB;
1562     $item = new stdClass();
1563     $item->feedback = $data->feedbackid;
1565     $item->template=0;
1566     if (isset($data->templateid)) {
1567             $item->template = intval($data->templateid);
1568     }
1570     $itemname = trim($data->itemname);
1571     $item->name = ($itemname ? $data->itemname : get_string('no_itemname', 'feedback'));
1573     if (!empty($data->itemlabel)) {
1574         $item->label = trim($data->itemlabel);
1575     } else {
1576         $item->label = get_string('no_itemlabel', 'feedback');
1577     }
1579     $itemobj = feedback_get_item_class($data->typ);
1580     $item->presentation = ''; //the date comes from postupdate() of the itemobj
1582     $item->hasvalue = $itemobj->get_hasvalue();
1584     $item->typ = $data->typ;
1585     $item->position = $data->position;
1587     $item->required=0;
1588     if (!empty($data->required)) {
1589         $item->required = $data->required;
1590     }
1592     $item->id = $DB->insert_record('feedback_item', $item);
1594     //move all itemdata to the data
1595     $data->id = $item->id;
1596     $data->feedback = $item->feedback;
1597     $data->name = $item->name;
1598     $data->label = $item->label;
1599     $data->required = $item->required;
1600     return $itemobj->postupdate($data);
1603 /**
1604  * save the changes of a given item.
1605  *
1606  * @global object
1607  * @param object $item
1608  * @return boolean
1609  */
1610 function feedback_update_item($item) {
1611     global $DB;
1612     return $DB->update_record("feedback_item", $item);
1615 /**
1616  * deletes an item and also deletes all related values
1617  *
1618  * @global object
1619  * @uses CONTEXT_MODULE
1620  * @param int $itemid
1621  * @param boolean $renumber should the kept items renumbered Yes/No
1622  * @param object $template if the template is given so the items are bound to it
1623  * @return void
1624  */
1625 function feedback_delete_item($itemid, $renumber = true, $template = false) {
1626     global $DB;
1628     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1630     //deleting the files from the item
1631     $fs = get_file_storage();
1633     if ($template) {
1634         if ($template->ispublic) {
1635             $context = context_system::instance();
1636         } else {
1637             $context = context_course::instance($template->course);
1638         }
1639         $templatefiles = $fs->get_area_files($context->id,
1640                                     'mod_feedback',
1641                                     'template',
1642                                     $item->id,
1643                                     "id",
1644                                     false);
1646         if ($templatefiles) {
1647             $fs->delete_area_files($context->id, 'mod_feedback', 'template', $item->id);
1648         }
1649     } else {
1650         if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1651             return false;
1652         }
1653         $context = context_module::instance($cm->id);
1655         $itemfiles = $fs->get_area_files($context->id,
1656                                     'mod_feedback',
1657                                     'item',
1658                                     $item->id,
1659                                     "id", false);
1661         if ($itemfiles) {
1662             $fs->delete_area_files($context->id, 'mod_feedback', 'item', $item->id);
1663         }
1664     }
1666     $DB->delete_records("feedback_value", array("item"=>$itemid));
1667     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1669     //remove all depends
1670     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1671     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1673     $DB->delete_records("feedback_item", array("id"=>$itemid));
1674     if ($renumber) {
1675         feedback_renumber_items($item->feedback);
1676     }
1679 /**
1680  * deletes all items of the given feedbackid
1681  *
1682  * @global object
1683  * @param int $feedbackid
1684  * @return void
1685  */
1686 function feedback_delete_all_items($feedbackid) {
1687     global $DB, $CFG;
1688     require_once($CFG->libdir.'/completionlib.php');
1690     if (!$feedback = $DB->get_record('feedback', array('id'=>$feedbackid))) {
1691         return false;
1692     }
1694     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
1695         return false;
1696     }
1698     if (!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
1699         return false;
1700     }
1702     if (!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1703         return;
1704     }
1705     foreach ($items as $item) {
1706         feedback_delete_item($item->id, false);
1707     }
1708     if ($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1709         $completion = new completion_info($course);
1710         foreach ($completeds as $completed) {
1711             // Update completion state
1712             if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
1713                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1714             }
1715             $DB->delete_records('feedback_completed', array('id'=>$completed->id));
1716         }
1717     }
1719     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1723 /**
1724  * this function toggled the item-attribute required (yes/no)
1725  *
1726  * @global object
1727  * @param object $item
1728  * @return boolean
1729  */
1730 function feedback_switch_item_required($item) {
1731     global $DB, $CFG;
1733     $itemobj = feedback_get_item_class($item->typ);
1735     if ($itemobj->can_switch_require()) {
1736         $new_require_val = (int)!(bool)$item->required;
1737         $params = array('id'=>$item->id);
1738         $DB->set_field('feedback_item', 'required', $new_require_val, $params);
1739     }
1740     return true;
1743 /**
1744  * renumbers all items of the given feedbackid
1745  *
1746  * @global object
1747  * @param int $feedbackid
1748  * @return void
1749  */
1750 function feedback_renumber_items($feedbackid) {
1751     global $DB;
1753     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1754     $pos = 1;
1755     if ($items) {
1756         foreach ($items as $item) {
1757             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1758             $pos++;
1759         }
1760     }
1763 /**
1764  * this decreases the position of the given item
1765  *
1766  * @global object
1767  * @param object $item
1768  * @return bool
1769  */
1770 function feedback_moveup_item($item) {
1771     global $DB;
1773     if ($item->position == 1) {
1774         return true;
1775     }
1777     $params = array('feedback'=>$item->feedback);
1778     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1779         return false;
1780     }
1782     $itembefore = null;
1783     foreach ($items as $i) {
1784         if ($i->id == $item->id) {
1785             if (is_null($itembefore)) {
1786                 return true;
1787             }
1788             $itembefore->position = $item->position;
1789             $item->position--;
1790             feedback_update_item($itembefore);
1791             feedback_update_item($item);
1792             feedback_renumber_items($item->feedback);
1793             return true;
1794         }
1795         $itembefore = $i;
1796     }
1797     return false;
1800 /**
1801  * this increased the position of the given item
1802  *
1803  * @global object
1804  * @param object $item
1805  * @return bool
1806  */
1807 function feedback_movedown_item($item) {
1808     global $DB;
1810     $params = array('feedback'=>$item->feedback);
1811     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1812         return false;
1813     }
1815     $movedownitem = null;
1816     foreach ($items as $i) {
1817         if (!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1818             $movedownitem->position = $i->position;
1819             $i->position--;
1820             feedback_update_item($movedownitem);
1821             feedback_update_item($i);
1822             feedback_renumber_items($item->feedback);
1823             return true;
1824         }
1825         $movedownitem = $i;
1826     }
1827     return false;
1830 /**
1831  * here the position of the given item will be set to the value in $pos
1832  *
1833  * @global object
1834  * @param object $moveitem
1835  * @param int $pos
1836  * @return boolean
1837  */
1838 function feedback_move_item($moveitem, $pos) {
1839     global $DB;
1841     $params = array('feedback'=>$moveitem->feedback);
1842     if (!$allitems = $DB->get_records('feedback_item', $params, 'position')) {
1843         return false;
1844     }
1845     if (is_array($allitems)) {
1846         $index = 1;
1847         foreach ($allitems as $item) {
1848             if ($index == $pos) {
1849                 $index++;
1850             }
1851             if ($item->id == $moveitem->id) {
1852                 $moveitem->position = $pos;
1853                 feedback_update_item($moveitem);
1854                 continue;
1855             }
1856             $item->position = $index;
1857             feedback_update_item($item);
1858             $index++;
1859         }
1860         return true;
1861     }
1862     return false;
1865 /**
1866  * prints the given item as a preview.
1867  * each item-class has an own print_item_preview function implemented.
1868  *
1869  * @deprecated since Moodle 3.1
1870  * @global object
1871  * @param object $item the item what we want to print out
1872  * @return void
1873  */
1874 function feedback_print_item_preview($item) {
1875     debugging('Function feedback_print_item_preview() is deprecated and does nothing. '
1876             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
1879 /**
1880  * prints the given item in the completion form.
1881  * each item-class has an own print_item_complete function implemented.
1882  *
1883  * @deprecated since Moodle 3.1
1884  * @param object $item the item what we want to print out
1885  * @param mixed $value the value
1886  * @param boolean $highlightrequire if this set true and the value are false on completing so the item will be highlighted
1887  * @return void
1888  */
1889 function feedback_print_item_complete($item, $value = false, $highlightrequire = false) {
1890     debugging('Function feedback_print_item_complete() is deprecated and does nothing. '
1891             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
1894 /**
1895  * prints the given item in the show entries page.
1896  * each item-class has an own print_item_show_value function implemented.
1897  *
1898  * @deprecated since Moodle 3.1
1899  * @param object $item the item what we want to print out
1900  * @param mixed $value
1901  * @return void
1902  */
1903 function feedback_print_item_show_value($item, $value = false) {
1904     debugging('Function feedback_print_item_show_value() is deprecated and does nothing. '
1905             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
1908 /**
1909  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1910  * the values are not saved permanently until the user click on save button
1911  *
1912  * @global object
1913  * @param object $feedbackcompleted
1914  * @return object temporary saved completed-record
1915  */
1916 function feedback_set_tmp_values($feedbackcompleted) {
1917     global $DB;
1918     debugging('Function feedback_set_tmp_values() is deprecated and since it is '
1919             . 'no longer used in mod_feedback', DEBUG_DEVELOPER);
1921     //first we create a completedtmp
1922     $tmpcpl = new stdClass();
1923     foreach ($feedbackcompleted as $key => $value) {
1924         $tmpcpl->{$key} = $value;
1925     }
1926     unset($tmpcpl->id);
1927     $tmpcpl->timemodified = time();
1928     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1929     //get all values of original-completed
1930     if (!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1931         return;
1932     }
1933     foreach ($values as $value) {
1934         unset($value->id);
1935         $value->completed = $tmpcpl->id;
1936         $DB->insert_record('feedback_valuetmp', $value);
1937     }
1938     return $tmpcpl;
1941 /**
1942  * this saves the temporary saved values permanently
1943  *
1944  * @global object
1945  * @param object $feedbackcompletedtmp the temporary completed
1946  * @param object $feedbackcompleted the target completed
1947  * @return int the id of the completed
1948  */
1949 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted) {
1950     global $DB;
1952     $tmpcplid = $feedbackcompletedtmp->id;
1953     if ($feedbackcompleted) {
1954         //first drop all existing values
1955         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1956         //update the current completed
1957         $feedbackcompleted->timemodified = time();
1958         $DB->update_record('feedback_completed', $feedbackcompleted);
1959     } else {
1960         $feedbackcompleted = clone($feedbackcompletedtmp);
1961         $feedbackcompleted->id = '';
1962         $feedbackcompleted->timemodified = time();
1963         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
1964     }
1966     $allitems = $DB->get_records('feedback_item', array('feedback' => $feedbackcompleted->feedback));
1968     //save all the new values from feedback_valuetmp
1969     //get all values of tmp-completed
1970     $params = array('completed'=>$feedbackcompletedtmp->id);
1971     $values = $DB->get_records('feedback_valuetmp', $params);
1972     foreach ($values as $value) {
1973         //check if there are depend items
1974         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
1975         if ($item->dependitem > 0 && isset($allitems[$item->dependitem])) {
1976             $check = feedback_compare_item_value($tmpcplid,
1977                                         $allitems[$item->dependitem],
1978                                         $item->dependvalue,
1979                                         true);
1980         } else {
1981             $check = true;
1982         }
1983         if ($check) {
1984             unset($value->id);
1985             $value->completed = $feedbackcompleted->id;
1986             $DB->insert_record('feedback_value', $value);
1987         }
1988     }
1989     //drop all the tmpvalues
1990     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1991     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1993     // Trigger event for the delete action we performed.
1994     $cm = get_coursemodule_from_instance('feedback', $feedbackcompleted->feedback);
1995     $event = \mod_feedback\event\response_submitted::create_from_record($feedbackcompleted, $cm);
1996     $event->trigger();
1997     return $feedbackcompleted->id;
2001 /**
2002  * deletes the given temporary completed and all related temporary values
2003  *
2004  * @deprecated since Moodle 3.1
2005  *
2006  * @param int $tmpcplid
2007  * @return void
2008  */
2009 function feedback_delete_completedtmp($tmpcplid) {
2010     global $DB;
2012     debugging('Function feedback_delete_completedtmp() is deprecated because it is no longer used',
2013             DEBUG_DEVELOPER);
2015     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
2016     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
2019 ////////////////////////////////////////////////
2020 ////////////////////////////////////////////////
2021 ////////////////////////////////////////////////
2022 //functions to handle the pagebreaks
2023 ////////////////////////////////////////////////
2025 /**
2026  * this creates a pagebreak.
2027  * a pagebreak is a special kind of item
2028  *
2029  * @global object
2030  * @param int $feedbackid
2031  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
2032  */
2033 function feedback_create_pagebreak($feedbackid) {
2034     global $DB;
2036     //check if there already is a pagebreak on the last position
2037     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
2038     if ($lastposition == feedback_get_last_break_position($feedbackid)) {
2039         return false;
2040     }
2042     $item = new stdClass();
2043     $item->feedback = $feedbackid;
2045     $item->template=0;
2047     $item->name = '';
2049     $item->presentation = '';
2050     $item->hasvalue = 0;
2052     $item->typ = 'pagebreak';
2053     $item->position = $lastposition + 1;
2055     $item->required=0;
2057     return $DB->insert_record('feedback_item', $item);
2060 /**
2061  * get all positions of pagebreaks in the given feedback
2062  *
2063  * @global object
2064  * @param int $feedbackid
2065  * @return array all ordered pagebreak positions
2066  */
2067 function feedback_get_all_break_positions($feedbackid) {
2068     global $DB;
2070     $params = array('typ'=>'pagebreak', 'feedback'=>$feedbackid);
2071     $allbreaks = $DB->get_records_menu('feedback_item', $params, 'position', 'id, position');
2072     if (!$allbreaks) {
2073         return false;
2074     }
2075     return array_values($allbreaks);
2078 /**
2079  * get the position of the last pagebreak
2080  *
2081  * @param int $feedbackid
2082  * @return int the position of the last pagebreak
2083  */
2084 function feedback_get_last_break_position($feedbackid) {
2085     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2086         return false;
2087     }
2088     return $allbreaks[count($allbreaks) - 1];
2091 /**
2092  * this returns the position where the user can continue the completing.
2093  *
2094  * @deprecated since Moodle 3.1
2095  * @global object
2096  * @global object
2097  * @global object
2098  * @param int $feedbackid
2099  * @param int $courseid
2100  * @param string $guestid this id will be saved temporary and is unique
2101  * @return int the position to continue
2102  */
2103 function feedback_get_page_to_continue($feedbackid, $courseid = false, $guestid = false) {
2104     global $CFG, $USER, $DB;
2106     debugging('Function feedback_get_page_to_continue() is deprecated and since it is '
2107             . 'no longer used in mod_feedback', DEBUG_DEVELOPER);
2109     //is there any break?
2111     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2112         return false;
2113     }
2115     $params = array();
2116     if ($courseid) {
2117         $courseselect = "AND fv.course_id = :courseid";
2118         $params['courseid'] = $courseid;
2119     } else {
2120         $courseselect = '';
2121     }
2123     if ($guestid) {
2124         $userselect = "AND fc.guestid = :guestid";
2125         $usergroup = "GROUP BY fc.guestid";
2126         $params['guestid'] = $guestid;
2127     } else {
2128         $userselect = "AND fc.userid = :userid";
2129         $usergroup = "GROUP BY fc.userid";
2130         $params['userid'] = $USER->id;
2131     }
2133     $sql =  "SELECT MAX(fi.position)
2134                FROM {feedback_completedtmp} fc, {feedback_valuetmp} fv, {feedback_item} fi
2135               WHERE fc.id = fv.completed
2136                     $userselect
2137                     AND fc.feedback = :feedbackid
2138                     $courseselect
2139                     AND fi.id = fv.item
2140          $usergroup";
2141     $params['feedbackid'] = $feedbackid;
2143     $lastpos = $DB->get_field_sql($sql, $params);
2145     //the index of found pagebreak is the searched pagenumber
2146     foreach ($allbreaks as $pagenr => $br) {
2147         if ($lastpos < $br) {
2148             return $pagenr;
2149         }
2150     }
2151     return count($allbreaks);
2154 ////////////////////////////////////////////////
2155 ////////////////////////////////////////////////
2156 ////////////////////////////////////////////////
2157 //functions to handle the values
2158 ////////////////////////////////////////////////
2160 /**
2161  * cleans the userinput while submitting the form.
2162  *
2163  * @deprecated since Moodle 3.1
2164  * @param mixed $value
2165  * @return mixed
2166  */
2167 function feedback_clean_input_value($item, $value) {
2168     debugging('Function feedback_clean_input_value() is deprecated and does nothing. '
2169             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
2172 /**
2173  * this saves the values of an completed.
2174  * if the param $tmp is set true so the values are saved temporary in table feedback_valuetmp.
2175  * if there is already a completed and the userid is set so the values are updated.
2176  * on all other things new value records will be created.
2177  *
2178  * @deprecated since Moodle 3.1
2179  *
2180  * @param int $usrid
2181  * @param boolean $tmp
2182  * @return mixed false on error or the completeid
2183  */
2184 function feedback_save_values($usrid, $tmp = false) {
2185     global $DB;
2187     debugging('Function feedback_save_values() was deprecated because it did not have '.
2188             'enough arguments, was not suitable for non-temporary table and was taking '.
2189             'data directly from input', DEBUG_DEVELOPER);
2191     $completedid = optional_param('completedid', 0, PARAM_INT);
2192     $tmpstr = $tmp ? 'tmp' : '';
2193     $time = time();
2194     $timemodified = mktime(0, 0, 0, date('m', $time), date('d', $time), date('Y', $time));
2196     if ($usrid == 0) {
2197         return feedback_create_values($usrid, $timemodified, $tmp);
2198     }
2199     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2200     if (!$completed) {
2201         return feedback_create_values($usrid, $timemodified, $tmp);
2202     } else {
2203         $completed->timemodified = $timemodified;
2204         return feedback_update_values($completed, $tmp);
2205     }
2208 /**
2209  * this saves the values from anonymous user such as guest on the main-site
2210  *
2211  * @deprecated since Moodle 3.1
2212  *
2213  * @param string $guestid the unique guestidentifier
2214  * @return mixed false on error or the completeid
2215  */
2216 function feedback_save_guest_values($guestid) {
2217     global $DB;
2219     debugging('Function feedback_save_guest_values() was deprecated because it did not have '.
2220             'enough arguments, was not suitable for non-temporary table and was taking '.
2221             'data directly from input', DEBUG_DEVELOPER);
2223     $completedid = optional_param('completedid', false, PARAM_INT);
2225     $timemodified = time();
2226     if (!$completed = $DB->get_record('feedback_completedtmp', array('id'=>$completedid))) {
2227         return feedback_create_values(0, $timemodified, true, $guestid);
2228     } else {
2229         $completed->timemodified = $timemodified;
2230         return feedback_update_values($completed, true);
2231     }
2234 /**
2235  * get the value from the given item related to the given completed.
2236  * the value can come as temporary or as permanently value. the deciding is done by $tmp
2237  *
2238  * @global object
2239  * @param int $completeid
2240  * @param int $itemid
2241  * @param boolean $tmp
2242  * @return mixed the value, the type depends on plugin-definition
2243  */
2244 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
2245     global $DB;
2247     $tmpstr = $tmp ? 'tmp' : '';
2248     $params = array('completed'=>$completedid, 'item'=>$itemid);
2249     return $DB->get_field('feedback_value'.$tmpstr, 'value', $params);
2252 /**
2253  * compares the value of the itemid related to the completedid with the dependvalue.
2254  * this is used if a depend item is set.
2255  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
2256  *
2257  * @param int $completedid
2258  * @param stdClass|int $item
2259  * @param mixed $dependvalue
2260  * @param bool $tmp
2261  * @return bool
2262  */
2263 function feedback_compare_item_value($completedid, $item, $dependvalue, $tmp = false) {
2264     global $DB;
2266     if (is_int($item)) {
2267         $item = $DB->get_record('feedback_item', array('id' => $item));
2268     }
2270     $dbvalue = feedback_get_item_value($completedid, $item->id, $tmp);
2272     $itemobj = feedback_get_item_class($item->typ);
2273     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
2276 /**
2277  * this function checks the correctness of values.
2278  * the rules for this are implemented in the class of each item.
2279  * it can be the required attribute or the value self e.g. numeric.
2280  * the params first/lastitem are given to determine the visible range between pagebreaks.
2281  *
2282  * @global object
2283  * @param int $firstitem the position of firstitem for checking
2284  * @param int $lastitem the position of lastitem for checking
2285  * @return boolean
2286  */
2287 function feedback_check_values($firstitem, $lastitem) {
2288     debugging('Function feedback_check_values() is deprecated and does nothing. '
2289             . 'Items must implement complete_form_element()', DEBUG_DEVELOPER);
2290     return true;
2293 /**
2294  * this function create a complete-record and the related value-records.
2295  * depending on the $tmp (true/false) the values are saved temporary or permanently
2296  *
2297  * @deprecated since Moodle 3.1
2298  *
2299  * @param int $userid
2300  * @param int $timemodified
2301  * @param boolean $tmp
2302  * @param string $guestid a unique identifier to save temporary data
2303  * @return mixed false on error or the completedid
2304  */
2305 function feedback_create_values($usrid, $timemodified, $tmp = false, $guestid = false) {
2306     global $DB;
2308     debugging('Function feedback_create_values() was deprecated because it did not have '.
2309             'enough arguments, was not suitable for non-temporary table and was taking '.
2310             'data directly from input', DEBUG_DEVELOPER);
2312     $tmpstr = $tmp ? 'tmp' : '';
2313     //first we create a new completed record
2314     $completed = new stdClass();
2315     $completed->feedback           = $feedbackid;
2316     $completed->userid             = $usrid;
2317     $completed->guestid            = $guestid;
2318     $completed->timemodified       = $timemodified;
2319     $completed->anonymous_response = $anonymous_response;
2321     $completedid = $DB->insert_record('feedback_completed'.$tmpstr, $completed);
2323     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2325     //the keys are in the form like abc_xxx
2326     //with explode we make an array with(abc, xxx) and (abc=typ und xxx=itemnr)
2328     //get the items of the feedback
2329     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2330         return false;
2331     }
2332     foreach ($allitems as $item) {
2333         if (!$item->hasvalue) {
2334             continue;
2335         }
2336         //get the class of item-typ
2337         $itemobj = feedback_get_item_class($item->typ);
2339         $keyname = $item->typ.'_'.$item->id;
2341         if ($item->typ === 'multichoice') {
2342             $itemvalue = optional_param_array($keyname, null, PARAM_INT);
2343         } else {
2344             $itemvalue = optional_param($keyname, null, PARAM_NOTAGS);
2345         }
2347         if (is_null($itemvalue)) {
2348             continue;
2349         }
2351         $value = new stdClass();
2352         $value->item = $item->id;
2353         $value->completed = $completed->id;
2354         $value->course_id = $courseid;
2356         //the kind of values can be absolutely different
2357         //so we run create_value directly by the item-class
2358         $value->value = $itemobj->create_value($itemvalue);
2359         $DB->insert_record('feedback_value'.$tmpstr, $value);
2360     }
2361     return $completed->id;
2364 /**
2365  * this function updates a complete-record and the related value-records.
2366  * depending on the $tmp (true/false) the values are saved temporary or permanently
2367  *
2368  * @global object
2369  * @param object $completed
2370  * @param boolean $tmp
2371  * @return int the completedid
2372  */
2373 function feedback_update_values($completed, $tmp = false) {
2374     global $DB;
2376     debugging('Function feedback_update_values() was deprecated because it did not have '.
2377             'enough arguments, was not suitable for non-temporary table and was taking '.
2378             'data directly from input', DEBUG_DEVELOPER);
2380     $courseid = optional_param('courseid', false, PARAM_INT);
2381     $tmpstr = $tmp ? 'tmp' : '';
2383     $DB->update_record('feedback_completed'.$tmpstr, $completed);
2384     //get the values of this completed
2385     $values = $DB->get_records('feedback_value'.$tmpstr, array('completed'=>$completed->id));
2387     //get the items of the feedback
2388     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2389         return false;
2390     }
2391     foreach ($allitems as $item) {
2392         if (!$item->hasvalue) {
2393             continue;
2394         }
2395         //get the class of item-typ
2396         $itemobj = feedback_get_item_class($item->typ);
2398         $keyname = $item->typ.'_'.$item->id;
2400         if ($item->typ === 'multichoice') {
2401             $itemvalue = optional_param_array($keyname, null, PARAM_INT);
2402         } else {
2403             $itemvalue = optional_param($keyname, null, PARAM_NOTAGS);
2404         }
2406         //is the itemvalue set (could be a subset of items because pagebreak)?
2407         if (is_null($itemvalue)) {
2408             continue;
2409         }
2411         $newvalue = new stdClass();
2412         $newvalue->item = $item->id;
2413         $newvalue->completed = $completed->id;
2414         $newvalue->course_id = $courseid;
2416         //the kind of values can be absolutely different
2417         //so we run create_value directly by the item-class
2418         $newvalue->value = $itemobj->create_value($itemvalue);
2420         //check, if we have to create or update the value
2421         $exist = false;
2422         foreach ($values as $value) {
2423             if ($value->item == $newvalue->item) {
2424                 $newvalue->id = $value->id;
2425                 $exist = true;
2426                 break;
2427             }
2428         }
2429         if ($exist) {
2430             $DB->update_record('feedback_value'.$tmpstr, $newvalue);
2431         } else {
2432             $DB->insert_record('feedback_value'.$tmpstr, $newvalue);
2433         }
2434     }
2436     return $completed->id;
2439 /**
2440  * get the values of an item depending on the given groupid.
2441  * if the feedback is anonymous so the values are shuffled
2442  *
2443  * @global object
2444  * @global object
2445  * @param object $item
2446  * @param int $groupid
2447  * @param int $courseid
2448  * @param bool $ignore_empty if this is set true so empty values are not delivered
2449  * @return array the value-records
2450  */
2451 function feedback_get_group_values($item,
2452                                    $groupid = false,
2453                                    $courseid = false,
2454                                    $ignore_empty = false) {
2456     global $CFG, $DB;
2458     //if the groupid is given?
2459     if (intval($groupid) > 0) {
2460         $params = array();
2461         if ($ignore_empty) {
2462             $value = $DB->sql_compare_text('fbv.value');
2463             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2464             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2465         } else {
2466             $ignore_empty_select = "";
2467         }
2469         $query = 'SELECT fbv .  *
2470                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2471                    WHERE fbv.item = :itemid
2472                          AND fbv.completed = fbc.id
2473                          AND fbc.userid = gm.userid
2474                          '.$ignore_empty_select.'
2475                          AND gm.groupid = :groupid
2476                 ORDER BY fbc.timemodified';
2477         $params += array('itemid' => $item->id, 'groupid' => $groupid);
2478         $values = $DB->get_records_sql($query, $params);
2480     } else {
2481         $params = array();
2482         if ($ignore_empty) {
2483             $value = $DB->sql_compare_text('value');
2484             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2485             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2486         } else {
2487             $ignore_empty_select = "";
2488         }
2490         if ($courseid) {
2491             $select = "item = :itemid AND course_id = :courseid ".$ignore_empty_select;
2492             $params += array('itemid' => $item->id, 'courseid' => $courseid);
2493             $values = $DB->get_records_select('feedback_value', $select, $params);
2494         } else {
2495             $select = "item = :itemid ".$ignore_empty_select;
2496             $params += array('itemid' => $item->id);
2497             $values = $DB->get_records_select('feedback_value', $select, $params);
2498         }
2499     }
2500     $params = array('id'=>$item->feedback);
2501     if ($DB->get_field('feedback', 'anonymous', $params) == FEEDBACK_ANONYMOUS_YES) {
2502         if (is_array($values)) {
2503             shuffle($values);
2504         }
2505     }
2506     return $values;
2509 /**
2510  * check for multiple_submit = false.
2511  * if the feedback is global so the courseid must be given
2512  *
2513  * @global object
2514  * @global object
2515  * @param int $feedbackid
2516  * @param int $courseid
2517  * @return boolean true if the feedback already is submitted otherwise false
2518  */
2519 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2520     global $USER, $DB;
2522     if (!isloggedin() || isguestuser()) {
2523         return false;
2524     }
2526     $params = array('userid' => $USER->id, 'feedback' => $feedbackid);
2527     if ($courseid) {
2528         $params['courseid'] = $courseid;
2529     }
2530     return $DB->record_exists('feedback_completed', $params);
2533 /**
2534  * if the completion of a feedback will be continued eg.
2535  * by pagebreak or by multiple submit so the complete must be found.
2536  * if the param $tmp is set true so all things are related to temporary completeds
2537  *
2538  * @deprecated since Moodle 3.1
2539  * @param int $feedbackid
2540  * @param boolean $tmp
2541  * @param int $courseid
2542  * @param string $guestid
2543  * @return int the id of the found completed
2544  */
2545 function feedback_get_current_completed($feedbackid,
2546                                         $tmp = false,
2547                                         $courseid = false,
2548                                         $guestid = false) {
2550     debugging('Function feedback_get_current_completed() is deprecated. Please use either '.
2551             'feedback_get_current_completed_tmp() or feedback_get_last_completed()',
2552             DEBUG_DEVELOPER);
2554     global $USER, $CFG, $DB;
2556     $tmpstr = $tmp ? 'tmp' : '';
2558     if (!$courseid) {
2559         if ($guestid) {
2560             $params = array('feedback'=>$feedbackid, 'guestid'=>$guestid);
2561             return $DB->get_record('feedback_completed'.$tmpstr, $params);
2562         } else {
2563             $params = array('feedback'=>$feedbackid, 'userid'=>$USER->id);
2564             return $DB->get_record('feedback_completed'.$tmpstr, $params);
2565         }
2566     }
2568     $params = array();
2570     if ($guestid) {
2571         $userselect = "AND fc.guestid = :guestid";
2572         $params['guestid'] = $guestid;
2573     } else {
2574         $userselect = "AND fc.userid = :userid";
2575         $params['userid'] = $USER->id;
2576     }
2577     //if courseid is set the feedback is global.
2578     //there can be more than one completed on one feedback
2579     $sql =  "SELECT DISTINCT fc.*
2580                FROM {feedback_value{$tmpstr}} fv, {feedback_completed{$tmpstr}} fc
2581               WHERE fv.course_id = :courseid
2582                     AND fv.completed = fc.id
2583                     $userselect
2584                     AND fc.feedback = :feedbackid";
2585     $params['courseid']   = intval($courseid);
2586     $params['feedbackid'] = $feedbackid;
2588     if (!$sqlresult = $DB->get_records_sql($sql, $params)) {
2589         return false;
2590     }
2591     foreach ($sqlresult as $r) {
2592         return $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$r->id));
2593     }
2596 /**
2597  * get the completeds depending on the given groupid.
2598  *
2599  * @global object
2600  * @global object
2601  * @param object $feedback
2602  * @param int $groupid
2603  * @param int $courseid
2604  * @return mixed array of found completeds otherwise false
2605  */
2606 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2607     global $CFG, $DB;
2609     if (intval($groupid) > 0) {
2610         $query = "SELECT fbc.*
2611                     FROM {feedback_completed} fbc, {groups_members} gm
2612                    WHERE fbc.feedback = ?
2613                          AND gm.groupid = ?
2614                          AND fbc.userid = gm.userid";
2615         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2616             return $values;
2617         } else {
2618             return false;
2619         }
2620     } else {
2621         if ($courseid) {
2622             $query = "SELECT DISTINCT fbc.*
2623                         FROM {feedback_completed} fbc, {feedback_value} fbv
2624                         WHERE fbc.id = fbv.completed
2625                             AND fbc.feedback = ?
2626                             AND fbv.course_id = ?
2627                         ORDER BY random_response";
2628             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2629                 return $values;
2630             } else {
2631                 return false;
2632             }
2633         } else {
2634             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2635                 return $values;
2636             } else {
2637                 return false;
2638             }
2639         }
2640     }
2643 /**
2644  * get the count of completeds depending on the given groupid.
2645  *
2646  * @global object
2647  * @global object
2648  * @param object $feedback
2649  * @param int $groupid
2650  * @param int $courseid
2651  * @return mixed count of completeds or false
2652  */
2653 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2654     global $CFG, $DB;
2656     if ($courseid > 0 AND !$groupid <= 0) {
2657         $sql = "SELECT id, COUNT(item) AS ci
2658                   FROM {feedback_value}
2659                  WHERE course_id  = ?
2660               GROUP BY item ORDER BY ci DESC";
2661         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2662             $foundrecs = array_values($foundrecs);
2663             return $foundrecs[0]->ci;
2664         }
2665         return false;
2666     }
2667     if ($values = feedback_get_completeds_group($feedback, $groupid)) {
2668         return count($values);
2669     } else {
2670         return false;
2671     }
2674 /**
2675  * deletes all completed-recordsets from a feedback.
2676  * all related data such as values also will be deleted
2677  *
2678  * @param stdClass|int $feedback
2679  * @param stdClass|cm_info $cm
2680  * @param stdClass $course
2681  * @return void
2682  */
2683 function feedback_delete_all_completeds($feedback, $cm = null, $course = null) {
2684     global $DB;
2686     if (is_int($feedback)) {
2687         $feedback = $DB->get_record('feedback', array('id' => $feedback));
2688     }
2690     if (!$completeds = $DB->get_records('feedback_completed', array('feedback' => $feedback->id))) {
2691         return;
2692     }
2694     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2695         return false;
2696     }
2698     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2699         return false;
2700     }
2702     foreach ($completeds as $completed) {
2703         feedback_delete_completed($completed, $feedback, $cm, $course);
2704     }
2707 /**
2708  * deletes a completed given by completedid.
2709  * all related data such values or tracking data also will be deleted
2710  *
2711  * @param int|stdClass $completed
2712  * @param stdClass $feedback
2713  * @param stdClass|cm_info $cm
2714  * @param stdClass $course
2715  * @return boolean
2716  */
2717 function feedback_delete_completed($completed, $feedback = null, $cm = null, $course = null) {
2718     global $DB, $CFG;
2719     require_once($CFG->libdir.'/completionlib.php');
2721     if (!isset($completed->id)) {
2722         if (!$completed = $DB->get_record('feedback_completed', array('id' => $completed))) {
2723             return false;
2724         }
2725     }
2727     if (!$feedback && !($feedback = $DB->get_record('feedback', array('id' => $completed->feedback)))) {
2728         return false;
2729     }
2731     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2732         return false;
2733     }
2735     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2736         return false;
2737     }
2739     //first we delete all related values
2740     $DB->delete_records('feedback_value', array('completed' => $completed->id));
2742     // Update completion state
2743     $completion = new completion_info($course);
2744     if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
2745         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
2746     }
2747     // Last we delete the completed-record.
2748     $return = $DB->delete_records('feedback_completed', array('id' => $completed->id));
2750     // Trigger event for the delete action we performed.
2751     $event = \mod_feedback\event\response_deleted::create_from_record($completed, $cm, $feedback);
2752     $event->trigger();
2754     return $return;
2757 ////////////////////////////////////////////////
2758 ////////////////////////////////////////////////
2759 ////////////////////////////////////////////////
2760 //functions to handle sitecourse mapping
2761 ////////////////////////////////////////////////
2763 /**
2764  * checks if the course and the feedback is in the table feedback_sitecourse_map.
2765  *
2766  * @deprecated since 3.1
2767  * @param int $feedbackid
2768  * @param int $courseid
2769  * @return int the count of records
2770  */
2771 function feedback_is_course_in_sitecourse_map($feedbackid, $courseid) {
2772     debugging('Function feedback_is_course_in_sitecourse_map() is deprecated because it was not used.',
2773             DEBUG_DEVELOPER);
2774     global $DB;
2775     $params = array('feedbackid'=>$feedbackid, 'courseid'=>$courseid);
2776     return $DB->count_records('feedback_sitecourse_map', $params);
2779 /**
2780  * checks if the feedback is in the table feedback_sitecourse_map.
2781  *
2782  * @deprecated since 3.1
2783  * @param int $feedbackid
2784  * @return boolean
2785  */
2786 function feedback_is_feedback_in_sitecourse_map($feedbackid) {
2787     debugging('Function feedback_is_feedback_in_sitecourse_map() is deprecated because it was not used.',
2788             DEBUG_DEVELOPER);
2789     global $DB;
2790     return $DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$feedbackid));
2793 /**
2794  * gets the feedbacks from table feedback_sitecourse_map.
2795  * this is used to show the global feedbacks on the feedback block
2796  * all feedbacks with the following criteria will be selected:<br />
2797  *
2798  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2799  * 2) all feedbacks which not are listed in sitecoursemap
2800  *
2801  * @global object
2802  * @param int $courseid
2803  * @return array the feedback-records
2804  */
2805 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2806     global $DB;
2808     //first get all feedbacks listed in sitecourse_map with named courseid
2809     $sql = "SELECT f.id AS id,
2810                    cm.id AS cmid,
2811                    f.name AS name,
2812                    f.timeopen AS timeopen,
2813                    f.timeclose AS timeclose
2814             FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2815             WHERE f.id = cm.instance
2816                    AND f.course = '".SITEID."'
2817                    AND m.id = cm.module
2818                    AND m.name = 'feedback'
2819                    AND sm.courseid = ?
2820                    AND sm.feedbackid = f.id";
2822     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2823         $feedbacks1 = array();
2824     }
2826     //second get all feedbacks not listed in sitecourse_map
2827     $feedbacks2 = array();
2828     $sql = "SELECT f.id AS id,
2829                    cm.id AS cmid,
2830                    f.name AS name,
2831                    f.timeopen AS timeopen,
2832                    f.timeclose AS timeclose
2833             FROM {feedback} f, {course_modules} cm, {modules} m
2834             WHERE f.id = cm.instance
2835                    AND f.course = '".SITEID."'
2836                    AND m.id = cm.module
2837                    AND m.name = 'feedback'";
2838     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2839         $allfeedbacks = array();
2840     }
2841     foreach ($allfeedbacks as $a) {
2842         if (!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2843             $feedbacks2[] = $a;
2844         }
2845     }
2847     $feedbacks = array_merge($feedbacks1, $feedbacks2);
2848     $modinfo = get_fast_modinfo(SITEID);
2849     return array_filter($feedbacks, function($f) use ($modinfo) {
2850         return ($cm = $modinfo->get_cm($f->cmid)) && $cm->uservisible;
2851     });
2855 /**
2856  * Gets the courses from table feedback_sitecourse_map
2857  *
2858  * @param int $feedbackid
2859  * @return array the course-records
2860  */
2861 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2862     global $DB;
2864     $sql = "SELECT c.id, c.fullname, c.shortname
2865               FROM {feedback_sitecourse_map} f, {course} c
2866              WHERE c.id = f.courseid
2867                    AND f.feedbackid = ?
2868           ORDER BY c.fullname";
2870     return $DB->get_records_sql($sql, array($feedbackid));
2874 /**
2875  * Updates the course mapping for the feedback
2876  *
2877  * @param stdClass $feedback
2878  * @param array $courses array of course ids
2879  */
2880 function feedback_update_sitecourse_map($feedback, $courses) {
2881     global $DB;
2882     if (empty($courses)) {
2883         $courses = array();
2884     }
2885     $currentmapping = $DB->get_fieldset_select('feedback_sitecourse_map', 'courseid', 'feedbackid=?', array($feedback->id));
2886     foreach (array_diff($courses, $currentmapping) as $courseid) {
2887         $DB->insert_record('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2888     }
2889     foreach (array_diff($currentmapping, $courses) as $courseid) {
2890         $DB->delete_records('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2891     }
2892     // TODO MDL-53574 add events.
2895 /**
2896  * removes non existing courses or feedbacks from sitecourse_map.
2897  * it shouldn't be called all too often
2898  * a good place for it could be the mapcourse.php or unmapcourse.php
2899  *
2900  * @deprecated since 3.1
2901  * @global object
2902  * @return void
2903  */
2904 function feedback_clean_up_sitecourse_map() {
2905     global $DB;
2906     debugging('Function feedback_clean_up_sitecourse_map() is deprecated because it was not used.',
2907             DEBUG_DEVELOPER);
2909     $maps = $DB->get_records('feedback_sitecourse_map');
2910     foreach ($maps as $map) {
2911         if (!$DB->get_record('course', array('id'=>$map->courseid))) {
2912             $params = array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid);
2913             $DB->delete_records('feedback_sitecourse_map', $params);
2914             continue;
2915         }
2916         if (!$DB->get_record('feedback', array('id'=>$map->feedbackid))) {
2917             $params = array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid);
2918             $DB->delete_records('feedback_sitecourse_map', $params);
2919             continue;
2920         }
2922     }
2925 ////////////////////////////////////////////////
2926 ////////////////////////////////////////////////
2927 ////////////////////////////////////////////////
2928 //not relatable functions
2929 ////////////////////////////////////////////////
2931 /**
2932  * prints the option items of a selection-input item (dropdownlist).
2933  * @deprecated since 3.1
2934  * @param int $startval the first value of the list
2935  * @param int $endval the last value of the list
2936  * @param int $selectval which item should be selected
2937  * @param int $interval the stepsize from the first to the last value
2938  * @return void
2939  */
2940 function feedback_print_numeric_option_list($startval, $endval, $selectval = '', $interval = 1) {
2941     debugging('Function feedback_print_numeric_option_list() is deprecated because it was not used.',
2942             DEBUG_DEVELOPER);
2943     for ($i = $startval; $i <= $endval; $i += $interval) {
2944         if ($selectval == ($i)) {
2945             $selected = 'selected="selected"';
2946         } else {
2947             $selected = '';
2948         }
2949         echo '<option '.$selected.'>'.$i.'</option>';
2950     }
2953 /**
2954  * sends an email to the teachers of the course where the given feedback is placed.
2955  *
2956  * @global object
2957  * @global object
2958  * @uses FEEDBACK_ANONYMOUS_NO
2959  * @uses FORMAT_PLAIN
2960  * @param object $cm the coursemodule-record
2961  * @param object $feedback
2962  * @param object $course
2963  * @param stdClass|int $user
2964  * @return void
2965  */
2966 function feedback_send_email($cm, $feedback, $course, $user) {
2967     global $CFG, $DB;
2969     if ($feedback->email_notification == 0) {  // No need to do anything
2970         return;
2971     }
2973     if (is_int($user)) {
2974         $user = $DB->get_record('user', array('id' => $user));
2975     }
2977     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
2978         $groupmode =  $cm->groupmode;
2979     } else {
2980         $groupmode = $course->groupmode;
2981     }
2983     if ($groupmode == SEPARATEGROUPS) {
2984         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
2985                                                FROM {groups} g, {groups_members} m
2986                                               WHERE g.courseid = ?
2987                                                     AND g.id = m.groupid
2988                                                     AND m.userid = ?
2989                                            ORDER BY name ASC", array($course->id, $user->id));
2990         $groups = array_values($groups);
2992         $teachers = feedback_get_receivemail_users($cm->id, $groups);
2993     } else {
2994         $teachers = feedback_get_receivemail_users($cm->id);
2995     }
2997     if ($teachers) {
2999         $strfeedbacks = get_string('modulenameplural', 'feedback');
3000         $strfeedback  = get_string('modulename', 'feedback');
3002         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
3003             $printusername = fullname($user);
3004         } else {
3005             $printusername = get_string('anonymous_user', 'feedback');
3006         }
3008         foreach ($teachers as $teacher) {
3009             $info = new stdClass();
3010             $info->username = $printusername;
3011             $info->feedback = format_string($feedback->name, true);
3012             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?'.
3013                             'id='.$cm->id.'&'.
3014                             'userid=' . $user->id;
3016             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
3018             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
3019             $posttext = feedback_send_email_text($info, $course);
3021             if ($teacher->mailformat == 1) {
3022                 $posthtml = feedback_send_email_html($info, $course, $cm);
3023             } else {
3024                 $posthtml = '';
3025             }
3027             if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
3028                 $eventdata = new \core\message\message();
3029                 $eventdata->courseid         = $course->id;
3030                 $eventdata->name             = 'submission';
3031                 $eventdata->component        = 'mod_feedback';
3032                 $eventdata->userfrom         = $user;
3033                 $eventdata->userto           = $teacher;
3034                 $eventdata->subject          = $postsubject;
3035                 $eventdata->fullmessage      = $posttext;
3036                 $eventdata->fullmessageformat = FORMAT_PLAIN;
3037                 $eventdata->fullmessagehtml  = $posthtml;
3038                 $eventdata->smallmessage     = '';
3039                 $eventdata->courseid         = $course->id;
3040                 $eventdata->contexturl       = $info->url;
3041                 $eventdata->contexturlname   = $info->feedback;
3042                 message_send($eventdata);
3043             } else {
3044                 $eventdata = new \core\message\message();
3045                 $eventdata->courseid         = $course->id;
3046                 $eventdata->name             = 'submission';
3047                 $eventdata->component        = 'mod_feedback';
3048                 $eventdata->userfrom         = $teacher;
3049                 $eventdata->userto           = $teacher;
3050                 $eventdata->subject          = $postsubject;
3051                 $eventdata->fullmessage      = $posttext;
3052                 $eventdata->fullmessageformat = FORMAT_PLAIN;
3053                 $eventdata->fullmessagehtml  = $posthtml;
3054                 $eventdata->smallmessage     = '';
3055                 $eventdata->courseid         = $course->id;
3056                 $eventdata->contexturl       = $info->url;
3057                 $eventdata->contexturlname   = $info->feedback;
3058                 message_send($eventdata);
3059             }
3060         }
3061     }
3064 /**
3065  * sends an email to the teachers of the course where the given feedback is placed.
3066  *
3067  * @global object
3068  * @uses FORMAT_PLAIN
3069  * @param object $cm the coursemodule-record
3070  * @param object $feedback
3071  * @param object $course
3072  * @return void
3073  */
3074 function feedback_send_email_anonym($cm, $feedback, $course) {
3075     global $CFG;
3077     if ($feedback->email_notification == 0) { // No need to do anything
3078         return;
3079     }
3081     $teachers = feedback_get_receivemail_users($cm->id);
3083     if ($teachers) {
3085         $strfeedbacks = get_string('modulenameplural', 'feedback');
3086         $strfeedback  = get_string('modulename', 'feedback');
3087         $printusername = get_string('anonymous_user', 'feedback');
3089         foreach ($teachers as $teacher) {
3090             $info = new stdClass();
3091             $info->username = $printusername;
3092             $info->feedback = format_string($feedback->name, true);
3093             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?id=' . $cm->id;
3095             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
3097             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
3098             $posttext = feedback_send_email_text($info, $course);
3100             if ($teacher->mailformat == 1) {
3101                 $posthtml = feedback_send_email_html($info, $course, $cm);
3102             } else {
3103                 $posthtml = '';
3104             }
3106             $eventdata = new \core\message\message();
3107             $eventdata->courseid         = $course->id;
3108             $eventdata->name             = 'submission';
3109             $eventdata->component        = 'mod_feedback';
3110             $eventdata->userfrom         = $teacher;
3111             $eventdata->userto           = $teacher;
3112             $eventdata->subject          = $postsubject;
3113             $eventdata->fullmessage      = $posttext;
3114             $eventdata->fullmessageformat = FORMAT_PLAIN;
3115             $eventdata->fullmessagehtml  = $posthtml;
3116             $eventdata->smallmessage     = '';
3117             $eventdata->courseid         = $course->id;
3118             $eventdata->contexturl       = $info->url;
3119             $eventdata->contexturlname   = $info->feedback;
3120             message_send($eventdata);
3121         }
3122     }
3125 /**
3126  * send the text-part of the email
3127  *
3128  * @param object $info includes some infos about the feedback you want to send
3129  * @param object $course
3130  * @return string the text you want to post
3131  */
3132 function feedback_send_email_text($info, $course) {
3133     $coursecontext = context_course::instance($course->id);
3134     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
3135     $posttext  = $courseshortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
3136                     $info->feedback."\n";
3137     $posttext .= '---------------------------------------------------------------------'."\n";
3138     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
3139     $posttext .= '---------------------------------------------------------------------'."\n";
3140     return $posttext;
3144 /**
3145  * send the html-part of the email
3146  *
3147  * @global object
3148  * @param object $info includes some infos about the feedback you want to send
3149  * @param object $course
3150  * @return string the text you want to post
3151  */
3152 function feedback_send_email_html($info, $course, $cm) {
3153     global $CFG;
3154     $coursecontext = context_course::instance($course->id);
3155     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
3156     $course_url = $CFG->wwwroot.'/course/view.php?id='.$course->id;
3157     $feedback_all_url = $CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id;
3158     $feedback_url = $CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id;
3160     $posthtml = '<p><font face="sans-serif">'.
3161             '<a href="'.$course_url.'">'.$courseshortname.'</a> ->'.
3162             '<a href="'.$feedback_all_url.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
3163             '<a href="'.$feedback_url.'">'.$info->feedback.'</a></font></p>';
3164     $posthtml .= '<hr /><font face="sans-serif">';
3165     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
3166     $posthtml .= '</font><hr />';
3167     return $posthtml;
3170 /**
3171  * @param string $url
3172  * @return string
3173  */
3174 function feedback_encode_target_url($url) {
3175     if (strpos($url, '?')) {
3176         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
3177         return $part1 . '?' . htmlentities($part2);
3178     } else {
3179         return $url;
3180     }
3183 /**
3184  * Adds module specific settings to the settings block
3185  *
3186  * @param settings_navigation $settings The settings navigation object
3187  * @param navigation_node $feedbacknode The node to add module settings to
3188  */
3189 function feedback_extend_settings_navigation(settings_navigation $settings,
3190                                              navigation_node $feedbacknode) {
3192     global $PAGE;
3194     if (!$context = context_module::instance($PAGE->cm->id, IGNORE_MISSING)) {
3195         print_error('badcontext');
3196     }
3198     if (has_capability('mod/feedback:edititems', $context)) {
3199         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
3201         $questionnode->add(get_string('edit_items', 'feedback'),
3202                     new moodle_url('/mod/feedback/edit.php',
3203                                     array('id' => $PAGE->cm->id,
3204                                           'do_show' => 'edit')));
3206         $questionnode->add(get_string('export_questions', 'feedback'),
3207                     new moodle_url('/mod/feedback/export.php',
3208                                     array('id' => $PAGE->cm->id,
3209                                           'action' => 'exportfile')));
3211         $questionnode->add(get_string('import_questions', 'feedback'),
3212                     new moodle_url('/mod/feedback/import.php',
3213                                     array('id' => $PAGE->cm->id)));
3215         $questionnode->add(get_string('templates', 'feedback'),
3216                     new moodle_url('/mod/feedback/edit.php',
3217                                     array('id' => $PAGE->cm->id,
3218                                           'do_show' => 'templates')));
3219     }
3221     if (has_capability('mod/feedback:mapcourse', $context) && $PAGE->course->id == SITEID) {
3222         $feedbacknode->add(get_string('mappedcourses', 'feedback'),
3223                     new moodle_url('/mod/feedback/mapcourse.php',
3224                                     array('id' => $PAGE->cm->id)));
3225     }
3227     if (has_capability('mod/feedback:viewreports', $context)) {
3228         $feedback = $PAGE->activityrecord;
3229         if ($feedback->course == SITEID) {
3230             $feedbacknode->add(get_string('analysis', 'feedback'),
3231                     new moodle_url('/mod/feedback/analysis_course.php',
3232                                     array('id' => $PAGE->cm->id)));
3233         } else {
3234             $feedbacknode->add(get_string('analysis', 'feedback'),
3235                     new moodle_url('/mod/feedback/analysis.php',
3236                                     array('id' => $PAGE->cm->id)));
3237         }
3239         $feedbacknode->add(get_string('show_entries', 'feedback'),
3240                     new moodle_url('/mod/feedback/show_entries.php',
3241                                     array('id' => $PAGE->cm->id)));
3243         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO AND $feedback->course != SITEID) {
3244             $feedbacknode->add(get_string('show_nonrespondents', 'feedback'),
3245                         new moodle_url('/mod/feedback/show_nonrespondents.php',
3246                                         array('id' => $PAGE->cm->id)));
3247         }
3248     }
3251 function feedback_init_feedback_session() {
3252     //initialize the feedback-Session - not nice at all!!
3253     global $SESSION;
3254     if (!empty($SESSION)) {
3255         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
3256             $SESSION->feedback = new stdClass();
3257         }
3258     }
3261 /**
3262  * Return a list of page types
3263  * @param string $pagetype current page type
3264  * @param stdClass $parentcontext Block's parent context
3265  * @param stdClass $currentcontext Current context of block
3266  */
3267 function feedback_page_type_list($pagetype, $parentcontext, $currentcontext) {
3268     $module_pagetype = array('mod-feedback-*'=>get_string('page-mod-feedback-x', 'feedback'));
3269     return $module_pagetype;
3272 /**
3273  * Move save the items of the given $feedback in the order of $itemlist.
3274  * @param string $itemlist a comma separated list with item ids
3275  * @param stdClass $feedback
3276  * @return bool true if success
3277  */
3278 function feedback_ajax_saveitemorder($itemlist, $feedback) {
3279     global $DB;
3281     $result = true;
3282     $position = 0;
3283     foreach ($itemlist as $itemid) {
3284         $position++;
3285         $result = $result && $DB->set_field('feedback_item',
3286                                             'position',
3287                                             $position,
3288                                             array('id'=>$itemid, 'feedback'=>$feedback->id));
3289     }
3290     return $result;
3293 /**
3294  * Checks if current user is able to view feedback on this course.
3295  *
3296  * @param stdClass $feedback
3297  * @param context_module $context
3298  * @param int $courseid
3299  * @return bool
3300  */
3301 function feedback_can_view_analysis($feedback, $context, $courseid = false) {
3302     if (has_capability('mod/feedback:viewreports', $context)) {
3303         return true;
3304     }
3306     if (intval($feedback->publish_stats) != 1 ||
3307             !has_capability('mod/feedback:viewanalysepage', $context)) {
3308         return false;
3309     }
3311     if (!isloggedin() || isguestuser()) {
3312         // There is no tracking for the guests, assume that they can view analysis if condition above is satisfied.
3313         return $feedback->course == SITEID;
3314     }
3316     return feedback_is_already_submitted($feedback->id, $courseid);
3319 /**
3320  * Get icon mapping for font-awesome.
3321  */
3322 function mod_feedback_get_fontawesome_icon_map() {
3323     return [
3324         'mod_feedback:required' => 'fa-exclamation-circle',
3325         'mod_feedback:notrequired' => 'fa-question-circle-o',
3326     ];
3329 /**
3330  * Check if the module has any update that affects the current user since a given time.
3331  *
3332  * @param  cm_info $cm course module data
3333  * @param  int $from the time to check updates from
3334  * @param  array $filter if we need to check only specific updates
3335  * @return stdClass an object with the different type of areas indicating if they were updated or not
3336  * @since Moodle 3.3
3337  */
3338 function feedback_check_updates_since(cm_info $cm, $from, $filter = array()) {
3339     global $DB, $USER, $CFG;
3341     $updates = course_check_module_updates_since($cm, $from, array(), $filter);
3343     // Check for new attempts.
3344     $updates->attemptsfinished = (object) array('updated' => false);
3345     $updates->attemptsunfinished = (object) array('updated' => false);
3346     $select = 'feedback = ? AND userid = ? AND timemodified > ?';
3347     $params = array($cm->instance, $USER->id, $from);
3349     $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
3350     if (!empty($attemptsfinished)) {
3351         $updates->attemptsfinished->updated = true;
3352         $updates->attemptsfinished->itemids = array_keys($attemptsfinished);
3353     }
3354     $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
3355     if (!empty($attemptsunfinished)) {
3356         $updates->attemptsunfinished->updated = true;
3357         $updates->attemptsunfinished->itemids = array_keys($attemptsunfinished);
3358     }
3360     // Now, teachers should see other students updates.
3361     if (has_capability('mod/feedback:viewreports', $cm->context)) {
3362         $select = 'feedback = ? AND timemodified > ?';
3363         $params = array($cm->instance, $from);
3365         if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
3366             $groupusers = array_keys(groups_get_activity_shared_group_members($cm));
3367             if (empty($groupusers)) {
3368                 return $updates;
3369             }
3370             list($insql, $inparams) = $DB->get_in_or_equal($groupusers);
3371             $select .= ' AND userid ' . $insql;
3372             $params = array_merge($params, $inparams);
3373         }
3375         $updates->userattemptsfinished = (object) array('updated' => false);
3376         $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
3377         if (!empty($attemptsfinished)) {
3378             $updates->userattemptsfinished->updated = true;
3379             $updates->userattemptsfinished->itemids = array_keys($attemptsfinished);
3380         }
3382         $updates->userattemptsunfinished = (object) array('updated' => false);
3383         $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
3384         if (!empty($attemptsunfinished)) {
3385             $updates->userattemptsunfinished->updated = true;
3386             $updates->userattemptsunfinished->itemids = array_keys($attemptsunfinished);
3387         }
3388     }
3390     return $updates;