MDL-55188 events: First deprecation of eventslib.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 forms lib.
29 require_once($CFG->libdir.'/formslib.php');
31 define('FEEDBACK_ANONYMOUS_YES', 1);
32 define('FEEDBACK_ANONYMOUS_NO', 2);
33 define('FEEDBACK_MIN_ANONYMOUS_COUNT_IN_GROUP', 2);
34 define('FEEDBACK_DECIMAL', '.');
35 define('FEEDBACK_THOUSAND', ',');
36 define('FEEDBACK_RESETFORM_RESET', 'feedback_reset_data_');
37 define('FEEDBACK_RESETFORM_DROP', 'feedback_drop_feedback_');
38 define('FEEDBACK_MAX_PIX_LENGTH', '400'); //max. Breite des grafischen Balkens in der Auswertung
39 define('FEEDBACK_DEFAULT_PAGE_COUNT', 20);
41 // Event types.
42 define('FEEDBACK_EVENT_TYPE_OPEN', 'open');
43 define('FEEDBACK_EVENT_TYPE_CLOSE', 'close');
45 /**
46  * Returns all other caps used in module.
47  *
48  * @return array
49  */
50 function feedback_get_extra_capabilities() {
51     return array('moodle/site:accessallgroups');
52 }
54 /**
55  * @uses FEATURE_GROUPS
56  * @uses FEATURE_GROUPINGS
57  * @uses FEATURE_MOD_INTRO
58  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
59  * @uses FEATURE_GRADE_HAS_GRADE
60  * @uses FEATURE_GRADE_OUTCOMES
61  * @param string $feature FEATURE_xx constant for requested feature
62  * @return mixed True if module supports feature, null if doesn't know
63  */
64 function feedback_supports($feature) {
65     switch($feature) {
66         case FEATURE_GROUPS:                  return true;
67         case FEATURE_GROUPINGS:               return true;
68         case FEATURE_MOD_INTRO:               return true;
69         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
70         case FEATURE_COMPLETION_HAS_RULES:    return true;
71         case FEATURE_GRADE_HAS_GRADE:         return false;
72         case FEATURE_GRADE_OUTCOMES:          return false;
73         case FEATURE_BACKUP_MOODLE2:          return true;
74         case FEATURE_SHOW_DESCRIPTION:        return true;
76         default: return null;
77     }
78 }
80 /**
81  * this will create a new instance and return the id number
82  * of the new instance.
83  *
84  * @global object
85  * @param object $feedback the object given by mod_feedback_mod_form
86  * @return int
87  */
88 function feedback_add_instance($feedback) {
89     global $DB;
91     $feedback->timemodified = time();
92     $feedback->id = '';
94     if (empty($feedback->site_after_submit)) {
95         $feedback->site_after_submit = '';
96     }
98     //saving the feedback in db
99     $feedbackid = $DB->insert_record("feedback", $feedback);
101     $feedback->id = $feedbackid;
103     feedback_set_events($feedback);
105     if (!isset($feedback->coursemodule)) {
106         $cm = get_coursemodule_from_id('feedback', $feedback->id);
107         $feedback->coursemodule = $cm->id;
108     }
109     $context = context_module::instance($feedback->coursemodule);
111     if (!empty($feedback->completionexpected)) {
112         \core_completion\api::update_completion_date_event($feedback->coursemodule, 'feedback', $feedback->id,
113                 $feedback->completionexpected);
114     }
116     $editoroptions = feedback_get_editor_options();
118     // process the custom wysiwyg editor in page_after_submit
119     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
120         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
121                                                     'mod_feedback', 'page_after_submit',
122                                                     0, $editoroptions,
123                                                     $feedback->page_after_submit_editor['text']);
125         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
126     }
127     $DB->update_record('feedback', $feedback);
129     return $feedbackid;
132 /**
133  * this will update a given instance
134  *
135  * @global object
136  * @param object $feedback the object given by mod_feedback_mod_form
137  * @return boolean
138  */
139 function feedback_update_instance($feedback) {
140     global $DB;
142     $feedback->timemodified = time();
143     $feedback->id = $feedback->instance;
145     if (empty($feedback->site_after_submit)) {
146         $feedback->site_after_submit = '';
147     }
149     //save the feedback into the db
150     $DB->update_record("feedback", $feedback);
152     //create or update the new events
153     feedback_set_events($feedback);
154     $completionexpected = (!empty($feedback->completionexpected)) ? $feedback->completionexpected : null;
155     \core_completion\api::update_completion_date_event($feedback->coursemodule, 'feedback', $feedback->id, $completionexpected);
157     $context = context_module::instance($feedback->coursemodule);
159     $editoroptions = feedback_get_editor_options();
161     // process the custom wysiwyg editor in page_after_submit
162     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
163         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
164                                                     'mod_feedback', 'page_after_submit',
165                                                     0, $editoroptions,
166                                                     $feedback->page_after_submit_editor['text']);
168         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
169     }
170     $DB->update_record('feedback', $feedback);
172     return true;
175 /**
176  * Serves the files included in feedback items like label. Implements needed access control ;-)
177  *
178  * There are two situations in general where the files will be sent.
179  * 1) filearea = item, 2) filearea = template
180  *
181  * @package  mod_feedback
182  * @category files
183  * @param stdClass $course course object
184  * @param stdClass $cm course module object
185  * @param stdClass $context context object
186  * @param string $filearea file area
187  * @param array $args extra arguments
188  * @param bool $forcedownload whether or not force download
189  * @param array $options additional options affecting the file serving
190  * @return bool false if file not found, does not return if found - justsend the file
191  */
192 function feedback_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
193     global $CFG, $DB;
195     if ($filearea === 'item' or $filearea === 'template') {
196         $itemid = (int)array_shift($args);
197         //get the item what includes the file
198         if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
199             return false;
200         }
201         $feedbackid = $item->feedback;
202         $templateid = $item->template;
203     }
205     if ($filearea === 'page_after_submit' or $filearea === 'item') {
206         if (! $feedback = $DB->get_record("feedback", array("id"=>$cm->instance))) {
207             return false;
208         }
210         $feedbackid = $feedback->id;
212         //if the filearea is "item" so we check the permissions like view/complete the feedback
213         $canload = false;
214         //first check whether the user has the complete capability
215         if (has_capability('mod/feedback:complete', $context)) {
216             $canload = true;
217         }
219         //now we check whether the user has the view capability
220         if (has_capability('mod/feedback:view', $context)) {
221             $canload = true;
222         }
224         //if the feedback is on frontpage and anonymous and the fullanonymous is allowed
225         //so the file can be loaded too.
226         if (isset($CFG->feedback_allowfullanonymous)
227                     AND $CFG->feedback_allowfullanonymous
228                     AND $course->id == SITEID
229                     AND $feedback->anonymous == FEEDBACK_ANONYMOUS_YES ) {
230             $canload = true;
231         }
233         if (!$canload) {
234             return false;
235         }
236     } else if ($filearea === 'template') { //now we check files in templates
237         if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
238             return false;
239         }
241         //if the file is not public so the capability edititems has to be there
242         if (!$template->ispublic) {
243             if (!has_capability('mod/feedback:edititems', $context)) {
244                 return false;
245             }
246         } else { //on public templates, at least the user has to be logged in
247             if (!isloggedin()) {
248                 return false;
249             }
250         }
251     } else {
252         return false;
253     }
255     if ($context->contextlevel == CONTEXT_MODULE) {
256         if ($filearea !== 'item' and $filearea !== 'page_after_submit') {
257             return false;
258         }
259     }
261     if ($context->contextlevel == CONTEXT_COURSE || $context->contextlevel == CONTEXT_SYSTEM) {
262         if ($filearea !== 'template') {
263             return false;
264         }
265     }
267     $relativepath = implode('/', $args);
268     if ($filearea === 'page_after_submit') {
269         $fullpath = "/{$context->id}/mod_feedback/$filearea/$relativepath";
270     } else {
271         $fullpath = "/{$context->id}/mod_feedback/$filearea/{$item->id}/$relativepath";
272     }
274     $fs = get_file_storage();
276     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
277         return false;
278     }
280     // finally send the file
281     send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
283     return false;
286 /**
287  * this will delete a given instance.
288  * all referenced data also will be deleted
289  *
290  * @global object
291  * @param int $id the instanceid of feedback
292  * @return boolean
293  */
294 function feedback_delete_instance($id) {
295     global $DB;
297     //get all referenced items
298     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
300     //deleting all referenced items and values
301     if (is_array($feedbackitems)) {
302         foreach ($feedbackitems as $feedbackitem) {
303             $DB->delete_records("feedback_value", array("item"=>$feedbackitem->id));
304             $DB->delete_records("feedback_valuetmp", array("item"=>$feedbackitem->id));
305         }
306         if ($delitems = $DB->get_records("feedback_item", array("feedback"=>$id))) {
307             foreach ($delitems as $delitem) {
308                 feedback_delete_item($delitem->id, false);
309             }
310         }
311     }
313     //deleting the completeds
314     $DB->delete_records("feedback_completed", array("feedback"=>$id));
316     //deleting the unfinished completeds
317     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
319     //deleting old events
320     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
321     return $DB->delete_records("feedback", array("id"=>$id));
324 /**
325  * Return a small object with summary information about what a
326  * user has done with a given particular instance of this module
327  * Used for user activity reports.
328  * $return->time = the time they did it
329  * $return->info = a short text description
330  *
331  * @param stdClass $course
332  * @param stdClass $user
333  * @param cm_info|stdClass $mod
334  * @param stdClass $feedback
335  * @return stdClass
336  */
337 function feedback_user_outline($course, $user, $mod, $feedback) {
338     global $DB;
339     $outline = (object)['info' => '', 'time' => 0];
340     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
341         // Do not disclose any user info if feedback is anonymous.
342         return $outline;
343     }
344     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
345         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
346     $status = null;
347     $context = context_module::instance($mod->id);
348     if ($completed = $DB->get_record('feedback_completed', $params)) {
349         // User has completed feedback.
350         $outline->info = get_string('completed', 'feedback');
351         $outline->time = $completed->timemodified;
352     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
353         // User has started but not completed feedback.
354         $outline->info = get_string('started', 'feedback');
355         $outline->time = $completedtmp->timemodified;
356     } else if (has_capability('mod/feedback:complete', $context, $user)) {
357         // User has not started feedback but has capability to do so.
358         $outline->info = get_string('not_started', 'feedback');
359     }
361     return $outline;
364 /**
365  * Returns all users who has completed a specified feedback since a given time
366  * many thanks to Manolescu Dorel, who contributed these two functions
367  *
368  * @global object
369  * @global object
370  * @global object
371  * @global object
372  * @uses CONTEXT_MODULE
373  * @param array $activities Passed by reference
374  * @param int $index Passed by reference
375  * @param int $timemodified Timestamp
376  * @param int $courseid
377  * @param int $cmid
378  * @param int $userid
379  * @param int $groupid
380  * @return void
381  */
382 function feedback_get_recent_mod_activity(&$activities, &$index,
383                                           $timemodified, $courseid,
384                                           $cmid, $userid="", $groupid="") {
386     global $CFG, $COURSE, $USER, $DB;
388     if ($COURSE->id == $courseid) {
389         $course = $COURSE;
390     } else {
391         $course = $DB->get_record('course', array('id'=>$courseid));
392     }
394     $modinfo = get_fast_modinfo($course);
396     $cm = $modinfo->cms[$cmid];
398     $sqlargs = array();
400     $userfields = user_picture::fields('u', null, 'useridagain');
401     $sql = " SELECT fk . * , fc . * , $userfields
402                 FROM {feedback_completed} fc
403                     JOIN {feedback} fk ON fk.id = fc.feedback
404                     JOIN {user} u ON u.id = fc.userid ";
406     if ($groupid) {
407         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
408     }
410     $sql .= " WHERE fc.timemodified > ?
411                 AND fk.id = ?
412                 AND fc.anonymous_response = ?";
413     $sqlargs[] = $timemodified;
414     $sqlargs[] = $cm->instance;
415     $sqlargs[] = FEEDBACK_ANONYMOUS_NO;
417     if ($userid) {
418         $sql .= " AND u.id = ? ";
419         $sqlargs[] = $userid;
420     }
422     if ($groupid) {
423         $sql .= " AND gm.groupid = ? ";
424         $sqlargs[] = $groupid;
425     }
427     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
428         return;
429     }
431     $cm_context = context_module::instance($cm->id);
433     if (!has_capability('mod/feedback:view', $cm_context)) {
434         return;
435     }
437     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
438     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cm_context);
439     $groupmode       = groups_get_activity_groupmode($cm, $course);
441     $aname = format_string($cm->name, true);
442     foreach ($feedbackitems as $feedbackitem) {
443         if ($feedbackitem->userid != $USER->id) {
445             if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
446                 $usersgroups = groups_get_all_groups($course->id,
447                                                      $feedbackitem->userid,
448                                                      $cm->groupingid);
449                 if (!is_array($usersgroups)) {
450                     continue;
451                 }
452                 $usersgroups = array_keys($usersgroups);
453                 $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
454                 if (empty($intersect)) {
455                     continue;
456                 }
457             }
458         }
460         $tmpactivity = new stdClass();
462         $tmpactivity->type      = 'feedback';
463         $tmpactivity->cmid      = $cm->id;
464         $tmpactivity->name      = $aname;
465         $tmpactivity->sectionnum= $cm->sectionnum;
466         $tmpactivity->timestamp = $feedbackitem->timemodified;
468         $tmpactivity->content = new stdClass();
469         $tmpactivity->content->feedbackid = $feedbackitem->id;
470         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
472         $tmpactivity->user = user_picture::unalias($feedbackitem, null, 'useridagain');
473         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
475         $activities[$index++] = $tmpactivity;
476     }
478     return;
481 /**
482  * Prints all users who has completed a specified feedback since a given time
483  * many thanks to Manolescu Dorel, who contributed these two functions
484  *
485  * @global object
486  * @param object $activity
487  * @param int $courseid
488  * @param string $detail
489  * @param array $modnames
490  * @return void Output is echo'd
491  */
492 function feedback_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
493     global $CFG, $OUTPUT;
495     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
497     echo "<tr><td class=\"userpicture\" valign=\"top\">";
498     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
499     echo "</td><td>";
501     if ($detail) {
502         $modname = $modnames[$activity->type];
503         echo '<div class="title">';
504         echo $OUTPUT->image_icon('icon', $modname, $activity->type);
505         echo "<a href=\"$CFG->wwwroot/mod/feedback/view.php?id={$activity->cmid}\">{$activity->name}</a>";
506         echo '</div>';
507     }
509     echo '<div class="title">';
510     echo '</div>';
512     echo '<div class="user">';
513     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&amp;course=$courseid\">"
514          ."{$activity->user->fullname}</a> - ".userdate($activity->timestamp);
515     echo '</div>';
517     echo "</td></tr></table>";
519     return;
522 /**
523  * Obtains the automatic completion state for this feedback based on the condition
524  * in feedback settings.
525  *
526  * @param object $course Course
527  * @param object $cm Course-module
528  * @param int $userid User ID
529  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
530  * @return bool True if completed, false if not, $type if conditions not set.
531  */
532 function feedback_get_completion_state($course, $cm, $userid, $type) {
533     global $CFG, $DB;
535     // Get feedback details
536     $feedback = $DB->get_record('feedback', array('id'=>$cm->instance), '*', MUST_EXIST);
538     // If completion option is enabled, evaluate it and return true/false
539     if ($feedback->completionsubmit) {
540         $params = array('userid'=>$userid, 'feedback'=>$feedback->id);
541         return $DB->record_exists('feedback_completed', $params);
542     } else {
543         // Completion option is not enabled so just return $type
544         return $type;
545     }
548 /**
549  * Print a detailed representation of what a  user has done with
550  * a given particular instance of this module, for user activity reports.
551  *
552  * @param stdClass $course
553  * @param stdClass $user
554  * @param cm_info|stdClass $mod
555  * @param stdClass $feedback
556  */
557 function feedback_user_complete($course, $user, $mod, $feedback) {
558     global $DB;
559     if ($feedback->anonymous != FEEDBACK_ANONYMOUS_NO) {
560         // Do not disclose any user info if feedback is anonymous.
561         return;
562     }
563     $params = array('userid' => $user->id, 'feedback' => $feedback->id,
564         'anonymous_response' => FEEDBACK_ANONYMOUS_NO);
565     $url = $status = null;
566     $context = context_module::instance($mod->id);
567     if ($completed = $DB->get_record('feedback_completed', $params)) {
568         // User has completed feedback.
569         if (has_capability('mod/feedback:viewreports', $context)) {
570             $url = new moodle_url('/mod/feedback/show_entries.php',
571                 ['id' => $mod->id, 'userid' => $user->id,
572                     'showcompleted' => $completed->id]);
573         }
574         $status = get_string('completedon', 'feedback', userdate($completed->timemodified));
575     } else if ($completedtmp = $DB->get_record('feedback_completedtmp', $params)) {
576         // User has started but not completed feedback.
577         $status = get_string('startedon', 'feedback', userdate($completedtmp->timemodified));
578     } else if (has_capability('mod/feedback:complete', $context, $user)) {
579         // User has not started feedback but has capability to do so.
580         $status = get_string('not_started', 'feedback');
581     }
583     if ($url && $status) {
584         echo html_writer::link($url, $status);
585     } else if ($status) {
586         echo html_writer::div($status);
587     }
590 /**
591  * @return bool true
592  */
593 function feedback_cron () {
594     return true;
597 /**
598  * @return bool false
599  */
600 function feedback_scale_used ($feedbackid, $scaleid) {
601     return false;
604 /**
605  * Checks if scale is being used by any instance of feedback
606  *
607  * This is used to find out if scale used anywhere
608  * @param $scaleid int
609  * @return boolean True if the scale is used by any assignment
610  */
611 function feedback_scale_used_anywhere($scaleid) {
612     return false;
615 /**
616  * List the actions that correspond to a view of this module.
617  * This is used by the participation report.
618  *
619  * Note: This is not used by new logging system. Event with
620  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
621  *       be considered as view action.
622  *
623  * @return array
624  */
625 function feedback_get_view_actions() {
626     return array('view', 'view all');
629 /**
630  * List the actions that correspond to a post of this module.
631  * This is used by the participation report.
632  *
633  * Note: This is not used by new logging system. Event with
634  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
635  *       will be considered as post action.
636  *
637  * @return array
638  */
639 function feedback_get_post_actions() {
640     return array('submit');
643 /**
644  * This function is used by the reset_course_userdata function in moodlelib.
645  * This function will remove all responses from the specified feedback
646  * and clean up any related data.
647  *
648  * @global object
649  * @global object
650  * @uses FEEDBACK_RESETFORM_RESET
651  * @uses FEEDBACK_RESETFORM_DROP
652  * @param object $data the data submitted from the reset course.
653  * @return array status array
654  */
655 function feedback_reset_userdata($data) {
656     global $CFG, $DB;
658     $resetfeedbacks = array();
659     $dropfeedbacks = array();
660     $status = array();
661     $componentstr = get_string('modulenameplural', 'feedback');
663     //get the relevant entries from $data
664     foreach ($data as $key => $value) {
665         switch(true) {
666             case substr($key, 0, strlen(FEEDBACK_RESETFORM_RESET)) == FEEDBACK_RESETFORM_RESET:
667                 if ($value == 1) {
668                     $templist = explode('_', $key);
669                     if (isset($templist[3])) {
670                         $resetfeedbacks[] = intval($templist[3]);
671                     }
672                 }
673             break;
674             case substr($key, 0, strlen(FEEDBACK_RESETFORM_DROP)) == FEEDBACK_RESETFORM_DROP:
675                 if ($value == 1) {
676                     $templist = explode('_', $key);
677                     if (isset($templist[3])) {
678                         $dropfeedbacks[] = intval($templist[3]);
679                     }
680                 }
681             break;
682         }
683     }
685     //reset the selected feedbacks
686     foreach ($resetfeedbacks as $id) {
687         $feedback = $DB->get_record('feedback', array('id'=>$id));
688         feedback_delete_all_completeds($feedback);
689         $status[] = array('component'=>$componentstr.':'.$feedback->name,
690                         'item'=>get_string('resetting_data', 'feedback'),
691                         'error'=>false);
692     }
694     // Updating dates - shift may be negative too.
695     if ($data->timeshift) {
696         // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
697         // See MDL-9367.
698         $shifterror = !shift_course_mod_dates('feedback', array('timeopen', 'timeclose'), $data->timeshift, $data->courseid);
699         $status[] = array('component' => $componentstr, 'item' => get_string('datechanged'), 'error' => $shifterror);
700     }
702     return $status;
705 /**
706  * Called by course/reset.php
707  *
708  * @global object
709  * @uses FEEDBACK_RESETFORM_RESET
710  * @param object $mform form passed by reference
711  */
712 function feedback_reset_course_form_definition(&$mform) {
713     global $COURSE, $DB;
715     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
717     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')) {
718         return;
719     }
721     $mform->addElement('static', 'hint', get_string('resetting_data', 'feedback'));
722     foreach ($feedbacks as $feedback) {
723         $mform->addElement('checkbox', FEEDBACK_RESETFORM_RESET.$feedback->id, $feedback->name);
724     }
727 /**
728  * Course reset form defaults.
729  *
730  * @global object
731  * @uses FEEDBACK_RESETFORM_RESET
732  * @param object $course
733  */
734 function feedback_reset_course_form_defaults($course) {
735     global $DB;
737     $return = array();
738     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
739         return;
740     }
741     foreach ($feedbacks as $feedback) {
742         $return[FEEDBACK_RESETFORM_RESET.$feedback->id] = true;
743     }
744     return $return;
747 /**
748  * Called by course/reset.php and shows the formdata by coursereset.
749  * it prints checkboxes for each feedback available at the given course
750  * there are two checkboxes:
751  * 1) delete userdata and keep the feedback
752  * 2) delete userdata and drop the feedback
753  *
754  * @global object
755  * @uses FEEDBACK_RESETFORM_RESET
756  * @uses FEEDBACK_RESETFORM_DROP
757  * @param object $course
758  * @return void
759  */
760 function feedback_reset_course_form($course) {
761     global $DB, $OUTPUT;
763     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
764     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
765         return;
766     }
768     foreach ($feedbacks as $feedback) {
769         echo '<p>';
770         echo get_string('name', 'feedback').': '.$feedback->name.'<br />';
771         echo html_writer::checkbox(FEEDBACK_RESETFORM_RESET.$feedback->id,
772                                 1, true,
773                                 get_string('resetting_data', 'feedback'));
774         echo '<br />';
775         echo html_writer::checkbox(FEEDBACK_RESETFORM_DROP.$feedback->id,
776                                 1, false,
777                                 get_string('drop_feedback', 'feedback'));
778         echo '</p>';
779     }
782 /**
783  * This gets an array with default options for the editor
784  *
785  * @return array the options
786  */
787 function feedback_get_editor_options() {
788     return array('maxfiles' => EDITOR_UNLIMITED_FILES,
789                 'trusttext'=>true);
792 /**
793  * This creates new events given as timeopen and closeopen by $feedback.
794  *
795  * @global object
796  * @param object $feedback
797  * @return void
798  */
799 function feedback_set_events($feedback) {
800     global $DB, $CFG;
802     // Include calendar/lib.php.
803     require_once($CFG->dirroot.'/calendar/lib.php');
805     // Get CMID if not sent as part of $feedback.
806     if (!isset($feedback->coursemodule)) {
807         $cm = get_coursemodule_from_instance('feedback', $feedback->id, $feedback->course);
808         $feedback->coursemodule = $cm->id;
809     }
811     // Feedback start calendar events.
812     $eventid = $DB->get_field('event', 'id',
813             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => FEEDBACK_EVENT_TYPE_OPEN));
815     if (isset($feedback->timeopen) && $feedback->timeopen > 0) {
816         $event = new stdClass();
817         $event->eventtype    = FEEDBACK_EVENT_TYPE_OPEN;
818         $event->type         = empty($feedback->timeclose) ? CALENDAR_EVENT_TYPE_ACTION : CALENDAR_EVENT_TYPE_STANDARD;
819         $event->name         = get_string('calendarstart', 'feedback', $feedback->name);
820         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
821         $event->timestart    = $feedback->timeopen;
822         $event->timesort     = $feedback->timeopen;
823         $event->visible      = instance_is_visible('feedback', $feedback);
824         $event->timeduration = 0;
825         if ($eventid) {
826             // Calendar event exists so update it.
827             $event->id = $eventid;
828             $calendarevent = calendar_event::load($event->id);
829             $calendarevent->update($event);
830         } else {
831             // Event doesn't exist so create one.
832             $event->courseid     = $feedback->course;
833             $event->groupid      = 0;
834             $event->userid       = 0;
835             $event->modulename   = 'feedback';
836             $event->instance     = $feedback->id;
837             $event->eventtype    = FEEDBACK_EVENT_TYPE_OPEN;
838             calendar_event::create($event);
839         }
840     } else if ($eventid) {
841         // Calendar event is on longer needed.
842         $calendarevent = calendar_event::load($eventid);
843         $calendarevent->delete();
844     }
846     // Feedback close calendar events.
847     $eventid = $DB->get_field('event', 'id',
848             array('modulename' => 'feedback', 'instance' => $feedback->id, 'eventtype' => FEEDBACK_EVENT_TYPE_CLOSE));
850     if (isset($feedback->timeclose) && $feedback->timeclose > 0) {
851         $event = new stdClass();
852         $event->type         = CALENDAR_EVENT_TYPE_ACTION;
853         $event->eventtype    = FEEDBACK_EVENT_TYPE_CLOSE;
854         $event->name         = get_string('calendarend', 'feedback', $feedback->name);
855         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
856         $event->timestart    = $feedback->timeclose;
857         $event->timesort     = $feedback->timeclose;
858         $event->visible      = instance_is_visible('feedback', $feedback);
859         $event->timeduration = 0;
860         if ($eventid) {
861             // Calendar event exists so update it.
862             $event->id = $eventid;
863             $calendarevent = calendar_event::load($event->id);
864             $calendarevent->update($event);
865         } else {
866             // Event doesn't exist so create one.
867             $event->courseid     = $feedback->course;
868             $event->groupid      = 0;
869             $event->userid       = 0;
870             $event->modulename   = 'feedback';
871             $event->instance     = $feedback->id;
872             calendar_event::create($event);
873         }
874     } else if ($eventid) {
875         // Calendar event is on longer needed.
876         $calendarevent = calendar_event::load($eventid);
877         $calendarevent->delete();
878     }
881 /**
882  * This standard function will check all instances of this module
883  * and make sure there are up-to-date events created for each of them.
884  * If courseid = 0, then every feedback event in the site is checked, else
885  * only feedback events belonging to the course specified are checked.
886  * This function is used, in its new format, by restore_refresh_events()
887  *
888  * @param int $courseid
889  * @param int|stdClass $instance Feedback module instance or ID.
890  * @param int|stdClass $cm Course module object or ID (not used in this module).
891  * @return bool
892  */
893 function feedback_refresh_events($courseid = 0, $instance = null, $cm = null) {
894     global $DB;
896     // If we have instance information then we can just update the one event instead of updating all events.
897     if (isset($instance)) {
898         if (!is_object($instance)) {
899             $instance = $DB->get_record('feedback', array('id' => $instance), '*', MUST_EXIST);
900         }
901         feedback_set_events($instance);
902         return true;
903     }
905     if ($courseid) {
906         if (! $feedbacks = $DB->get_records("feedback", array("course" => $courseid))) {
907             return true;
908         }
909     } else {
910         if (! $feedbacks = $DB->get_records("feedback")) {
911             return true;
912         }
913     }
915     foreach ($feedbacks as $feedback) {
916         feedback_set_events($feedback);
917     }
918     return true;
921 /**
922  * this function is called by {@link feedback_delete_userdata()}
923  * it drops the feedback-instance from the course_module table
924  *
925  * @global object
926  * @param int $id the id from the coursemodule
927  * @return boolean
928  */
929 function feedback_delete_course_module($id) {
930     global $DB;
932     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
933         return true;
934     }
935     return $DB->delete_records('course_modules', array('id'=>$cm->id));
940 ////////////////////////////////////////////////
941 //functions to handle capabilities
942 ////////////////////////////////////////////////
944 /**
945  * @deprecated since 3.1
946  */
947 function feedback_get_context() {
948     throw new coding_exception('feedback_get_context() can not be used anymore.');
951 /**
952  *  returns true if the current role is faked by switching role feature
953  *
954  * @global object
955  * @return boolean
956  */
957 function feedback_check_is_switchrole() {
958     global $USER;
959     if (isset($USER->switchrole) AND
960             is_array($USER->switchrole) AND
961             count($USER->switchrole) > 0) {
963         return true;
964     }
965     return false;
968 /**
969  * count users which have not completed the feedback
970  *
971  * @global object
972  * @uses CONTEXT_MODULE
973  * @param cm_info $cm Course-module object
974  * @param int $group single groupid
975  * @param string $sort
976  * @param int $startpage
977  * @param int $pagecount
978  * @param bool $includestatus to return if the user started or not the feedback among the complete user record
979  * @return array array of user ids or user objects when $includestatus set to true
980  */
981 function feedback_get_incomplete_users(cm_info $cm,
982                                        $group = false,
983                                        $sort = '',
984                                        $startpage = false,
985                                        $pagecount = false,
986                                        $includestatus = false) {
988     global $DB;
990     $context = context_module::instance($cm->id);
992     //first get all user who can complete this feedback
993     $cap = 'mod/feedback:complete';
994     $allnames = get_all_user_name_fields(true, 'u');
995     $fields = 'u.id, ' . $allnames . ', u.picture, u.email, u.imagealt';
996     if (!$allusers = get_users_by_capability($context,
997                                             $cap,
998                                             $fields,
999                                             $sort,
1000                                             '',
1001                                             '',
1002                                             $group,
1003                                             '',
1004                                             true)) {
1005         return false;
1006     }
1007     // Filter users that are not in the correct group/grouping.
1008     $info = new \core_availability\info_module($cm);
1009     $allusersrecords = $info->filter_user_list($allusers);
1011     $allusers = array_keys($allusersrecords);
1013     //now get all completeds
1014     $params = array('feedback'=>$cm->instance);
1015     if ($completedusers = $DB->get_records_menu('feedback_completed', $params, '', 'id, userid')) {
1016         // Now strike all completedusers from allusers.
1017         $allusers = array_diff($allusers, $completedusers);
1018     }
1020     //for paging I use array_slice()
1021     if ($startpage !== false AND $pagecount !== false) {
1022         $allusers = array_slice($allusers, $startpage, $pagecount);
1023     }
1025     // Check if we should return the full users objects.
1026     if ($includestatus) {
1027         $userrecords = [];
1028         $startedusers = $DB->get_records_menu('feedback_completedtmp', ['feedback' => $cm->instance], '', 'id, userid');
1029         $startedusers = array_flip($startedusers);
1030         foreach ($allusers as $userid) {
1031             $allusersrecords[$userid]->feedbackstarted = isset($startedusers[$userid]);
1032             $userrecords[] = $allusersrecords[$userid];
1033         }
1034         return $userrecords;
1035     } else {    // Return just user ids.
1036         return $allusers;
1037     }
1040 /**
1041  * count users which have not completed the feedback
1042  *
1043  * @global object
1044  * @param object $cm
1045  * @param int $group single groupid
1046  * @return int count of userrecords
1047  */
1048 function feedback_count_incomplete_users($cm, $group = false) {
1049     if ($allusers = feedback_get_incomplete_users($cm, $group)) {
1050         return count($allusers);
1051     }
1052     return 0;
1055 /**
1056  * count users which have completed a feedback
1057  *
1058  * @global object
1059  * @uses FEEDBACK_ANONYMOUS_NO
1060  * @param object $cm
1061  * @param int $group single groupid
1062  * @return int count of userrecords
1063  */
1064 function feedback_count_complete_users($cm, $group = false) {
1065     global $DB;
1067     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
1069     $fromgroup = '';
1070     $wheregroup = '';
1071     if ($group) {
1072         $fromgroup = ', {groups_members} g';
1073         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
1074         $params[] = $group;
1075     }
1077     $sql = 'SELECT COUNT(u.id) FROM {user} u, {feedback_completed} c'.$fromgroup.'
1078               WHERE anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
1079               '.$wheregroup;
1081     return $DB->count_records_sql($sql, $params);
1085 /**
1086  * get users which have completed a feedback
1087  *
1088  * @global object
1089  * @uses CONTEXT_MODULE
1090  * @uses FEEDBACK_ANONYMOUS_NO
1091  * @param object $cm
1092  * @param int $group single groupid
1093  * @param string $where a sql where condition (must end with " AND ")
1094  * @param array parameters used in $where
1095  * @param string $sort a table field
1096  * @param int $startpage
1097  * @param int $pagecount
1098  * @return object the userrecords
1099  */
1100 function feedback_get_complete_users($cm,
1101                                      $group = false,
1102                                      $where = '',
1103                                      array $params = null,
1104                                      $sort = '',
1105                                      $startpage = false,
1106                                      $pagecount = false) {
1108     global $DB;
1110     $context = context_module::instance($cm->id);
1112     $params = (array)$params;
1114     $params['anon'] = FEEDBACK_ANONYMOUS_NO;
1115     $params['instance'] = $cm->instance;
1117     $fromgroup = '';
1118     $wheregroup = '';
1119     if ($group) {
1120         $fromgroup = ', {groups_members} g';
1121         $wheregroup = ' AND g.groupid = :group AND g.userid = c.userid';
1122         $params['group'] = $group;
1123     }
1125     if ($sort) {
1126         $sortsql = ' ORDER BY '.$sort;
1127     } else {
1128         $sortsql = '';
1129     }
1131     $ufields = user_picture::fields('u');
1132     $sql = 'SELECT DISTINCT '.$ufields.', c.timemodified as completed_timemodified
1133             FROM {user} u, {feedback_completed} c '.$fromgroup.'
1134             WHERE '.$where.' anonymous_response = :anon
1135                 AND u.id = c.userid
1136                 AND c.feedback = :instance
1137               '.$wheregroup.$sortsql;
1139     if ($startpage === false OR $pagecount === false) {
1140         $startpage = false;
1141         $pagecount = false;
1142     }
1143     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
1146 /**
1147  * get users which have the viewreports-capability
1148  *
1149  * @uses CONTEXT_MODULE
1150  * @param int $cmid
1151  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1152  * @return object the userrecords
1153  */
1154 function feedback_get_viewreports_users($cmid, $groups = false) {
1156     $context = context_module::instance($cmid);
1158     //description of the call below:
1159     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1160     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1161     return get_users_by_capability($context,
1162                             'mod/feedback:viewreports',
1163                             '',
1164                             'lastname',
1165                             '',
1166                             '',
1167                             $groups,
1168                             '',
1169                             false);
1172 /**
1173  * get users which have the receivemail-capability
1174  *
1175  * @uses CONTEXT_MODULE
1176  * @param int $cmid
1177  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1178  * @return object the userrecords
1179  */
1180 function feedback_get_receivemail_users($cmid, $groups = false) {
1182     $context = context_module::instance($cmid);
1184     //description of the call below:
1185     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1186     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1187     return get_users_by_capability($context,
1188                             'mod/feedback:receivemail',
1189                             '',
1190                             'lastname',
1191                             '',
1192                             '',
1193                             $groups,
1194                             '',
1195                             false);
1198 ////////////////////////////////////////////////
1199 //functions to handle the templates
1200 ////////////////////////////////////////////////
1201 ////////////////////////////////////////////////
1203 /**
1204  * creates a new template-record.
1205  *
1206  * @global object
1207  * @param int $courseid
1208  * @param string $name the name of template shown in the templatelist
1209  * @param int $ispublic 0:privat 1:public
1210  * @return int the new templateid
1211  */
1212 function feedback_create_template($courseid, $name, $ispublic = 0) {
1213     global $DB;
1215     $templ = new stdClass();
1216     $templ->course   = ($ispublic ? 0 : $courseid);
1217     $templ->name     = $name;
1218     $templ->ispublic = $ispublic;
1220     $templid = $DB->insert_record('feedback_template', $templ);
1221     return $DB->get_record('feedback_template', array('id'=>$templid));
1224 /**
1225  * creates new template items.
1226  * all items will be copied and the attribute feedback will be set to 0
1227  * and the attribute template will be set to the new templateid
1228  *
1229  * @global object
1230  * @uses CONTEXT_MODULE
1231  * @uses CONTEXT_COURSE
1232  * @param object $feedback
1233  * @param string $name the name of template shown in the templatelist
1234  * @param int $ispublic 0:privat 1:public
1235  * @return boolean
1236  */
1237 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
1238     global $DB;
1239     $fs = get_file_storage();
1241     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1242         return false;
1243     }
1245     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
1246         return false;
1247     }
1249     //files in the template_item are in the context of the current course or
1250     //if the template is public the files are in the system context
1251     //files in the feedback_item are in the feedback_context of the feedback
1252     if ($ispublic) {
1253         $s_context = context_system::instance();
1254     } else {
1255         $s_context = context_course::instance($newtempl->course);
1256     }
1257     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1258     $f_context = context_module::instance($cm->id);
1260     //create items of this new template
1261     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1262     //we also store a mapping of all items array(oldid => newid)
1263     $dependitemsmap = array();
1264     $itembackup = array();
1265     foreach ($feedbackitems as $item) {
1267         $t_item = clone($item);
1269         unset($t_item->id);
1270         $t_item->feedback = 0;
1271         $t_item->template     = $newtempl->id;
1272         $t_item->id = $DB->insert_record('feedback_item', $t_item);
1273         //copy all included files to the feedback_template filearea
1274         $itemfiles = $fs->get_area_files($f_context->id,
1275                                     'mod_feedback',
1276                                     'item',
1277                                     $item->id,
1278                                     "id",
1279                                     false);
1280         if ($itemfiles) {
1281             foreach ($itemfiles as $ifile) {
1282                 $file_record = new stdClass();
1283                 $file_record->contextid = $s_context->id;
1284                 $file_record->component = 'mod_feedback';
1285                 $file_record->filearea = 'template';
1286                 $file_record->itemid = $t_item->id;
1287                 $fs->create_file_from_storedfile($file_record, $ifile);
1288             }
1289         }
1291         $itembackup[$item->id] = $t_item->id;
1292         if ($t_item->dependitem) {
1293             $dependitemsmap[$t_item->id] = $t_item->dependitem;
1294         }
1296     }
1298     //remapping the dependency
1299     foreach ($dependitemsmap as $key => $dependitem) {
1300         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1301         $newitem->dependitem = $itembackup[$newitem->dependitem];
1302         $DB->update_record('feedback_item', $newitem);
1303     }
1305     return true;
1308 /**
1309  * deletes all feedback_items related to the given template id
1310  *
1311  * @global object
1312  * @uses CONTEXT_COURSE
1313  * @param object $template the template
1314  * @return void
1315  */
1316 function feedback_delete_template($template) {
1317     global $DB;
1319     //deleting the files from the item is done by feedback_delete_item
1320     if ($t_items = $DB->get_records("feedback_item", array("template"=>$template->id))) {
1321         foreach ($t_items as $t_item) {
1322             feedback_delete_item($t_item->id, false, $template);
1323         }
1324     }
1325     $DB->delete_records("feedback_template", array("id"=>$template->id));
1328 /**
1329  * creates new feedback_item-records from template.
1330  * if $deleteold is set true so the existing items of the given feedback will be deleted
1331  * if $deleteold is set false so the new items will be appanded to the old items
1332  *
1333  * @global object
1334  * @uses CONTEXT_COURSE
1335  * @uses CONTEXT_MODULE
1336  * @param object $feedback
1337  * @param int $templateid
1338  * @param boolean $deleteold
1339  */
1340 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1341     global $DB, $CFG;
1343     require_once($CFG->libdir.'/completionlib.php');
1345     $fs = get_file_storage();
1347     if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
1348         return false;
1349     }
1350     //get all templateitems
1351     if (!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1352         return false;
1353     }
1355     //files in the template_item are in the context of the current course
1356     //files in the feedback_item are in the feedback_context of the feedback
1357     if ($template->ispublic) {
1358         $s_context = context_system::instance();
1359     } else {
1360         $s_context = context_course::instance($feedback->course);
1361     }
1362     $course = $DB->get_record('course', array('id'=>$feedback->course));
1363     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1364     $f_context = context_module::instance($cm->id);
1366     //if deleteold then delete all old items before
1367     //get all items
1368     if ($deleteold) {
1369         if ($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1370             //delete all items of this feedback
1371             foreach ($feedbackitems as $item) {
1372                 feedback_delete_item($item->id, false);
1373             }
1375             $params = array('feedback'=>$feedback->id);
1376             if ($completeds = $DB->get_records('feedback_completed', $params)) {
1377                 $completion = new completion_info($course);
1378                 foreach ($completeds as $completed) {
1379                     $DB->delete_records('feedback_completed', array('id' => $completed->id));
1380                     // Update completion state
1381                     if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC &&
1382                             $feedback->completionsubmit) {
1383                         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1384                     }
1385                 }
1386             }
1387             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1388         }
1389         $positionoffset = 0;
1390     } else {
1391         //if the old items are kept the new items will be appended
1392         //therefor the new position has an offset
1393         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1394     }
1396     //create items of this new template
1397     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1398     //we also store a mapping of all items array(oldid => newid)
1399     $dependitemsmap = array();
1400     $itembackup = array();
1401     foreach ($templitems as $t_item) {
1402         $item = clone($t_item);
1403         unset($item->id);
1404         $item->feedback = $feedback->id;
1405         $item->template = 0;
1406         $item->position = $item->position + $positionoffset;
1408         $item->id = $DB->insert_record('feedback_item', $item);
1410         //moving the files to the new item
1411         $templatefiles = $fs->get_area_files($s_context->id,
1412                                         'mod_feedback',
1413                                         'template',
1414                                         $t_item->id,
1415                                         "id",
1416                                         false);
1417         if ($templatefiles) {
1418             foreach ($templatefiles as $tfile) {
1419                 $file_record = new stdClass();
1420                 $file_record->contextid = $f_context->id;
1421                 $file_record->component = 'mod_feedback';
1422                 $file_record->filearea = 'item';
1423                 $file_record->itemid = $item->id;
1424                 $fs->create_file_from_storedfile($file_record, $tfile);
1425             }
1426         }
1428         $itembackup[$t_item->id] = $item->id;
1429         if ($item->dependitem) {
1430             $dependitemsmap[$item->id] = $item->dependitem;
1431         }
1432     }
1434     //remapping the dependency
1435     foreach ($dependitemsmap as $key => $dependitem) {
1436         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1437         $newitem->dependitem = $itembackup[$newitem->dependitem];
1438         $DB->update_record('feedback_item', $newitem);
1439     }
1442 /**
1443  * get the list of available templates.
1444  * if the $onlyown param is set true so only templates from own course will be served
1445  * this is important for droping templates
1446  *
1447  * @global object
1448  * @param object $course
1449  * @param string $onlyownorpublic
1450  * @return array the template recordsets
1451  */
1452 function feedback_get_template_list($course, $onlyownorpublic = '') {
1453     global $DB, $CFG;
1455     switch($onlyownorpublic) {
1456         case '':
1457             $templates = $DB->get_records_select('feedback_template',
1458                                                  'course = ? OR ispublic = 1',
1459                                                  array($course->id),
1460                                                  'name');
1461             break;
1462         case 'own':
1463             $templates = $DB->get_records('feedback_template',
1464                                           array('course'=>$course->id),
1465                                           'name');
1466             break;
1467         case 'public':
1468             $templates = $DB->get_records('feedback_template', array('ispublic'=>1), 'name');
1469             break;
1470     }
1471     return $templates;
1474 ////////////////////////////////////////////////
1475 //Handling der Items
1476 ////////////////////////////////////////////////
1477 ////////////////////////////////////////////////
1479 /**
1480  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1481  *
1482  * @param string $typ
1483  * @return feedback_item_base the instance of itemclass
1484  */
1485 function feedback_get_item_class($typ) {
1486     global $CFG;
1488     //get the class of item-typ
1489     $itemclass = 'feedback_item_'.$typ;
1490     //get the instance of item-class
1491     if (!class_exists($itemclass)) {
1492         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1493     }
1494     return new $itemclass();
1497 /**
1498  * load the available item plugins from given subdirectory of $CFG->dirroot
1499  * the default is "mod/feedback/item"
1500  *
1501  * @global object
1502  * @param string $dir the subdir
1503  * @return array pluginnames as string
1504  */
1505 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1506     global $CFG;
1507     $names = get_list_of_plugins($dir);
1508     $ret_names = array();
1510     foreach ($names as $name) {
1511         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1512         if (class_exists('feedback_item_'.$name)) {
1513             $ret_names[] = $name;
1514         }
1515     }
1516     return $ret_names;
1519 /**
1520  * load the available item plugins to use as dropdown-options
1521  *
1522  * @global object
1523  * @return array pluginnames as string
1524  */
1525 function feedback_load_feedback_items_options() {
1526     global $CFG;
1528     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1530     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1531         return array();
1532     }
1534     foreach ($feedback_names as $fn) {
1535         $feedback_options[$fn] = get_string($fn, 'feedback');
1536     }
1537     asort($feedback_options);
1538     return $feedback_options;
1541 /**
1542  * load the available items for the depend item dropdown list shown in the edit_item form
1543  *
1544  * @global object
1545  * @param object $feedback
1546  * @param object $item the item of the edit_item form
1547  * @return array all items except the item $item, labels and pagebreaks
1548  */
1549 function feedback_get_depend_candidates_for_item($feedback, $item) {
1550     global $DB;
1551     //all items for dependitem
1552     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1553     $params = array($feedback->id);
1554     if (isset($item->id) AND $item->id) {
1555         $where .= ' AND id != ?';
1556         $params[] = $item->id;
1557     }
1558     $dependitems = array(0 => get_string('choose'));
1559     $feedbackitems = $DB->get_records_select_menu('feedback_item',
1560                                                   $where,
1561                                                   $params,
1562                                                   'position',
1563                                                   'id, label');
1565     if (!$feedbackitems) {
1566         return $dependitems;
1567     }
1568     //adding the choose-option
1569     foreach ($feedbackitems as $key => $val) {
1570         if (trim(strval($val)) !== '') {
1571             $dependitems[$key] = format_string($val);
1572         }
1573     }
1574     return $dependitems;
1577 /**
1578  * @deprecated since 3.1
1579  */
1580 function feedback_create_item() {
1581     throw new coding_exception('feedback_create_item() can not be used anymore.');
1584 /**
1585  * save the changes of a given item.
1586  *
1587  * @global object
1588  * @param object $item
1589  * @return boolean
1590  */
1591 function feedback_update_item($item) {
1592     global $DB;
1593     return $DB->update_record("feedback_item", $item);
1596 /**
1597  * deletes an item and also deletes all related values
1598  *
1599  * @global object
1600  * @uses CONTEXT_MODULE
1601  * @param int $itemid
1602  * @param boolean $renumber should the kept items renumbered Yes/No
1603  * @param object $template if the template is given so the items are bound to it
1604  * @return void
1605  */
1606 function feedback_delete_item($itemid, $renumber = true, $template = false) {
1607     global $DB;
1609     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1611     //deleting the files from the item
1612     $fs = get_file_storage();
1614     if ($template) {
1615         if ($template->ispublic) {
1616             $context = context_system::instance();
1617         } else {
1618             $context = context_course::instance($template->course);
1619         }
1620         $templatefiles = $fs->get_area_files($context->id,
1621                                     'mod_feedback',
1622                                     'template',
1623                                     $item->id,
1624                                     "id",
1625                                     false);
1627         if ($templatefiles) {
1628             $fs->delete_area_files($context->id, 'mod_feedback', 'template', $item->id);
1629         }
1630     } else {
1631         if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1632             return false;
1633         }
1634         $context = context_module::instance($cm->id);
1636         $itemfiles = $fs->get_area_files($context->id,
1637                                     'mod_feedback',
1638                                     'item',
1639                                     $item->id,
1640                                     "id", false);
1642         if ($itemfiles) {
1643             $fs->delete_area_files($context->id, 'mod_feedback', 'item', $item->id);
1644         }
1645     }
1647     $DB->delete_records("feedback_value", array("item"=>$itemid));
1648     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1650     //remove all depends
1651     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1652     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1654     $DB->delete_records("feedback_item", array("id"=>$itemid));
1655     if ($renumber) {
1656         feedback_renumber_items($item->feedback);
1657     }
1660 /**
1661  * deletes all items of the given feedbackid
1662  *
1663  * @global object
1664  * @param int $feedbackid
1665  * @return void
1666  */
1667 function feedback_delete_all_items($feedbackid) {
1668     global $DB, $CFG;
1669     require_once($CFG->libdir.'/completionlib.php');
1671     if (!$feedback = $DB->get_record('feedback', array('id'=>$feedbackid))) {
1672         return false;
1673     }
1675     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
1676         return false;
1677     }
1679     if (!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
1680         return false;
1681     }
1683     if (!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1684         return;
1685     }
1686     foreach ($items as $item) {
1687         feedback_delete_item($item->id, false);
1688     }
1689     if ($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1690         $completion = new completion_info($course);
1691         foreach ($completeds as $completed) {
1692             $DB->delete_records('feedback_completed', array('id' => $completed->id));
1693             // Update completion state
1694             if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC &&
1695                     $feedback->completionsubmit) {
1696                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1697             }
1698         }
1699     }
1701     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1705 /**
1706  * this function toggled the item-attribute required (yes/no)
1707  *
1708  * @global object
1709  * @param object $item
1710  * @return boolean
1711  */
1712 function feedback_switch_item_required($item) {
1713     global $DB, $CFG;
1715     $itemobj = feedback_get_item_class($item->typ);
1717     if ($itemobj->can_switch_require()) {
1718         $new_require_val = (int)!(bool)$item->required;
1719         $params = array('id'=>$item->id);
1720         $DB->set_field('feedback_item', 'required', $new_require_val, $params);
1721     }
1722     return true;
1725 /**
1726  * renumbers all items of the given feedbackid
1727  *
1728  * @global object
1729  * @param int $feedbackid
1730  * @return void
1731  */
1732 function feedback_renumber_items($feedbackid) {
1733     global $DB;
1735     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1736     $pos = 1;
1737     if ($items) {
1738         foreach ($items as $item) {
1739             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1740             $pos++;
1741         }
1742     }
1745 /**
1746  * this decreases the position of the given item
1747  *
1748  * @global object
1749  * @param object $item
1750  * @return bool
1751  */
1752 function feedback_moveup_item($item) {
1753     global $DB;
1755     if ($item->position == 1) {
1756         return true;
1757     }
1759     $params = array('feedback'=>$item->feedback);
1760     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1761         return false;
1762     }
1764     $itembefore = null;
1765     foreach ($items as $i) {
1766         if ($i->id == $item->id) {
1767             if (is_null($itembefore)) {
1768                 return true;
1769             }
1770             $itembefore->position = $item->position;
1771             $item->position--;
1772             feedback_update_item($itembefore);
1773             feedback_update_item($item);
1774             feedback_renumber_items($item->feedback);
1775             return true;
1776         }
1777         $itembefore = $i;
1778     }
1779     return false;
1782 /**
1783  * this increased the position of the given item
1784  *
1785  * @global object
1786  * @param object $item
1787  * @return bool
1788  */
1789 function feedback_movedown_item($item) {
1790     global $DB;
1792     $params = array('feedback'=>$item->feedback);
1793     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1794         return false;
1795     }
1797     $movedownitem = null;
1798     foreach ($items as $i) {
1799         if (!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1800             $movedownitem->position = $i->position;
1801             $i->position--;
1802             feedback_update_item($movedownitem);
1803             feedback_update_item($i);
1804             feedback_renumber_items($item->feedback);
1805             return true;
1806         }
1807         $movedownitem = $i;
1808     }
1809     return false;
1812 /**
1813  * here the position of the given item will be set to the value in $pos
1814  *
1815  * @global object
1816  * @param object $moveitem
1817  * @param int $pos
1818  * @return boolean
1819  */
1820 function feedback_move_item($moveitem, $pos) {
1821     global $DB;
1823     $params = array('feedback'=>$moveitem->feedback);
1824     if (!$allitems = $DB->get_records('feedback_item', $params, 'position')) {
1825         return false;
1826     }
1827     if (is_array($allitems)) {
1828         $index = 1;
1829         foreach ($allitems as $item) {
1830             if ($index == $pos) {
1831                 $index++;
1832             }
1833             if ($item->id == $moveitem->id) {
1834                 $moveitem->position = $pos;
1835                 feedback_update_item($moveitem);
1836                 continue;
1837             }
1838             $item->position = $index;
1839             feedback_update_item($item);
1840             $index++;
1841         }
1842         return true;
1843     }
1844     return false;
1847 /**
1848  * @deprecated since Moodle 3.1
1849  */
1850 function feedback_print_item_preview() {
1851     throw new coding_exception('feedback_print_item_preview() can not be used anymore. '
1852             . 'Items must implement complete_form_element().');
1855 /**
1856  * @deprecated since Moodle 3.1
1857  */
1858 function feedback_print_item_complete() {
1859     throw new coding_exception('feedback_print_item_complete() can not be used anymore. '
1860         . 'Items must implement complete_form_element().');
1863 /**
1864  * @deprecated since Moodle 3.1
1865  */
1866 function feedback_print_item_show_value() {
1867     throw new coding_exception('feedback_print_item_show_value() can not be used anymore. '
1868         . 'Items must implement complete_form_element().');
1871 /**
1872  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1873  * the values are not saved permanently until the user click on save button
1874  *
1875  * @global object
1876  * @param object $feedbackcompleted
1877  * @return object temporary saved completed-record
1878  */
1879 function feedback_set_tmp_values($feedbackcompleted) {
1880     global $DB;
1882     //first we create a completedtmp
1883     $tmpcpl = new stdClass();
1884     foreach ($feedbackcompleted as $key => $value) {
1885         $tmpcpl->{$key} = $value;
1886     }
1887     unset($tmpcpl->id);
1888     $tmpcpl->timemodified = time();
1889     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1890     //get all values of original-completed
1891     if (!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1892         return;
1893     }
1894     foreach ($values as $value) {
1895         unset($value->id);
1896         $value->completed = $tmpcpl->id;
1897         $DB->insert_record('feedback_valuetmp', $value);
1898     }
1899     return $tmpcpl;
1902 /**
1903  * this saves the temporary saved values permanently
1904  *
1905  * @global object
1906  * @param object $feedbackcompletedtmp the temporary completed
1907  * @param object $feedbackcompleted the target completed
1908  * @return int the id of the completed
1909  */
1910 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted) {
1911     global $DB;
1913     $tmpcplid = $feedbackcompletedtmp->id;
1914     if ($feedbackcompleted) {
1915         //first drop all existing values
1916         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1917         //update the current completed
1918         $feedbackcompleted->timemodified = time();
1919         $DB->update_record('feedback_completed', $feedbackcompleted);
1920     } else {
1921         $feedbackcompleted = clone($feedbackcompletedtmp);
1922         $feedbackcompleted->id = '';
1923         $feedbackcompleted->timemodified = time();
1924         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
1925     }
1927     $allitems = $DB->get_records('feedback_item', array('feedback' => $feedbackcompleted->feedback));
1929     //save all the new values from feedback_valuetmp
1930     //get all values of tmp-completed
1931     $params = array('completed'=>$feedbackcompletedtmp->id);
1932     $values = $DB->get_records('feedback_valuetmp', $params);
1933     foreach ($values as $value) {
1934         //check if there are depend items
1935         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
1936         if ($item->dependitem > 0 && isset($allitems[$item->dependitem])) {
1937             $check = feedback_compare_item_value($tmpcplid,
1938                                         $allitems[$item->dependitem],
1939                                         $item->dependvalue,
1940                                         true);
1941         } else {
1942             $check = true;
1943         }
1944         if ($check) {
1945             unset($value->id);
1946             $value->completed = $feedbackcompleted->id;
1947             $DB->insert_record('feedback_value', $value);
1948         }
1949     }
1950     //drop all the tmpvalues
1951     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1952     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1954     // Trigger event for the delete action we performed.
1955     $cm = get_coursemodule_from_instance('feedback', $feedbackcompleted->feedback);
1956     $event = \mod_feedback\event\response_submitted::create_from_record($feedbackcompleted, $cm);
1957     $event->trigger();
1958     return $feedbackcompleted->id;
1962 /**
1963  * @deprecated since Moodle 3.1
1964  */
1965 function feedback_delete_completedtmp() {
1966     throw new coding_exception('feedback_delete_completedtmp() can not be used anymore.');
1970 ////////////////////////////////////////////////
1971 ////////////////////////////////////////////////
1972 ////////////////////////////////////////////////
1973 //functions to handle the pagebreaks
1974 ////////////////////////////////////////////////
1976 /**
1977  * this creates a pagebreak.
1978  * a pagebreak is a special kind of item
1979  *
1980  * @global object
1981  * @param int $feedbackid
1982  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
1983  */
1984 function feedback_create_pagebreak($feedbackid) {
1985     global $DB;
1987     //check if there already is a pagebreak on the last position
1988     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
1989     if ($lastposition == feedback_get_last_break_position($feedbackid)) {
1990         return false;
1991     }
1993     $item = new stdClass();
1994     $item->feedback = $feedbackid;
1996     $item->template=0;
1998     $item->name = '';
2000     $item->presentation = '';
2001     $item->hasvalue = 0;
2003     $item->typ = 'pagebreak';
2004     $item->position = $lastposition + 1;
2006     $item->required=0;
2008     return $DB->insert_record('feedback_item', $item);
2011 /**
2012  * get all positions of pagebreaks in the given feedback
2013  *
2014  * @global object
2015  * @param int $feedbackid
2016  * @return array all ordered pagebreak positions
2017  */
2018 function feedback_get_all_break_positions($feedbackid) {
2019     global $DB;
2021     $params = array('typ'=>'pagebreak', 'feedback'=>$feedbackid);
2022     $allbreaks = $DB->get_records_menu('feedback_item', $params, 'position', 'id, position');
2023     if (!$allbreaks) {
2024         return false;
2025     }
2026     return array_values($allbreaks);
2029 /**
2030  * get the position of the last pagebreak
2031  *
2032  * @param int $feedbackid
2033  * @return int the position of the last pagebreak
2034  */
2035 function feedback_get_last_break_position($feedbackid) {
2036     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2037         return false;
2038     }
2039     return $allbreaks[count($allbreaks) - 1];
2042 /**
2043  * @deprecated since Moodle 3.1
2044  */
2045 function feedback_get_page_to_continue() {
2046     throw new coding_exception('feedback_get_page_to_continue() can not be used anymore.');
2049 ////////////////////////////////////////////////
2050 ////////////////////////////////////////////////
2051 ////////////////////////////////////////////////
2052 //functions to handle the values
2053 ////////////////////////////////////////////////
2055 /**
2056  * @deprecated since Moodle 3.1
2057  */
2058 function feedback_clean_input_value() {
2059     throw new coding_exception('feedback_clean_input_value() can not be used anymore. '
2060         . 'Items must implement complete_form_element().');
2064 /**
2065  * @deprecated since Moodle 3.1
2066  */
2067 function feedback_save_values() {
2068     throw new coding_exception('feedback_save_values() can not be used anymore.');
2071 /**
2072  * @deprecated since Moodle 3.1
2073  */
2074 function feedback_save_guest_values() {
2075     throw new coding_exception('feedback_save_guest_values() can not be used anymore.');
2078 /**
2079  * get the value from the given item related to the given completed.
2080  * the value can come as temporary or as permanently value. the deciding is done by $tmp
2081  *
2082  * @global object
2083  * @param int $completeid
2084  * @param int $itemid
2085  * @param boolean $tmp
2086  * @return mixed the value, the type depends on plugin-definition
2087  */
2088 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
2089     global $DB;
2091     $tmpstr = $tmp ? 'tmp' : '';
2092     $params = array('completed'=>$completedid, 'item'=>$itemid);
2093     return $DB->get_field('feedback_value'.$tmpstr, 'value', $params);
2096 /**
2097  * compares the value of the itemid related to the completedid with the dependvalue.
2098  * this is used if a depend item is set.
2099  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
2100  *
2101  * @param int $completedid
2102  * @param stdClass|int $item
2103  * @param mixed $dependvalue
2104  * @param bool $tmp
2105  * @return bool
2106  */
2107 function feedback_compare_item_value($completedid, $item, $dependvalue, $tmp = false) {
2108     global $DB;
2110     if (is_int($item)) {
2111         $item = $DB->get_record('feedback_item', array('id' => $item));
2112     }
2114     $dbvalue = feedback_get_item_value($completedid, $item->id, $tmp);
2116     $itemobj = feedback_get_item_class($item->typ);
2117     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
2120 /**
2121  * @deprecated since Moodle 3.1
2122  */
2123 function feedback_check_values() {
2124     throw new coding_exception('feedback_check_values() can not be used anymore. '
2125         . 'Items must implement complete_form_element().');
2128 /**
2129  * @deprecated since Moodle 3.1
2130  */
2131 function feedback_create_values() {
2132     throw new coding_exception('feedback_create_values() can not be used anymore.');
2135 /**
2136  * @deprecated since Moodle 3.1
2137  */
2138 function feedback_update_values() {
2139     throw new coding_exception('feedback_update_values() can not be used anymore.');
2142 /**
2143  * get the values of an item depending on the given groupid.
2144  * if the feedback is anonymous so the values are shuffled
2145  *
2146  * @global object
2147  * @global object
2148  * @param object $item
2149  * @param int $groupid
2150  * @param int $courseid
2151  * @param bool $ignore_empty if this is set true so empty values are not delivered
2152  * @return array the value-records
2153  */
2154 function feedback_get_group_values($item,
2155                                    $groupid = false,
2156                                    $courseid = false,
2157                                    $ignore_empty = false) {
2159     global $CFG, $DB;
2161     //if the groupid is given?
2162     if (intval($groupid) > 0) {
2163         $params = array();
2164         if ($ignore_empty) {
2165             $value = $DB->sql_compare_text('fbv.value');
2166             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2167             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2168         } else {
2169             $ignore_empty_select = "";
2170         }
2172         $query = 'SELECT fbv .  *
2173                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2174                    WHERE fbv.item = :itemid
2175                          AND fbv.completed = fbc.id
2176                          AND fbc.userid = gm.userid
2177                          '.$ignore_empty_select.'
2178                          AND gm.groupid = :groupid
2179                 ORDER BY fbc.timemodified';
2180         $params += array('itemid' => $item->id, 'groupid' => $groupid);
2181         $values = $DB->get_records_sql($query, $params);
2183     } else {
2184         $params = array();
2185         if ($ignore_empty) {
2186             $value = $DB->sql_compare_text('value');
2187             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2188             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2189         } else {
2190             $ignore_empty_select = "";
2191         }
2193         if ($courseid) {
2194             $select = "item = :itemid AND course_id = :courseid ".$ignore_empty_select;
2195             $params += array('itemid' => $item->id, 'courseid' => $courseid);
2196             $values = $DB->get_records_select('feedback_value', $select, $params);
2197         } else {
2198             $select = "item = :itemid ".$ignore_empty_select;
2199             $params += array('itemid' => $item->id);
2200             $values = $DB->get_records_select('feedback_value', $select, $params);
2201         }
2202     }
2203     $params = array('id'=>$item->feedback);
2204     if ($DB->get_field('feedback', 'anonymous', $params) == FEEDBACK_ANONYMOUS_YES) {
2205         if (is_array($values)) {
2206             shuffle($values);
2207         }
2208     }
2209     return $values;
2212 /**
2213  * check for multiple_submit = false.
2214  * if the feedback is global so the courseid must be given
2215  *
2216  * @global object
2217  * @global object
2218  * @param int $feedbackid
2219  * @param int $courseid
2220  * @return boolean true if the feedback already is submitted otherwise false
2221  */
2222 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2223     global $USER, $DB;
2225     if (!isloggedin() || isguestuser()) {
2226         return false;
2227     }
2229     $params = array('userid' => $USER->id, 'feedback' => $feedbackid);
2230     if ($courseid) {
2231         $params['courseid'] = $courseid;
2232     }
2233     return $DB->record_exists('feedback_completed', $params);
2236 /**
2237  * @deprecated since Moodle 3.1. Use feedback_get_current_completed_tmp() or feedback_get_last_completed.
2238  */
2239 function feedback_get_current_completed() {
2240     throw new coding_exception('feedback_get_current_completed() can not be used anymore. Please ' .
2241             'use either feedback_get_current_completed_tmp() or feedback_get_last_completed()');
2244 /**
2245  * get the completeds depending on the given groupid.
2246  *
2247  * @global object
2248  * @global object
2249  * @param object $feedback
2250  * @param int $groupid
2251  * @param int $courseid
2252  * @return mixed array of found completeds otherwise false
2253  */
2254 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2255     global $CFG, $DB;
2257     if (intval($groupid) > 0) {
2258         $query = "SELECT fbc.*
2259                     FROM {feedback_completed} fbc, {groups_members} gm
2260                    WHERE fbc.feedback = ?
2261                          AND gm.groupid = ?
2262                          AND fbc.userid = gm.userid";
2263         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2264             return $values;
2265         } else {
2266             return false;
2267         }
2268     } else {
2269         if ($courseid) {
2270             $query = "SELECT DISTINCT fbc.*
2271                         FROM {feedback_completed} fbc, {feedback_value} fbv
2272                         WHERE fbc.id = fbv.completed
2273                             AND fbc.feedback = ?
2274                             AND fbv.course_id = ?
2275                         ORDER BY random_response";
2276             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2277                 return $values;
2278             } else {
2279                 return false;
2280             }
2281         } else {
2282             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2283                 return $values;
2284             } else {
2285                 return false;
2286             }
2287         }
2288     }
2291 /**
2292  * get the count of completeds depending on the given groupid.
2293  *
2294  * @global object
2295  * @global object
2296  * @param object $feedback
2297  * @param int $groupid
2298  * @param int $courseid
2299  * @return mixed count of completeds or false
2300  */
2301 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2302     global $CFG, $DB;
2304     if ($courseid > 0 AND !$groupid <= 0) {
2305         $sql = "SELECT id, COUNT(item) AS ci
2306                   FROM {feedback_value}
2307                  WHERE course_id  = ?
2308               GROUP BY item ORDER BY ci DESC";
2309         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2310             $foundrecs = array_values($foundrecs);
2311             return $foundrecs[0]->ci;
2312         }
2313         return false;
2314     }
2315     if ($values = feedback_get_completeds_group($feedback, $groupid)) {
2316         return count($values);
2317     } else {
2318         return false;
2319     }
2322 /**
2323  * deletes all completed-recordsets from a feedback.
2324  * all related data such as values also will be deleted
2325  *
2326  * @param stdClass|int $feedback
2327  * @param stdClass|cm_info $cm
2328  * @param stdClass $course
2329  * @return void
2330  */
2331 function feedback_delete_all_completeds($feedback, $cm = null, $course = null) {
2332     global $DB;
2334     if (is_int($feedback)) {
2335         $feedback = $DB->get_record('feedback', array('id' => $feedback));
2336     }
2338     if (!$completeds = $DB->get_records('feedback_completed', array('feedback' => $feedback->id))) {
2339         return;
2340     }
2342     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2343         return false;
2344     }
2346     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2347         return false;
2348     }
2350     foreach ($completeds as $completed) {
2351         feedback_delete_completed($completed, $feedback, $cm, $course);
2352     }
2355 /**
2356  * deletes a completed given by completedid.
2357  * all related data such values or tracking data also will be deleted
2358  *
2359  * @param int|stdClass $completed
2360  * @param stdClass $feedback
2361  * @param stdClass|cm_info $cm
2362  * @param stdClass $course
2363  * @return boolean
2364  */
2365 function feedback_delete_completed($completed, $feedback = null, $cm = null, $course = null) {
2366     global $DB, $CFG;
2367     require_once($CFG->libdir.'/completionlib.php');
2369     if (!isset($completed->id)) {
2370         if (!$completed = $DB->get_record('feedback_completed', array('id' => $completed))) {
2371             return false;
2372         }
2373     }
2375     if (!$feedback && !($feedback = $DB->get_record('feedback', array('id' => $completed->feedback)))) {
2376         return false;
2377     }
2379     if (!$course && !($course = $DB->get_record('course', array('id' => $feedback->course)))) {
2380         return false;
2381     }
2383     if (!$cm && !($cm = get_coursemodule_from_instance('feedback', $feedback->id))) {
2384         return false;
2385     }
2387     //first we delete all related values
2388     $DB->delete_records('feedback_value', array('completed' => $completed->id));
2390     // Delete the completed record.
2391     $return = $DB->delete_records('feedback_completed', array('id' => $completed->id));
2393     // Update completion state
2394     $completion = new completion_info($course);
2395     if ($completion->is_enabled($cm) && $cm->completion == COMPLETION_TRACKING_AUTOMATIC && $feedback->completionsubmit) {
2396         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
2397     }
2398     // Trigger event for the delete action we performed.
2399     $event = \mod_feedback\event\response_deleted::create_from_record($completed, $cm, $feedback);
2400     $event->trigger();
2402     return $return;
2405 ////////////////////////////////////////////////
2406 ////////////////////////////////////////////////
2407 ////////////////////////////////////////////////
2408 //functions to handle sitecourse mapping
2409 ////////////////////////////////////////////////
2411 /**
2412  * @deprecated since 3.1
2413  */
2414 function feedback_is_course_in_sitecourse_map() {
2415     throw new coding_exception('feedback_is_course_in_sitecourse_map() can not be used anymore.');
2418 /**
2419  * @deprecated since 3.1
2420  */
2421 function feedback_is_feedback_in_sitecourse_map() {
2422     throw new coding_exception('feedback_is_feedback_in_sitecourse_map() can not be used anymore.');
2425 /**
2426  * gets the feedbacks from table feedback_sitecourse_map.
2427  * this is used to show the global feedbacks on the feedback block
2428  * all feedbacks with the following criteria will be selected:<br />
2429  *
2430  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2431  * 2) all feedbacks which not are listed in sitecoursemap
2432  *
2433  * @global object
2434  * @param int $courseid
2435  * @return array the feedback-records
2436  */
2437 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2438     global $DB;
2440     //first get all feedbacks listed in sitecourse_map with named courseid
2441     $sql = "SELECT f.id AS id,
2442                    cm.id AS cmid,
2443                    f.name AS name,
2444                    f.timeopen AS timeopen,
2445                    f.timeclose AS timeclose
2446             FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2447             WHERE f.id = cm.instance
2448                    AND f.course = '".SITEID."'
2449                    AND m.id = cm.module
2450                    AND m.name = 'feedback'
2451                    AND sm.courseid = ?
2452                    AND sm.feedbackid = f.id";
2454     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2455         $feedbacks1 = array();
2456     }
2458     //second get all feedbacks not listed in sitecourse_map
2459     $feedbacks2 = array();
2460     $sql = "SELECT f.id AS id,
2461                    cm.id AS cmid,
2462                    f.name AS name,
2463                    f.timeopen AS timeopen,
2464                    f.timeclose AS timeclose
2465             FROM {feedback} f, {course_modules} cm, {modules} m
2466             WHERE f.id = cm.instance
2467                    AND f.course = '".SITEID."'
2468                    AND m.id = cm.module
2469                    AND m.name = 'feedback'";
2470     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2471         $allfeedbacks = array();
2472     }
2473     foreach ($allfeedbacks as $a) {
2474         if (!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2475             $feedbacks2[] = $a;
2476         }
2477     }
2479     $feedbacks = array_merge($feedbacks1, $feedbacks2);
2480     $modinfo = get_fast_modinfo(SITEID);
2481     return array_filter($feedbacks, function($f) use ($modinfo) {
2482         return ($cm = $modinfo->get_cm($f->cmid)) && $cm->uservisible;
2483     });
2487 /**
2488  * Gets the courses from table feedback_sitecourse_map
2489  *
2490  * @param int $feedbackid
2491  * @return array the course-records
2492  */
2493 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2494     global $DB;
2496     $sql = "SELECT c.id, c.fullname, c.shortname
2497               FROM {feedback_sitecourse_map} f, {course} c
2498              WHERE c.id = f.courseid
2499                    AND f.feedbackid = ?
2500           ORDER BY c.fullname";
2502     return $DB->get_records_sql($sql, array($feedbackid));
2506 /**
2507  * Updates the course mapping for the feedback
2508  *
2509  * @param stdClass $feedback
2510  * @param array $courses array of course ids
2511  */
2512 function feedback_update_sitecourse_map($feedback, $courses) {
2513     global $DB;
2514     if (empty($courses)) {
2515         $courses = array();
2516     }
2517     $currentmapping = $DB->get_fieldset_select('feedback_sitecourse_map', 'courseid', 'feedbackid=?', array($feedback->id));
2518     foreach (array_diff($courses, $currentmapping) as $courseid) {
2519         $DB->insert_record('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2520     }
2521     foreach (array_diff($currentmapping, $courses) as $courseid) {
2522         $DB->delete_records('feedback_sitecourse_map', array('feedbackid' => $feedback->id, 'courseid' => $courseid));
2523     }
2524     // TODO MDL-53574 add events.
2527 /**
2528  * @deprecated since 3.1
2529  */
2530 function feedback_clean_up_sitecourse_map() {
2531     throw new coding_exception('feedback_clean_up_sitecourse_map() can not be used anymore.');
2534 ////////////////////////////////////////////////
2535 ////////////////////////////////////////////////
2536 ////////////////////////////////////////////////
2537 //not relatable functions
2538 ////////////////////////////////////////////////
2540 /**
2541  * @deprecated since 3.1
2542  */
2543 function feedback_print_numeric_option_list() {
2544     throw new coding_exception('feedback_print_numeric_option_list() can not be used anymore.');
2547 /**
2548  * sends an email to the teachers of the course where the given feedback is placed.
2549  *
2550  * @global object
2551  * @global object
2552  * @uses FEEDBACK_ANONYMOUS_NO
2553  * @uses FORMAT_PLAIN
2554  * @param object $cm the coursemodule-record
2555  * @param object $feedback
2556  * @param object $course
2557  * @param stdClass|int $user
2558  * @param stdClass $completed record from feedback_completed if known
2559  * @return void
2560  */
2561 function feedback_send_email($cm, $feedback, $course, $user, $completed = null) {
2562     global $CFG, $DB;
2564     if ($feedback->email_notification == 0) {  // No need to do anything
2565         return;
2566     }
2568     if (is_int($user)) {
2569         $user = $DB->get_record('user', array('id' => $user));
2570     }
2572     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
2573         $groupmode =  $cm->groupmode;
2574     } else {
2575         $groupmode = $course->groupmode;
2576     }
2578     if ($groupmode == SEPARATEGROUPS) {
2579         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
2580                                                FROM {groups} g, {groups_members} m
2581                                               WHERE g.courseid = ?
2582                                                     AND g.id = m.groupid
2583                                                     AND m.userid = ?
2584                                            ORDER BY name ASC", array($course->id, $user->id));
2585         $groups = array_values($groups);
2587         $teachers = feedback_get_receivemail_users($cm->id, $groups);
2588     } else {
2589         $teachers = feedback_get_receivemail_users($cm->id);
2590     }
2592     if ($teachers) {
2594         $strfeedbacks = get_string('modulenameplural', 'feedback');
2595         $strfeedback  = get_string('modulename', 'feedback');
2597         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2598             $printusername = fullname($user);
2599         } else {
2600             $printusername = get_string('anonymous_user', 'feedback');
2601         }
2603         foreach ($teachers as $teacher) {
2604             $info = new stdClass();
2605             $info->username = $printusername;
2606             $info->feedback = format_string($feedback->name, true);
2607             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?'.
2608                             'id='.$cm->id.'&'.
2609                             'userid=' . $user->id;
2610             if ($completed) {
2611                 $info->url .= '&showcompleted=' . $completed->id;
2612                 if ($feedback->course == SITEID) {
2613                     // Course where feedback was completed (for site feedbacks only).
2614                     $info->url .= '&courseid=' . $completed->courseid;
2615                 }
2616             }
2618             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
2620             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
2621             $posttext = feedback_send_email_text($info, $course);
2623             if ($teacher->mailformat == 1) {
2624                 $posthtml = feedback_send_email_html($info, $course, $cm);
2625             } else {
2626                 $posthtml = '';
2627             }
2629             if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2630                 $eventdata = new \core\message\message();
2631                 $eventdata->courseid         = $course->id;
2632                 $eventdata->name             = 'submission';
2633                 $eventdata->component        = 'mod_feedback';
2634                 $eventdata->userfrom         = $user;
2635                 $eventdata->userto           = $teacher;
2636                 $eventdata->subject          = $postsubject;
2637                 $eventdata->fullmessage      = $posttext;
2638                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2639                 $eventdata->fullmessagehtml  = $posthtml;
2640                 $eventdata->smallmessage     = '';
2641                 $eventdata->courseid         = $course->id;
2642                 $eventdata->contexturl       = $info->url;
2643                 $eventdata->contexturlname   = $info->feedback;
2644                 message_send($eventdata);
2645             } else {
2646                 $eventdata = new \core\message\message();
2647                 $eventdata->courseid         = $course->id;
2648                 $eventdata->name             = 'submission';
2649                 $eventdata->component        = 'mod_feedback';
2650                 $eventdata->userfrom         = $teacher;
2651                 $eventdata->userto           = $teacher;
2652                 $eventdata->subject          = $postsubject;
2653                 $eventdata->fullmessage      = $posttext;
2654                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2655                 $eventdata->fullmessagehtml  = $posthtml;
2656                 $eventdata->smallmessage     = '';
2657                 $eventdata->courseid         = $course->id;
2658                 $eventdata->contexturl       = $info->url;
2659                 $eventdata->contexturlname   = $info->feedback;
2660                 message_send($eventdata);
2661             }
2662         }
2663     }
2666 /**
2667  * sends an email to the teachers of the course where the given feedback is placed.
2668  *
2669  * @global object
2670  * @uses FORMAT_PLAIN
2671  * @param object $cm the coursemodule-record
2672  * @param object $feedback
2673  * @param object $course
2674  * @return void
2675  */
2676 function feedback_send_email_anonym($cm, $feedback, $course) {
2677     global $CFG;
2679     if ($feedback->email_notification == 0) { // No need to do anything
2680         return;
2681     }
2683     $teachers = feedback_get_receivemail_users($cm->id);
2685     if ($teachers) {
2687         $strfeedbacks = get_string('modulenameplural', 'feedback');
2688         $strfeedback  = get_string('modulename', 'feedback');
2689         $printusername = get_string('anonymous_user', 'feedback');
2691         foreach ($teachers as $teacher) {
2692             $info = new stdClass();
2693             $info->username = $printusername;
2694             $info->feedback = format_string($feedback->name, true);
2695             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?id=' . $cm->id;
2697             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
2699             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
2700             $posttext = feedback_send_email_text($info, $course);
2702             if ($teacher->mailformat == 1) {
2703                 $posthtml = feedback_send_email_html($info, $course, $cm);
2704             } else {
2705                 $posthtml = '';
2706             }
2708             $eventdata = new \core\message\message();
2709             $eventdata->courseid         = $course->id;
2710             $eventdata->name             = 'submission';
2711             $eventdata->component        = 'mod_feedback';
2712             $eventdata->userfrom         = $teacher;
2713             $eventdata->userto           = $teacher;
2714             $eventdata->subject          = $postsubject;
2715             $eventdata->fullmessage      = $posttext;
2716             $eventdata->fullmessageformat = FORMAT_PLAIN;
2717             $eventdata->fullmessagehtml  = $posthtml;
2718             $eventdata->smallmessage     = '';
2719             $eventdata->courseid         = $course->id;
2720             $eventdata->contexturl       = $info->url;
2721             $eventdata->contexturlname   = $info->feedback;
2722             message_send($eventdata);
2723         }
2724     }
2727 /**
2728  * send the text-part of the email
2729  *
2730  * @param object $info includes some infos about the feedback you want to send
2731  * @param object $course
2732  * @return string the text you want to post
2733  */
2734 function feedback_send_email_text($info, $course) {
2735     $coursecontext = context_course::instance($course->id);
2736     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
2737     $posttext  = $courseshortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
2738                     $info->feedback."\n";
2739     $posttext .= '---------------------------------------------------------------------'."\n";
2740     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
2741     $posttext .= '---------------------------------------------------------------------'."\n";
2742     return $posttext;
2746 /**
2747  * send the html-part of the email
2748  *
2749  * @global object
2750  * @param object $info includes some infos about the feedback you want to send
2751  * @param object $course
2752  * @return string the text you want to post
2753  */
2754 function feedback_send_email_html($info, $course, $cm) {
2755     global $CFG;
2756     $coursecontext = context_course::instance($course->id);
2757     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
2758     $course_url = $CFG->wwwroot.'/course/view.php?id='.$course->id;
2759     $feedback_all_url = $CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id;
2760     $feedback_url = $CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id;
2762     $posthtml = '<p><font face="sans-serif">'.
2763             '<a href="'.$course_url.'">'.$courseshortname.'</a> ->'.
2764             '<a href="'.$feedback_all_url.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
2765             '<a href="'.$feedback_url.'">'.$info->feedback.'</a></font></p>';
2766     $posthtml .= '<hr /><font face="sans-serif">';
2767     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
2768     $posthtml .= '</font><hr />';
2769     return $posthtml;
2772 /**
2773  * @param string $url
2774  * @return string
2775  */
2776 function feedback_encode_target_url($url) {
2777     if (strpos($url, '?')) {
2778         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
2779         return $part1 . '?' . htmlentities($part2);
2780     } else {
2781         return $url;
2782     }
2785 /**
2786  * Adds module specific settings to the settings block
2787  *
2788  * @param settings_navigation $settings The settings navigation object
2789  * @param navigation_node $feedbacknode The node to add module settings to
2790  */
2791 function feedback_extend_settings_navigation(settings_navigation $settings,
2792                                              navigation_node $feedbacknode) {
2794     global $PAGE;
2796     if (!$context = context_module::instance($PAGE->cm->id, IGNORE_MISSING)) {
2797         print_error('badcontext');
2798     }
2800     if (has_capability('mod/feedback:edititems', $context)) {
2801         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
2803         $questionnode->add(get_string('edit_items', 'feedback'),
2804                     new moodle_url('/mod/feedback/edit.php',
2805                                     array('id' => $PAGE->cm->id,
2806                                           'do_show' => 'edit')));
2808         $questionnode->add(get_string('export_questions', 'feedback'),
2809                     new moodle_url('/mod/feedback/export.php',
2810                                     array('id' => $PAGE->cm->id,
2811                                           'action' => 'exportfile')));
2813         $questionnode->add(get_string('import_questions', 'feedback'),
2814                     new moodle_url('/mod/feedback/import.php',
2815                                     array('id' => $PAGE->cm->id)));
2817         $questionnode->add(get_string('templates', 'feedback'),
2818                     new moodle_url('/mod/feedback/edit.php',
2819                                     array('id' => $PAGE->cm->id,
2820                                           'do_show' => 'templates')));
2821     }
2823     if (has_capability('mod/feedback:mapcourse', $context) && $PAGE->course->id == SITEID) {
2824         $feedbacknode->add(get_string('mappedcourses', 'feedback'),
2825                     new moodle_url('/mod/feedback/mapcourse.php',
2826                                     array('id' => $PAGE->cm->id)));
2827     }
2829     if (has_capability('mod/feedback:viewreports', $context)) {
2830         $feedback = $PAGE->activityrecord;
2831         if ($feedback->course == SITEID) {
2832             $feedbacknode->add(get_string('analysis', 'feedback'),
2833                     new moodle_url('/mod/feedback/analysis_course.php',
2834                                     array('id' => $PAGE->cm->id)));
2835         } else {
2836             $feedbacknode->add(get_string('analysis', 'feedback'),
2837                     new moodle_url('/mod/feedback/analysis.php',
2838                                     array('id' => $PAGE->cm->id)));
2839         }
2841         $feedbacknode->add(get_string('show_entries', 'feedback'),
2842                     new moodle_url('/mod/feedback/show_entries.php',
2843                                     array('id' => $PAGE->cm->id)));
2845         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO AND $feedback->course != SITEID) {
2846             $feedbacknode->add(get_string('show_nonrespondents', 'feedback'),
2847                         new moodle_url('/mod/feedback/show_nonrespondents.php',
2848                                         array('id' => $PAGE->cm->id)));
2849         }
2850     }
2853 function feedback_init_feedback_session() {
2854     //initialize the feedback-Session - not nice at all!!
2855     global $SESSION;
2856     if (!empty($SESSION)) {
2857         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
2858             $SESSION->feedback = new stdClass();
2859         }
2860     }
2863 /**
2864  * Return a list of page types
2865  * @param string $pagetype current page type
2866  * @param stdClass $parentcontext Block's parent context
2867  * @param stdClass $currentcontext Current context of block
2868  */
2869 function feedback_page_type_list($pagetype, $parentcontext, $currentcontext) {
2870     $module_pagetype = array('mod-feedback-*'=>get_string('page-mod-feedback-x', 'feedback'));
2871     return $module_pagetype;
2874 /**
2875  * Move save the items of the given $feedback in the order of $itemlist.
2876  * @param string $itemlist a comma separated list with item ids
2877  * @param stdClass $feedback
2878  * @return bool true if success
2879  */
2880 function feedback_ajax_saveitemorder($itemlist, $feedback) {
2881     global $DB;
2883     $result = true;
2884     $position = 0;
2885     foreach ($itemlist as $itemid) {
2886         $position++;
2887         $result = $result && $DB->set_field('feedback_item',
2888                                             'position',
2889                                             $position,
2890                                             array('id'=>$itemid, 'feedback'=>$feedback->id));
2891     }
2892     return $result;
2895 /**
2896  * Checks if current user is able to view feedback on this course.
2897  *
2898  * @param stdClass $feedback
2899  * @param context_module $context
2900  * @param int $courseid
2901  * @return bool
2902  */
2903 function feedback_can_view_analysis($feedback, $context, $courseid = false) {
2904     if (has_capability('mod/feedback:viewreports', $context)) {
2905         return true;
2906     }
2908     if (intval($feedback->publish_stats) != 1 ||
2909             !has_capability('mod/feedback:viewanalysepage', $context)) {
2910         return false;
2911     }
2913     if (!isloggedin() || isguestuser()) {
2914         // There is no tracking for the guests, assume that they can view analysis if condition above is satisfied.
2915         return $feedback->course == SITEID;
2916     }
2918     return feedback_is_already_submitted($feedback->id, $courseid);
2921 /**
2922  * Get icon mapping for font-awesome.
2923  */
2924 function mod_feedback_get_fontawesome_icon_map() {
2925     return [
2926         'mod_feedback:required' => 'fa-exclamation-circle',
2927         'mod_feedback:notrequired' => 'fa-question-circle-o',
2928     ];
2931 /**
2932  * Check if the module has any update that affects the current user since a given time.
2933  *
2934  * @param  cm_info $cm course module data
2935  * @param  int $from the time to check updates from
2936  * @param  array $filter if we need to check only specific updates
2937  * @return stdClass an object with the different type of areas indicating if they were updated or not
2938  * @since Moodle 3.3
2939  */
2940 function feedback_check_updates_since(cm_info $cm, $from, $filter = array()) {
2941     global $DB, $USER, $CFG;
2943     $updates = course_check_module_updates_since($cm, $from, array(), $filter);
2945     // Check for new attempts.
2946     $updates->attemptsfinished = (object) array('updated' => false);
2947     $updates->attemptsunfinished = (object) array('updated' => false);
2948     $select = 'feedback = ? AND userid = ? AND timemodified > ?';
2949     $params = array($cm->instance, $USER->id, $from);
2951     $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
2952     if (!empty($attemptsfinished)) {
2953         $updates->attemptsfinished->updated = true;
2954         $updates->attemptsfinished->itemids = array_keys($attemptsfinished);
2955     }
2956     $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
2957     if (!empty($attemptsunfinished)) {
2958         $updates->attemptsunfinished->updated = true;
2959         $updates->attemptsunfinished->itemids = array_keys($attemptsunfinished);
2960     }
2962     // Now, teachers should see other students updates.
2963     if (has_capability('mod/feedback:viewreports', $cm->context)) {
2964         $select = 'feedback = ? AND timemodified > ?';
2965         $params = array($cm->instance, $from);
2967         if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
2968             $groupusers = array_keys(groups_get_activity_shared_group_members($cm));
2969             if (empty($groupusers)) {
2970                 return $updates;
2971             }
2972             list($insql, $inparams) = $DB->get_in_or_equal($groupusers);
2973             $select .= ' AND userid ' . $insql;
2974             $params = array_merge($params, $inparams);
2975         }
2977         $updates->userattemptsfinished = (object) array('updated' => false);
2978         $attemptsfinished = $DB->get_records_select('feedback_completed', $select, $params, '', 'id');
2979         if (!empty($attemptsfinished)) {
2980             $updates->userattemptsfinished->updated = true;
2981             $updates->userattemptsfinished->itemids = array_keys($attemptsfinished);
2982         }
2984         $updates->userattemptsunfinished = (object) array('updated' => false);
2985         $attemptsunfinished = $DB->get_records_select('feedback_completedtmp', $select, $params, '', 'id');
2986         if (!empty($attemptsunfinished)) {
2987             $updates->userattemptsunfinished->updated = true;
2988             $updates->userattemptsunfinished->itemids = array_keys($attemptsunfinished);
2989         }
2990     }
2992     return $updates;
2995 /**
2996  * This function receives a calendar event and returns the action associated with it, or null if there is none.
2997  *
2998  * This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
2999  * is not displayed on the block.
3000  *
3001  * @param calendar_event $event
3002  * @param \core_calendar\action_factory $factory
3003  * @return \core_calendar\local\event\entities\action_interface|null
3004  */
3005 function mod_feedback_core_calendar_provide_event_action(calendar_event $event,
3006                                                          \core_calendar\action_factory $factory) {
3008     $cm = get_fast_modinfo($event->courseid)->instances['feedback'][$event->instance];
3009     $feedbackcompletion = new mod_feedback_completion(null, $cm, 0);
3011     if (!empty($cm->customdata['timeclose']) && $cm->customdata['timeclose'] < time()) {
3012         // Feedback is already closed, do not display it even if it was never submitted.
3013         return null;
3014     }
3016     if (!$feedbackcompletion->can_complete()) {
3017         // The user can't complete the feedback so there is no action for them.
3018         return null;
3019     }
3021     // The feedback is actionable if it does not have timeopen or timeopen is in the past.
3022     $actionable = $feedbackcompletion->is_open();
3024     if ($actionable && $feedbackcompletion->is_already_submitted()) {
3025         // There is no need to display anything if the user has already submitted the feedback.
3026         return null;
3027     }
3029     return $factory->create_instance(
3030         get_string('answerquestions', 'feedback'),
3031         new \moodle_url('/mod/feedback/view.php', ['id' => $cm->id]),
3032         1,
3033         $actionable
3034     );
3037 /**
3038  * Add a get_coursemodule_info function in case any feedback type wants to add 'extra' information
3039  * for the course (see resource).
3040  *
3041  * Given a course_module object, this function returns any "extra" information that may be needed
3042  * when printing this activity in a course listing.  See get_array_of_activities() in course/lib.php.
3043  *
3044  * @param stdClass $coursemodule The coursemodule object (record).
3045  * @return cached_cm_info An object on information that the courses
3046  *                        will know about (most noticeably, an icon).
3047  */
3048 function feedback_get_coursemodule_info($coursemodule) {
3049     global $DB;
3051     $dbparams = ['id' => $coursemodule->instance];
3052     $fields = 'id, name, intro, introformat, completionsubmit, timeopen, timeclose, anonymous';
3053     if (!$feedback = $DB->get_record('feedback', $dbparams, $fields)) {
3054         return false;
3055     }
3057     $result = new cached_cm_info();
3058     $result->name = $feedback->name;
3060     if ($coursemodule->showdescription) {
3061         // Convert intro to html. Do not filter cached version, filters run at display time.
3062         $result->content = format_module_intro('feedback', $feedback, $coursemodule->id, false);
3063     }
3065     // Populate the custom completion rules as key => value pairs, but only if the completion mode is 'automatic'.
3066     if ($coursemodule->completion == COMPLETION_TRACKING_AUTOMATIC) {
3067         $result->customdata['customcompletionrules']['completionsubmit'] = $feedback->completionsubmit;
3068     }
3069     // Populate some other values that can be used in calendar or on dashboard.
3070     if ($feedback->timeopen) {
3071         $result->customdata['timeopen'] = $feedback->timeopen;
3072     }
3073     if ($feedback->timeclose) {
3074         $result->customdata['timeclose'] = $feedback->timeclose;
3075     }
3076     if ($feedback->anonymous) {
3077         $result->customdata['anonymous'] = $feedback->anonymous;
3078     }
3080     return $result;
3083 /**
3084  * Callback which returns human-readable strings describing the active completion custom rules for the module instance.
3085  *
3086  * @param cm_info|stdClass $cm object with fields ->completion and ->customdata['customcompletionrules']
3087  * @return array $descriptions the array of descriptions for the custom rules.
3088  */
3089 function mod_feedback_get_completion_active_rule_descriptions($cm) {
3090     // Values will be present in cm_info, and we assume these are up to date.
3091     if (empty($cm->customdata['customcompletionrules'])
3092         || $cm->completion != COMPLETION_TRACKING_AUTOMATIC) {
3093         return [];
3094     }
3096     $descriptions = [];
3097     foreach ($cm->customdata['customcompletionrules'] as $key => $val) {
3098         switch ($key) {
3099             case 'completionsubmit':
3100                 if (empty($val)) {
3101                     continue;
3102                 }
3103                 $descriptions[] = get_string('completionsubmit', 'feedback');
3104                 break;
3105             default:
3106                 break;
3107         }
3108     }
3109     return $descriptions;
3112 /**
3113  * This function calculates the minimum and maximum cutoff values for the timestart of
3114  * the given event.
3115  *
3116  * It will return an array with two values, the first being the minimum cutoff value and
3117  * the second being the maximum cutoff value. Either or both values can be null, which
3118  * indicates there is no minimum or maximum, respectively.
3119  *
3120  * If a cutoff is required then the function must return an array containing the cutoff
3121  * timestamp and error string to display to the user if the cutoff value is violated.
3122  *
3123  * A minimum and maximum cutoff return value will look like:
3124  * [
3125  *     [1505704373, 'The due date must be after the sbumission start date'],
3126  *     [1506741172, 'The due date must be before the cutoff date']
3127  * ]
3128  *
3129  * @param calendar_event $event The calendar event to get the time range for
3130  * @param stdClass $instance The module instance to get the range from
3131  * @return array
3132  */
3133 function mod_feedback_core_calendar_get_valid_event_timestart_range(\calendar_event $event, \stdClass $instance) {
3134     $mindate = null;
3135     $maxdate = null;
3137     if ($event->eventtype == FEEDBACK_EVENT_TYPE_OPEN) {
3138         // The start time of the open event can't be equal to or after the
3139         // close time of the choice activity.
3140         if (!empty($instance->timeclose)) {
3141             $maxdate = [
3142                 $instance->timeclose,
3143                 get_string('openafterclose', 'feedback')
3144             ];
3145         }
3146     } else if ($event->eventtype == FEEDBACK_EVENT_TYPE_CLOSE) {
3147         // The start time of the close event can't be equal to or earlier than the
3148         // open time of the choice activity.
3149         if (!empty($instance->timeopen)) {
3150             $mindate = [
3151                 $instance->timeopen,
3152                 get_string('closebeforeopen', 'feedback')
3153             ];
3154         }
3155     }
3157     return [$mindate, $maxdate];
3160 /**
3161  * This function will update the feedback module according to the
3162  * event that has been modified.
3163  *
3164  * It will set the timeopen or timeclose value of the feedback instance
3165  * according to the type of event provided.
3166  *
3167  * @throws \moodle_exception
3168  * @param \calendar_event $event
3169  * @param stdClass $feedback The module instance to get the range from
3170  */
3171 function mod_feedback_core_calendar_event_timestart_updated(\calendar_event $event, \stdClass $feedback) {
3172     global $CFG, $DB;
3174     if (empty($event->instance) || $event->modulename != 'feedback') {
3175         return;
3176     }
3178     if ($event->instance != $feedback->id) {
3179         return;
3180     }
3182     if (!in_array($event->eventtype, [FEEDBACK_EVENT_TYPE_OPEN, FEEDBACK_EVENT_TYPE_CLOSE])) {
3183         return;
3184     }
3186     $courseid = $event->courseid;
3187     $modulename = $event->modulename;
3188     $instanceid = $event->instance;
3189     $modified = false;
3191     $coursemodule = get_fast_modinfo($courseid)->instances[$modulename][$instanceid];
3192     $context = context_module::instance($coursemodule->id);
3194     // The user does not have the capability to modify this activity.
3195     if (!has_capability('moodle/course:manageactivities', $context)) {
3196         return;
3197     }
3199     if ($event->eventtype == FEEDBACK_EVENT_TYPE_OPEN) {
3200         // If the event is for the feedback activity opening then we should
3201         // set the start time of the feedback activity to be the new start
3202         // time of the event.
3203         if ($feedback->timeopen != $event->timestart) {
3204             $feedback->timeopen = $event->timestart;
3205             $feedback->timemodified = time();
3206             $modified = true;
3207         }
3208     } else if ($event->eventtype == FEEDBACK_EVENT_TYPE_CLOSE) {
3209         // If the event is for the feedback activity closing then we should
3210         // set the end time of the feedback activity to be the new start
3211         // time of the event.
3212         if ($feedback->timeclose != $event->timestart) {
3213             $feedback->timeclose = $event->timestart;
3214             $modified = true;
3215         }
3216     }
3218     if ($modified) {
3219         $feedback->timemodified = time();
3220         $DB->update_record('feedback', $feedback);
3221         $event = \core\event\course_module_updated::create_from_cm($coursemodule, $context);
3222         $event->trigger();
3223     }