MDL-53972 feedback: Final deprecation in mod/feedback/lib.php
[moodle.git] / mod / feedback / lib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Library of functions and constants for module feedback
19  * includes the main-part of feedback-functions
20  *
21  * @package mod_feedback
22  * @copyright Andreas Grabs
23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 /** Include eventslib.php */
29 require_once($CFG->libdir.'/eventslib.php');
30 // Include forms lib.
31 require_once($CFG->libdir.'/formslib.php');
33 define('FEEDBACK_ANONYMOUS_YES', 1);
34 define('FEEDBACK_ANONYMOUS_NO', 2);
35 define('FEEDBACK_MIN_ANONYMOUS_COUNT_IN_GROUP', 2);
36 define('FEEDBACK_DECIMAL', '.');
37 define('FEEDBACK_THOUSAND', ',');
38 define('FEEDBACK_RESETFORM_RESET', 'feedback_reset_data_');
39 define('FEEDBACK_RESETFORM_DROP', 'feedback_drop_feedback_');
40 define('FEEDBACK_MAX_PIX_LENGTH', '400'); //max. Breite des grafischen Balkens in der Auswertung
41 define('FEEDBACK_DEFAULT_PAGE_COUNT', 20);
43 // Event types.
44 define('FEEDBACK_EVENT_TYPE_OPEN', 'open');
45 define('FEEDBACK_EVENT_TYPE_CLOSE', 'close');
47 /**
48  * Returns all other caps used in module.
49  *
50  * @return array
51  */
52 function feedback_get_extra_capabilities() {
53     return array('moodle/site:accessallgroups');
54 }
56 /**
57  * @uses FEATURE_GROUPS
58  * @uses FEATURE_GROUPINGS
59  * @uses FEATURE_MOD_INTRO
60  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
61  * @uses FEATURE_GRADE_HAS_GRADE
62  * @uses FEATURE_GRADE_OUTCOMES
63  * @param string $feature FEATURE_xx constant for requested feature
64  * @return mixed True if module supports feature, null if doesn't know
65  */
66 function feedback_supports($feature) {
67     switch($feature) {
68         case FEATURE_GROUPS:                  return true;
69         case FEATURE_GROUPINGS:               return true;
70         case FEATURE_MOD_INTRO:               return true;
71         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
72         case FEATURE_COMPLETION_HAS_RULES:    return true;
73         case FEATURE_GRADE_HAS_GRADE:         return false;
74         case FEATURE_GRADE_OUTCOMES:          return false;
75         case FEATURE_BACKUP_MOODLE2:          return true;
76         case FEATURE_SHOW_DESCRIPTION:        return true;
78         default: return null;
79     }
80 }
82 /**
83  * this will create a new instance and return the id number
84  * of the new instance.
85  *
86  * @global object
87  * @param object $feedback the object given by mod_feedback_mod_form
88  * @return int
89  */
90 function feedback_add_instance($feedback) {
91     global $DB;
93     $feedback->timemodified = time();
94     $feedback->id = '';
96     if (empty($feedback->site_after_submit)) {
97         $feedback->site_after_submit = '';
98     }
100     //saving the feedback in db
101     $feedbackid = $DB->insert_record("feedback", $feedback);
103     $feedback->id = $feedbackid;
105     feedback_set_events($feedback);
107     if (!isset($feedback->coursemodule)) {
108         $cm = get_coursemodule_from_id('feedback', $feedback->id);
109         $feedback->coursemodule = $cm->id;
110     }
111     $context = context_module::instance($feedback->coursemodule);
113     if (!empty($feedback->completionexpected)) {
114         \core_completion\api::update_completion_date_event($feedback->coursemodule, 'feedback', $feedback->id,
115                 $feedback->completionexpected);
116     }
118     $editoroptions = feedback_get_editor_options();
120     // process the custom wysiwyg editor in page_after_submit
121     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
122         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
123                                                     'mod_feedback', 'page_after_submit',
124                                                     0, $editoroptions,
125                                                     $feedback->page_after_submit_editor['text']);
127         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
128     }
129     $DB->update_record('feedback', $feedback);
131     return $feedbackid;
134 /**
135  * this will update a given instance
136  *
137  * @global object
138  * @param object $feedback the object given by mod_feedback_mod_form
139  * @return boolean
140  */
141 function feedback_update_instance($feedback) {
142     global $DB;
144     $feedback->timemodified = time();
145     $feedback->id = $feedback->instance;
147     if (empty($feedback->site_after_submit)) {
148         $feedback->site_after_submit = '';
149     }
151     //save the feedback into the db
152     $DB->update_record("feedback", $feedback);
154     //create or update the new events
155     feedback_set_events($feedback);
156     $completionexpected = (!empty($feedback->completionexpected)) ? $feedback->completionexpected : null;
157     \core_completion\api::update_completion_date_event($feedback->coursemodule, 'feedback', $feedback->id, $completionexpected);
159     $context = context_module::instance($feedback->coursemodule);
161     $editoroptions = feedback_get_editor_options();
163     // process the custom wysiwyg editor in page_after_submit
164     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
165         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
166                                                     'mod_feedback', 'page_after_submit',
167                                                     0, $editoroptions,
168                                                     $feedback->page_after_submit_editor['text']);
170         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
171     }
172     $DB->update_record('feedback', $feedback);
174     return true;
177 /**
178  * Serves the files included in feedback items like label. Implements needed access control ;-)
179  *
180  * There are two situations in general where the files will be sent.
181  * 1) filearea = item, 2) filearea = template
182  *
183  * @package  mod_feedback
184  * @category files
185  * @param stdClass $course course object
186  * @param stdClass $cm course module object
187  * @param stdClass $context context object
188  * @param string $filearea file area
189  * @param array $args extra arguments
190  * @param bool $forcedownload whether or not force download
191  * @param array $options additional options affecting the file serving
192  * @return bool false if file not found, does not return if found - justsend the file
193  */
194 function feedback_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
195     global $CFG, $DB;
197     if ($filearea === 'item' or $filearea === 'template') {
198         $itemid = (int)array_shift($args);
199         //get the item what includes the file
200         if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
201             return false;
202         }
203         $feedbackid = $item->feedback;
204         $templateid = $item->template;
205     }
207     if ($filearea === 'page_after_submit' or $filearea === 'item') {
208         if (! $feedback = $DB->get_record("feedback", array("id"=>$cm->instance))) {
209             return false;
210         }
212         $feedbackid = $feedback->id;
214         //if the filearea is "item" so we check the permissions like view/complete the feedback
215         $canload = false;
216         //first check whether the user has the complete capability
217         if (has_capability('mod/feedback:complete', $context)) {
218             $canload = true;
219         }
221         //now we check whether the user has the view capability
222         if (has_capability('mod/feedback:view', $context)) {
223             $canload = true;
224         }
226         //if the feedback is on frontpage and anonymous and the fullanonymous is allowed
227         //so the file can be loaded too.
228         if (isset($CFG->feedback_allowfullanonymous)
229                     AND $CFG->feedback_allowfullanonymous
230                     AND $course->id == SITEID
231                     AND $feedback->anonymous == FEEDBACK_ANONYMOUS_YES ) {
232             $canload = true;
233         }
235         if (!$canload) {
236             return false;
237         }
238     } else if ($filearea === 'template') { //now we check files in templates
239         if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
240             return false;
241         }
243         //if the file is not public so the capability edititems has to be there
244         if (!$template->ispublic) {
245             if (!has_capability('mod/feedback:edititems', $context)) {
246                 return false;
247             }
248         } else { //on public templates, at least the user has to be logged in
249             if (!isloggedin()) {
250                 return false;
251             }
252         }
253     } else {
254         return false;
255     }
257     if ($context->contextlevel == CONTEXT_MODULE) {
258         if ($filearea !== 'item' and $filearea !== 'page_after_submit') {
259             return false;
260         }
261     }
263     if ($context->contextlevel == CONTEXT_COURSE || $context->contextlevel == CONTEXT_SYSTEM) {
264         if ($filearea !== 'template') {
265             return false;
266         }
267     }
269     $relativepath = implode('/', $args);
270     if ($filearea === 'page_after_submit') {
271         $fullpath = "/{$context->id}/mod_feedback/$filearea/$relativepath";
272     } else {
273         $fullpath = "/{$context->id}/mod_feedback/$filearea/{$item->id}/$relativepath";
274     }
276     $fs = get_file_storage();
278     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
279         return false;
280     }
282     // finally send the file
283     send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
285     return false;
288 /**
289  * this will delete a given instance.
290  * all referenced data also will be deleted
291  *
292  * @global object
293  * @param int $id the instanceid of feedback
294  * @return boolean
295  */
296 function feedback_delete_instance($id) {
297     global $DB;
299     //get all referenced items
300     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
302     //deleting all referenced items and values
303     if (is_array($feedbackitems)) {
304         foreach ($feedbackitems as $feedbackitem) {
305             $DB->delete_records("feedback_value", array("item"=>$feedbackitem->id));
306             $DB->delete_records("feedback_valuetmp", array("item"=>$feedbackitem->id));
307         }
308         if ($delitems = $DB->get_records("feedback_item", array("feedback"=>$id))) {
309             foreach ($delitems as $delitem) {
310                 feedback_delete_item($delitem->id, false);
311             }
312         }
313     }
315     //deleting the completeds
316     $DB->delete_records("feedback_completed", array("feedback"=>$id));
318     //deleting the unfinished completeds
319     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
321     //deleting old events
322     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
323     return $DB->delete_records("feedback", array("id"=>$id));
326 /**
327  * Return a small object with summary information about what a
328  * user has done with a given particular instance of this module
329  * Used for user activity reports.
330  * $return->time = the time they did it
331  * $return->info = a short text description
332  *
333  * @param stdClass $course
334  * @param stdClass $user
335  * @param cm_info|stdClass $mod
336  * @param stdClass $feedback
337  * @return stdClass
338  */
339 function feedback_user_outline($course, $user, $mod, $feedback) {
340     global $DB;
341     $outline = (object)['info' => '', 'time' => 0];
342     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
343         // Do not disclose any user info if feedback is anonymous.
344         return $outline;
345     }
346     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
347         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
348     $status = null;
349     $context = context_module::instance($mod->id);
350     if ($completed = $DB->get_record('feedback_completed', $params)) {
351         // User has completed feedback.
352         $outline->info = get_string('completed', 'feedback');
353         $outline->time = $completed->timemodified;
354     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
355         // User has started but not completed feedback.
356         $outline->info = get_string('started', 'feedback');
357         $outline->time = $completedtmp->timemodified;
358     } else if (has_capability('mod/feedback:complete', $context, $user)) {
359         // User has not started feedback but has capability to do so.
360         $outline->info = get_string('not_started', 'feedback');
361     }
363     return $outline;
366 /**
367  * Returns all users who has completed a specified feedback since a given time
368  * many thanks to Manolescu Dorel, who contributed these two functions
369  *
370  * @global object
371  * @global object
372  * @global object
373  * @global object
374  * @uses CONTEXT_MODULE
375  * @param array $activities Passed by reference
376  * @param int $index Passed by reference
377  * @param int $timemodified Timestamp
378  * @param int $courseid
379  * @param int $cmid
380  * @param int $userid
381  * @param int $groupid
382  * @return void
383  */
384 function feedback_get_recent_mod_activity(&$activities, &$index,
385                                           $timemodified, $courseid,
386                                           $cmid, $userid="", $groupid="") {
388     global $CFG, $COURSE, $USER, $DB;
390     if ($COURSE->id == $courseid) {
391         $course = $COURSE;
392     } else {
393         $course = $DB->get_record('course', array('id'=>$courseid));
394     }
396     $modinfo = get_fast_modinfo($course);
398     $cm = $modinfo->cms[$cmid];
400     $sqlargs = array();
402     $userfields = user_picture::fields('u', null, 'useridagain');
403     $sql = " SELECT fk . * , fc . * , $userfields
404                 FROM {feedback_completed} fc
405                     JOIN {feedback} fk ON fk.id = fc.feedback
406                     JOIN {user} u ON u.id = fc.userid ";
408     if ($groupid) {
409         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
410     }
412     $sql .= " WHERE fc.timemodified > ?
413                 AND fk.id = ?
414                 AND fc.anonymous_response = ?";
415     $sqlargs[] = $timemodified;
416     $sqlargs[] = $cm->instance;
417     $sqlargs[] = FEEDBACK_ANONYMOUS_NO;
419     if ($userid) {
420         $sql .= " AND u.id = ? ";
421         $sqlargs[] = $userid;
422     }
424     if ($groupid) {
425         $sql .= " AND gm.groupid = ? ";
426         $sqlargs[] = $groupid;
427     }
429     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
430         return;
431     }
433     $cm_context = context_module::instance($cm->id);
435     if (!has_capability('mod/feedback:view', $cm_context)) {
436         return;
437     }
439     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
440     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cm_context);
441     $groupmode       = groups_get_activity_groupmode($cm, $course);
443     $aname = format_string($cm->name, true);
444     foreach ($feedbackitems as $feedbackitem) {
445         if ($feedbackitem->userid != $USER->id) {
447             if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
448                 $usersgroups = groups_get_all_groups($course->id,
449                                                      $feedbackitem->userid,
450                                                      $cm->groupingid);
451                 if (!is_array($usersgroups)) {
452                     continue;
453                 }
454                 $usersgroups = array_keys($usersgroups);
455                 $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
456                 if (empty($intersect)) {
457                     continue;
458                 }
459             }
460         }
462         $tmpactivity = new stdClass();
464         $tmpactivity->type      = 'feedback';
465         $tmpactivity->cmid      = $cm->id;
466         $tmpactivity->name      = $aname;
467         $tmpactivity->sectionnum= $cm->sectionnum;
468         $tmpactivity->timestamp = $feedbackitem->timemodified;
470         $tmpactivity->content = new stdClass();
471         $tmpactivity->content->feedbackid = $feedbackitem->id;
472         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
474         $tmpactivity->user = user_picture::unalias($feedbackitem, null, 'useridagain');
475         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
477         $activities[$index++] = $tmpactivity;
478     }
480     return;
483 /**
484  * Prints all users who has completed a specified feedback since a given time
485  * many thanks to Manolescu Dorel, who contributed these two functions
486  *
487  * @global object
488  * @param object $activity
489  * @param int $courseid
490  * @param string $detail
491  * @param array $modnames
492  * @return void Output is echo'd
493  */
494 function feedback_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
495     global $CFG, $OUTPUT;
497     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
499     echo "<tr><td class=\"userpicture\" valign=\"top\">";
500     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
501     echo "</td><td>";
503     if ($detail) {
504         $modname = $modnames[$activity->type];
505         echo '<div class="title">';
506         echo $OUTPUT->image_icon('icon', $modname, $activity->type);
507         echo "<a href=\"$CFG->wwwroot/mod/feedback/view.php?id={$activity->cmid}\">{$activity->name}</a>";
508         echo '</div>';
509     }
511     echo '<div class="title">';
512     echo '</div>';
514     echo '<div class="user">';
515     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&amp;course=$courseid\">"
516          ."{$activity->user->fullname}</a> - ".userdate($activity->timestamp);
517     echo '</div>';
519     echo "</td></tr></table>";
521     return;
524 /**
525  * Obtains the automatic completion state for this feedback based on the condition
526  * in feedback settings.
527  *
528  * @param object $course Course
529  * @param object $cm Course-module
530  * @param int $userid User ID
531  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
532  * @return bool True if completed, false if not, $type if conditions not set.
533  */
534 function feedback_get_completion_state($course, $cm, $userid, $type) {
535     global $CFG, $DB;
537     // Get feedback details
538     $feedback = $DB->get_record('feedback', array('id'=>$cm->instance), '*', MUST_EXIST);
540     // If completion option is enabled, evaluate it and return true/false
541     if ($feedback->completionsubmit) {
542         $params = array('userid'=>$userid, 'feedback'=>$feedback->id);
543         return $DB->record_exists('feedback_completed', $params);
544     } else {
545         // Completion option is not enabled so just return $type
546         return $type;
547     }
550 /**
551  * Print a detailed representation of what a  user has done with
552  * a given particular instance of this module, for user activity reports.
553  *
554  * @param stdClass $course
555  * @param stdClass $user
556  * @param cm_info|stdClass $mod
557  * @param stdClass $feedback
558  */
559 function feedback_user_complete($course, $user, $mod, $feedback) {
560     global $DB;
561     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
562         // Do not disclose any user info if feedback is anonymous.
563         return;
564     }
565     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
566         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
567     $url = $status = null;
568     $context = context_module::instance($mod->id);
569     if ($completed = $DB->get_record('feedback_completed', $params)) {
570         // User has completed feedback.
571         if (has_capability('mod/feedback:viewreports', $context)) {
572             $url = new moodle_url('/mod/feedback/show_entries.php',
573                 ['id' => $mod->id, 'userid' => $user->id,
574                     'showcompleted' => $completed->id]);
575         }
576         $status = get_string('completedon', 'feedback', userdate($completed->timemodified));
577     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
578         // User has started but not completed feedback.
579         $status = get_string('startedon', 'feedback', userdate($completedtmp->timemodified));
580     } else if (has_capability('mod/feedback:complete', $context, $user)) {
581         // User has not started feedback but has capability to do so.
582         $status = get_string('not_started', 'feedback');
583     }
585     if ($url && $status) {
586         echo html_writer::link($url, $status);
587     } else if ($status) {
588         echo html_writer::div($status);
589     }
592 /**
593  * @return bool true
594  */
595 function feedback_cron () {
596     return true;
599 /**
600  * @return bool false
601  */
602 function feedback_scale_used ($feedbackid, $scaleid) {
603     return false;
606 /**
607  * Checks if scale is being used by any instance of feedback
608  *
609  * This is used to find out if scale used anywhere
610  * @param $scaleid int
611  * @return boolean True if the scale is used by any assignment
612  */
613 function feedback_scale_used_anywhere($scaleid) {
614     return false;
617 /**
618  * List the actions that correspond to a view of this module.
619  * This is used by the participation report.
620  *
621  * Note: This is not used by new logging system. Event with
622  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
623  *       be considered as view action.
624  *
625  * @return array
626  */
627 function feedback_get_view_actions() {
628     return array('view', 'view all');
631 /**
632  * List the actions that correspond to a post of this module.
633  * This is used by the participation report.
634  *
635  * Note: This is not used by new logging system. Event with
636  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
637  *       will be considered as post action.
638  *
639  * @return array
640  */
641 function feedback_get_post_actions() {
642     return array('submit');
645 /**
646  * This function is used by the reset_course_userdata function in moodlelib.
647  * This function will remove all responses from the specified feedback
648  * and clean up any related data.
649  *
650  * @global object
651  * @global object
652  * @uses FEEDBACK_RESETFORM_RESET
653  * @uses FEEDBACK_RESETFORM_DROP
654  * @param object $data the data submitted from the reset course.
655  * @return array status array
656  */
657 function feedback_reset_userdata($data) {
658     global $CFG, $DB;
660     $resetfeedbacks = array();
661     $dropfeedbacks = array();
662     $status = array();
663     $componentstr = get_string('modulenameplural', 'feedback');
665     //get the relevant entries from $data
666     foreach ($data as $key => $value) {
667         switch(true) {
668             case substr($key, 0, strlen(FEEDBACK_RESETFORM_RESET)) == FEEDBACK_RESETFORM_RESET:
669                 if ($value == 1) {
670                     $templist = explode('_', $key);
671                     if (isset($templist[3])) {
672                         $resetfeedbacks[] = intval($templist[3]);
673                     }
674                 }
675             break;
676             case substr($key, 0, strlen(FEEDBACK_RESETFORM_DROP)) == FEEDBACK_RESETFORM_DROP:
677                 if ($value == 1) {
678                     $templist = explode('_', $key);
679                     if (isset($templist[3])) {
680                         $dropfeedbacks[] = intval($templist[3]);
681                     }
682                 }
683             break;
684         }
685     }
687     //reset the selected feedbacks
688     foreach ($resetfeedbacks as $id) {
689         $feedback = $DB->get_record('feedback', array('id'=>$id));
690         feedback_delete_all_completeds($feedback);
691         $status[] = array('component'=>$componentstr.':'.$feedback->name,
692                         'item'=>get_string('resetting_data', 'feedback'),
693                         'error'=>false);
694     }
696     // Updating dates - shift may be negative too.
697     if ($data->timeshift) {
698         // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
699         // See MDL-9367.
700         $shifterror = !shift_course_mod_dates('feedback', array('timeopen', 'timeclose'), $data->timeshift, $data->courseid);
701         $status[] = array('component' => $componentstr, 'item' => get_string('datechanged'), 'error' => $shifterror);
702     }
704     return $status;
707 /**
708  * Called by course/reset.php
709  *
710  * @global object
711  * @uses FEEDBACK_RESETFORM_RESET
712  * @param object $mform form passed by reference
713  */
714 function feedback_reset_course_form_definition(&$mform) {
715     global $COURSE, $DB;
717     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
719     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')) {
720         return;
721     }
723     $mform->addElement('static', 'hint', get_string('resetting_data', 'feedback'));
724     foreach ($feedbacks as $feedback) {
725         $mform->addElement('checkbox', FEEDBACK_RESETFORM_RESET.$feedback->id, $feedback->name);
726     }
729 /**
730  * Course reset form defaults.
731  *
732  * @global object
733  * @uses FEEDBACK_RESETFORM_RESET
734  * @param object $course
735  */
736 function feedback_reset_course_form_defaults($course) {
737     global $DB;
739     $return = array();
740     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
741         return;
742     }
743     foreach ($feedbacks as $feedback) {
744         $return[FEEDBACK_RESETFORM_RESET.$feedback->id] = true;
745     }
746     return $return;
749 /**
750  * Called by course/reset.php and shows the formdata by coursereset.
751  * it prints checkboxes for each feedback available at the given course
752  * there are two checkboxes:
753  * 1) delete userdata and keep the feedback
754  * 2) delete userdata and drop the feedback
755  *
756  * @global object
757  * @uses FEEDBACK_RESETFORM_RESET
758  * @uses FEEDBACK_RESETFORM_DROP
759  * @param object $course
760  * @return void
761  */
762 function feedback_reset_course_form($course) {
763     global $DB, $OUTPUT;
765     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
766     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
767         return;
768     }
770     foreach ($feedbacks as $feedback) {
771         echo '<p>';
772         echo get_string('name', 'feedback').': '.$feedback->name.'<br />';
773         echo html_writer::checkbox(FEEDBACK_RESETFORM_RESET.$feedback->id,
774                                 1, true,
775                                 get_string('resetting_data', 'feedback'));
776         echo '<br />';
777         echo html_writer::checkbox(FEEDBACK_RESETFORM_DROP.$feedback->id,
778                                 1, false,
779                                 get_string('drop_feedback', 'feedback'));
780         echo '</p>';
781     }
784 /**
785  * This gets an array with default options for the editor
786  *
787  * @return array the options
788  */
789 function feedback_get_editor_options() {
790     return array('maxfiles' => EDITOR_UNLIMITED_FILES,
791                 'trusttext'=>true);
794 /**
795  * This creates new events given as timeopen and closeopen by $feedback.
796  *
797  * @global object
798  * @param object $feedback
799  * @return void
800  */
801 function feedback_set_events($feedback) {
802     global $DB, $CFG;
804     // Include calendar/lib.php.
805     require_once($CFG->dirroot.'/calendar/lib.php');
807     // Get CMID if not sent as part of $feedback.
808     if (!isset($feedback->coursemodule)) {
809         $cm = get_coursemodule_from_instance('feedback', $feedback->id, $feedback->course);
810         $feedback->coursemodule = $cm->id;
811     }
813     // Feedback start calendar events.
814     $eventid = $DB->get_field('event', 'id',
815             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => FEEDBACK_EVENT_TYPE_OPEN));
817     if (isset($feedback->timeopen) && $feedback->timeopen > 0) {
818         $event = new stdClass();
819         $event->eventtype    = FEEDBACK_EVENT_TYPE_OPEN;
820         $event->type         = empty($feedback->timeclose) ? CALENDAR_EVENT_TYPE_ACTION : CALENDAR_EVENT_TYPE_STANDARD;
821         $event->name         = get_string('calendarstart', 'feedback', $feedback->name);
822         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
823         $event->timestart    = $feedback->timeopen;
824         $event->timesort     = $feedback->timeopen;
825         $event->visible      = instance_is_visible('feedback', $feedback);
826         $event->timeduration = 0;
827         if ($eventid) {
828             // Calendar event exists so update it.
829             $event->id = $eventid;
830             $calendarevent = calendar_event::load($event->id);
831             $calendarevent->update($event);
832         } else {
833             // Event doesn't exist so create one.
834             $event->courseid     = $feedback->course;
835             $event->groupid      = 0;
836             $event->userid       = 0;
837             $event->modulename   = 'feedback';
838             $event->instance     = $feedback->id;
839             $event->eventtype    = FEEDBACK_EVENT_TYPE_OPEN;
840             calendar_event::create($event);
841         }
842     } else if ($eventid) {
843         // Calendar event is on longer needed.
844         $calendarevent = calendar_event::load($eventid);
845         $calendarevent->delete();
846     }
848     // Feedback close calendar events.
849     $eventid = $DB->get_field('event', 'id',
850             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => FEEDBACK_EVENT_TYPE_CLOSE));
852     if (isset($feedback->timeclose) && $feedback->timeclose > 0) {
853         $event = new stdClass();
854         $event->type         = CALENDAR_EVENT_TYPE_ACTION;
855         $event->eventtype    = FEEDBACK_EVENT_TYPE_CLOSE;
856         $event->name         = get_string('calendarend', 'feedback', $feedback->name);
857         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
858         $event->timestart    = $feedback->timeclose;
859         $event->timesort     = $feedback->timeclose;
860         $event->visible      = instance_is_visible('feedback', $feedback);
861         $event->timeduration = 0;
862         if ($eventid) {
863             // Calendar event exists so update it.
864             $event->id = $eventid;
865             $calendarevent = calendar_event::load($event->id);
866             $calendarevent->update($event);
867         } else {
868             // Event doesn't exist so create one.
869             $event->courseid     = $feedback->course;
870             $event->groupid      = 0;
871             $event->userid       = 0;
872             $event->modulename   = 'feedback';
873             $event->instance     = $feedback->id;
874             calendar_event::create($event);
875         }
876     } else if ($eventid) {
877         // Calendar event is on longer needed.
878         $calendarevent = calendar_event::load($eventid);
879         $calendarevent->delete();
880     }
883 /**
884  * This standard function will check all instances of this module
885  * and make sure there are up-to-date events created for each of them.
886  * If courseid = 0, then every feedback event in the site is checked, else
887  * only feedback events belonging to the course specified are checked.
888  * This function is used, in its new format, by restore_refresh_events()
889  *
890  * @param int $courseid
891  * @param int|stdClass $instance Feedback module instance or ID.
892  * @param int|stdClass $cm Course module object or ID (not used in this module).
893  * @return bool
894  */
895 function feedback_refresh_events($courseid = 0, $instance = null, $cm = null) {
896     global $DB;
898     // If we have instance information then we can just update the one event instead of updating all events.
899     if (isset($instance)) {
900         if (!is_object($instance)) {
901             $instance = $DB->get_record('feedback', array('id' => $instance), '*', MUST_EXIST);
902         }
903         feedback_set_events($instance);
904         return true;
905     }
907     if ($courseid) {
908         if (! $feedbacks = $DB->get_records("feedback", array("course" => $courseid))) {
909             return true;
910         }
911     } else {
912         if (! $feedbacks = $DB->get_records("feedback")) {
913             return true;
914         }
915     }
917     foreach ($feedbacks as $feedback) {
918         feedback_set_events($feedback);
919     }
920     return true;
923 /**
924  * this function is called by {@link feedback_delete_userdata()}
925  * it drops the feedback-instance from the course_module table
926  *
927  * @global object
928  * @param int $id the id from the coursemodule
929  * @return boolean
930  */
931 function feedback_delete_course_module($id) {
932     global $DB;
934     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
935         return true;
936     }
937     return $DB->delete_records('course_modules', array('id'=>$cm->id));
942 ////////////////////////////////////////////////
943 //functions to handle capabilities
944 ////////////////////////////////////////////////
946 /**
947  * @deprecated since 3.1
948  */
949 function feedback_get_context() {
950     throw new coding_exception('feedback_get_context() can not be used anymore.');
953 /**
954  *  returns true if the current role is faked by switching role feature
955  *
956  * @global object
957  * @return boolean
958  */
959 function feedback_check_is_switchrole() {
960     global $USER;
961     if (isset($USER->switchrole) AND
962             is_array($USER->switchrole) AND
963             count($USER->switchrole) > 0) {
965         return true;
966     }
967     return false;
970 /**
971  * count users which have not completed the feedback
972  *
973  * @global object
974  * @uses CONTEXT_MODULE
975  * @param cm_info $cm Course-module object
976  * @param int $group single groupid
977  * @param string $sort
978  * @param int $startpage
979  * @param int $pagecount
980  * @param bool $includestatus to return if the user started or not the feedback among the complete user record
981  * @return array array of user ids or user objects when $includestatus set to true
982  */
983 function feedback_get_incomplete_users(cm_info $cm,
984                                        $group = false,
985                                        $sort = '',
986                                        $startpage = false,
987                                        $pagecount = false,
988                                        $includestatus = false) {
990     global $DB;
992     $context = context_module::instance($cm->id);
994     //first get all user who can complete this feedback
995     $cap = 'mod/feedback:complete';
996     $allnames = get_all_user_name_fields(true, 'u');
997     $fields = 'u.id, ' . $allnames . ', u.picture, u.email, u.imagealt';
998     if (!$allusers = get_users_by_capability($context,
999                                             $cap,
1000                                             $fields,
1001                                             $sort,
1002                                             '',
1003                                             '',
1004                                             $group,
1005                                             '',
1006                                             true)) {
1007         return false;
1008     }
1009     // Filter users that are not in the correct group/grouping.
1010     $info = new \core_availability\info_module($cm);
1011     $allusersrecords = $info->filter_user_list($allusers);
1013     $allusers = array_keys($allusersrecords);
1015     //now get all completeds
1016     $params = array('feedback'=>$cm->instance);
1017     if ($completedusers = $DB->get_records_menu('feedback_completed', $params, '', 'id, userid')) {
1018         // Now strike all completedusers from allusers.
1019         $allusers = array_diff($allusers, $completedusers);
1020     }
1022     //for paging I use array_slice()
1023     if ($startpage !== false AND $pagecount !== false) {
1024         $allusers = array_slice($allusers, $startpage, $pagecount);
1025     }
1027     // Check if we should return the full users objects.
1028     if ($includestatus) {
1029         $userrecords = [];
1030         $startedusers = $DB->get_records_menu('feedback_completedtmp', ['feedback' => $cm->instance], '', 'id, userid');
1031         $startedusers = array_flip($startedusers);
1032         foreach ($allusers as $userid) {
1033             $allusersrecords[$userid]->feedbackstarted = isset($startedusers[$userid]);
1034             $userrecords[] = $allusersrecords[$userid];
1035         }
1036         return $userrecords;
1037     } else {    // Return just user ids.
1038         return $allusers;
1039     }
1042 /**
1043  * count users which have not completed the feedback
1044  *
1045  * @global object
1046  * @param object $cm
1047  * @param int $group single groupid
1048  * @return int count of userrecords
1049  */
1050 function feedback_count_incomplete_users($cm, $group = false) {
1051     if ($allusers = feedback_get_incomplete_users($cm, $group)) {
1052         return count($allusers);
1053     }
1054     return 0;
1057 /**
1058  * count users which have completed a feedback
1059  *
1060  * @global object
1061  * @uses FEEDBACK_ANONYMOUS_NO
1062  * @param object $cm
1063  * @param int $group single groupid
1064  * @return int count of userrecords
1065  */
1066 function feedback_count_complete_users($cm, $group = false) {
1067     global $DB;
1069     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
1071     $fromgroup = '';
1072     $wheregroup = '';
1073     if ($group) {
1074         $fromgroup = ', {groups_members} g';
1075         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
1076         $params[] = $group;
1077     }
1079     $sql = 'SELECT COUNT(u.id) FROM {user} u, {feedback_completed} c'.$fromgroup.'
1080               WHERE anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
1081               '.$wheregroup;
1083     return $DB->count_records_sql($sql, $params);
1087 /**
1088  * get users which have completed a feedback
1089  *
1090  * @global object
1091  * @uses CONTEXT_MODULE
1092  * @uses FEEDBACK_ANONYMOUS_NO
1093  * @param object $cm
1094  * @param int $group single groupid
1095  * @param string $where a sql where condition (must end with " AND ")
1096  * @param array parameters used in $where
1097  * @param string $sort a table field
1098  * @param int $startpage
1099  * @param int $pagecount
1100  * @return object the userrecords
1101  */
1102 function feedback_get_complete_users($cm,
1103                                      $group = false,
1104                                      $where = '',
1105                                      array $params = null,
1106                                      $sort = '',
1107                                      $startpage = false,
1108                                      $pagecount = false) {
1110     global $DB;
1112     $context = context_module::instance($cm->id);
1114     $params = (array)$params;
1116     $params['anon'] = FEEDBACK_ANONYMOUS_NO;
1117     $params['instance'] = $cm->instance;
1119     $fromgroup = '';
1120     $wheregroup = '';
1121     if ($group) {
1122         $fromgroup = ', {groups_members} g';
1123         $wheregroup = ' AND g.groupid = :group AND g.userid = c.userid';
1124         $params['group'] = $group;
1125     }
1127     if ($sort) {
1128         $sortsql = ' ORDER BY '.$sort;
1129     } else {
1130         $sortsql = '';
1131     }
1133     $ufields = user_picture::fields('u');
1134     $sql = 'SELECT DISTINCT '.$ufields.', c.timemodified as completed_timemodified
1135             FROM {user} u, {feedback_completed} c '.$fromgroup.'
1136             WHERE '.$where.' anonymous_response = :anon
1137                 AND u.id = c.userid
1138                 AND c.feedback = :instance
1139               '.$wheregroup.$sortsql;
1141     if ($startpage === false OR $pagecount === false) {
1142         $startpage = false;
1143         $pagecount = false;
1144     }
1145     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
1148 /**
1149  * get users which have the viewreports-capability
1150  *
1151  * @uses CONTEXT_MODULE
1152  * @param int $cmid
1153  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1154  * @return object the userrecords
1155  */
1156 function feedback_get_viewreports_users($cmid, $groups = false) {
1158     $context = context_module::instance($cmid);
1160     //description of the call below:
1161     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1162     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1163     return get_users_by_capability($context,
1164                             'mod/feedback:viewreports',
1165                             '',
1166                             'lastname',
1167                             '',
1168                             '',
1169                             $groups,
1170                             '',
1171                             false);
1174 /**
1175  * get users which have the receivemail-capability
1176  *
1177  * @uses CONTEXT_MODULE
1178  * @param int $cmid
1179  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1180  * @return object the userrecords
1181  */
1182 function feedback_get_receivemail_users($cmid, $groups = false) {
1184     $context = context_module::instance($cmid);
1186     //description of the call below:
1187     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1188     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1189     return get_users_by_capability($context,
1190                             'mod/feedback:receivemail',
1191                             '',
1192                             'lastname',
1193                             '',
1194                             '',
1195                             $groups,
1196                             '',
1197                             false);
1200 ////////////////////////////////////////////////
1201 //functions to handle the templates
1202 ////////////////////////////////////////////////
1203 ////////////////////////////////////////////////
1205 /**
1206  * creates a new template-record.
1207  *
1208  * @global object
1209  * @param int $courseid
1210  * @param string $name the name of template shown in the templatelist
1211  * @param int $ispublic 0:privat 1:public
1212  * @return int the new templateid
1213  */
1214 function feedback_create_template($courseid, $name, $ispublic = 0) {
1215     global $DB;
1217     $templ = new stdClass();
1218     $templ->course   = ($ispublic ? 0 : $courseid);
1219     $templ->name     = $name;
1220     $templ->ispublic = $ispublic;
1222     $templid = $DB->insert_record('feedback_template', $templ);
1223     return $DB->get_record('feedback_template', array('id'=>$templid));
1226 /**
1227  * creates new template items.
1228  * all items will be copied and the attribute feedback will be set to 0
1229  * and the attribute template will be set to the new templateid
1230  *
1231  * @global object
1232  * @uses CONTEXT_MODULE
1233  * @uses CONTEXT_COURSE
1234  * @param object $feedback
1235  * @param string $name the name of template shown in the templatelist
1236  * @param int $ispublic 0:privat 1:public
1237  * @return boolean
1238  */
1239 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
1240     global $DB;
1241     $fs = get_file_storage();
1243     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1244         return false;
1245     }
1247     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
1248         return false;
1249     }
1251     //files in the template_item are in the context of the current course or
1252     //if the template is public the files are in the system context
1253     //files in the feedback_item are in the feedback_context of the feedback
1254     if ($ispublic) {
1255         $s_context = context_system::instance();
1256     } else {
1257         $s_context = context_course::instance($newtempl->course);
1258     }
1259     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1260     $f_context = context_module::instance($cm->id);
1262     //create items of this new template
1263     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1264     //we also store a mapping of all items array(oldid => newid)
1265     $dependitemsmap = array();
1266     $itembackup = array();
1267     foreach ($feedbackitems as $item) {
1269         $t_item = clone($item);
1271         unset($t_item->id);
1272         $t_item->feedback = 0;
1273         $t_item->template     = $newtempl->id;
1274         $t_item->id = $DB->insert_record('feedback_item', $t_item);
1275         //copy all included files to the feedback_template filearea
1276         $itemfiles = $fs->get_area_files($f_context->id,
1277                                     'mod_feedback',
1278                                     'item',
1279                                     $item->id,
1280                                     "id",
1281                                     false);
1282         if ($itemfiles) {
1283             foreach ($itemfiles as $ifile) {
1284                 $file_record = new stdClass();
1285                 $file_record->contextid = $s_context->id;
1286                 $file_record->component = 'mod_feedback';
1287                 $file_record->filearea = 'template';
1288                 $file_record->itemid = $t_item->id;
1289                 $fs->create_file_from_storedfile($file_record, $ifile);
1290             }
1291         }
1293         $itembackup[$item->id] = $t_item->id;
1294         if ($t_item->dependitem) {
1295             $dependitemsmap[$t_item->id] = $t_item->dependitem;
1296         }
1298     }
1300     //remapping the dependency
1301     foreach ($dependitemsmap as $key => $dependitem) {
1302         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1303         $newitem->dependitem = $itembackup[$newitem->dependitem];
1304         $DB->update_record('feedback_item', $newitem);
1305     }
1307     return true;
1310 /**
1311  * deletes all feedback_items related to the given template id
1312  *
1313  * @global object
1314  * @uses CONTEXT_COURSE
1315  * @param object $template the template
1316  * @return void
1317  */
1318 function feedback_delete_template($template) {
1319     global $DB;
1321     //deleting the files from the item is done by feedback_delete_item
1322     if ($t_items = $DB->get_records("feedback_item", array("template"=>$template->id))) {
1323         foreach ($t_items as $t_item) {
1324             feedback_delete_item($t_item->id, false, $template);
1325         }
1326     }
1327     $DB->delete_records("feedback_template", array("id"=>$template->id));
1330 /**
1331  * creates new feedback_item-records from template.
1332  * if $deleteold is set true so the existing items of the given feedback will be deleted
1333  * if $deleteold is set false so the new items will be appanded to the old items
1334  *
1335  * @global object
1336  * @uses CONTEXT_COURSE
1337  * @uses CONTEXT_MODULE
1338  * @param object $feedback
1339  * @param int $templateid
1340  * @param boolean $deleteold
1341  */
1342 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1343     global $DB, $CFG;
1345     require_once($CFG->libdir.'/completionlib.php');
1347     $fs = get_file_storage();
1349     if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
1350         return false;
1351     }
1352     //get all templateitems
1353     if (!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1354         return false;
1355     }
1357     //files in the template_item are in the context of the current course
1358     //files in the feedback_item are in the feedback_context of the feedback
1359     if ($template->ispublic) {
1360         $s_context = context_system::instance();
1361     } else {
1362         $s_context = context_course::instance($feedback->course);
1363     }
1364     $course = $DB->get_record('course', array('id'=>$feedback->course));
1365     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1366     $f_context = context_module::instance($cm->id);
1368     //if deleteold then delete all old items before
1369     //get all items
1370     if ($deleteold) {
1371         if ($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1372             //delete all items of this feedback
1373             foreach ($feedbackitems as $item) {
1374                 feedback_delete_item($item->id, false);
1375             }
1377             $params = array('feedback'=>$feedback->id);
1378             if ($completeds = $DB->get_records('feedback_completed', $params)) {
1379                 $completion = new completion_info($course);
1380                 foreach ($completeds as $completed) {
1381                     $DB->delete_records('feedback_completed', array('id' => $completed->id));
1382                     // Update completion state
1383                     if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC &&
1384                             $feedback->completionsubmit) {
1385                         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1386                     }
1387                 }
1388             }
1389             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1390         }
1391         $positionoffset = 0;
1392     } else {
1393         //if the old items are kept the new items will be appended
1394         //therefor the new position has an offset
1395         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1396     }
1398     //create items of this new template
1399     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1400     //we also store a mapping of all items array(oldid => newid)
1401     $dependitemsmap = array();
1402     $itembackup = array();
1403     foreach ($templitems as $t_item) {
1404         $item = clone($t_item);
1405         unset($item->id);
1406         $item->feedback = $feedback->id;
1407         $item->template = 0;
1408         $item->position = $item->position + $positionoffset;
1410         $item->id = $DB->insert_record('feedback_item', $item);
1412         //moving the files to the new item
1413         $templatefiles = $fs->get_area_files($s_context->id,
1414                                         'mod_feedback',
1415                                         'template',
1416                                         $t_item->id,
1417                                         "id",
1418                                         false);
1419         if ($templatefiles) {
1420             foreach ($templatefiles as $tfile) {
1421                 $file_record = new stdClass();
1422                 $file_record->contextid = $f_context->id;
1423                 $file_record->component = 'mod_feedback';
1424                 $file_record->filearea = 'item';
1425                 $file_record->itemid = $item->id;
1426                 $fs->create_file_from_storedfile($file_record, $tfile);
1427             }
1428         }
1430         $itembackup[$t_item->id] = $item->id;
1431         if ($item->dependitem) {
1432             $dependitemsmap[$item->id] = $item->dependitem;
1433         }
1434     }
1436     //remapping the dependency
1437     foreach ($dependitemsmap as $key => $dependitem) {
1438         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1439         $newitem->dependitem = $itembackup[$newitem->dependitem];
1440         $DB->update_record('feedback_item', $newitem);
1441     }
1444 /**
1445  * get the list of available templates.
1446  * if the $onlyown param is set true so only templates from own course will be served
1447  * this is important for droping templates
1448  *
1449  * @global object
1450  * @param object $course
1451  * @param string $onlyownorpublic
1452  * @return array the template recordsets
1453  */
1454 function feedback_get_template_list($course, $onlyownorpublic = '') {
1455     global $DB, $CFG;
1457     switch($onlyownorpublic) {
1458         case '':
1459             $templates = $DB->get_records_select('feedback_template',
1460                                                  'course = ? OR ispublic = 1',
1461                                                  array($course->id),
1462                                                  'name');
1463             break;
1464         case 'own':
1465             $templates = $DB->get_records('feedback_template',
1466                                           array('course'=>$course->id),
1467                                           'name');
1468             break;
1469         case 'public':
1470             $templates = $DB->get_records('feedback_template', array('ispublic'=>1), 'name');
1471             break;
1472     }
1473     return $templates;
1476 ////////////////////////////////////////////////
1477 //Handling der Items
1478 ////////////////////////////////////////////////
1479 ////////////////////////////////////////////////
1481 /**
1482  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1483  *
1484  * @param string $typ
1485  * @return feedback_item_base the instance of itemclass
1486  */
1487 function feedback_get_item_class($typ) {
1488     global $CFG;
1490     //get the class of item-typ
1491     $itemclass = 'feedback_item_'.$typ;
1492     //get the instance of item-class
1493     if (!class_exists($itemclass)) {
1494         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1495     }
1496     return new $itemclass();
1499 /**
1500  * load the available item plugins from given subdirectory of $CFG->dirroot
1501  * the default is "mod/feedback/item"
1502  *
1503  * @global object
1504  * @param string $dir the subdir
1505  * @return array pluginnames as string
1506  */
1507 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1508     global $CFG;
1509     $names = get_list_of_plugins($dir);
1510     $ret_names = array();
1512     foreach ($names as $name) {
1513         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1514         if (class_exists('feedback_item_'.$name)) {
1515             $ret_names[] = $name;
1516         }
1517     }
1518     return $ret_names;
1521 /**
1522  * load the available item plugins to use as dropdown-options
1523  *
1524  * @global object
1525  * @return array pluginnames as string
1526  */
1527 function feedback_load_feedback_items_options() {
1528     global $CFG;
1530     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1532     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1533         return array();
1534     }
1536     foreach ($feedback_names as $fn) {
1537         $feedback_options[$fn] = get_string($fn, 'feedback');
1538     }
1539     asort($feedback_options);
1540     return $feedback_options;
1543 /**
1544  * load the available items for the depend item dropdown list shown in the edit_item form
1545  *
1546  * @global object
1547  * @param object $feedback
1548  * @param object $item the item of the edit_item form
1549  * @return array all items except the item $item, labels and pagebreaks
1550  */
1551 function feedback_get_depend_candidates_for_item($feedback, $item) {
1552     global $DB;
1553     //all items for dependitem
1554     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1555     $params = array($feedback->id);
1556     if (isset($item->id) AND $item->id) {
1557         $where .= ' AND id != ?';
1558         $params[] = $item->id;
1559     }
1560     $dependitems = array(0 => get_string('choose'));
1561     $feedbackitems = $DB->get_records_select_menu('feedback_item',
1562                                                   $where,
1563                                                   $params,
1564                                                   'position',
1565                                                   'id, label');
1567     if (!$feedbackitems) {
1568         return $dependitems;
1569     }
1570     //adding the choose-option
1571     foreach ($feedbackitems as $key => $val) {
1572         if (trim(strval($val)) !== '') {
1573             $dependitems[$key] = format_string($val);
1574         }
1575     }
1576     return $dependitems;
1579 /**
1580  * @deprecated since 3.1
1581  */
1582 function feedback_create_item() {
1583     throw new coding_exception('feedback_create_item() can not be used anymore.');
1586 /**
1587  * save the changes of a given item.
1588  *
1589  * @global object
1590  * @param object $item
1591  * @return boolean
1592  */
1593 function feedback_update_item($item) {
1594     global $DB;
1595     return $DB->update_record("feedback_item", $item);
1598 /**
1599  * deletes an item and also deletes all related values
1600  *
1601  * @global object
1602  * @uses CONTEXT_MODULE
1603  * @param int $itemid
1604  * @param boolean $renumber should the kept items renumbered Yes/No
1605  * @param object $template if the template is given so the items are bound to it
1606  * @return void
1607  */
1608 function feedback_delete_item($itemid, $renumber = true, $template = false) {
1609     global $DB;
1611     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1613     //deleting the files from the item
1614     $fs = get_file_storage();
1616     if ($template) {
1617         if ($template->ispublic) {
1618             $context = context_system::instance();
1619         } else {
1620             $context = context_course::instance($template->course);
1621         }
1622         $templatefiles = $fs->get_area_files($context->id,
1623                                     'mod_feedback',
1624                                     'template',
1625                                     $item->id,
1626                                     "id",
1627                                     false);
1629         if ($templatefiles) {
1630             $fs->delete_area_files($context->id, 'mod_feedback', 'template', $item->id);
1631         }
1632     } else {
1633         if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1634             return false;
1635         }
1636         $context = context_module::instance($cm->id);
1638         $itemfiles = $fs->get_area_files($context->id,
1639                                     'mod_feedback',
1640                                     'item',
1641                                     $item->id,
1642                                     "id", false);
1644         if ($itemfiles) {
1645             $fs->delete_area_files($context->id, 'mod_feedback', 'item', $item->id);
1646         }
1647     }
1649     $DB->delete_records("feedback_value", array("item"=>$itemid));
1650     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1652     //remove all depends
1653     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1654     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1656     $DB->delete_records("feedback_item", array("id"=>$itemid));
1657     if ($renumber) {
1658         feedback_renumber_items($item->feedback);
1659     }
1662 /**
1663  * deletes all items of the given feedbackid
1664  *
1665  * @global object
1666  * @param int $feedbackid
1667  * @return void
1668  */
1669 function feedback_delete_all_items($feedbackid) {
1670     global $DB, $CFG;
1671     require_once($CFG->libdir.'/completionlib.php');
1673     if (!$feedback = $DB->get_record('feedback', array('id'=>$feedbackid))) {
1674         return false;
1675     }
1677     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
1678         return false;
1679     }
1681     if (!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
1682         return false;
1683     }
1685     if (!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1686         return;
1687     }
1688     foreach ($items as $item) {
1689         feedback_delete_item($item->id, false);
1690     }
1691     if ($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1692         $completion = new completion_info($course);
1693         foreach ($completeds as $completed) {
1694             $DB->delete_records('feedback_completed', array('id' => $completed->id));
1695             // Update completion state
1696             if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC &&
1697                     $feedback->completionsubmit) {
1698                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1699             }
1700         }
1701     }
1703     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1707 /**
1708  * this function toggled the item-attribute required (yes/no)
1709  *
1710  * @global object
1711  * @param object $item
1712  * @return boolean
1713  */
1714 function feedback_switch_item_required($item) {
1715     global $DB, $CFG;
1717     $itemobj = feedback_get_item_class($item->typ);
1719     if ($itemobj->can_switch_require()) {
1720         $new_require_val = (int)!(bool)$item->required;
1721         $params = array('id'=>$item->id);
1722         $DB->set_field('feedback_item', 'required', $new_require_val, $params);
1723     }
1724     return true;
1727 /**
1728  * renumbers all items of the given feedbackid
1729  *
1730  * @global object
1731  * @param int $feedbackid
1732  * @return void
1733  */
1734 function feedback_renumber_items($feedbackid) {
1735     global $DB;
1737     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1738     $pos = 1;
1739     if ($items) {
1740         foreach ($items as $item) {
1741             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1742             $pos++;
1743         }
1744     }
1747 /**
1748  * this decreases the position of the given item
1749  *
1750  * @global object
1751  * @param object $item
1752  * @return bool
1753  */
1754 function feedback_moveup_item($item) {
1755     global $DB;
1757     if ($item->position == 1) {
1758         return true;
1759     }
1761     $params = array('feedback'=>$item->feedback);
1762     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1763         return false;
1764     }
1766     $itembefore = null;
1767     foreach ($items as $i) {
1768         if ($i->id == $item->id) {
1769             if (is_null($itembefore)) {
1770                 return true;
1771             }
1772             $itembefore->position = $item->position;
1773             $item->position--;
1774             feedback_update_item($itembefore);
1775             feedback_update_item($item);
1776             feedback_renumber_items($item->feedback);
1777             return true;
1778         }
1779         $itembefore = $i;
1780     }
1781     return false;
1784 /**
1785  * this increased the position of the given item
1786  *
1787  * @global object
1788  * @param object $item
1789  * @return bool
1790  */
1791 function feedback_movedown_item($item) {
1792     global $DB;
1794     $params = array('feedback'=>$item->feedback);
1795     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1796         return false;
1797     }
1799     $movedownitem = null;
1800     foreach ($items as $i) {
1801         if (!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1802             $movedownitem->position = $i->position;
1803             $i->position--;
1804             feedback_update_item($movedownitem);
1805             feedback_update_item($i);
1806             feedback_renumber_items($item->feedback);
1807             return true;
1808         }
1809         $movedownitem = $i;
1810     }
1811     return false;
1814 /**
1815  * here the position of the given item will be set to the value in $pos
1816  *
1817  * @global object
1818  * @param object $moveitem
1819  * @param int $pos
1820  * @return boolean
1821  */
1822 function feedback_move_item($moveitem, $pos) {
1823     global $DB;
1825     $params = array('feedback'=>$moveitem->feedback);
1826     if (!$allitems = $DB->get_records('feedback_item', $params, 'position')) {
1827         return false;
1828     }
1829     if (is_array($allitems)) {
1830         $index = 1;
1831         foreach ($allitems as $item) {
1832             if ($index == $pos) {
1833                 $index++;
1834             }
1835             if ($item->id == $moveitem->id) {
1836                 $moveitem->position = $pos;
1837                 feedback_update_item($moveitem);
1838                 continue;
1839             }
1840             $item->position = $index;
1841             feedback_update_item($item);
1842             $index++;
1843         }
1844         return true;
1845     }
1846     return false;
1849 /**
1850  * @deprecated since Moodle 3.1
1851  */
1852 function feedback_print_item_preview() {
1853     throw new coding_exception('feedback_print_item_preview() can not be used anymore. '
1854             . 'Items must implement complete_form_element().');
1857 /**
1858  * @deprecated since Moodle 3.1
1859  */
1860 function feedback_print_item_complete() {
1861     throw new coding_exception('feedback_print_item_complete() can not be used anymore. '
1862         . 'Items must implement complete_form_element().');
1865 /**
1866  * @deprecated since Moodle 3.1
1867  */
1868 function feedback_print_item_show_value() {
1869     throw new coding_exception('feedback_print_item_show_value() can not be used anymore. '
1870         . 'Items must implement complete_form_element().');
1873 /**
1874  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1875  * the values are not saved permanently until the user click on save button
1876  *
1877  * @global object
1878  * @param object $feedbackcompleted
1879  * @return object temporary saved completed-record
1880  */
1881 function feedback_set_tmp_values($feedbackcompleted) {
1882     global $DB;
1884     //first we create a completedtmp
1885     $tmpcpl = new stdClass();
1886     foreach ($feedbackcompleted as $key => $value) {
1887         $tmpcpl->{$key} = $value;
1888     }
1889     unset($tmpcpl->id);
1890     $tmpcpl->timemodified = time();
1891     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1892     //get all values of original-completed
1893     if (!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1894         return;
1895     }
1896     foreach ($values as $value) {
1897         unset($value->id);
1898         $value->completed = $tmpcpl->id;
1899         $DB->insert_record('feedback_valuetmp', $value);
1900     }
1901     return $tmpcpl;
1904 /**
1905  * this saves the temporary saved values permanently
1906  *
1907  * @global object
1908  * @param object $feedbackcompletedtmp the temporary completed
1909  * @param object $feedbackcompleted the target completed
1910  * @return int the id of the completed
1911  */
1912 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted) {
1913     global $DB;
1915     $tmpcplid = $feedbackcompletedtmp->id;
1916     if ($feedbackcompleted) {
1917         //first drop all existing values
1918         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1919         //update the current completed
1920         $feedbackcompleted->timemodified = time();
1921         $DB->update_record('feedback_completed', $feedbackcompleted);
1922     } else {
1923         $feedbackcompleted = clone($feedbackcompletedtmp);
1924         $feedbackcompleted->id = '';
1925         $feedbackcompleted->timemodified = time();
1926         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
1927     }
1929     $allitems = $DB->get_records('feedback_item', array('feedback' => $feedbackcompleted->feedback));
1931     //save all the new values from feedback_valuetmp
1932     //get all values of tmp-completed
1933     $params = array('completed'=>$feedbackcompletedtmp->id);
1934     $values = $DB->get_records('feedback_valuetmp', $params);
1935     foreach ($values as $value) {
1936         //check if there are depend items
1937         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
1938         if ($item->dependitem > 0 && isset($allitems[$item->dependitem])) {
1939             $check = feedback_compare_item_value($tmpcplid,
1940                                         $allitems[$item->dependitem],
1941                                         $item->dependvalue,
1942                                         true);
1943         } else {
1944             $check = true;
1945         }
1946         if ($check) {
1947             unset($value->id);
1948             $value->completed = $feedbackcompleted->id;
1949             $DB->insert_record('feedback_value', $value);
1950         }
1951     }
1952     //drop all the tmpvalues
1953     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1954     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1956     // Trigger event for the delete action we performed.
1957     $cm = get_coursemodule_from_instance('feedback', $feedbackcompleted->feedback);
1958     $event = \mod_feedback\event\response_submitted::create_from_record($feedbackcompleted, $cm);
1959     $event->trigger();
1960     return $feedbackcompleted->id;
1964 /**
1965  * @deprecated since Moodle 3.1
1966  */
1967 function feedback_delete_completedtmp() {
1968     throw new coding_exception('feedback_delete_completedtmp() can not be used anymore.');
1972 ////////////////////////////////////////////////
1973 ////////////////////////////////////////////////
1974 ////////////////////////////////////////////////
1975 //functions to handle the pagebreaks
1976 ////////////////////////////////////////////////
1978 /**
1979  * this creates a pagebreak.
1980  * a pagebreak is a special kind of item
1981  *
1982  * @global object
1983  * @param int $feedbackid
1984  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
1985  */
1986 function feedback_create_pagebreak($feedbackid) {
1987     global $DB;
1989     //check if there already is a pagebreak on the last position
1990     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
1991     if ($lastposition == feedback_get_last_break_position($feedbackid)) {
1992         return false;
1993     }
1995     $item = new stdClass();
1996     $item->feedback = $feedbackid;
1998     $item->template=0;
2000     $item->name = '';
2002     $item->presentation = '';
2003     $item->hasvalue = 0;
2005     $item->typ = 'pagebreak';
2006     $item->position = $lastposition + 1;
2008     $item->required=0;
2010     return $DB->insert_record('feedback_item', $item);
2013 /**
2014  * get all positions of pagebreaks in the given feedback
2015  *
2016  * @global object
2017  * @param int $feedbackid
2018  * @return array all ordered pagebreak positions
2019  */
2020 function feedback_get_all_break_positions($feedbackid) {
2021     global $DB;
2023     $params = array('typ'=>'pagebreak', 'feedback'=>$feedbackid);
2024     $allbreaks = $DB->get_records_menu('feedback_item', $params, 'position', 'id, position');
2025     if (!$allbreaks) {
2026         return false;
2027     }
2028     return array_values($allbreaks);
2031 /**
2032  * get the position of the last pagebreak
2033  *
2034  * @param int $feedbackid
2035  * @return int the position of the last pagebreak
2036  */
2037 function feedback_get_last_break_position($feedbackid) {
2038     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2039         return false;
2040     }
2041     return $allbreaks[count($allbreaks) - 1];
2044 /**
2045  * @deprecated since Moodle 3.1
2046  */
2047 function feedback_get_page_to_continue() {
2048     throw new coding_exception('feedback_get_page_to_continue() can not be used anymore.');
2051 ////////////////////////////////////////////////
2052 ////////////////////////////////////////////////
2053 ////////////////////////////////////////////////
2054 //functions to handle the values
2055 ////////////////////////////////////////////////
2057 /**
2058  * @deprecated since Moodle 3.1
2059  */
2060 function feedback_clean_input_value() {
2061     throw new coding_exception('feedback_clean_input_value() can not be used anymore. '
2062         . 'Items must implement complete_form_element().');
2066 /**
2067  * @deprecated since Moodle 3.1
2068  */
2069 function feedback_save_values() {
2070     throw new coding_exception('feedback_save_values() can not be used anymore.');
2073 /**
2074  * @deprecated since Moodle 3.1
2075  */
2076 function feedback_save_guest_values() {
2077     throw new coding_exception('feedback_save_guest_values() can not be used anymore.');
2080 /**
2081  * get the value from the given item related to the given completed.
2082  * the value can come as temporary or as permanently value. the deciding is done by $tmp
2083  *
2084  * @global object
2085  * @param int $completeid
2086  * @param int $itemid
2087  * @param boolean $tmp
2088  * @return mixed the value, the type depends on plugin-definition
2089  */
2090 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
2091     global $DB;
2093     $tmpstr = $tmp ? 'tmp' : '';
2094     $params = array('completed'=>$completedid, 'item'=>$itemid);
2095     return $DB->get_field('feedback_value'.$tmpstr, 'value', $params);
2098 /**
2099  * compares the value of the itemid related to the completedid with the dependvalue.
2100  * this is used if a depend item is set.
2101  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
2102  *
2103  * @param int $completedid
2104  * @param stdClass|int $item
2105  * @param mixed $dependvalue
2106  * @param bool $tmp
2107  * @return bool
2108  */
2109 function feedback_compare_item_value($completedid, $item, $dependvalue, $tmp = false) {
2110     global $DB;
2112     if (is_int($item)) {
2113         $item = $DB->get_record('feedback_item', array('id' => $item));
2114     }
2116     $dbvalue = feedback_get_item_value($completedid, $item->id, $tmp);
2118     $itemobj = feedback_get_item_class($item->typ);
2119     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
2122 /**
2123  * @deprecated since Moodle 3.1
2124  */
2125 function feedback_check_values() {
2126     throw new coding_exception('feedback_check_values() can not be used anymore. '
2127         . 'Items must implement complete_form_element().');
2130 /**
2131  * @deprecated since Moodle 3.1
2132  */
2133 function feedback_create_values() {
2134     throw new coding_exception('feedback_create_values() can not be used anymore.');
2137 /**
2138  * @deprecated since Moodle 3.1
2139  */
2140 function feedback_update_values() {
2141     throw new coding_exception('feedback_update_values() can not be used anymore.');
2144 /**
2145  * get the values of an item depending on the given groupid.
2146  * if the feedback is anonymous so the values are shuffled
2147  *
2148  * @global object
2149  * @global object
2150  * @param object $item
2151  * @param int $groupid
2152  * @param int $courseid
2153  * @param bool $ignore_empty if this is set true so empty values are not delivered
2154  * @return array the value-records
2155  */
2156 function feedback_get_group_values($item,
2157                                    $groupid = false,
2158                                    $courseid = false,
2159                                    $ignore_empty = false) {
2161     global $CFG, $DB;
2163     //if the groupid is given?
2164     if (intval($groupid) > 0) {
2165         $params = array();
2166         if ($ignore_empty) {
2167             $value = $DB->sql_compare_text('fbv.value');
2168             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2169             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2170         } else {
2171             $ignore_empty_select = "";
2172         }
2174         $query = 'SELECT fbv .  *
2175                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2176                    WHERE fbv.item = :itemid
2177                          AND fbv.completed = fbc.id
2178                          AND fbc.userid = gm.userid
2179                          '.$ignore_empty_select.'
2180                          AND gm.groupid = :groupid
2181                 ORDER BY fbc.timemodified';
2182         $params += array('itemid' => $item->id, 'groupid' => $groupid);
2183         $values = $DB->get_records_sql($query, $params);
2185     } else {
2186         $params = array();
2187         if ($ignore_empty) {
2188             $value = $DB->sql_compare_text('value');
2189             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2190             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2191         } else {
2192             $ignore_empty_select = "";
2193         }
2195         if ($courseid) {
2196             $select = "item = :itemid AND course_id = :courseid ".$ignore_empty_select;
2197             $params += array('itemid' => $item->id, 'courseid' => $courseid);
2198             $values = $DB->get_records_select('feedback_value', $select, $params);
2199         } else {
2200             $select = "item = :itemid ".$ignore_empty_select;
2201             $params += array('itemid' => $item->id);
2202             $values = $DB->get_records_select('feedback_value', $select, $params);
2203         }
2204     }
2205     $params = array('id'=>$item->feedback);
2206     if ($DB->get_field('feedback', 'anonymous', $params) == FEEDBACK_ANONYMOUS_YES) {
2207         if (is_array($values)) {
2208             shuffle($values);
2209         }
2210     }
2211     return $values;
2214 /**
2215  * check for multiple_submit = false.
2216  * if the feedback is global so the courseid must be given
2217  *
2218  * @global object
2219  * @global object
2220  * @param int $feedbackid
2221  * @param int $courseid
2222  * @return boolean true if the feedback already is submitted otherwise false
2223  */
2224 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2225     global $USER, $DB;
2227     if (!isloggedin() || isguestuser()) {
2228         return false;
2229     }
2231     $params = array('userid' => $USER->id, 'feedback' => $feedbackid);
2232     if ($courseid) {
2233         $params['courseid'] = $courseid;
2234     }
2235     return $DB->record_exists('feedback_completed', $params);
2238 /**
2239  * @deprecated since Moodle 3.1. Use feedback_get_current_completed_tmp() or feedback_get_last_completed.
2240  */
2241 function feedback_get_current_completed() {
2242     throw new coding_exception('feedback_get_current_completed() can not be used anymore. Please ' .
2243             'use either feedback_get_current_completed_tmp() or feedback_get_last_completed()');
2246 /**
2247  * get the completeds depending on the given groupid.
2248  *
2249  * @global object
2250  * @global object
2251  * @param object $feedback
2252  * @param int $groupid
2253  * @param int $courseid
2254  * @return mixed array of found completeds otherwise false
2255  */
2256 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2257     global $CFG, $DB;
2259     if (intval($groupid) > 0) {
2260         $query = "SELECT fbc.*
2261                     FROM {feedback_completed} fbc, {groups_members} gm
2262                    WHERE fbc.feedback = ?
2263                          AND gm.groupid = ?
2264                          AND fbc.userid = gm.userid";
2265         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2266             return $values;
2267         } else {
2268             return false;
2269         }
2270     } else {
2271         if ($courseid) {
2272             $query = "SELECT DISTINCT fbc.*
2273                         FROM {feedback_completed} fbc, {feedback_value} fbv
2274                         WHERE fbc.id = fbv.completed
2275                             AND fbc.feedback = ?
2276                             AND fbv.course_id = ?
2277                         ORDER BY random_response";
2278             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2279                 return $values;
2280             } else {
2281                 return false;
2282             }
2283         } else {
2284             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2285                 return $values;
2286             } else {
2287                 return false;
2288             }
2289         }
2290     }
2293 /**
2294  * get the count of completeds depending on the given groupid.
2295  *
2296  * @global object
2297  * @global object
2298  * @param object $feedback
2299  * @param int $groupid
2300  * @param int $courseid
2301  * @return mixed count of completeds or false
2302  */
2303 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2304     global $CFG, $DB;
2306     if ($courseid > 0 AND !$groupid <= 0) {
2307         $sql = "SELECT id, COUNT(item) AS ci
2308                   FROM {feedback_value}
2309                  WHERE course_id  = ?
2310               GROUP BY item ORDER BY ci DESC";
2311         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2312             $foundrecs = array_values($foundrecs);
2313             return $foundrecs[0]->ci;
2314         }
2315         return false;
2316     }
2317     if ($values = feedback_get_completeds_group($feedback, $groupid)) {
2318         return count($values);
2319     } else {
2320         return false;
2321     }
2324 /**
2325  * deletes all completed-recordsets from a feedback.
2326  * all related data such as values also will be deleted
2327  *
2328  * @param stdClass|int $feedback
2329  * @param stdClass|cm_info $cm
2330  * @param stdClass $course
2331  * @return void
2332  */
2333 function feedback_delete_all_completeds($feedback, $cm = null, $course = null) {
2334     global $DB;
2336     if (is_int($feedback)) {
2337         $feedback = $DB->get_record('feedback', array('id' => $feedback));
2338     }
2340     if (!$completeds = $DB->get_records('feedback_completed', array('feedback' => $feedback->id))) {
2341         return;
2342     }
2344     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2345         return false;
2346     }
2348     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2349         return false;
2350     }
2352     foreach ($completeds as $completed) {
2353         feedback_delete_completed($completed, $feedback, $cm, $course);
2354     }
2357 /**
2358  * deletes a completed given by completedid.
2359  * all related data such values or tracking data also will be deleted
2360  *
2361  * @param int|stdClass $completed
2362  * @param stdClass $feedback
2363  * @param stdClass|cm_info $cm
2364  * @param stdClass $course
2365  * @return boolean
2366  */
2367 function feedback_delete_completed($completed, $feedback = null, $cm = null, $course = null) {
2368     global $DB, $CFG;
2369     require_once($CFG->libdir.'/completionlib.php');
2371     if (!isset($completed->id)) {
2372         if (!$completed = $DB->get_record('feedback_completed', array('id' => $completed))) {
2373             return false;
2374         }
2375     }
2377     if (!$feedback && !($feedback = $DB->get_record('feedback', array('id' => $completed->feedback)))) {
2378         return false;
2379     }
2381     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2382         return false;
2383     }
2385     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2386         return false;
2387     }
2389     //first we delete all related values
2390     $DB->delete_records('feedback_value', array('completed' => $completed->id));
2392     // Delete the completed record.
2393     $return = $DB->delete_records('feedback_completed', array('id' => $completed->id));
2395     // Update completion state
2396     $completion = new completion_info($course);
2397     if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC && $feedback->completionsubmit) {
2398         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
2399     }
2400     // Trigger event for the delete action we performed.
2401     $event = \mod_feedback\event\response_deleted::create_from_record($completed, $cm, $feedback);
2402     $event->trigger();
2404     return $return;
2407 ////////////////////////////////////////////////
2408 ////////////////////////////////////////////////
2409 ////////////////////////////////////////////////
2410 //functions to handle sitecourse mapping
2411 ////////////////////////////////////////////////
2413 /**
2414  * @deprecated since 3.1
2415  */
2416 function feedback_is_course_in_sitecourse_map() {
2417     throw new coding_exception('feedback_is_course_in_sitecourse_map() can not be used anymore.');
2420 /**
2421  * @deprecated since 3.1
2422  */
2423 function feedback_is_feedback_in_sitecourse_map() {
2424     throw new coding_exception('feedback_is_feedback_in_sitecourse_map() can not be used anymore.');
2427 /**
2428  * gets the feedbacks from table feedback_sitecourse_map.
2429  * this is used to show the global feedbacks on the feedback block
2430  * all feedbacks with the following criteria will be selected:<br />
2431  *
2432  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2433  * 2) all feedbacks which not are listed in sitecoursemap
2434  *
2435  * @global object
2436  * @param int $courseid
2437  * @return array the feedback-records
2438  */
2439 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2440     global $DB;
2442     //first get all feedbacks listed in sitecourse_map with named courseid
2443     $sql = "SELECT f.id AS id,
2444                    cm.id AS cmid,
2445                    f.name AS name,
2446                    f.timeopen AS timeopen,
2447                    f.timeclose AS timeclose
2448             FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2449             WHERE f.id = cm.instance
2450                    AND f.course = '".SITEID."'
2451                    AND m.id = cm.module
2452                    AND m.name = 'feedback'
2453                    AND sm.courseid = ?
2454                    AND sm.feedbackid = f.id";
2456     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2457         $feedbacks1 = array();
2458     }
2460     //second get all feedbacks not listed in sitecourse_map
2461     $feedbacks2 = array();
2462     $sql = "SELECT f.id AS id,
2463                    cm.id AS cmid,
2464                    f.name AS name,
2465                    f.timeopen AS timeopen,
2466                    f.timeclose AS timeclose
2467             FROM {feedback} f, {course_modules} cm, {modules} m
2468             WHERE f.id = cm.instance
2469                    AND f.course = '".SITEID."'
2470                    AND m.id = cm.module
2471                    AND m.name = 'feedback'";
2472     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2473         $allfeedbacks = array();
2474     }
2475     foreach ($allfeedbacks as $a) {
2476         if (!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2477             $feedbacks2[] = $a;
2478         }
2479     }
2481     $feedbacks = array_merge($feedbacks1, $feedbacks2);
2482     $modinfo = get_fast_modinfo(SITEID);
2483     return array_filter($feedbacks, function($f) use ($modinfo) {
2484         return ($cm = $modinfo->get_cm($f->cmid)) && $cm->uservisible;
2485     });
2489 /**
2490  * Gets the courses from table feedback_sitecourse_map
2491  *
2492  * @param int $feedbackid
2493  * @return array the course-records
2494  */
2495 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2496     global $DB;
2498     $sql = "SELECT c.id, c.fullname, c.shortname
2499               FROM {feedback_sitecourse_map} f, {course} c
2500              WHERE c.id = f.courseid
2501                    AND f.feedbackid = ?
2502           ORDER BY c.fullname";
2504     return $DB->get_records_sql($sql, array($feedbackid));
2508 /**
2509  * Updates the course mapping for the feedback
2510  *
2511  * @param stdClass $feedback
2512  * @param array $courses array of course ids
2513  */
2514 function feedback_update_sitecourse_map($feedback, $courses) {
2515     global $DB;
2516     if (empty($courses)) {
2517         $courses = array();
2518     }
2519     $currentmapping = $DB->get_fieldset_select('feedback_sitecourse_map', 'courseid', 'feedbackid=?', array($feedback->id));
2520     foreach (array_diff($courses, $currentmapping) as $courseid) {
2521         $DB->insert_record('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2522     }
2523     foreach (array_diff($currentmapping, $courses) as $courseid) {
2524         $DB->delete_records('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2525     }
2526     // TODO MDL-53574 add events.
2529 /**
2530  * @deprecated since 3.1
2531  */
2532 function feedback_clean_up_sitecourse_map() {
2533     throw new coding_exception('feedback_clean_up_sitecourse_map() can not be used anymore.');
2536 ////////////////////////////////////////////////
2537 ////////////////////////////////////////////////
2538 ////////////////////////////////////////////////
2539 //not relatable functions
2540 ////////////////////////////////////////////////
2542 /**
2543  * @deprecated since 3.1
2544  */
2545 function feedback_print_numeric_option_list() {
2546     throw new coding_exception('feedback_print_numeric_option_list() can not be used anymore.');
2549 /**
2550  * sends an email to the teachers of the course where the given feedback is placed.
2551  *
2552  * @global object
2553  * @global object
2554  * @uses FEEDBACK_ANONYMOUS_NO
2555  * @uses FORMAT_PLAIN
2556  * @param object $cm the coursemodule-record
2557  * @param object $feedback
2558  * @param object $course
2559  * @param stdClass|int $user
2560  * @param stdClass $completed record from feedback_completed if known
2561  * @return void
2562  */
2563 function feedback_send_email($cm, $feedback, $course, $user, $completed = null) {
2564     global $CFG, $DB;
2566     if ($feedback->email_notification == 0) {  // No need to do anything
2567         return;
2568     }
2570     if (is_int($user)) {
2571         $user = $DB->get_record('user', array('id' => $user));
2572     }
2574     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
2575         $groupmode =  $cm->groupmode;
2576     } else {
2577         $groupmode = $course->groupmode;
2578     }
2580     if ($groupmode == SEPARATEGROUPS) {
2581         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
2582                                                FROM {groups} g, {groups_members} m
2583                                               WHERE g.courseid = ?
2584                                                     AND g.id = m.groupid
2585                                                     AND m.userid = ?
2586                                            ORDER BY name ASC", array($course->id, $user->id));
2587         $groups = array_values($groups);
2589         $teachers = feedback_get_receivemail_users($cm->id, $groups);
2590     } else {
2591         $teachers = feedback_get_receivemail_users($cm->id);
2592     }
2594     if ($teachers) {
2596         $strfeedbacks = get_string('modulenameplural', 'feedback');
2597         $strfeedback  = get_string('modulename', 'feedback');
2599         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2600             $printusername = fullname($user);
2601         } else {
2602             $printusername = get_string('anonymous_user', 'feedback');
2603         }
2605         foreach ($teachers as $teacher) {
2606             $info = new stdClass();
2607             $info->username = $printusername;
2608             $info->feedback = format_string($feedback->name, true);
2609             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?'.
2610                             'id='.$cm->id.'&'.
2611                             'userid=' . $user->id;
2612             if ($completed) {
2613                 $info->url .= '&showcompleted=' . $completed->id;
2614                 if ($feedback->course == SITEID) {
2615                     // Course where feedback was completed (for site feedbacks only).
2616                     $info->url .= '&courseid=' . $completed->courseid;
2617                 }
2618             }
2620             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
2622             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
2623             $posttext = feedback_send_email_text($info, $course);
2625             if ($teacher->mailformat == 1) {
2626                 $posthtml = feedback_send_email_html($info, $course, $cm);
2627             } else {
2628                 $posthtml = '';
2629             }
2631             if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2632                 $eventdata = new \core\message\message();
2633                 $eventdata->courseid         = $course->id;
2634                 $eventdata->name             = 'submission';
2635                 $eventdata->component        = 'mod_feedback';
2636                 $eventdata->userfrom         = $user;
2637                 $eventdata->userto           = $teacher;
2638                 $eventdata->subject          = $postsubject;
2639                 $eventdata->fullmessage      = $posttext;
2640                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2641                 $eventdata->fullmessagehtml  = $posthtml;
2642                 $eventdata->smallmessage     = '';
2643                 $eventdata->courseid         = $course->id;
2644                 $eventdata->contexturl       = $info->url;
2645                 $eventdata->contexturlname   = $info->feedback;
2646                 message_send($eventdata);
2647             } else {
2648                 $eventdata = new \core\message\message();
2649                 $eventdata->courseid         = $course->id;
2650                 $eventdata->name             = 'submission';
2651                 $eventdata->component        = 'mod_feedback';
2652                 $eventdata->userfrom         = $teacher;
2653                 $eventdata->userto           = $teacher;
2654                 $eventdata->subject          = $postsubject;
2655                 $eventdata->fullmessage      = $posttext;
2656                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2657                 $eventdata->fullmessagehtml  = $posthtml;
2658                 $eventdata->smallmessage     = '';
2659                 $eventdata->courseid         = $course->id;
2660                 $eventdata->contexturl       = $info->url;
2661                 $eventdata->contexturlname   = $info->feedback;
2662                 message_send($eventdata);
2663             }
2664         }
2665     }
2668 /**
2669  * sends an email to the teachers of the course where the given feedback is placed.
2670  *
2671  * @global object
2672  * @uses FORMAT_PLAIN
2673  * @param object $cm the coursemodule-record
2674  * @param object $feedback
2675  * @param object $course
2676  * @return void
2677  */
2678 function feedback_send_email_anonym($cm, $feedback, $course) {
2679     global $CFG;
2681     if ($feedback->email_notification == 0) { // No need to do anything
2682         return;
2683     }
2685     $teachers = feedback_get_receivemail_users($cm->id);
2687     if ($teachers) {
2689         $strfeedbacks = get_string('modulenameplural', 'feedback');
2690         $strfeedback  = get_string('modulename', 'feedback');
2691         $printusername = get_string('anonymous_user', 'feedback');
2693         foreach ($teachers as $teacher) {
2694             $info = new stdClass();
2695             $info->username = $printusername;
2696             $info->feedback = format_string($feedback->name, true);
2697             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?id=' . $cm->id;
2699             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
2701             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
2702             $posttext = feedback_send_email_text($info, $course);
2704             if ($teacher->mailformat == 1) {
2705                 $posthtml = feedback_send_email_html($info, $course, $cm);
2706             } else {
2707                 $posthtml = '';
2708             }
2710             $eventdata = new \core\message\message();
2711             $eventdata->courseid         = $course->id;
2712             $eventdata->name             = 'submission';
2713             $eventdata->component        = 'mod_feedback';
2714             $eventdata->userfrom         = $teacher;
2715             $eventdata->userto           = $teacher;
2716             $eventdata->subject          = $postsubject;
2717             $eventdata->fullmessage      = $posttext;
2718             $eventdata->fullmessageformat = FORMAT_PLAIN;
2719             $eventdata->fullmessagehtml  = $posthtml;
2720             $eventdata->smallmessage     = '';
2721             $eventdata->courseid         = $course->id;
2722             $eventdata->contexturl       = $info->url;
2723             $eventdata->contexturlname   = $info->feedback;
2724             message_send($eventdata);
2725         }
2726     }
2729 /**
2730  * send the text-part of the email
2731  *
2732  * @param object $info includes some infos about the feedback you want to send
2733  * @param object $course
2734  * @return string the text you want to post
2735  */
2736 function feedback_send_email_text($info, $course) {
2737     $coursecontext = context_course::instance($course->id);
2738     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
2739     $posttext  = $courseshortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
2740                     $info->feedback."\n";
2741     $posttext .= '---------------------------------------------------------------------'."\n";
2742     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
2743     $posttext .= '---------------------------------------------------------------------'."\n";
2744     return $posttext;
2748 /**
2749  * send the html-part of the email
2750  *
2751  * @global object
2752  * @param object $info includes some infos about the feedback you want to send
2753  * @param object $course
2754  * @return string the text you want to post
2755  */
2756 function feedback_send_email_html($info, $course, $cm) {
2757     global $CFG;
2758     $coursecontext = context_course::instance($course->id);
2759     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
2760     $course_url = $CFG->wwwroot.'/course/view.php?id='.$course->id;
2761     $feedback_all_url = $CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id;
2762     $feedback_url = $CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id;
2764     $posthtml = '<p><font face="sans-serif">'.
2765             '<a href="'.$course_url.'">'.$courseshortname.'</a> ->'.
2766             '<a href="'.$feedback_all_url.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
2767             '<a href="'.$feedback_url.'">'.$info->feedback.'</a></font></p>';
2768     $posthtml .= '<hr /><font face="sans-serif">';
2769     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
2770     $posthtml .= '</font><hr />';
2771     return $posthtml;
2774 /**
2775  * @param string $url
2776  * @return string
2777  */
2778 function feedback_encode_target_url($url) {
2779     if (strpos($url, '?')) {
2780         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
2781         return $part1 . '?' . htmlentities($part2);
2782     } else {
2783         return $url;
2784     }
2787 /**
2788  * Adds module specific settings to the settings block
2789  *
2790  * @param settings_navigation $settings The settings navigation object
2791  * @param navigation_node $feedbacknode The node to add module settings to
2792  */
2793 function feedback_extend_settings_navigation(settings_navigation $settings,
2794                                              navigation_node $feedbacknode) {
2796     global $PAGE;
2798     if (!$context = context_module::instance($PAGE->cm->id, IGNORE_MISSING)) {
2799         print_error('badcontext');
2800     }
2802     if (has_capability('mod/feedback:edititems', $context)) {
2803         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
2805         $questionnode->add(get_string('edit_items', 'feedback'),
2806                     new moodle_url('/mod/feedback/edit.php',
2807                                     array('id' => $PAGE->cm->id,
2808                                           'do_show' => 'edit')));
2810         $questionnode->add(get_string('export_questions', 'feedback'),
2811                     new moodle_url('/mod/feedback/export.php',
2812                                     array('id' => $PAGE->cm->id,
2813                                           'action' => 'exportfile')));
2815         $questionnode->add(get_string('import_questions', 'feedback'),
2816                     new moodle_url('/mod/feedback/import.php',
2817                                     array('id' => $PAGE->cm->id)));
2819         $questionnode->add(get_string('templates', 'feedback'),
2820                     new moodle_url('/mod/feedback/edit.php',
2821                                     array('id' => $PAGE->cm->id,
2822                                           'do_show' => 'templates')));
2823     }
2825     if (has_capability('mod/feedback:mapcourse', $context) && $PAGE->course->id == SITEID) {
2826         $feedbacknode->add(get_string('mappedcourses', 'feedback'),
2827                     new moodle_url('/mod/feedback/mapcourse.php',
2828                                     array('id' => $PAGE->cm->id)));
2829     }
2831     if (has_capability('mod/feedback:viewreports', $context)) {
2832         $feedback = $PAGE->activityrecord;
2833         if ($feedback->course == SITEID) {
2834             $feedbacknode->add(get_string('analysis', 'feedback'),
2835                     new moodle_url('/mod/feedback/analysis_course.php',
2836                                     array('id' => $PAGE->cm->id)));
2837         } else {
2838             $feedbacknode->add(get_string('analysis', 'feedback'),
2839                     new moodle_url('/mod/feedback/analysis.php',
2840                                     array('id' => $PAGE->cm->id)));
2841         }
2843         $feedbacknode->add(get_string('show_entries', 'feedback'),
2844                     new moodle_url('/mod/feedback/show_entries.php',
2845                                     array('id' => $PAGE->cm->id)));
2847         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO AND $feedback->course != SITEID) {
2848             $feedbacknode->add(get_string('show_nonrespondents', 'feedback'),
2849                         new moodle_url('/mod/feedback/show_nonrespondents.php',
2850                                         array('id' => $PAGE->cm->id)));
2851         }
2852     }
2855 function feedback_init_feedback_session() {
2856     //initialize the feedback-Session - not nice at all!!
2857     global $SESSION;
2858     if (!empty($SESSION)) {
2859         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
2860             $SESSION->feedback = new stdClass();
2861         }
2862     }
2865 /**
2866  * Return a list of page types
2867  * @param string $pagetype current page type
2868  * @param stdClass $parentcontext Block's parent context
2869  * @param stdClass $currentcontext Current context of block
2870  */
2871 function feedback_page_type_list($pagetype, $parentcontext, $currentcontext) {
2872     $module_pagetype = array('mod-feedback-*'=>get_string('page-mod-feedback-x', 'feedback'));
2873     return $module_pagetype;
2876 /**
2877  * Move save the items of the given $feedback in the order of $itemlist.
2878  * @param string $itemlist a comma separated list with item ids
2879  * @param stdClass $feedback
2880  * @return bool true if success
2881  */
2882 function feedback_ajax_saveitemorder($itemlist, $feedback) {
2883     global $DB;
2885     $result = true;
2886     $position = 0;
2887     foreach ($itemlist as $itemid) {
2888         $position++;
2889         $result = $result && $DB->set_field('feedback_item',
2890                                             'position',
2891                                             $position,
2892                                             array('id'=>$itemid, 'feedback'=>$feedback->id));
2893     }
2894     return $result;
2897 /**
2898  * Checks if current user is able to view feedback on this course.
2899  *
2900  * @param stdClass $feedback
2901  * @param context_module $context
2902  * @param int $courseid
2903  * @return bool
2904  */
2905 function feedback_can_view_analysis($feedback, $context, $courseid = false) {
2906     if (has_capability('mod/feedback:viewreports', $context)) {
2907         return true;
2908     }
2910     if (intval($feedback->publish_stats) != 1 ||
2911             !has_capability('mod/feedback:viewanalysepage', $context)) {
2912         return false;
2913     }
2915     if (!isloggedin() || isguestuser()) {
2916         // There is no tracking for the guests, assume that they can view analysis if condition above is satisfied.
2917         return $feedback->course == SITEID;
2918     }
2920     return feedback_is_already_submitted($feedback->id, $courseid);
2923 /**
2924  * Get icon mapping for font-awesome.
2925  */
2926 function mod_feedback_get_fontawesome_icon_map() {
2927     return [
2928         'mod_feedback:required' => 'fa-exclamation-circle',
2929         'mod_feedback:notrequired' => 'fa-question-circle-o',
2930     ];
2933 /**
2934  * Check if the module has any update that affects the current user since a given time.
2935  *
2936  * @param  cm_info $cm course module data
2937  * @param  int $from the time to check updates from
2938  * @param  array $filter if we need to check only specific updates
2939  * @return stdClass an object with the different type of areas indicating if they were updated or not
2940  * @since Moodle 3.3
2941  */
2942 function feedback_check_updates_since(cm_info $cm, $from, $filter = array()) {
2943     global $DB, $USER, $CFG;
2945     $updates = course_check_module_updates_since($cm, $from, array(), $filter);
2947     // Check for new attempts.
2948     $updates->attemptsfinished = (object) array('updated' => false);
2949     $updates->attemptsunfinished = (object) array('updated' => false);
2950     $select = 'feedback = ? AND userid = ? AND timemodified > ?';
2951     $params = array($cm->instance, $USER->id, $from);
2953     $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
2954     if (!empty($attemptsfinished)) {
2955         $updates->attemptsfinished->updated = true;
2956         $updates->attemptsfinished->itemids = array_keys($attemptsfinished);
2957     }
2958     $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
2959     if (!empty($attemptsunfinished)) {
2960         $updates->attemptsunfinished->updated = true;
2961         $updates->attemptsunfinished->itemids = array_keys($attemptsunfinished);
2962     }
2964     // Now, teachers should see other students updates.
2965     if (has_capability('mod/feedback:viewreports', $cm->context)) {
2966         $select = 'feedback = ? AND timemodified > ?';
2967         $params = array($cm->instance, $from);
2969         if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
2970             $groupusers = array_keys(groups_get_activity_shared_group_members($cm));
2971             if (empty($groupusers)) {
2972                 return $updates;
2973             }
2974             list($insql, $inparams) = $DB->get_in_or_equal($groupusers);
2975             $select .= ' AND userid ' . $insql;
2976             $params = array_merge($params, $inparams);
2977         }
2979         $updates->userattemptsfinished = (object) array('updated' => false);
2980         $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
2981         if (!empty($attemptsfinished)) {
2982             $updates->userattemptsfinished->updated = true;
2983             $updates->userattemptsfinished->itemids = array_keys($attemptsfinished);
2984         }
2986         $updates->userattemptsunfinished = (object) array('updated' => false);
2987         $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
2988         if (!empty($attemptsunfinished)) {
2989             $updates->userattemptsunfinished->updated = true;
2990             $updates->userattemptsunfinished->itemids = array_keys($attemptsunfinished);
2991         }
2992     }
2994     return $updates;
2997 /**
2998  * This function receives a calendar event and returns the action associated with it, or null if there is none.
2999  *
3000  * This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
3001  * is not displayed on the block.
3002  *
3003  * @param calendar_event $event
3004  * @param \core_calendar\action_factory $factory
3005  * @return \core_calendar\local\event\entities\action_interface|null
3006  */
3007 function mod_feedback_core_calendar_provide_event_action(calendar_event $event,
3008                                                          \core_calendar\action_factory $factory) {
3010     $cm = get_fast_modinfo($event->courseid)->instances['feedback'][$event->instance];
3011     $feedbackcompletion = new mod_feedback_completion(null, $cm, 0);
3013     if (!empty($cm->customdata['timeclose']) && $cm->customdata['timeclose'] < time()) {
3014         // Feedback is already closed, do not display it even if it was never submitted.
3015         return null;
3016     }
3018     if (!$feedbackcompletion->can_complete()) {
3019         // The user can't complete the feedback so there is no action for them.
3020         return null;
3021     }
3023     // The feedback is actionable if it does not have timeopen or timeopen is in the past.
3024     $actionable = $feedbackcompletion->is_open();
3026     if ($actionable && $feedbackcompletion->is_already_submitted()) {
3027         // There is no need to display anything if the user has already submitted the feedback.
3028         return null;
3029     }
3031     return $factory->create_instance(
3032         get_string('answerquestions', 'feedback'),
3033         new \moodle_url('/mod/feedback/view.php', ['id' => $cm->id]),
3034         1,
3035         $actionable
3036     );
3039 /**
3040  * Add a get_coursemodule_info function in case any feedback type wants to add 'extra' information
3041  * for the course (see resource).
3042  *
3043  * Given a course_module object, this function returns any "extra" information that may be needed
3044  * when printing this activity in a course listing.  See get_array_of_activities() in course/lib.php.
3045  *
3046  * @param stdClass $coursemodule The coursemodule object (record).
3047  * @return cached_cm_info An object on information that the courses
3048  *                        will know about (most noticeably, an icon).
3049  */
3050 function feedback_get_coursemodule_info($coursemodule) {
3051     global $DB;
3053     $dbparams = ['id' => $coursemodule->instance];
3054     $fields = 'id, name, intro, introformat, completionsubmit, timeopen, timeclose, anonymous';
3055     if (!$feedback = $DB->get_record('feedback', $dbparams, $fields)) {
3056         return false;
3057     }
3059     $result = new cached_cm_info();
3060     $result->name = $feedback->name;
3062     if ($coursemodule->showdescription) {
3063         // Convert intro to html. Do not filter cached version, filters run at display time.
3064         $result->content = format_module_intro('feedback', $feedback, $coursemodule->id, false);
3065     }
3067     // Populate the custom completion rules as key => value pairs, but only if the completion mode is 'automatic'.
3068     if ($coursemodule->completion == COMPLETION_TRACKING_AUTOMATIC) {
3069         $result->customdata['customcompletionrules']['completionsubmit'] = $feedback->completionsubmit;
3070     }
3071     // Populate some other values that can be used in calendar or on dashboard.
3072     if ($feedback->timeopen) {
3073         $result->customdata['timeopen'] = $feedback->timeopen;
3074     }
3075     if ($feedback->timeclose) {
3076         $result->customdata['timeclose'] = $feedback->timeclose;
3077     }
3078     if ($feedback->anonymous) {
3079         $result->customdata['anonymous'] = $feedback->anonymous;
3080     }
3082     return $result;
3085 /**
3086  * Callback which returns human-readable strings describing the active completion custom rules for the module instance.
3087  *
3088  * @param cm_info|stdClass $cm object with fields ->completion and ->customdata['customcompletionrules']
3089  * @return array $descriptions the array of descriptions for the custom rules.
3090  */
3091 function mod_feedback_get_completion_active_rule_descriptions($cm) {
3092     // Values will be present in cm_info, and we assume these are up to date.
3093     if (empty($cm->customdata['customcompletionrules'])
3094         || $cm->completion != COMPLETION_TRACKING_AUTOMATIC) {
3095         return [];
3096     }
3098     $descriptions = [];
3099     foreach ($cm->customdata['customcompletionrules'] as $key => $val) {
3100         switch ($key) {
3101             case 'completionsubmit':
3102                 if (empty($val)) {
3103                     continue;
3104                 }
3105                 $descriptions[] = get_string('completionsubmit', 'feedback');
3106                 break;
3107             default:
3108                 break;
3109         }
3110     }
3111     return $descriptions;
3114 /**
3115  * This function calculates the minimum and maximum cutoff values for the timestart of
3116  * the given event.
3117  *
3118  * It will return an array with two values, the first being the minimum cutoff value and
3119  * the second being the maximum cutoff value. Either or both values can be null, which
3120  * indicates there is no minimum or maximum, respectively.
3121  *
3122  * If a cutoff is required then the function must return an array containing the cutoff
3123  * timestamp and error string to display to the user if the cutoff value is violated.
3124  *
3125  * A minimum and maximum cutoff return value will look like:
3126  * [
3127  *     [1505704373, 'The due date must be after the sbumission start date'],
3128  *     [1506741172, 'The due date must be before the cutoff date']
3129  * ]
3130  *
3131  * @param calendar_event $event The calendar event to get the time range for
3132  * @param stdClass $instance The module instance to get the range from
3133  * @return array
3134  */
3135 function mod_feedback_core_calendar_get_valid_event_timestart_range(\calendar_event $event, \stdClass $instance) {
3136     $mindate = null;
3137     $maxdate = null;
3139     if ($event->eventtype == FEEDBACK_EVENT_TYPE_OPEN) {
3140         // The start time of the open event can't be equal to or after the
3141         // close time of the choice activity.
3142         if (!empty($instance->timeclose)) {
3143             $maxdate = [
3144                 $instance->timeclose,
3145                 get_string('openafterclose', 'feedback')
3146             ];
3147         }
3148     } else if ($event->eventtype == FEEDBACK_EVENT_TYPE_CLOSE) {
3149         // The start time of the close event can't be equal to or earlier than the
3150         // open time of the choice activity.
3151         if (!empty($instance->timeopen)) {
3152             $mindate = [
3153                 $instance->timeopen,
3154                 get_string('closebeforeopen', 'feedback')
3155             ];
3156         }
3157     }
3159     return [$mindate, $maxdate];
3162 /**
3163  * This function will update the feedback module according to the
3164  * event that has been modified.
3165  *
3166  * It will set the timeopen or timeclose value of the feedback instance
3167  * according to the type of event provided.
3168  *
3169  * @throws \moodle_exception
3170  * @param \calendar_event $event
3171  * @param stdClass $feedback The module instance to get the range from
3172  */
3173 function mod_feedback_core_calendar_event_timestart_updated(\calendar_event $event, \stdClass $feedback) {
3174     global $CFG, $DB;
3176     if (empty($event->instance) || $event->modulename != 'feedback') {
3177         return;
3178     }
3180     if ($event->instance != $feedback->id) {
3181         return;
3182     }
3184     if (!in_array($event->eventtype, [FEEDBACK_EVENT_TYPE_OPEN, FEEDBACK_EVENT_TYPE_CLOSE])) {
3185         return;
3186     }
3188     $courseid = $event->courseid;
3189     $modulename = $event->modulename;
3190     $instanceid = $event->instance;
3191     $modified = false;
3193     $coursemodule = get_fast_modinfo($courseid)->instances[$modulename][$instanceid];
3194     $context = context_module::instance($coursemodule->id);
3196     // The user does not have the capability to modify this activity.
3197     if (!has_capability('moodle/course:manageactivities', $context)) {
3198         return;
3199     }
3201     if ($event->eventtype == FEEDBACK_EVENT_TYPE_OPEN) {
3202         // If the event is for the feedback activity opening then we should
3203         // set the start time of the feedback activity to be the new start
3204         // time of the event.
3205         if ($feedback->timeopen != $event->timestart) {
3206             $feedback->timeopen = $event->timestart;
3207             $feedback->timemodified = time();
3208             $modified = true;
3209         }
3210     } else if ($event->eventtype == FEEDBACK_EVENT_TYPE_CLOSE) {
3211         // If the event is for the feedback activity closing then we should
3212         // set the end time of the feedback activity to be the new start
3213         // time of the event.
3214         if ($feedback->timeclose != $event->timestart) {
3215             $feedback->timeclose = $event->timestart;
3216             $modified = true;
3217         }
3218     }
3220     if ($modified) {
3221         $feedback->timemodified = time();
3222         $DB->update_record('feedback', $feedback);
3223         $event = \core\event\course_module_updated::create_from_cm($coursemodule, $context);
3224         $event->trigger();
3225     }