Merge branch 'wip-MDL-53227-master' of git://github.com/marinaglancy/moodle
[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 /** Include eventslib.php */
27 require_once($CFG->libdir.'/eventslib.php');
28 /** Include calendar/lib.php */
29 require_once($CFG->dirroot.'/calendar/lib.php');
30 // Include forms lib.
31 require_once($CFG->libdir.'/formslib.php');
33 define('FEEDBACK_ANONYMOUS_YES', 1);
34 define('FEEDBACK_ANONYMOUS_NO', 2);
35 define('FEEDBACK_MIN_ANONYMOUS_COUNT_IN_GROUP', 2);
36 define('FEEDBACK_DECIMAL', '.');
37 define('FEEDBACK_THOUSAND', ',');
38 define('FEEDBACK_RESETFORM_RESET', 'feedback_reset_data_');
39 define('FEEDBACK_RESETFORM_DROP', 'feedback_drop_feedback_');
40 define('FEEDBACK_MAX_PIX_LENGTH', '400'); //max. Breite des grafischen Balkens in der Auswertung
41 define('FEEDBACK_DEFAULT_PAGE_COUNT', 20);
43 /**
44  * Returns all other caps used in module.
45  *
46  * @return array
47  */
48 function feedback_get_extra_capabilities() {
49     return array('moodle/site:accessallgroups');
50 }
52 /**
53  * @uses FEATURE_GROUPS
54  * @uses FEATURE_GROUPINGS
55  * @uses FEATURE_MOD_INTRO
56  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
57  * @uses FEATURE_GRADE_HAS_GRADE
58  * @uses FEATURE_GRADE_OUTCOMES
59  * @param string $feature FEATURE_xx constant for requested feature
60  * @return mixed True if module supports feature, null if doesn't know
61  */
62 function feedback_supports($feature) {
63     switch($feature) {
64         case FEATURE_GROUPS:                  return true;
65         case FEATURE_GROUPINGS:               return true;
66         case FEATURE_MOD_INTRO:               return true;
67         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
68         case FEATURE_COMPLETION_HAS_RULES:    return true;
69         case FEATURE_GRADE_HAS_GRADE:         return false;
70         case FEATURE_GRADE_OUTCOMES:          return false;
71         case FEATURE_BACKUP_MOODLE2:          return true;
72         case FEATURE_SHOW_DESCRIPTION:        return true;
74         default: return null;
75     }
76 }
78 /**
79  * this will create a new instance and return the id number
80  * of the new instance.
81  *
82  * @global object
83  * @param object $feedback the object given by mod_feedback_mod_form
84  * @return int
85  */
86 function feedback_add_instance($feedback) {
87     global $DB;
89     $feedback->timemodified = time();
90     $feedback->id = '';
92     if (empty($feedback->site_after_submit)) {
93         $feedback->site_after_submit = '';
94     }
96     //saving the feedback in db
97     $feedbackid = $DB->insert_record("feedback", $feedback);
99     $feedback->id = $feedbackid;
101     feedback_set_events($feedback);
103     if (!isset($feedback->coursemodule)) {
104         $cm = get_coursemodule_from_id('feedback', $feedback->id);
105         $feedback->coursemodule = $cm->id;
106     }
107     $context = context_module::instance($feedback->coursemodule);
109     $editoroptions = feedback_get_editor_options();
111     // process the custom wysiwyg editor in page_after_submit
112     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
113         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
114                                                     'mod_feedback', 'page_after_submit',
115                                                     0, $editoroptions,
116                                                     $feedback->page_after_submit_editor['text']);
118         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
119     }
120     $DB->update_record('feedback', $feedback);
122     return $feedbackid;
125 /**
126  * this will update a given instance
127  *
128  * @global object
129  * @param object $feedback the object given by mod_feedback_mod_form
130  * @return boolean
131  */
132 function feedback_update_instance($feedback) {
133     global $DB;
135     $feedback->timemodified = time();
136     $feedback->id = $feedback->instance;
138     if (empty($feedback->site_after_submit)) {
139         $feedback->site_after_submit = '';
140     }
142     //save the feedback into the db
143     $DB->update_record("feedback", $feedback);
145     //create or update the new events
146     feedback_set_events($feedback);
148     $context = context_module::instance($feedback->coursemodule);
150     $editoroptions = feedback_get_editor_options();
152     // process the custom wysiwyg editor in page_after_submit
153     if ($draftitemid = $feedback->page_after_submit_editor['itemid']) {
154         $feedback->page_after_submit = file_save_draft_area_files($draftitemid, $context->id,
155                                                     'mod_feedback', 'page_after_submit',
156                                                     0, $editoroptions,
157                                                     $feedback->page_after_submit_editor['text']);
159         $feedback->page_after_submitformat = $feedback->page_after_submit_editor['format'];
160     }
161     $DB->update_record('feedback', $feedback);
163     return true;
166 /**
167  * Serves the files included in feedback items like label. Implements needed access control ;-)
168  *
169  * There are two situations in general where the files will be sent.
170  * 1) filearea = item, 2) filearea = template
171  *
172  * @package  mod_feedback
173  * @category files
174  * @param stdClass $course course object
175  * @param stdClass $cm course module object
176  * @param stdClass $context context object
177  * @param string $filearea file area
178  * @param array $args extra arguments
179  * @param bool $forcedownload whether or not force download
180  * @param array $options additional options affecting the file serving
181  * @return bool false if file not found, does not return if found - justsend the file
182  */
183 function feedback_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
184     global $CFG, $DB;
186     if ($filearea === 'item' or $filearea === 'template') {
187         $itemid = (int)array_shift($args);
188         //get the item what includes the file
189         if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
190             return false;
191         }
192         $feedbackid = $item->feedback;
193         $templateid = $item->template;
194     }
196     if ($filearea === 'page_after_submit' or $filearea === 'item') {
197         if (! $feedback = $DB->get_record("feedback", array("id"=>$cm->instance))) {
198             return false;
199         }
201         $feedbackid = $feedback->id;
203         //if the filearea is "item" so we check the permissions like view/complete the feedback
204         $canload = false;
205         //first check whether the user has the complete capability
206         if (has_capability('mod/feedback:complete', $context)) {
207             $canload = true;
208         }
210         //now we check whether the user has the view capability
211         if (has_capability('mod/feedback:view', $context)) {
212             $canload = true;
213         }
215         //if the feedback is on frontpage and anonymous and the fullanonymous is allowed
216         //so the file can be loaded too.
217         if (isset($CFG->feedback_allowfullanonymous)
218                     AND $CFG->feedback_allowfullanonymous
219                     AND $course->id == SITEID
220                     AND $feedback->anonymous == FEEDBACK_ANONYMOUS_YES ) {
221             $canload = true;
222         }
224         if (!$canload) {
225             return false;
226         }
227     } else if ($filearea === 'template') { //now we check files in templates
228         if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
229             return false;
230         }
232         //if the file is not public so the capability edititems has to be there
233         if (!$template->ispublic) {
234             if (!has_capability('mod/feedback:edititems', $context)) {
235                 return false;
236             }
237         } else { //on public templates, at least the user has to be logged in
238             if (!isloggedin()) {
239                 return false;
240             }
241         }
242     } else {
243         return false;
244     }
246     if ($context->contextlevel == CONTEXT_MODULE) {
247         if ($filearea !== 'item' and $filearea !== 'page_after_submit') {
248             return false;
249         }
250     }
252     if ($context->contextlevel == CONTEXT_COURSE || $context->contextlevel == CONTEXT_SYSTEM) {
253         if ($filearea !== 'template') {
254             return false;
255         }
256     }
258     $relativepath = implode('/', $args);
259     if ($filearea === 'page_after_submit') {
260         $fullpath = "/{$context->id}/mod_feedback/$filearea/$relativepath";
261     } else {
262         $fullpath = "/{$context->id}/mod_feedback/$filearea/{$item->id}/$relativepath";
263     }
265     $fs = get_file_storage();
267     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
268         return false;
269     }
271     // finally send the file
272     send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
274     return false;
277 /**
278  * this will delete a given instance.
279  * all referenced data also will be deleted
280  *
281  * @global object
282  * @param int $id the instanceid of feedback
283  * @return boolean
284  */
285 function feedback_delete_instance($id) {
286     global $DB;
288     //get all referenced items
289     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
291     //deleting all referenced items and values
292     if (is_array($feedbackitems)) {
293         foreach ($feedbackitems as $feedbackitem) {
294             $DB->delete_records("feedback_value", array("item"=>$feedbackitem->id));
295             $DB->delete_records("feedback_valuetmp", array("item"=>$feedbackitem->id));
296         }
297         if ($delitems = $DB->get_records("feedback_item", array("feedback"=>$id))) {
298             foreach ($delitems as $delitem) {
299                 feedback_delete_item($delitem->id, false);
300             }
301         }
302     }
304     //deleting the referenced tracking data
305     $DB->delete_records('feedback_tracking', array('feedback'=>$id));
307     //deleting the completeds
308     $DB->delete_records("feedback_completed", array("feedback"=>$id));
310     //deleting the unfinished completeds
311     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
313     //deleting old events
314     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
315     return $DB->delete_records("feedback", array("id"=>$id));
318 /**
319  * this is called after deleting all instances if the course will be deleted.
320  * only templates have to be deleted
321  *
322  * @global object
323  * @param object $course
324  * @return boolean
325  */
326 function feedback_delete_course($course) {
327     global $DB;
329     //delete all templates of given course
330     return $DB->delete_records('feedback_template', array('course'=>$course->id));
333 /**
334  * Return a small object with summary information about what a
335  * user has done with a given particular instance of this module
336  * Used for user activity reports.
337  * $return->time = the time they did it
338  * $return->info = a short text description
339  *
340  * @param object $course
341  * @param object $user
342  * @param object $mod
343  * @param object $feedback
344  * @return object
345  */
346 function feedback_user_outline($course, $user, $mod, $feedback) {
347     return null;
350 /**
351  * Returns all users who has completed a specified feedback since a given time
352  * many thanks to Manolescu Dorel, who contributed these two functions
353  *
354  * @global object
355  * @global object
356  * @global object
357  * @global object
358  * @uses CONTEXT_MODULE
359  * @param array $activities Passed by reference
360  * @param int $index Passed by reference
361  * @param int $timemodified Timestamp
362  * @param int $courseid
363  * @param int $cmid
364  * @param int $userid
365  * @param int $groupid
366  * @return void
367  */
368 function feedback_get_recent_mod_activity(&$activities, &$index,
369                                           $timemodified, $courseid,
370                                           $cmid, $userid="", $groupid="") {
372     global $CFG, $COURSE, $USER, $DB;
374     if ($COURSE->id == $courseid) {
375         $course = $COURSE;
376     } else {
377         $course = $DB->get_record('course', array('id'=>$courseid));
378     }
380     $modinfo = get_fast_modinfo($course);
382     $cm = $modinfo->cms[$cmid];
384     $sqlargs = array();
386     $userfields = user_picture::fields('u', null, 'useridagain');
387     $sql = " SELECT fk . * , fc . * , $userfields
388                 FROM {feedback_completed} fc
389                     JOIN {feedback} fk ON fk.id = fc.feedback
390                     JOIN {user} u ON u.id = fc.userid ";
392     if ($groupid) {
393         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
394     }
396     $sql .= " WHERE fc.timemodified > ?
397                 AND fk.id = ?
398                 AND fc.anonymous_response = ?";
399     $sqlargs[] = $timemodified;
400     $sqlargs[] = $cm->instance;
401     $sqlargs[] = FEEDBACK_ANONYMOUS_NO;
403     if ($userid) {
404         $sql .= " AND u.id = ? ";
405         $sqlargs[] = $userid;
406     }
408     if ($groupid) {
409         $sql .= " AND gm.groupid = ? ";
410         $sqlargs[] = $groupid;
411     }
413     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
414         return;
415     }
417     $cm_context = context_module::instance($cm->id);
419     if (!has_capability('mod/feedback:view', $cm_context)) {
420         return;
421     }
423     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
424     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cm_context);
425     $groupmode       = groups_get_activity_groupmode($cm, $course);
427     $aname = format_string($cm->name, true);
428     foreach ($feedbackitems as $feedbackitem) {
429         if ($feedbackitem->userid != $USER->id) {
431             if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
432                 $usersgroups = groups_get_all_groups($course->id,
433                                                      $feedbackitem->userid,
434                                                      $cm->groupingid);
435                 if (!is_array($usersgroups)) {
436                     continue;
437                 }
438                 $usersgroups = array_keys($usersgroups);
439                 $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
440                 if (empty($intersect)) {
441                     continue;
442                 }
443             }
444         }
446         $tmpactivity = new stdClass();
448         $tmpactivity->type      = 'feedback';
449         $tmpactivity->cmid      = $cm->id;
450         $tmpactivity->name      = $aname;
451         $tmpactivity->sectionnum= $cm->sectionnum;
452         $tmpactivity->timestamp = $feedbackitem->timemodified;
454         $tmpactivity->content = new stdClass();
455         $tmpactivity->content->feedbackid = $feedbackitem->id;
456         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
458         $tmpactivity->user = user_picture::unalias($feedbackitem, null, 'useridagain');
459         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
461         $activities[$index++] = $tmpactivity;
462     }
464     return;
467 /**
468  * Prints all users who has completed a specified feedback since a given time
469  * many thanks to Manolescu Dorel, who contributed these two functions
470  *
471  * @global object
472  * @param object $activity
473  * @param int $courseid
474  * @param string $detail
475  * @param array $modnames
476  * @return void Output is echo'd
477  */
478 function feedback_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
479     global $CFG, $OUTPUT;
481     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
483     echo "<tr><td class=\"userpicture\" valign=\"top\">";
484     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
485     echo "</td><td>";
487     if ($detail) {
488         $modname = $modnames[$activity->type];
489         echo '<div class="title">';
490         echo "<img src=\"" . $OUTPUT->pix_url('icon', $activity->type) . "\" ".
491              "class=\"icon\" alt=\"$modname\" />";
492         echo "<a href=\"$CFG->wwwroot/mod/feedback/view.php?id={$activity->cmid}\">{$activity->name}</a>";
493         echo '</div>';
494     }
496     echo '<div class="title">';
497     echo '</div>';
499     echo '<div class="user">';
500     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&amp;course=$courseid\">"
501          ."{$activity->user->fullname}</a> - ".userdate($activity->timestamp);
502     echo '</div>';
504     echo "</td></tr></table>";
506     return;
509 /**
510  * Obtains the automatic completion state for this feedback based on the condition
511  * in feedback settings.
512  *
513  * @param object $course Course
514  * @param object $cm Course-module
515  * @param int $userid User ID
516  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
517  * @return bool True if completed, false if not, $type if conditions not set.
518  */
519 function feedback_get_completion_state($course, $cm, $userid, $type) {
520     global $CFG, $DB;
522     // Get feedback details
523     $feedback = $DB->get_record('feedback', array('id'=>$cm->instance), '*', MUST_EXIST);
525     // If completion option is enabled, evaluate it and return true/false
526     if ($feedback->completionsubmit) {
527         $params = array('userid'=>$userid, 'feedback'=>$feedback->id);
528         return $DB->record_exists('feedback_tracking', $params);
529     } else {
530         // Completion option is not enabled so just return $type
531         return $type;
532     }
536 /**
537  * Print a detailed representation of what a  user has done with
538  * a given particular instance of this module, for user activity reports.
539  *
540  * @param object $course
541  * @param object $user
542  * @param object $mod
543  * @param object $feedback
544  * @return bool
545  */
546 function feedback_user_complete($course, $user, $mod, $feedback) {
547     return true;
550 /**
551  * @return bool true
552  */
553 function feedback_cron () {
554     return true;
557 /**
558  * @return bool false
559  */
560 function feedback_scale_used ($feedbackid, $scaleid) {
561     return false;
564 /**
565  * Checks if scale is being used by any instance of feedback
566  *
567  * This is used to find out if scale used anywhere
568  * @param $scaleid int
569  * @return boolean True if the scale is used by any assignment
570  */
571 function feedback_scale_used_anywhere($scaleid) {
572     return false;
575 /**
576  * List the actions that correspond to a view of this module.
577  * This is used by the participation report.
578  *
579  * Note: This is not used by new logging system. Event with
580  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
581  *       be considered as view action.
582  *
583  * @return array
584  */
585 function feedback_get_view_actions() {
586     return array('view', 'view all');
589 /**
590  * List the actions that correspond to a post of this module.
591  * This is used by the participation report.
592  *
593  * Note: This is not used by new logging system. Event with
594  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
595  *       will be considered as post action.
596  *
597  * @return array
598  */
599 function feedback_get_post_actions() {
600     return array('submit');
603 /**
604  * This function is used by the reset_course_userdata function in moodlelib.
605  * This function will remove all responses from the specified feedback
606  * and clean up any related data.
607  *
608  * @global object
609  * @global object
610  * @uses FEEDBACK_RESETFORM_RESET
611  * @uses FEEDBACK_RESETFORM_DROP
612  * @param object $data the data submitted from the reset course.
613  * @return array status array
614  */
615 function feedback_reset_userdata($data) {
616     global $CFG, $DB;
618     $resetfeedbacks = array();
619     $dropfeedbacks = array();
620     $status = array();
621     $componentstr = get_string('modulenameplural', 'feedback');
623     //get the relevant entries from $data
624     foreach ($data as $key => $value) {
625         switch(true) {
626             case substr($key, 0, strlen(FEEDBACK_RESETFORM_RESET)) == FEEDBACK_RESETFORM_RESET:
627                 if ($value == 1) {
628                     $templist = explode('_', $key);
629                     if (isset($templist[3])) {
630                         $resetfeedbacks[] = intval($templist[3]);
631                     }
632                 }
633             break;
634             case substr($key, 0, strlen(FEEDBACK_RESETFORM_DROP)) == FEEDBACK_RESETFORM_DROP:
635                 if ($value == 1) {
636                     $templist = explode('_', $key);
637                     if (isset($templist[3])) {
638                         $dropfeedbacks[] = intval($templist[3]);
639                     }
640                 }
641             break;
642         }
643     }
645     //reset the selected feedbacks
646     foreach ($resetfeedbacks as $id) {
647         $feedback = $DB->get_record('feedback', array('id'=>$id));
648         feedback_delete_all_completeds($id);
649         $status[] = array('component'=>$componentstr.':'.$feedback->name,
650                         'item'=>get_string('resetting_data', 'feedback'),
651                         'error'=>false);
652     }
654     return $status;
657 /**
658  * Called by course/reset.php
659  *
660  * @global object
661  * @uses FEEDBACK_RESETFORM_RESET
662  * @param object $mform form passed by reference
663  */
664 function feedback_reset_course_form_definition(&$mform) {
665     global $COURSE, $DB;
667     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
669     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')) {
670         return;
671     }
673     $mform->addElement('static', 'hint', get_string('resetting_data', 'feedback'));
674     foreach ($feedbacks as $feedback) {
675         $mform->addElement('checkbox', FEEDBACK_RESETFORM_RESET.$feedback->id, $feedback->name);
676     }
679 /**
680  * Course reset form defaults.
681  *
682  * @global object
683  * @uses FEEDBACK_RESETFORM_RESET
684  * @param object $course
685  */
686 function feedback_reset_course_form_defaults($course) {
687     global $DB;
689     $return = array();
690     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
691         return;
692     }
693     foreach ($feedbacks as $feedback) {
694         $return[FEEDBACK_RESETFORM_RESET.$feedback->id] = true;
695     }
696     return $return;
699 /**
700  * Called by course/reset.php and shows the formdata by coursereset.
701  * it prints checkboxes for each feedback available at the given course
702  * there are two checkboxes:
703  * 1) delete userdata and keep the feedback
704  * 2) delete userdata and drop the feedback
705  *
706  * @global object
707  * @uses FEEDBACK_RESETFORM_RESET
708  * @uses FEEDBACK_RESETFORM_DROP
709  * @param object $course
710  * @return void
711  */
712 function feedback_reset_course_form($course) {
713     global $DB, $OUTPUT;
715     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
716     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
717         return;
718     }
720     foreach ($feedbacks as $feedback) {
721         echo '<p>';
722         echo get_string('name', 'feedback').': '.$feedback->name.'<br />';
723         echo html_writer::checkbox(FEEDBACK_RESETFORM_RESET.$feedback->id,
724                                 1, true,
725                                 get_string('resetting_data', 'feedback'));
726         echo '<br />';
727         echo html_writer::checkbox(FEEDBACK_RESETFORM_DROP.$feedback->id,
728                                 1, false,
729                                 get_string('drop_feedback', 'feedback'));
730         echo '</p>';
731     }
734 /**
735  * This gets an array with default options for the editor
736  *
737  * @return array the options
738  */
739 function feedback_get_editor_options() {
740     return array('maxfiles' => EDITOR_UNLIMITED_FILES,
741                 'trusttext'=>true);
744 /**
745  * This creates new events given as timeopen and closeopen by $feedback.
746  *
747  * @global object
748  * @param object $feedback
749  * @return void
750  */
751 function feedback_set_events($feedback) {
752     global $DB;
754     // adding the feedback to the eventtable (I have seen this at quiz-module)
755     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$feedback->id));
757     if (!isset($feedback->coursemodule)) {
758         $cm = get_coursemodule_from_id('feedback', $feedback->id);
759         $feedback->coursemodule = $cm->id;
760     }
762     // the open-event
763     if ($feedback->timeopen > 0) {
764         $event = new stdClass();
765         $event->name         = get_string('start', 'feedback').' '.$feedback->name;
766         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
767         $event->courseid     = $feedback->course;
768         $event->groupid      = 0;
769         $event->userid       = 0;
770         $event->modulename   = 'feedback';
771         $event->instance     = $feedback->id;
772         $event->eventtype    = 'open';
773         $event->timestart    = $feedback->timeopen;
774         $event->visible      = instance_is_visible('feedback', $feedback);
775         if ($feedback->timeclose > 0) {
776             $event->timeduration = ($feedback->timeclose - $feedback->timeopen);
777         } else {
778             $event->timeduration = 0;
779         }
781         calendar_event::create($event);
782     }
784     // the close-event
785     if ($feedback->timeclose > 0) {
786         $event = new stdClass();
787         $event->name         = get_string('stop', 'feedback').' '.$feedback->name;
788         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
789         $event->courseid     = $feedback->course;
790         $event->groupid      = 0;
791         $event->userid       = 0;
792         $event->modulename   = 'feedback';
793         $event->instance     = $feedback->id;
794         $event->eventtype    = 'close';
795         $event->timestart    = $feedback->timeclose;
796         $event->visible      = instance_is_visible('feedback', $feedback);
797         $event->timeduration = 0;
799         calendar_event::create($event);
800     }
803 /**
804  * this function is called by {@link feedback_delete_userdata()}
805  * it drops the feedback-instance from the course_module table
806  *
807  * @global object
808  * @param int $id the id from the coursemodule
809  * @return boolean
810  */
811 function feedback_delete_course_module($id) {
812     global $DB;
814     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
815         return true;
816     }
817     return $DB->delete_records('course_modules', array('id'=>$cm->id));
822 ////////////////////////////////////////////////
823 //functions to handle capabilities
824 ////////////////////////////////////////////////
826 /**
827  * returns the context-id related to the given coursemodule-id
828  *
829  * @staticvar object $context
830  * @param int $cmid the coursemodule-id
831  * @return object $context
832  */
833 function feedback_get_context($cmid) {
834     static $context;
836     if (isset($context)) {
837         return $context;
838     }
840     $context = context_module::instance($cmid);
841     return $context;
844 /**
845  *  returns true if the current role is faked by switching role feature
846  *
847  * @global object
848  * @return boolean
849  */
850 function feedback_check_is_switchrole() {
851     global $USER;
852     if (isset($USER->switchrole) AND
853             is_array($USER->switchrole) AND
854             count($USER->switchrole) > 0) {
856         return true;
857     }
858     return false;
861 /**
862  * count users which have not completed the feedback
863  *
864  * @global object
865  * @uses CONTEXT_MODULE
866  * @param cm_info $cm Course-module object
867  * @param int $group single groupid
868  * @param string $sort
869  * @param int $startpage
870  * @param int $pagecount
871  * @return object the userrecords
872  */
873 function feedback_get_incomplete_users(cm_info $cm,
874                                        $group = false,
875                                        $sort = '',
876                                        $startpage = false,
877                                        $pagecount = false) {
879     global $DB;
881     $context = context_module::instance($cm->id);
883     //first get all user who can complete this feedback
884     $cap = 'mod/feedback:complete';
885     $fields = 'u.id, u.username';
886     if (!$allusers = get_users_by_capability($context,
887                                             $cap,
888                                             $fields,
889                                             $sort,
890                                             '',
891                                             '',
892                                             $group,
893                                             '',
894                                             true)) {
895         return false;
896     }
897     // Filter users that are not in the correct group/grouping.
898     $info = new \core_availability\info_module($cm);
899     $allusers = $info->filter_user_list($allusers);
901     $allusers = array_keys($allusers);
903     //now get all completeds
904     $params = array('feedback'=>$cm->instance);
905     if (!$completedusers = $DB->get_records_menu('feedback_completed', $params, '', 'userid,id')) {
906         return $allusers;
907     }
908     $completedusers = array_keys($completedusers);
910     //now strike all completedusers from allusers
911     $allusers = array_diff($allusers, $completedusers);
913     //for paging I use array_slice()
914     if ($startpage !== false AND $pagecount !== false) {
915         $allusers = array_slice($allusers, $startpage, $pagecount);
916     }
918     return $allusers;
921 /**
922  * count users which have not completed the feedback
923  *
924  * @global object
925  * @param object $cm
926  * @param int $group single groupid
927  * @return int count of userrecords
928  */
929 function feedback_count_incomplete_users($cm, $group = false) {
930     if ($allusers = feedback_get_incomplete_users($cm, $group)) {
931         return count($allusers);
932     }
933     return 0;
936 /**
937  * count users which have completed a feedback
938  *
939  * @global object
940  * @uses FEEDBACK_ANONYMOUS_NO
941  * @param object $cm
942  * @param int $group single groupid
943  * @return int count of userrecords
944  */
945 function feedback_count_complete_users($cm, $group = false) {
946     global $DB;
948     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
950     $fromgroup = '';
951     $wheregroup = '';
952     if ($group) {
953         $fromgroup = ', {groups_members} g';
954         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
955         $params[] = $group;
956     }
958     $sql = 'SELECT COUNT(u.id) FROM {user} u, {feedback_completed} c'.$fromgroup.'
959               WHERE anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
960               '.$wheregroup;
962     return $DB->count_records_sql($sql, $params);
966 /**
967  * get users which have completed a feedback
968  *
969  * @global object
970  * @uses CONTEXT_MODULE
971  * @uses FEEDBACK_ANONYMOUS_NO
972  * @param object $cm
973  * @param int $group single groupid
974  * @param string $where a sql where condition (must end with " AND ")
975  * @param array parameters used in $where
976  * @param string $sort a table field
977  * @param int $startpage
978  * @param int $pagecount
979  * @return object the userrecords
980  */
981 function feedback_get_complete_users($cm,
982                                      $group = false,
983                                      $where = '',
984                                      array $params = null,
985                                      $sort = '',
986                                      $startpage = false,
987                                      $pagecount = false) {
989     global $DB;
991     $context = context_module::instance($cm->id);
993     $params = (array)$params;
995     $params['anon'] = FEEDBACK_ANONYMOUS_NO;
996     $params['instance'] = $cm->instance;
998     $fromgroup = '';
999     $wheregroup = '';
1000     if ($group) {
1001         $fromgroup = ', {groups_members} g';
1002         $wheregroup = ' AND g.groupid = :group AND g.userid = c.userid';
1003         $params['group'] = $group;
1004     }
1006     if ($sort) {
1007         $sortsql = ' ORDER BY '.$sort;
1008     } else {
1009         $sortsql = '';
1010     }
1012     $ufields = user_picture::fields('u');
1013     $sql = 'SELECT DISTINCT '.$ufields.', c.timemodified as completed_timemodified
1014             FROM {user} u, {feedback_completed} c '.$fromgroup.'
1015             WHERE '.$where.' anonymous_response = :anon
1016                 AND u.id = c.userid
1017                 AND c.feedback = :instance
1018               '.$wheregroup.$sortsql;
1020     if ($startpage === false OR $pagecount === false) {
1021         $startpage = false;
1022         $pagecount = false;
1023     }
1024     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
1027 /**
1028  * get users which have the viewreports-capability
1029  *
1030  * @uses CONTEXT_MODULE
1031  * @param int $cmid
1032  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1033  * @return object the userrecords
1034  */
1035 function feedback_get_viewreports_users($cmid, $groups = false) {
1037     $context = context_module::instance($cmid);
1039     //description of the call below:
1040     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1041     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1042     return get_users_by_capability($context,
1043                             'mod/feedback:viewreports',
1044                             '',
1045                             'lastname',
1046                             '',
1047                             '',
1048                             $groups,
1049                             '',
1050                             false);
1053 /**
1054  * get users which have the receivemail-capability
1055  *
1056  * @uses CONTEXT_MODULE
1057  * @param int $cmid
1058  * @param mixed $groups single groupid or array of groupids - group(s) user is in
1059  * @return object the userrecords
1060  */
1061 function feedback_get_receivemail_users($cmid, $groups = false) {
1063     $context = context_module::instance($cmid);
1065     //description of the call below:
1066     //get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='',
1067     //                          $limitnum='', $groups='', $exceptions='', $doanything=true)
1068     return get_users_by_capability($context,
1069                             'mod/feedback:receivemail',
1070                             '',
1071                             'lastname',
1072                             '',
1073                             '',
1074                             $groups,
1075                             '',
1076                             false);
1079 ////////////////////////////////////////////////
1080 //functions to handle the templates
1081 ////////////////////////////////////////////////
1082 ////////////////////////////////////////////////
1084 /**
1085  * creates a new template-record.
1086  *
1087  * @global object
1088  * @param int $courseid
1089  * @param string $name the name of template shown in the templatelist
1090  * @param int $ispublic 0:privat 1:public
1091  * @return int the new templateid
1092  */
1093 function feedback_create_template($courseid, $name, $ispublic = 0) {
1094     global $DB;
1096     $templ = new stdClass();
1097     $templ->course   = ($ispublic ? 0 : $courseid);
1098     $templ->name     = $name;
1099     $templ->ispublic = $ispublic;
1101     $templid = $DB->insert_record('feedback_template', $templ);
1102     return $DB->get_record('feedback_template', array('id'=>$templid));
1105 /**
1106  * creates new template items.
1107  * all items will be copied and the attribute feedback will be set to 0
1108  * and the attribute template will be set to the new templateid
1109  *
1110  * @global object
1111  * @uses CONTEXT_MODULE
1112  * @uses CONTEXT_COURSE
1113  * @param object $feedback
1114  * @param string $name the name of template shown in the templatelist
1115  * @param int $ispublic 0:privat 1:public
1116  * @return boolean
1117  */
1118 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
1119     global $DB;
1120     $fs = get_file_storage();
1122     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1123         return false;
1124     }
1126     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
1127         return false;
1128     }
1130     //files in the template_item are in the context of the current course or
1131     //if the template is public the files are in the system context
1132     //files in the feedback_item are in the feedback_context of the feedback
1133     if ($ispublic) {
1134         $s_context = context_system::instance();
1135     } else {
1136         $s_context = context_course::instance($newtempl->course);
1137     }
1138     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1139     $f_context = context_module::instance($cm->id);
1141     //create items of this new template
1142     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1143     //we also store a mapping of all items array(oldid => newid)
1144     $dependitemsmap = array();
1145     $itembackup = array();
1146     foreach ($feedbackitems as $item) {
1148         $t_item = clone($item);
1150         unset($t_item->id);
1151         $t_item->feedback = 0;
1152         $t_item->template     = $newtempl->id;
1153         $t_item->id = $DB->insert_record('feedback_item', $t_item);
1154         //copy all included files to the feedback_template filearea
1155         $itemfiles = $fs->get_area_files($f_context->id,
1156                                     'mod_feedback',
1157                                     'item',
1158                                     $item->id,
1159                                     "id",
1160                                     false);
1161         if ($itemfiles) {
1162             foreach ($itemfiles as $ifile) {
1163                 $file_record = new stdClass();
1164                 $file_record->contextid = $s_context->id;
1165                 $file_record->component = 'mod_feedback';
1166                 $file_record->filearea = 'template';
1167                 $file_record->itemid = $t_item->id;
1168                 $fs->create_file_from_storedfile($file_record, $ifile);
1169             }
1170         }
1172         $itembackup[$item->id] = $t_item->id;
1173         if ($t_item->dependitem) {
1174             $dependitemsmap[$t_item->id] = $t_item->dependitem;
1175         }
1177     }
1179     //remapping the dependency
1180     foreach ($dependitemsmap as $key => $dependitem) {
1181         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1182         $newitem->dependitem = $itembackup[$newitem->dependitem];
1183         $DB->update_record('feedback_item', $newitem);
1184     }
1186     return true;
1189 /**
1190  * deletes all feedback_items related to the given template id
1191  *
1192  * @global object
1193  * @uses CONTEXT_COURSE
1194  * @param object $template the template
1195  * @return void
1196  */
1197 function feedback_delete_template($template) {
1198     global $DB;
1200     //deleting the files from the item is done by feedback_delete_item
1201     if ($t_items = $DB->get_records("feedback_item", array("template"=>$template->id))) {
1202         foreach ($t_items as $t_item) {
1203             feedback_delete_item($t_item->id, false, $template);
1204         }
1205     }
1206     $DB->delete_records("feedback_template", array("id"=>$template->id));
1209 /**
1210  * creates new feedback_item-records from template.
1211  * if $deleteold is set true so the existing items of the given feedback will be deleted
1212  * if $deleteold is set false so the new items will be appanded to the old items
1213  *
1214  * @global object
1215  * @uses CONTEXT_COURSE
1216  * @uses CONTEXT_MODULE
1217  * @param object $feedback
1218  * @param int $templateid
1219  * @param boolean $deleteold
1220  */
1221 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1222     global $DB, $CFG;
1224     require_once($CFG->libdir.'/completionlib.php');
1226     $fs = get_file_storage();
1228     if (!$template = $DB->get_record('feedback_template', array('id'=>$templateid))) {
1229         return false;
1230     }
1231     //get all templateitems
1232     if (!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1233         return false;
1234     }
1236     //files in the template_item are in the context of the current course
1237     //files in the feedback_item are in the feedback_context of the feedback
1238     if ($template->ispublic) {
1239         $s_context = context_system::instance();
1240     } else {
1241         $s_context = context_course::instance($feedback->course);
1242     }
1243     $course = $DB->get_record('course', array('id'=>$feedback->course));
1244     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1245     $f_context = context_module::instance($cm->id);
1247     //if deleteold then delete all old items before
1248     //get all items
1249     if ($deleteold) {
1250         if ($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1251             //delete all items of this feedback
1252             foreach ($feedbackitems as $item) {
1253                 feedback_delete_item($item->id, false);
1254             }
1255             //delete tracking-data
1256             $DB->delete_records('feedback_tracking', array('feedback'=>$feedback->id));
1258             $params = array('feedback'=>$feedback->id);
1259             if ($completeds = $DB->get_records('feedback_completed', $params)) {
1260                 $completion = new completion_info($course);
1261                 foreach ($completeds as $completed) {
1262                     // Update completion state
1263                     if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
1264                         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1265                     }
1266                     $DB->delete_records('feedback_completed', array('id'=>$completed->id));
1267                 }
1268             }
1269             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1270         }
1271         $positionoffset = 0;
1272     } else {
1273         //if the old items are kept the new items will be appended
1274         //therefor the new position has an offset
1275         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1276     }
1278     //create items of this new template
1279     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1280     //we also store a mapping of all items array(oldid => newid)
1281     $dependitemsmap = array();
1282     $itembackup = array();
1283     foreach ($templitems as $t_item) {
1284         $item = clone($t_item);
1285         unset($item->id);
1286         $item->feedback = $feedback->id;
1287         $item->template = 0;
1288         $item->position = $item->position + $positionoffset;
1290         $item->id = $DB->insert_record('feedback_item', $item);
1292         //moving the files to the new item
1293         $templatefiles = $fs->get_area_files($s_context->id,
1294                                         'mod_feedback',
1295                                         'template',
1296                                         $t_item->id,
1297                                         "id",
1298                                         false);
1299         if ($templatefiles) {
1300             foreach ($templatefiles as $tfile) {
1301                 $file_record = new stdClass();
1302                 $file_record->contextid = $f_context->id;
1303                 $file_record->component = 'mod_feedback';
1304                 $file_record->filearea = 'item';
1305                 $file_record->itemid = $item->id;
1306                 $fs->create_file_from_storedfile($file_record, $tfile);
1307             }
1308         }
1310         $itembackup[$t_item->id] = $item->id;
1311         if ($item->dependitem) {
1312             $dependitemsmap[$item->id] = $item->dependitem;
1313         }
1314     }
1316     //remapping the dependency
1317     foreach ($dependitemsmap as $key => $dependitem) {
1318         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1319         $newitem->dependitem = $itembackup[$newitem->dependitem];
1320         $DB->update_record('feedback_item', $newitem);
1321     }
1324 /**
1325  * get the list of available templates.
1326  * if the $onlyown param is set true so only templates from own course will be served
1327  * this is important for droping templates
1328  *
1329  * @global object
1330  * @param object $course
1331  * @param string $onlyownorpublic
1332  * @return array the template recordsets
1333  */
1334 function feedback_get_template_list($course, $onlyownorpublic = '') {
1335     global $DB, $CFG;
1337     switch($onlyownorpublic) {
1338         case '':
1339             $templates = $DB->get_records_select('feedback_template',
1340                                                  'course = ? OR ispublic = 1',
1341                                                  array($course->id),
1342                                                  'name');
1343             break;
1344         case 'own':
1345             $templates = $DB->get_records('feedback_template',
1346                                           array('course'=>$course->id),
1347                                           'name');
1348             break;
1349         case 'public':
1350             $templates = $DB->get_records('feedback_template', array('ispublic'=>1), 'name');
1351             break;
1352     }
1353     return $templates;
1356 ////////////////////////////////////////////////
1357 //Handling der Items
1358 ////////////////////////////////////////////////
1359 ////////////////////////////////////////////////
1361 /**
1362  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1363  *
1364  * @global object
1365  * @param object $item
1366  * @return object the instanz of itemclass
1367  */
1368 function feedback_get_item_class($typ) {
1369     global $CFG;
1371     //get the class of item-typ
1372     $itemclass = 'feedback_item_'.$typ;
1373     //get the instance of item-class
1374     if (!class_exists($itemclass)) {
1375         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1376     }
1377     return new $itemclass();
1380 /**
1381  * load the available item plugins from given subdirectory of $CFG->dirroot
1382  * the default is "mod/feedback/item"
1383  *
1384  * @global object
1385  * @param string $dir the subdir
1386  * @return array pluginnames as string
1387  */
1388 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1389     global $CFG;
1390     $names = get_list_of_plugins($dir);
1391     $ret_names = array();
1393     foreach ($names as $name) {
1394         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1395         if (class_exists('feedback_item_'.$name)) {
1396             $ret_names[] = $name;
1397         }
1398     }
1399     return $ret_names;
1402 /**
1403  * load the available item plugins to use as dropdown-options
1404  *
1405  * @global object
1406  * @return array pluginnames as string
1407  */
1408 function feedback_load_feedback_items_options() {
1409     global $CFG;
1411     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1413     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1414         return array();
1415     }
1417     foreach ($feedback_names as $fn) {
1418         $feedback_options[$fn] = get_string($fn, 'feedback');
1419     }
1420     asort($feedback_options);
1421     return $feedback_options;
1424 /**
1425  * load the available items for the depend item dropdown list shown in the edit_item form
1426  *
1427  * @global object
1428  * @param object $feedback
1429  * @param object $item the item of the edit_item form
1430  * @return array all items except the item $item, labels and pagebreaks
1431  */
1432 function feedback_get_depend_candidates_for_item($feedback, $item) {
1433     global $DB;
1434     //all items for dependitem
1435     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1436     $params = array($feedback->id);
1437     if (isset($item->id) AND $item->id) {
1438         $where .= ' AND id != ?';
1439         $params[] = $item->id;
1440     }
1441     $dependitems = array(0 => get_string('choose'));
1442     $feedbackitems = $DB->get_records_select_menu('feedback_item',
1443                                                   $where,
1444                                                   $params,
1445                                                   'position',
1446                                                   'id, label');
1448     if (!$feedbackitems) {
1449         return $dependitems;
1450     }
1451     //adding the choose-option
1452     foreach ($feedbackitems as $key => $val) {
1453         $dependitems[$key] = $val;
1454     }
1455     return $dependitems;
1458 /**
1459  * creates a new item-record
1460  *
1461  * @global object
1462  * @param object $data the data from edit_item_form
1463  * @return int the new itemid
1464  */
1465 function feedback_create_item($data) {
1466     global $DB;
1468     $item = new stdClass();
1469     $item->feedback = $data->feedbackid;
1471     $item->template=0;
1472     if (isset($data->templateid)) {
1473             $item->template = intval($data->templateid);
1474     }
1476     $itemname = trim($data->itemname);
1477     $item->name = ($itemname ? $data->itemname : get_string('no_itemname', 'feedback'));
1479     if (!empty($data->itemlabel)) {
1480         $item->label = trim($data->itemlabel);
1481     } else {
1482         $item->label = get_string('no_itemlabel', 'feedback');
1483     }
1485     $itemobj = feedback_get_item_class($data->typ);
1486     $item->presentation = ''; //the date comes from postupdate() of the itemobj
1488     $item->hasvalue = $itemobj->get_hasvalue();
1490     $item->typ = $data->typ;
1491     $item->position = $data->position;
1493     $item->required=0;
1494     if (!empty($data->required)) {
1495         $item->required = $data->required;
1496     }
1498     $item->id = $DB->insert_record('feedback_item', $item);
1500     //move all itemdata to the data
1501     $data->id = $item->id;
1502     $data->feedback = $item->feedback;
1503     $data->name = $item->name;
1504     $data->label = $item->label;
1505     $data->required = $item->required;
1506     return $itemobj->postupdate($data);
1509 /**
1510  * save the changes of a given item.
1511  *
1512  * @global object
1513  * @param object $item
1514  * @return boolean
1515  */
1516 function feedback_update_item($item) {
1517     global $DB;
1518     return $DB->update_record("feedback_item", $item);
1521 /**
1522  * deletes an item and also deletes all related values
1523  *
1524  * @global object
1525  * @uses CONTEXT_MODULE
1526  * @param int $itemid
1527  * @param boolean $renumber should the kept items renumbered Yes/No
1528  * @param object $template if the template is given so the items are bound to it
1529  * @return void
1530  */
1531 function feedback_delete_item($itemid, $renumber = true, $template = false) {
1532     global $DB;
1534     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1536     //deleting the files from the item
1537     $fs = get_file_storage();
1539     if ($template) {
1540         if ($template->ispublic) {
1541             $context = context_system::instance();
1542         } else {
1543             $context = context_course::instance($template->course);
1544         }
1545         $templatefiles = $fs->get_area_files($context->id,
1546                                     'mod_feedback',
1547                                     'template',
1548                                     $item->id,
1549                                     "id",
1550                                     false);
1552         if ($templatefiles) {
1553             $fs->delete_area_files($context->id, 'mod_feedback', 'template', $item->id);
1554         }
1555     } else {
1556         if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1557             return false;
1558         }
1559         $context = context_module::instance($cm->id);
1561         $itemfiles = $fs->get_area_files($context->id,
1562                                     'mod_feedback',
1563                                     'item',
1564                                     $item->id,
1565                                     "id", false);
1567         if ($itemfiles) {
1568             $fs->delete_area_files($context->id, 'mod_feedback', 'item', $item->id);
1569         }
1570     }
1572     $DB->delete_records("feedback_value", array("item"=>$itemid));
1573     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1575     //remove all depends
1576     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1577     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1579     $DB->delete_records("feedback_item", array("id"=>$itemid));
1580     if ($renumber) {
1581         feedback_renumber_items($item->feedback);
1582     }
1585 /**
1586  * deletes all items of the given feedbackid
1587  *
1588  * @global object
1589  * @param int $feedbackid
1590  * @return void
1591  */
1592 function feedback_delete_all_items($feedbackid) {
1593     global $DB, $CFG;
1594     require_once($CFG->libdir.'/completionlib.php');
1596     if (!$feedback = $DB->get_record('feedback', array('id'=>$feedbackid))) {
1597         return false;
1598     }
1600     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
1601         return false;
1602     }
1604     if (!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
1605         return false;
1606     }
1608     if (!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1609         return;
1610     }
1611     foreach ($items as $item) {
1612         feedback_delete_item($item->id, false);
1613     }
1614     if ($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1615         $completion = new completion_info($course);
1616         foreach ($completeds as $completed) {
1617             // Update completion state
1618             if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
1619                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1620             }
1621             $DB->delete_records('feedback_completed', array('id'=>$completed->id));
1622         }
1623     }
1625     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1629 /**
1630  * this function toggled the item-attribute required (yes/no)
1631  *
1632  * @global object
1633  * @param object $item
1634  * @return boolean
1635  */
1636 function feedback_switch_item_required($item) {
1637     global $DB, $CFG;
1639     $itemobj = feedback_get_item_class($item->typ);
1641     if ($itemobj->can_switch_require()) {
1642         $new_require_val = (int)!(bool)$item->required;
1643         $params = array('id'=>$item->id);
1644         $DB->set_field('feedback_item', 'required', $new_require_val, $params);
1645     }
1646     return true;
1649 /**
1650  * renumbers all items of the given feedbackid
1651  *
1652  * @global object
1653  * @param int $feedbackid
1654  * @return void
1655  */
1656 function feedback_renumber_items($feedbackid) {
1657     global $DB;
1659     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1660     $pos = 1;
1661     if ($items) {
1662         foreach ($items as $item) {
1663             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1664             $pos++;
1665         }
1666     }
1669 /**
1670  * this decreases the position of the given item
1671  *
1672  * @global object
1673  * @param object $item
1674  * @return bool
1675  */
1676 function feedback_moveup_item($item) {
1677     global $DB;
1679     if ($item->position == 1) {
1680         return true;
1681     }
1683     $params = array('feedback'=>$item->feedback);
1684     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1685         return false;
1686     }
1688     $itembefore = null;
1689     foreach ($items as $i) {
1690         if ($i->id == $item->id) {
1691             if (is_null($itembefore)) {
1692                 return true;
1693             }
1694             $itembefore->position = $item->position;
1695             $item->position--;
1696             feedback_update_item($itembefore);
1697             feedback_update_item($item);
1698             feedback_renumber_items($item->feedback);
1699             return true;
1700         }
1701         $itembefore = $i;
1702     }
1703     return false;
1706 /**
1707  * this increased the position of the given item
1708  *
1709  * @global object
1710  * @param object $item
1711  * @return bool
1712  */
1713 function feedback_movedown_item($item) {
1714     global $DB;
1716     $params = array('feedback'=>$item->feedback);
1717     if (!$items = $DB->get_records('feedback_item', $params, 'position')) {
1718         return false;
1719     }
1721     $movedownitem = null;
1722     foreach ($items as $i) {
1723         if (!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1724             $movedownitem->position = $i->position;
1725             $i->position--;
1726             feedback_update_item($movedownitem);
1727             feedback_update_item($i);
1728             feedback_renumber_items($item->feedback);
1729             return true;
1730         }
1731         $movedownitem = $i;
1732     }
1733     return false;
1736 /**
1737  * here the position of the given item will be set to the value in $pos
1738  *
1739  * @global object
1740  * @param object $moveitem
1741  * @param int $pos
1742  * @return boolean
1743  */
1744 function feedback_move_item($moveitem, $pos) {
1745     global $DB;
1747     $params = array('feedback'=>$moveitem->feedback);
1748     if (!$allitems = $DB->get_records('feedback_item', $params, 'position')) {
1749         return false;
1750     }
1751     if (is_array($allitems)) {
1752         $index = 1;
1753         foreach ($allitems as $item) {
1754             if ($index == $pos) {
1755                 $index++;
1756             }
1757             if ($item->id == $moveitem->id) {
1758                 $moveitem->position = $pos;
1759                 feedback_update_item($moveitem);
1760                 continue;
1761             }
1762             $item->position = $index;
1763             feedback_update_item($item);
1764             $index++;
1765         }
1766         return true;
1767     }
1768     return false;
1771 /**
1772  * prints the given item as a preview.
1773  * each item-class has an own print_item_preview function implemented.
1774  *
1775  * @global object
1776  * @param object $item the item what we want to print out
1777  * @return void
1778  */
1779 function feedback_print_item_preview($item) {
1780     global $CFG;
1781     if ($item->typ == 'pagebreak') {
1782         return;
1783     }
1784     //get the instance of the item-class
1785     $itemobj = feedback_get_item_class($item->typ);
1786     $itemobj->print_item_preview($item);
1789 /**
1790  * prints the given item in the completion form.
1791  * each item-class has an own print_item_complete function implemented.
1792  *
1793  * @param object $item the item what we want to print out
1794  * @param mixed $value the value
1795  * @param boolean $highlightrequire if this set true and the value are false on completing so the item will be highlighted
1796  * @return void
1797  */
1798 function feedback_print_item_complete($item, $value = false, $highlightrequire = false) {
1799     global $CFG;
1800     if ($item->typ == 'pagebreak') {
1801         return;
1802     }
1804     //get the instance of the item-class
1805     $itemobj = feedback_get_item_class($item->typ);
1806     $itemobj->print_item_complete($item, $value, $highlightrequire);
1809 /**
1810  * prints the given item in the show entries page.
1811  * each item-class has an own print_item_show_value function implemented.
1812  *
1813  * @param object $item the item what we want to print out
1814  * @param mixed $value
1815  * @return void
1816  */
1817 function feedback_print_item_show_value($item, $value = false) {
1818     global $CFG;
1819     if ($item->typ == 'pagebreak') {
1820         return;
1821     }
1823     //get the instance of the item-class
1824     $itemobj = feedback_get_item_class($item->typ);
1825     $itemobj->print_item_show_value($item, $value);
1828 /**
1829  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1830  * the values are not saved permanently until the user click on save button
1831  *
1832  * @global object
1833  * @param object $feedbackcompleted
1834  * @return object temporary saved completed-record
1835  */
1836 function feedback_set_tmp_values($feedbackcompleted) {
1837     global $DB;
1839     //first we create a completedtmp
1840     $tmpcpl = new stdClass();
1841     foreach ($feedbackcompleted as $key => $value) {
1842         $tmpcpl->{$key} = $value;
1843     }
1844     unset($tmpcpl->id);
1845     $tmpcpl->timemodified = time();
1846     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1847     //get all values of original-completed
1848     if (!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1849         return;
1850     }
1851     foreach ($values as $value) {
1852         unset($value->id);
1853         $value->completed = $tmpcpl->id;
1854         $DB->insert_record('feedback_valuetmp', $value);
1855     }
1856     return $tmpcpl;
1859 /**
1860  * this saves the temporary saved values permanently
1861  *
1862  * @global object
1863  * @param object $feedbackcompletedtmp the temporary completed
1864  * @param object $feedbackcompleted the target completed
1865  * @param int $userid
1866  * @return int the id of the completed
1867  */
1868 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted, $userid) {
1869     global $DB;
1871     $tmpcplid = $feedbackcompletedtmp->id;
1872     if ($feedbackcompleted) {
1873         //first drop all existing values
1874         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1875         //update the current completed
1876         $feedbackcompleted->timemodified = time();
1877         $DB->update_record('feedback_completed', $feedbackcompleted);
1878     } else {
1879         $feedbackcompleted = clone($feedbackcompletedtmp);
1880         $feedbackcompleted->id = '';
1881         $feedbackcompleted->userid = $userid;
1882         $feedbackcompleted->timemodified = time();
1883         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
1884     }
1886     //save all the new values from feedback_valuetmp
1887     //get all values of tmp-completed
1888     $params = array('completed'=>$feedbackcompletedtmp->id);
1889     if (!$values = $DB->get_records('feedback_valuetmp', $params)) {
1890         return false;
1891     }
1892     foreach ($values as $value) {
1893         //check if there are depend items
1894         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
1895         if ($item->dependitem > 0) {
1896             $check = feedback_compare_item_value($tmpcplid,
1897                                         $item->dependitem,
1898                                         $item->dependvalue,
1899                                         true);
1900         } else {
1901             $check = true;
1902         }
1903         if ($check) {
1904             unset($value->id);
1905             $value->completed = $feedbackcompleted->id;
1906             $DB->insert_record('feedback_value', $value);
1907         }
1908     }
1909     //drop all the tmpvalues
1910     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1911     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1913     // Trigger event for the delete action we performed.
1914     $cm = get_coursemodule_from_instance('feedback', $feedbackcompleted->feedback);
1915     $event = \mod_feedback\event\response_submitted::create(array(
1916         'relateduserid' => $userid,
1917         'objectid' => $feedbackcompleted->id,
1918         'context' => context_module::instance($cm->id),
1919         'anonymous' => ($feedbackcompleted->anonymous_response == FEEDBACK_ANONYMOUS_YES),
1920         'other' => array(
1921             'cmid' => $cm->id,
1922             'instanceid' => $feedbackcompleted->feedback,
1923             'anonymous' => $feedbackcompleted->anonymous_response // Deprecated.
1924         )
1925     ));
1927     $event->add_record_snapshot('feedback_completed', $feedbackcompleted);
1929     $event->trigger();
1930     return $feedbackcompleted->id;
1934 /**
1935  * deletes the given temporary completed and all related temporary values
1936  *
1937  * @global object
1938  * @param int $tmpcplid
1939  * @return void
1940  */
1941 function feedback_delete_completedtmp($tmpcplid) {
1942     global $DB;
1944     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1945     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1948 ////////////////////////////////////////////////
1949 ////////////////////////////////////////////////
1950 ////////////////////////////////////////////////
1951 //functions to handle the pagebreaks
1952 ////////////////////////////////////////////////
1954 /**
1955  * this creates a pagebreak.
1956  * a pagebreak is a special kind of item
1957  *
1958  * @global object
1959  * @param int $feedbackid
1960  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
1961  */
1962 function feedback_create_pagebreak($feedbackid) {
1963     global $DB;
1965     //check if there already is a pagebreak on the last position
1966     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
1967     if ($lastposition == feedback_get_last_break_position($feedbackid)) {
1968         return false;
1969     }
1971     $item = new stdClass();
1972     $item->feedback = $feedbackid;
1974     $item->template=0;
1976     $item->name = '';
1978     $item->presentation = '';
1979     $item->hasvalue = 0;
1981     $item->typ = 'pagebreak';
1982     $item->position = $lastposition + 1;
1984     $item->required=0;
1986     return $DB->insert_record('feedback_item', $item);
1989 /**
1990  * get all positions of pagebreaks in the given feedback
1991  *
1992  * @global object
1993  * @param int $feedbackid
1994  * @return array all ordered pagebreak positions
1995  */
1996 function feedback_get_all_break_positions($feedbackid) {
1997     global $DB;
1999     $params = array('typ'=>'pagebreak', 'feedback'=>$feedbackid);
2000     $allbreaks = $DB->get_records_menu('feedback_item', $params, 'position', 'id, position');
2001     if (!$allbreaks) {
2002         return false;
2003     }
2004     return array_values($allbreaks);
2007 /**
2008  * get the position of the last pagebreak
2009  *
2010  * @param int $feedbackid
2011  * @return int the position of the last pagebreak
2012  */
2013 function feedback_get_last_break_position($feedbackid) {
2014     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2015         return false;
2016     }
2017     return $allbreaks[count($allbreaks) - 1];
2020 /**
2021  * this returns the position where the user can continue the completing.
2022  *
2023  * @global object
2024  * @global object
2025  * @global object
2026  * @param int $feedbackid
2027  * @param int $courseid
2028  * @param string $guestid this id will be saved temporary and is unique
2029  * @return int the position to continue
2030  */
2031 function feedback_get_page_to_continue($feedbackid, $courseid = false, $guestid = false) {
2032     global $CFG, $USER, $DB;
2034     //is there any break?
2036     if (!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
2037         return false;
2038     }
2040     $params = array();
2041     if ($courseid) {
2042         $courseselect = "AND fv.course_id = :courseid";
2043         $params['courseid'] = $courseid;
2044     } else {
2045         $courseselect = '';
2046     }
2048     if ($guestid) {
2049         $userselect = "AND fc.guestid = :guestid";
2050         $usergroup = "GROUP BY fc.guestid";
2051         $params['guestid'] = $guestid;
2052     } else {
2053         $userselect = "AND fc.userid = :userid";
2054         $usergroup = "GROUP BY fc.userid";
2055         $params['userid'] = $USER->id;
2056     }
2058     $sql =  "SELECT MAX(fi.position)
2059                FROM {feedback_completedtmp} fc, {feedback_valuetmp} fv, {feedback_item} fi
2060               WHERE fc.id = fv.completed
2061                     $userselect
2062                     AND fc.feedback = :feedbackid
2063                     $courseselect
2064                     AND fi.id = fv.item
2065          $usergroup";
2066     $params['feedbackid'] = $feedbackid;
2068     $lastpos = $DB->get_field_sql($sql, $params);
2070     //the index of found pagebreak is the searched pagenumber
2071     foreach ($allbreaks as $pagenr => $br) {
2072         if ($lastpos < $br) {
2073             return $pagenr;
2074         }
2075     }
2076     return count($allbreaks);
2079 ////////////////////////////////////////////////
2080 ////////////////////////////////////////////////
2081 ////////////////////////////////////////////////
2082 //functions to handle the values
2083 ////////////////////////////////////////////////
2085 /**
2086  * cleans the userinput while submitting the form.
2087  *
2088  * @param mixed $value
2089  * @return mixed
2090  */
2091 function feedback_clean_input_value($item, $value) {
2092     $itemobj = feedback_get_item_class($item->typ);
2093     return $itemobj->clean_input_value($value);
2096 /**
2097  * this saves the values of an completed.
2098  * if the param $tmp is set true so the values are saved temporary in table feedback_valuetmp.
2099  * if there is already a completed and the userid is set so the values are updated.
2100  * on all other things new value records will be created.
2101  *
2102  * @global object
2103  * @param int $userid
2104  * @param boolean $tmp
2105  * @return mixed false on error or the completeid
2106  */
2107 function feedback_save_values($usrid, $tmp = false) {
2108     global $DB;
2110     $completedid = optional_param('completedid', 0, PARAM_INT);
2112     $tmpstr = $tmp ? 'tmp' : '';
2113     $time = time();
2114     $timemodified = mktime(0, 0, 0, date('m', $time), date('d', $time), date('Y', $time));
2116     if ($usrid == 0) {
2117         return feedback_create_values($usrid, $timemodified, $tmp);
2118     }
2119     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2120     if (!$completed) {
2121         return feedback_create_values($usrid, $timemodified, $tmp);
2122     } else {
2123         $completed->timemodified = $timemodified;
2124         return feedback_update_values($completed, $tmp);
2125     }
2128 /**
2129  * this saves the values from anonymous user such as guest on the main-site
2130  *
2131  * @global object
2132  * @param string $guestid the unique guestidentifier
2133  * @return mixed false on error or the completeid
2134  */
2135 function feedback_save_guest_values($guestid) {
2136     global $DB;
2138     $completedid = optional_param('completedid', false, PARAM_INT);
2140     $timemodified = time();
2141     if (!$completed = $DB->get_record('feedback_completedtmp', array('id'=>$completedid))) {
2142         return feedback_create_values(0, $timemodified, true, $guestid);
2143     } else {
2144         $completed->timemodified = $timemodified;
2145         return feedback_update_values($completed, true);
2146     }
2149 /**
2150  * get the value from the given item related to the given completed.
2151  * the value can come as temporary or as permanently value. the deciding is done by $tmp
2152  *
2153  * @global object
2154  * @param int $completeid
2155  * @param int $itemid
2156  * @param boolean $tmp
2157  * @return mixed the value, the type depends on plugin-definition
2158  */
2159 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
2160     global $DB;
2162     $tmpstr = $tmp ? 'tmp' : '';
2163     $params = array('completed'=>$completedid, 'item'=>$itemid);
2164     return $DB->get_field('feedback_value'.$tmpstr, 'value', $params);
2167 /**
2168  * compares the value of the itemid related to the completedid with the dependvalue.
2169  * this is used if a depend item is set.
2170  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
2171  *
2172  * @global object
2173  * @global object
2174  * @param int $completeid
2175  * @param int $itemid
2176  * @param mixed $dependvalue
2177  * @param boolean $tmp
2178  * @return bool
2179  */
2180 function feedback_compare_item_value($completedid, $itemid, $dependvalue, $tmp = false) {
2181     global $DB, $CFG;
2183     $dbvalue = feedback_get_item_value($completedid, $itemid, $tmp);
2185     //get the class of the given item-typ
2186     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
2188     //get the instance of the item-class
2189     $itemobj = feedback_get_item_class($item->typ);
2190     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
2193 /**
2194  * this function checks the correctness of values.
2195  * the rules for this are implemented in the class of each item.
2196  * it can be the required attribute or the value self e.g. numeric.
2197  * the params first/lastitem are given to determine the visible range between pagebreaks.
2198  *
2199  * @global object
2200  * @param int $firstitem the position of firstitem for checking
2201  * @param int $lastitem the position of lastitem for checking
2202  * @return boolean
2203  */
2204 function feedback_check_values($firstitem, $lastitem) {
2205     global $DB, $CFG;
2207     $feedbackid = optional_param('feedbackid', 0, PARAM_INT);
2209     //get all items between the first- and lastitem
2210     $select = "feedback = ?
2211                     AND position >= ?
2212                     AND position <= ?
2213                     AND hasvalue = 1";
2214     $params = array($feedbackid, $firstitem, $lastitem);
2215     if (!$feedbackitems = $DB->get_records_select('feedback_item', $select, $params)) {
2216         //if no values are given so no values can be wrong ;-)
2217         return true;
2218     }
2220     foreach ($feedbackitems as $item) {
2221         //get the instance of the item-class
2222         $itemobj = feedback_get_item_class($item->typ);
2224         //the name of the input field of the completeform is given in a special form:
2225         //<item-typ>_<item-id> eg. numeric_234
2226         //this is the key to get the value for the correct item
2227         $formvalname = $item->typ . '_' . $item->id;
2229         if ($itemobj->value_is_array()) {
2230             //get the raw value here. It is cleaned after that by the object itself
2231             $value = optional_param_array($formvalname, null, PARAM_RAW);
2232         } else {
2233             //get the raw value here. It is cleaned after that by the object itself
2234             $value = optional_param($formvalname, null, PARAM_RAW);
2235         }
2236         $value = $itemobj->clean_input_value($value);
2238         // If the item is not visible due to its dependency so it shouldn't be required.
2239         // Many thanks to Pau Ferrer OcaƱa.
2240         if ($item->dependitem > 0 AND $item->required == 1) {
2241             $comparevalue = false;
2242             if ($feedbackcompletedtmp = feedback_get_current_completed($item->feedback, true)) {
2243                 $comparevalue = feedback_compare_item_value($feedbackcompletedtmp->id,
2244                                                             $item->dependitem,
2245                                                             $item->dependvalue,
2246                                                             true);
2247             }
2249             if (!$comparevalue) {
2250                 $item->required = 0; // Override the required property.
2251             }
2252         }
2254         //check if the value is set
2255         if (is_null($value) AND $item->required == 1) {
2256             return false;
2257         }
2259         //now we let check the value by the item-class
2260         if (!$itemobj->check_value($value, $item)) {
2261             return false;
2262         }
2263     }
2264     //if no wrong values so we can return true
2265     return true;
2268 /**
2269  * this function create a complete-record and the related value-records.
2270  * depending on the $tmp (true/false) the values are saved temporary or permanently
2271  *
2272  * @global object
2273  * @param int $userid
2274  * @param int $timemodified
2275  * @param boolean $tmp
2276  * @param string $guestid a unique identifier to save temporary data
2277  * @return mixed false on error or the completedid
2278  */
2279 function feedback_create_values($usrid, $timemodified, $tmp = false, $guestid = false) {
2280     global $DB;
2282     $feedbackid = optional_param('feedbackid', false, PARAM_INT);
2283     $anonymous_response = optional_param('anonymous_response', false, PARAM_INT);
2284     $courseid = optional_param('courseid', false, PARAM_INT);
2286     $tmpstr = $tmp ? 'tmp' : '';
2287     //first we create a new completed record
2288     $completed = new stdClass();
2289     $completed->feedback           = $feedbackid;
2290     $completed->userid             = $usrid;
2291     $completed->guestid            = $guestid;
2292     $completed->timemodified       = $timemodified;
2293     $completed->anonymous_response = $anonymous_response;
2295     $completedid = $DB->insert_record('feedback_completed'.$tmpstr, $completed);
2297     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2299     //the keys are in the form like abc_xxx
2300     //with explode we make an array with(abc, xxx) and (abc=typ und xxx=itemnr)
2302     //get the items of the feedback
2303     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2304         return false;
2305     }
2306     foreach ($allitems as $item) {
2307         if (!$item->hasvalue) {
2308             continue;
2309         }
2310         //get the class of item-typ
2311         $itemobj = feedback_get_item_class($item->typ);
2313         $keyname = $item->typ.'_'.$item->id;
2315         if ($itemobj->value_is_array()) {
2316             $itemvalue = optional_param_array($keyname, null, $itemobj->value_type());
2317         } else {
2318             $itemvalue = optional_param($keyname, null, $itemobj->value_type());
2319         }
2321         if (is_null($itemvalue)) {
2322             continue;
2323         }
2325         $value = new stdClass();
2326         $value->item = $item->id;
2327         $value->completed = $completed->id;
2328         $value->course_id = $courseid;
2330         //the kind of values can be absolutely different
2331         //so we run create_value directly by the item-class
2332         $value->value = $itemobj->create_value($itemvalue);
2333         $DB->insert_record('feedback_value'.$tmpstr, $value);
2334     }
2335     return $completed->id;
2338 /**
2339  * this function updates a complete-record and the related value-records.
2340  * depending on the $tmp (true/false) the values are saved temporary or permanently
2341  *
2342  * @global object
2343  * @param object $completed
2344  * @param boolean $tmp
2345  * @return int the completedid
2346  */
2347 function feedback_update_values($completed, $tmp = false) {
2348     global $DB;
2350     $courseid = optional_param('courseid', false, PARAM_INT);
2351     $tmpstr = $tmp ? 'tmp' : '';
2353     $DB->update_record('feedback_completed'.$tmpstr, $completed);
2354     //get the values of this completed
2355     $values = $DB->get_records('feedback_value'.$tmpstr, array('completed'=>$completed->id));
2357     //get the items of the feedback
2358     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2359         return false;
2360     }
2361     foreach ($allitems as $item) {
2362         if (!$item->hasvalue) {
2363             continue;
2364         }
2365         //get the class of item-typ
2366         $itemobj = feedback_get_item_class($item->typ);
2368         $keyname = $item->typ.'_'.$item->id;
2370         if ($itemobj->value_is_array()) {
2371             $itemvalue = optional_param_array($keyname, null, $itemobj->value_type());
2372         } else {
2373             $itemvalue = optional_param($keyname, null, $itemobj->value_type());
2374         }
2376         //is the itemvalue set (could be a subset of items because pagebreak)?
2377         if (is_null($itemvalue)) {
2378             continue;
2379         }
2381         $newvalue = new stdClass();
2382         $newvalue->item = $item->id;
2383         $newvalue->completed = $completed->id;
2384         $newvalue->course_id = $courseid;
2386         //the kind of values can be absolutely different
2387         //so we run create_value directly by the item-class
2388         $newvalue->value = $itemobj->create_value($itemvalue);
2390         //check, if we have to create or update the value
2391         $exist = false;
2392         foreach ($values as $value) {
2393             if ($value->item == $newvalue->item) {
2394                 $newvalue->id = $value->id;
2395                 $exist = true;
2396                 break;
2397             }
2398         }
2399         if ($exist) {
2400             $DB->update_record('feedback_value'.$tmpstr, $newvalue);
2401         } else {
2402             $DB->insert_record('feedback_value'.$tmpstr, $newvalue);
2403         }
2404     }
2406     return $completed->id;
2409 /**
2410  * get the values of an item depending on the given groupid.
2411  * if the feedback is anonymous so the values are shuffled
2412  *
2413  * @global object
2414  * @global object
2415  * @param object $item
2416  * @param int $groupid
2417  * @param int $courseid
2418  * @param bool $ignore_empty if this is set true so empty values are not delivered
2419  * @return array the value-records
2420  */
2421 function feedback_get_group_values($item,
2422                                    $groupid = false,
2423                                    $courseid = false,
2424                                    $ignore_empty = false) {
2426     global $CFG, $DB;
2428     //if the groupid is given?
2429     if (intval($groupid) > 0) {
2430         $params = array();
2431         if ($ignore_empty) {
2432             $value = $DB->sql_compare_text('fbv.value');
2433             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2434             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2435         } else {
2436             $ignore_empty_select = "";
2437         }
2439         $query = 'SELECT fbv .  *
2440                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2441                    WHERE fbv.item = :itemid
2442                          AND fbv.completed = fbc.id
2443                          AND fbc.userid = gm.userid
2444                          '.$ignore_empty_select.'
2445                          AND gm.groupid = :groupid
2446                 ORDER BY fbc.timemodified';
2447         $params += array('itemid' => $item->id, 'groupid' => $groupid);
2448         $values = $DB->get_records_sql($query, $params);
2450     } else {
2451         $params = array();
2452         if ($ignore_empty) {
2453             $value = $DB->sql_compare_text('value');
2454             $ignore_empty_select = "AND $value != :emptyvalue AND $value != :zerovalue";
2455             $params += array('emptyvalue' => '', 'zerovalue' => '0');
2456         } else {
2457             $ignore_empty_select = "";
2458         }
2460         if ($courseid) {
2461             $select = "item = :itemid AND course_id = :courseid ".$ignore_empty_select;
2462             $params += array('itemid' => $item->id, 'courseid' => $courseid);
2463             $values = $DB->get_records_select('feedback_value', $select, $params);
2464         } else {
2465             $select = "item = :itemid ".$ignore_empty_select;
2466             $params += array('itemid' => $item->id);
2467             $values = $DB->get_records_select('feedback_value', $select, $params);
2468         }
2469     }
2470     $params = array('id'=>$item->feedback);
2471     if ($DB->get_field('feedback', 'anonymous', $params) == FEEDBACK_ANONYMOUS_YES) {
2472         if (is_array($values)) {
2473             shuffle($values);
2474         }
2475     }
2476     return $values;
2479 /**
2480  * check for multiple_submit = false.
2481  * if the feedback is global so the courseid must be given
2482  *
2483  * @global object
2484  * @global object
2485  * @param int $feedbackid
2486  * @param int $courseid
2487  * @return boolean true if the feedback already is submitted otherwise false
2488  */
2489 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2490     global $USER, $DB;
2492     $params = array('userid'=>$USER->id, 'feedback'=>$feedbackid);
2493     if (!$trackings = $DB->get_records_menu('feedback_tracking', $params, '', 'id, completed')) {
2494         return false;
2495     }
2497     if ($courseid) {
2498         $select = 'completed IN ('.implode(',', $trackings).') AND course_id = ?';
2499         if (!$values = $DB->get_records_select('feedback_value', $select, array($courseid))) {
2500             return false;
2501         }
2502     }
2504     return true;
2507 /**
2508  * if the completion of a feedback will be continued eg.
2509  * by pagebreak or by multiple submit so the complete must be found.
2510  * if the param $tmp is set true so all things are related to temporary completeds
2511  *
2512  * @global object
2513  * @global object
2514  * @global object
2515  * @param int $feedbackid
2516  * @param boolean $tmp
2517  * @param int $courseid
2518  * @param string $guestid
2519  * @return int the id of the found completed
2520  */
2521 function feedback_get_current_completed($feedbackid,
2522                                         $tmp = false,
2523                                         $courseid = false,
2524                                         $guestid = false) {
2526     global $USER, $CFG, $DB;
2528     $tmpstr = $tmp ? 'tmp' : '';
2530     if (!$courseid) {
2531         if ($guestid) {
2532             $params = array('feedback'=>$feedbackid, 'guestid'=>$guestid);
2533             return $DB->get_record('feedback_completed'.$tmpstr, $params);
2534         } else {
2535             $params = array('feedback'=>$feedbackid, 'userid'=>$USER->id);
2536             return $DB->get_record('feedback_completed'.$tmpstr, $params);
2537         }
2538     }
2540     $params = array();
2542     if ($guestid) {
2543         $userselect = "AND fc.guestid = :guestid";
2544         $params['guestid'] = $guestid;
2545     } else {
2546         $userselect = "AND fc.userid = :userid";
2547         $params['userid'] = $USER->id;
2548     }
2549     //if courseid is set the feedback is global.
2550     //there can be more than one completed on one feedback
2551     $sql =  "SELECT DISTINCT fc.*
2552                FROM {feedback_value{$tmpstr}} fv, {feedback_completed{$tmpstr}} fc
2553               WHERE fv.course_id = :courseid
2554                     AND fv.completed = fc.id
2555                     $userselect
2556                     AND fc.feedback = :feedbackid";
2557     $params['courseid']   = intval($courseid);
2558     $params['feedbackid'] = $feedbackid;
2560     if (!$sqlresult = $DB->get_records_sql($sql, $params)) {
2561         return false;
2562     }
2563     foreach ($sqlresult as $r) {
2564         return $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$r->id));
2565     }
2568 /**
2569  * get the completeds depending on the given groupid.
2570  *
2571  * @global object
2572  * @global object
2573  * @param object $feedback
2574  * @param int $groupid
2575  * @param int $courseid
2576  * @return mixed array of found completeds otherwise false
2577  */
2578 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2579     global $CFG, $DB;
2581     if (intval($groupid) > 0) {
2582         $query = "SELECT fbc.*
2583                     FROM {feedback_completed} fbc, {groups_members} gm
2584                    WHERE fbc.feedback = ?
2585                          AND gm.groupid = ?
2586                          AND fbc.userid = gm.userid";
2587         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2588             return $values;
2589         } else {
2590             return false;
2591         }
2592     } else {
2593         if ($courseid) {
2594             $query = "SELECT DISTINCT fbc.*
2595                         FROM {feedback_completed} fbc, {feedback_value} fbv
2596                         WHERE fbc.id = fbv.completed
2597                             AND fbc.feedback = ?
2598                             AND fbv.course_id = ?
2599                         ORDER BY random_response";
2600             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2601                 return $values;
2602             } else {
2603                 return false;
2604             }
2605         } else {
2606             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2607                 return $values;
2608             } else {
2609                 return false;
2610             }
2611         }
2612     }
2615 /**
2616  * get the count of completeds depending on the given groupid.
2617  *
2618  * @global object
2619  * @global object
2620  * @param object $feedback
2621  * @param int $groupid
2622  * @param int $courseid
2623  * @return mixed count of completeds or false
2624  */
2625 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2626     global $CFG, $DB;
2628     if ($courseid > 0 AND !$groupid <= 0) {
2629         $sql = "SELECT id, COUNT(item) AS ci
2630                   FROM {feedback_value}
2631                  WHERE course_id  = ?
2632               GROUP BY item ORDER BY ci DESC";
2633         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2634             $foundrecs = array_values($foundrecs);
2635             return $foundrecs[0]->ci;
2636         }
2637         return false;
2638     }
2639     if ($values = feedback_get_completeds_group($feedback, $groupid)) {
2640         return count($values);
2641     } else {
2642         return false;
2643     }
2646 /**
2647  * deletes all completed-recordsets from a feedback.
2648  * all related data such as values also will be deleted
2649  *
2650  * @global object
2651  * @param int $feedbackid
2652  * @return void
2653  */
2654 function feedback_delete_all_completeds($feedbackid) {
2655     global $DB;
2657     if (!$completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedbackid))) {
2658         return;
2659     }
2660     foreach ($completeds as $completed) {
2661         feedback_delete_completed($completed->id);
2662     }
2665 /**
2666  * deletes a completed given by completedid.
2667  * all related data such values or tracking data also will be deleted
2668  *
2669  * @global object
2670  * @param int $completedid
2671  * @return boolean
2672  */
2673 function feedback_delete_completed($completedid) {
2674     global $DB, $CFG;
2675     require_once($CFG->libdir.'/completionlib.php');
2677     if (!$completed = $DB->get_record('feedback_completed', array('id'=>$completedid))) {
2678         return false;
2679     }
2681     if (!$feedback = $DB->get_record('feedback', array('id'=>$completed->feedback))) {
2682         return false;
2683     }
2685     if (!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
2686         return false;
2687     }
2689     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
2690         return false;
2691     }
2693     //first we delete all related values
2694     $DB->delete_records('feedback_value', array('completed'=>$completed->id));
2696     //now we delete all tracking data
2697     $params = array('completed'=>$completed->id, 'feedback'=>$completed->feedback);
2698     if ($tracking = $DB->get_record('feedback_tracking', $params)) {
2699         $DB->delete_records('feedback_tracking', array('completed'=>$completed->id));
2700     }
2702     // Update completion state
2703     $completion = new completion_info($course);
2704     if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
2705         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
2706     }
2707     // Last we delete the completed-record.
2708     $return = $DB->delete_records('feedback_completed', array('id'=>$completed->id));
2710     // Trigger event for the delete action we performed.
2711     $event = \mod_feedback\event\response_deleted::create(array(
2712         'relateduserid' => $completed->userid,
2713         'objectid' => $completedid,
2714         'courseid' => $course->id,
2715         'context' => context_module::instance($cm->id),
2716         'anonymous' => ($completed->anonymous_response == FEEDBACK_ANONYMOUS_YES),
2717         'other' => array(
2718             'cmid' => $cm->id,
2719             'instanceid' => $feedback->id,
2720             'anonymous' => $completed->anonymous_response) // Deprecated.
2721     ));
2723     $event->add_record_snapshot('feedback_completed', $completed);
2724     $event->add_record_snapshot('course', $course);
2725     $event->add_record_snapshot('feedback', $feedback);
2727     $event->trigger();
2729     return $return;
2732 ////////////////////////////////////////////////
2733 ////////////////////////////////////////////////
2734 ////////////////////////////////////////////////
2735 //functions to handle sitecourse mapping
2736 ////////////////////////////////////////////////
2738 /**
2739  * checks if the course and the feedback is in the table feedback_sitecourse_map.
2740  *
2741  * @global object
2742  * @param int $feedbackid
2743  * @param int $courseid
2744  * @return int the count of records
2745  */
2746 function feedback_is_course_in_sitecourse_map($feedbackid, $courseid) {
2747     global $DB;
2748     $params = array('feedbackid'=>$feedbackid, 'courseid'=>$courseid);
2749     return $DB->count_records('feedback_sitecourse_map', $params);
2752 /**
2753  * checks if the feedback is in the table feedback_sitecourse_map.
2754  *
2755  * @global object
2756  * @param int $feedbackid
2757  * @return boolean
2758  */
2759 function feedback_is_feedback_in_sitecourse_map($feedbackid) {
2760     global $DB;
2761     return $DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$feedbackid));
2764 /**
2765  * gets the feedbacks from table feedback_sitecourse_map.
2766  * this is used to show the global feedbacks on the feedback block
2767  * all feedbacks with the following criteria will be selected:<br />
2768  *
2769  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2770  * 2) all feedbacks which not are listed in sitecoursemap
2771  *
2772  * @global object
2773  * @param int $courseid
2774  * @return array the feedback-records
2775  */
2776 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2777     global $DB;
2779     //first get all feedbacks listed in sitecourse_map with named courseid
2780     $sql = "SELECT f.id AS id,
2781                    cm.id AS cmid,
2782                    f.name AS name,
2783                    f.timeopen AS timeopen,
2784                    f.timeclose AS timeclose
2785             FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2786             WHERE f.id = cm.instance
2787                    AND f.course = '".SITEID."'
2788                    AND m.id = cm.module
2789                    AND m.name = 'feedback'
2790                    AND sm.courseid = ?
2791                    AND sm.feedbackid = f.id";
2793     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2794         $feedbacks1 = array();
2795     }
2797     //second get all feedbacks not listed in sitecourse_map
2798     $feedbacks2 = array();
2799     $sql = "SELECT f.id AS id,
2800                    cm.id AS cmid,
2801                    f.name AS name,
2802                    f.timeopen AS timeopen,
2803                    f.timeclose AS timeclose
2804             FROM {feedback} f, {course_modules} cm, {modules} m
2805             WHERE f.id = cm.instance
2806                    AND f.course = '".SITEID."'
2807                    AND m.id = cm.module
2808                    AND m.name = 'feedback'";
2809     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2810         $allfeedbacks = array();
2811     }
2812     foreach ($allfeedbacks as $a) {
2813         if (!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2814             $feedbacks2[] = $a;
2815         }
2816     }
2818     $feedbacks = array_merge($feedbacks1, $feedbacks2);
2819     $modinfo = get_fast_modinfo(SITEID);
2820     return array_filter($feedbacks, function($f) use ($modinfo) {
2821         return ($cm = $modinfo->get_cm($f->cmid)) && $cm->uservisible;
2822     });
2826 /**
2827  * gets the courses from table feedback_sitecourse_map.
2828  *
2829  * @global object
2830  * @param int $feedbackid
2831  * @return array the course-records
2832  */
2833 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2834     global $DB;
2836     $sql = "SELECT f.id, f.courseid, c.fullname, c.shortname
2837               FROM {feedback_sitecourse_map} f, {course} c
2838              WHERE c.id = f.courseid
2839                    AND f.feedbackid = ?
2840           ORDER BY c.fullname";
2842     return $DB->get_records_sql($sql, array($feedbackid));
2846 /**
2847  * removes non existing courses or feedbacks from sitecourse_map.
2848  * it shouldn't be called all too often
2849  * a good place for it could be the mapcourse.php or unmapcourse.php
2850  *
2851  * @global object
2852  * @return void
2853  */
2854 function feedback_clean_up_sitecourse_map() {
2855     global $DB;
2857     $maps = $DB->get_records('feedback_sitecourse_map');
2858     foreach ($maps as $map) {
2859         if (!$DB->get_record('course', array('id'=>$map->courseid))) {
2860             $params = array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid);
2861             $DB->delete_records('feedback_sitecourse_map', $params);
2862             continue;
2863         }
2864         if (!$DB->get_record('feedback', array('id'=>$map->feedbackid))) {
2865             $params = array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid);
2866             $DB->delete_records('feedback_sitecourse_map', $params);
2867             continue;
2868         }
2870     }
2873 ////////////////////////////////////////////////
2874 ////////////////////////////////////////////////
2875 ////////////////////////////////////////////////
2876 //not relatable functions
2877 ////////////////////////////////////////////////
2879 /**
2880  * prints the option items of a selection-input item (dropdownlist).
2881  * @param int $startval the first value of the list
2882  * @param int $endval the last value of the list
2883  * @param int $selectval which item should be selected
2884  * @param int $interval the stepsize from the first to the last value
2885  * @return void
2886  */
2887 function feedback_print_numeric_option_list($startval, $endval, $selectval = '', $interval = 1) {
2888     for ($i = $startval; $i <= $endval; $i += $interval) {
2889         if ($selectval == ($i)) {
2890             $selected = 'selected="selected"';
2891         } else {
2892             $selected = '';
2893         }
2894         echo '<option '.$selected.'>'.$i.'</option>';
2895     }
2898 /**
2899  * sends an email to the teachers of the course where the given feedback is placed.
2900  *
2901  * @global object
2902  * @global object
2903  * @uses FEEDBACK_ANONYMOUS_NO
2904  * @uses FORMAT_PLAIN
2905  * @param object $cm the coursemodule-record
2906  * @param object $feedback
2907  * @param object $course
2908  * @param int $userid
2909  * @return void
2910  */
2911 function feedback_send_email($cm, $feedback, $course, $userid) {
2912     global $CFG, $DB;
2914     if ($feedback->email_notification == 0) {  // No need to do anything
2915         return;
2916     }
2918     $user = $DB->get_record('user', array('id'=>$userid));
2920     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
2921         $groupmode =  $cm->groupmode;
2922     } else {
2923         $groupmode = $course->groupmode;
2924     }
2926     if ($groupmode == SEPARATEGROUPS) {
2927         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
2928                                                FROM {groups} g, {groups_members} m
2929                                               WHERE g.courseid = ?
2930                                                     AND g.id = m.groupid
2931                                                     AND m.userid = ?
2932                                            ORDER BY name ASC", array($course->id, $userid));
2933         $groups = array_values($groups);
2935         $teachers = feedback_get_receivemail_users($cm->id, $groups);
2936     } else {
2937         $teachers = feedback_get_receivemail_users($cm->id);
2938     }
2940     if ($teachers) {
2942         $strfeedbacks = get_string('modulenameplural', 'feedback');
2943         $strfeedback  = get_string('modulename', 'feedback');
2945         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2946             $printusername = fullname($user);
2947         } else {
2948             $printusername = get_string('anonymous_user', 'feedback');
2949         }
2951         foreach ($teachers as $teacher) {
2952             $info = new stdClass();
2953             $info->username = $printusername;
2954             $info->feedback = format_string($feedback->name, true);
2955             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?'.
2956                             'id='.$cm->id.'&'.
2957                             'userid='.$userid.'&'.
2958                             'do_show=showentries';
2960             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
2962             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
2963             $posttext = feedback_send_email_text($info, $course);
2965             if ($teacher->mailformat == 1) {
2966                 $posthtml = feedback_send_email_html($info, $course, $cm);
2967             } else {
2968                 $posthtml = '';
2969             }
2971             if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2972                 $eventdata = new stdClass();
2973                 $eventdata->name             = 'submission';
2974                 $eventdata->component        = 'mod_feedback';
2975                 $eventdata->userfrom         = $user;
2976                 $eventdata->userto           = $teacher;
2977                 $eventdata->subject          = $postsubject;
2978                 $eventdata->fullmessage      = $posttext;
2979                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2980                 $eventdata->fullmessagehtml  = $posthtml;
2981                 $eventdata->smallmessage     = '';
2982                 message_send($eventdata);
2983             } else {
2984                 $eventdata = new stdClass();
2985                 $eventdata->name             = 'submission';
2986                 $eventdata->component        = 'mod_feedback';
2987                 $eventdata->userfrom         = $teacher;
2988                 $eventdata->userto           = $teacher;
2989                 $eventdata->subject          = $postsubject;
2990                 $eventdata->fullmessage      = $posttext;
2991                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2992                 $eventdata->fullmessagehtml  = $posthtml;
2993                 $eventdata->smallmessage     = '';
2994                 message_send($eventdata);
2995             }
2996         }
2997     }
3000 /**
3001  * sends an email to the teachers of the course where the given feedback is placed.
3002  *
3003  * @global object
3004  * @uses FORMAT_PLAIN
3005  * @param object $cm the coursemodule-record
3006  * @param object $feedback
3007  * @param object $course
3008  * @return void
3009  */
3010 function feedback_send_email_anonym($cm, $feedback, $course) {
3011     global $CFG;
3013     if ($feedback->email_notification == 0) { // No need to do anything
3014         return;
3015     }
3017     $teachers = feedback_get_receivemail_users($cm->id);
3019     if ($teachers) {
3021         $strfeedbacks = get_string('modulenameplural', 'feedback');
3022         $strfeedback  = get_string('modulename', 'feedback');
3023         $printusername = get_string('anonymous_user', 'feedback');
3025         foreach ($teachers as $teacher) {
3026             $info = new stdClass();
3027             $info->username = $printusername;
3028             $info->feedback = format_string($feedback->name, true);
3029             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries_anonym.php?id='.$cm->id;
3031             $a = array('username' => $info->username, 'feedbackname' => $feedback->name);
3033             $postsubject = get_string('feedbackcompleted', 'feedback', $a);
3034             $posttext = feedback_send_email_text($info, $course);
3036             if ($teacher->mailformat == 1) {
3037                 $posthtml = feedback_send_email_html($info, $course, $cm);
3038             } else {
3039                 $posthtml = '';
3040             }
3042             $eventdata = new stdClass();
3043             $eventdata->name             = 'submission';
3044             $eventdata->component        = 'mod_feedback';
3045             $eventdata->userfrom         = $teacher;
3046             $eventdata->userto           = $teacher;
3047             $eventdata->subject          = $postsubject;
3048             $eventdata->fullmessage      = $posttext;
3049             $eventdata->fullmessageformat = FORMAT_PLAIN;
3050             $eventdata->fullmessagehtml  = $posthtml;
3051             $eventdata->smallmessage     = '';
3052             message_send($eventdata);
3053         }
3054     }
3057 /**
3058  * send the text-part of the email
3059  *
3060  * @param object $info includes some infos about the feedback you want to send
3061  * @param object $course
3062  * @return string the text you want to post
3063  */
3064 function feedback_send_email_text($info, $course) {
3065     $coursecontext = context_course::instance($course->id);
3066     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
3067     $posttext  = $courseshortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
3068                     $info->feedback."\n";
3069     $posttext .= '---------------------------------------------------------------------'."\n";
3070     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
3071     $posttext .= '---------------------------------------------------------------------'."\n";
3072     return $posttext;
3076 /**
3077  * send the html-part of the email
3078  *
3079  * @global object
3080  * @param object $info includes some infos about the feedback you want to send
3081  * @param object $course
3082  * @return string the text you want to post
3083  */
3084 function feedback_send_email_html($info, $course, $cm) {
3085     global $CFG;
3086     $coursecontext = context_course::instance($course->id);
3087     $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
3088     $course_url = $CFG->wwwroot.'/course/view.php?id='.$course->id;
3089     $feedback_all_url = $CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id;
3090     $feedback_url = $CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id;
3092     $posthtml = '<p><font face="sans-serif">'.
3093             '<a href="'.$course_url.'">'.$courseshortname.'</a> ->'.
3094             '<a href="'.$feedback_all_url.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
3095             '<a href="'.$feedback_url.'">'.$info->feedback.'</a></font></p>';
3096     $posthtml .= '<hr /><font face="sans-serif">';
3097     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
3098     $posthtml .= '</font><hr />';
3099     return $posthtml;
3102 /**
3103  * @param string $url
3104  * @return string
3105  */
3106 function feedback_encode_target_url($url) {
3107     if (strpos($url, '?')) {
3108         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
3109         return $part1 . '?' . htmlentities($part2);
3110     } else {
3111         return $url;
3112     }
3115 /**
3116  * Adds module specific settings to the settings block
3117  *
3118  * @param settings_navigation $settings The settings navigation object
3119  * @param navigation_node $feedbacknode The node to add module settings to
3120  */
3121 function feedback_extend_settings_navigation(settings_navigation $settings,
3122                                              navigation_node $feedbacknode) {
3124     global $PAGE, $DB;
3126     if (!$context = context_module::instance($PAGE->cm->id, IGNORE_MISSING)) {
3127         print_error('badcontext');
3128     }
3130     if (has_capability('mod/feedback:edititems', $context)) {
3131         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
3133         $questionnode->add(get_string('edit_items', 'feedback'),
3134                     new moodle_url('/mod/feedback/edit.php',
3135                                     array('id' => $PAGE->cm->id,
3136                                           'do_show' => 'edit')));
3138         $questionnode->add(get_string('export_questions', 'feedback'),
3139                     new moodle_url('/mod/feedback/export.php',
3140                                     array('id' => $PAGE->cm->id,
3141                                           'action' => 'exportfile')));
3143         $questionnode->add(get_string('import_questions', 'feedback'),
3144                     new moodle_url('/mod/feedback/import.php',
3145                                     array('id' => $PAGE->cm->id)));
3147         $questionnode->add(get_string('templates', 'feedback'),
3148                     new moodle_url('/mod/feedback/edit.php',
3149                                     array('id' => $PAGE->cm->id,
3150                                           'do_show' => 'templates')));
3151     }
3153     if (has_capability('mod/feedback:viewreports', $context)) {
3154         $feedback = $DB->get_record('feedback', array('id'=>$PAGE->cm->instance));
3155         if ($feedback->course == SITEID) {
3156             $feedbacknode->add(get_string('analysis', 'feedback'),
3157                     new moodle_url('/mod/feedback/analysis_course.php',
3158                                     array('id' => $PAGE->cm->id,
3159                                           'course' => $PAGE->course->id,
3160                                           'do_show' => 'analysis')));
3161         } else {
3162             $feedbacknode->add(get_string('analysis', 'feedback'),
3163                     new moodle_url('/mod/feedback/analysis.php',
3164                                     array('id' => $PAGE->cm->id,
3165                                           'course' => $PAGE->course->id,
3166                                           'do_show' => 'analysis')));
3167         }
3169         $feedbacknode->add(get_string('show_entries', 'feedback'),
3170                     new moodle_url('/mod/feedback/show_entries.php',
3171                                     array('id' => $PAGE->cm->id,
3172                                           'do_show' => 'showentries')));
3174         if ($feedback->anonymous == FEEDBACK_ANONYMOUS_NO AND $feedback->course != SITEID) {
3175             $feedbacknode->add(get_string('show_nonrespondents', 'feedback'),
3176                         new moodle_url('/mod/feedback/show_nonrespondents.php',
3177                                         array('id' => $PAGE->cm->id)));
3178         }
3179     }
3182 function feedback_init_feedback_session() {
3183     //initialize the feedback-Session - not nice at all!!
3184     global $SESSION;
3185     if (!empty($SESSION)) {
3186         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
3187             $SESSION->feedback = new stdClass();
3188         }
3189     }
3192 /**
3193  * Return a list of page types
3194  * @param string $pagetype current page type
3195  * @param stdClass $parentcontext Block's parent context
3196  * @param stdClass $currentcontext Current context of block
3197  */
3198 function feedback_page_type_list($pagetype, $parentcontext, $currentcontext) {
3199     $module_pagetype = array('mod-feedback-*'=>get_string('page-mod-feedback-x', 'feedback'));
3200     return $module_pagetype;
3203 /**
3204  * Move save the items of the given $feedback in the order of $itemlist.
3205  * @param string $itemlist a comma separated list with item ids
3206  * @param stdClass $feedback
3207  * @return bool true if success
3208  */
3209 function feedback_ajax_saveitemorder($itemlist, $feedback) {
3210     global $DB;
3212     $result = true;
3213     $position = 0;
3214     foreach ($itemlist as $itemid) {
3215         $position++;
3216         $result = $result && $DB->set_field('feedback_item',
3217                                             'position',
3218                                             $position,
3219                                             array('id'=>$itemid, 'feedback'=>$feedback->id));
3220     }
3221     return $result;
3224 /**
3225  * Checks if current user is able to view feedback on this course.
3226  *
3227  * @param stdClass $feedback
3228  * @param context_module $context
3229  * @param int $courseid
3230  * @return bool
3231  */
3232 function feedback_can_view_analysis($feedback, $context, $courseid = false) {
3233     if (has_capability('mod/feedback:viewreports', $context)) {
3234         return true;
3235     }
3237     if (intval($feedback->publish_stats) != 1 ||
3238             !has_capability('mod/feedback:viewanalysepage', $context)) {
3239         return false;
3240     }
3242     if (!isloggedin() || isguestuser()) {
3243         // There is no tracking for the guests, assume that they can view analysis if condition above is satisfied.
3244         return $feedback->course == SITEID;
3245     }
3247     return feedback_is_already_submitted($feedback->id, $courseid);