b777e7e98f7aa40cbe81a30ff3617b8b4766ae1b
[moodle.git] / mod / feedback / lib.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * Library of functions and constants for module feedback
20  * includes the main-part of feedback-functions
21  *
22  * @package mod-feedback
23  * @copyright Andreas Grabs
24  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
25  */
27 /** Include eventslib.php */
28 require_once($CFG->libdir.'/eventslib.php');
29 /** Include calendar/lib.php */
30 require_once($CFG->dirroot.'/calendar/lib.php');
32 define('FEEDBACK_ANONYMOUS_YES', 1);
33 define('FEEDBACK_ANONYMOUS_NO', 2);
34 define('FEEDBACK_MIN_ANONYMOUS_COUNT_IN_GROUP', 2);
35 define('FEEDBACK_DECIMAL', '.');
36 define('FEEDBACK_THOUSAND', ',');
37 define('FEEDBACK_RESETFORM_RESET', 'feedback_reset_data_');
38 define('FEEDBACK_RESETFORM_DROP', 'feedback_drop_feedback_');
39 define('FEEDBACK_MAX_PIX_LENGTH', '400'); //max. Breite des grafischen Balkens in der Auswertung
40 define('FEEDBACK_DEFAULT_PAGE_COUNT', 20);
42 /**
43  * @uses FEATURE_GROUPS
44  * @uses FEATURE_GROUPINGS
45  * @uses FEATURE_GROUPMEMBERSONLY
46  * @uses FEATURE_MOD_INTRO
47  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
48  * @uses FEATURE_GRADE_HAS_GRADE
49  * @uses FEATURE_GRADE_OUTCOMES
50  * @param string $feature FEATURE_xx constant for requested feature
51  * @return mixed True if module supports feature, null if doesn't know
52  */
53 function feedback_supports($feature) {
54     switch($feature) {
55         case FEATURE_GROUPS:                  return true;
56         case FEATURE_GROUPINGS:               return true;
57         case FEATURE_GROUPMEMBERSONLY:        return true;
58         case FEATURE_MOD_INTRO:               return true;
59         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
60         case FEATURE_COMPLETION_HAS_RULES:    return true;
61         case FEATURE_GRADE_HAS_GRADE:         return false;
62         case FEATURE_GRADE_OUTCOMES:          return false;
63         case FEATURE_BACKUP_MOODLE2:          return true;
65         default: return null;
66     }
67 }
69 /**
70  * this will create a new instance and return the id number
71  * of the new instance.
72  *
73  * @global object
74  * @param object $feedback the object given by mod_feedback_mod_form
75  * @return int
76  */
77 function feedback_add_instance($feedback) {
78     global $DB;
80     $feedback->timemodified = time();
81     $feedback->id = '';
83     //check if openenable and/or closeenable is set and set correctly to save in db
84     if(empty($feedback->openenable)) {
85         $feedback->timeopen = 0;
86     }
87     if(empty($feedback->closeenable)) {
88         $feedback->timeclose = 0;
89     }
90     if(empty($feedback->site_after_submit)) {
91         $feedback->site_after_submit = '';
92     }
94     //saving the feedback in db
95     $feedbackid = $DB->insert_record("feedback", $feedback);
97     $feedback->id = $feedbackid;
99     feedback_set_events($feedback);
101     return $feedbackid;
104 /**
105  * this will update a given instance
106  *
107  * @global object
108  * @param object $feedback the object given by mod_feedback_mod_form
109  * @return boolean
110  */
111 function feedback_update_instance($feedback) {
112     global $DB;
114     $feedback->timemodified = time();
115     $feedback->id = $feedback->instance;
117     //check if openenable and/or closeenable is set and set correctly to save in db
118     if(empty($feedback->openenable)) {
119         $feedback->timeopen = 0;
120     }
121     if(empty($feedback->closeenable)) {
122         $feedback->timeclose = 0;
123     }
124     if(empty($feedback->site_after_submit)) {
125         $feedback->site_after_submit = '';
126     }
128     //save the feedback into the db
129     $DB->update_record("feedback", $feedback);
131     //create or update the new events
132     feedback_set_events($feedback);
134     return true;
137 /**
138  * Serves the files included in feedback items like label. Implements needed access control ;-)
139  *
140  * @param object $course
141  * @param object $cm
142  * @param object $context
143  * @param string $filearea
144  * @param array $args
145  * @param bool $forcedownload
146  * @return bool false if file not found, does not return if found - justsend the file
147  */
148 function feedback_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload) {
149     global $CFG, $DB;
151     require_login($course, false, $cm);
153     $itemid = (int)array_shift($args);
155     require_course_login($course, true, $cm);
157     if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
158         return false;
159     }
161     if (!has_capability('mod/feedback:view', $context)) {
162         return false;
163     }
165     if ($context->contextlevel == CONTEXT_MODULE) {
166         if ($filearea !== 'item') {
167             return false;
168         }
170         if ($item->feedback == $cm->instance) {
171             $filecontext = $context;
172         } else {
173             return false;
174         }
175     }
177     if ($context->contextlevel == CONTEXT_COURSE) {
178         if ($filearea !== 'template') {
179             return false;
180         }
181     }
183     $relativepath = implode('/', $args);
184     $fullpath = "/$context->id/mod_feedback/$filearea/$itemid/$relativepath";
186     $fs = get_file_storage();
187     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
188         return false;
189     }
191     // finally send the file
192     send_stored_file($file, 0, 0, true); // download MUST be forced - security!
194     return false;
198 /**
199  * this will delete a given instance.
200  * all referenced data also will be deleted
201  *
202  * @global object
203  * @param int $id the instanceid of feedback
204  * @return boolean
205  */
206 function feedback_delete_instance($id) {
207     global $DB;
209     //get all referenced items
210     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
212     //deleting all referenced items and values
213     if (is_array($feedbackitems)){
214         foreach($feedbackitems as $feedbackitem){
215             $DB->delete_records("feedback_value", array("item"=>$feedbackitem->id));
216             $DB->delete_records("feedback_valuetmp", array("item"=>$feedbackitem->id));
217         }
218         if($delitems = $DB->get_records("feedback_item", array("feedback"=>$id))) {
219             foreach($delitems as $delitem) {
220                 feedback_delete_item($delitem->id, false);
221             }
222         }
223     }
225     //deleting the referenced tracking data
226     $DB->delete_records('feedback_tracking', array('feedback'=>$id));
228     //deleting the completeds
229     $DB->delete_records("feedback_completed", array("feedback"=>$id));
231     //deleting the unfinished completeds
232     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
234     //deleting old events
235     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
236     return $DB->delete_records("feedback", array("id"=>$id));
239 /**
240  * this is called after deleting all instances if the course will be deleted.
241  * only templates have to be deleted
242  *
243  * @global object
244  * @param object $course
245  * @return boolean
246  */
247 function feedback_delete_course($course) {
248     global $DB;
250     //delete all templates of given course
251     return $DB->delete_records('feedback_template', array('course'=>$course->id));
254 /**
255  * Return a small object with summary information about what a
256  * user has done with a given particular instance of this module
257  * Used for user activity reports.
258  * $return->time = the time they did it
259  * $return->info = a short text description
260  *
261  * @param object $course
262  * @param object $user
263  * @param object $mod
264  * @param object $feedback
265  * @return object
266  */
267 function feedback_user_outline($course, $user, $mod, $feedback) {
268     return null;
271 /**
272  * Returns all users who has completed a specified feedback since a given time
273  * many thanks to Manolescu Dorel, who contributed these two functions
274  *
275  * @global object
276  * @global object
277  * @global object
278  * @global object
279  * @uses CONTEXT_MODULE
280  * @param array $activities Passed by reference
281  * @param int $index Passed by reference
282  * @param int $timemodified Timestamp
283  * @param int $courseid
284  * @param int $cmid
285  * @param int $userid
286  * @param int $groupid
287  * @return void
288  */
289 function feedback_get_recent_mod_activity(&$activities, &$index, $timemodified, $courseid, $cmid, $userid="", $groupid="")  {
290     global $CFG, $COURSE, $USER, $DB;
292     if ($COURSE->id == $courseid) {
293         $course = $COURSE;
294     } else {
295         $course = $DB->get_record('course', array('id'=>$courseid));
296     }
298     $modinfo =& get_fast_modinfo($course);
300     $cm = $modinfo->cms[$cmid];
302     $sqlargs = array();
304     //TODO: user user_picture::fields;
305     $sql = " SELECT fk . * , fc . * , u.firstname, u.lastname, u.email, u.picture, u.email
306                                             FROM {feedback_completed} fc
307                                                 JOIN {feedback} fk ON fk.id = fc.feedback
308                                                 JOIN {user} u ON u.id = fc.userid ";
310     if ($groupid) {
311         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
312     }
314     $sql .= " WHERE fc.timemodified > ? AND fk.id = ? ";
315     $sqlargs[] = $timemodified;
316     $sqlargs[] = $cm->instace;
318     if ($userid) {
319         $sql .= " AND u.id = ? ";
320         $sqlargs[] = $userid;
321     }
323     if ($groupid) {
324         $sql .= " AND gm.groupid = ? ";
325         $sqlargs[] = $groupid;
326     }
328     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
329         return;
330     }
332     $cm_context      = get_context_instance(CONTEXT_MODULE, $cm->id);
333     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
334     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cm_context);
335     $groupmode       = groups_get_activity_groupmode($cm, $course);
337     if (is_null($modinfo->groups)) {
338         $modinfo->groups = groups_get_user_groups($course->id); // load all my groups and cache it in modinfo
339     }
341     $aname = format_string($cm->name,true);
342     foreach ($feedbackitems as $feedbackitem) {
343         if ($feedbackitem->userid != $USER->id) {
345             if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
346                 $usersgroups = groups_get_all_groups($course->id, $feedbackitem->userid, $cm->groupingid);
347                 if (!is_array($usersgroups)) {
348                     continue;
349                 }
350                 $usersgroups = array_keys($usersgroups);
351                 $intersect = array_intersect($usersgroups, $modinfo->groups[$cm->id]);
352                 if (empty($intersect)) {
353                     continue;
354                 }
355             }
356        }
358         $tmpactivity = new stdClass();
360         $tmpactivity->type      = 'feedback';
361         $tmpactivity->cmid      = $cm->id;
362         $tmpactivity->name      = $aname;
363         $tmpactivity->sectionnum= $cm->sectionnum;
364         $tmpactivity->timestamp = $feedbackitem->timemodified;
366         $tmpactivity->content->feedbackid = $feedbackitem->id;
367         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
369         //TODO: add all necessary user fields, this is not enough for user_picture
370         $tmpactivity->user->userid   = $feedbackitem->userid;
371         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
372         $tmpactivity->user->picture  = $feedbackitem->picture;
374         $activities[$index++] = $tmpactivity;
375     }
377   return;
380 /**
381  * Prints all users who has completed a specified feedback since a given time
382  * many thanks to Manolescu Dorel, who contributed these two functions
383  *
384  * @global object
385  * @param object $activity
386  * @param int $courseid
387  * @param string $detail
388  * @param array $modnames
389  * @return void Output is echo'd
390  */
391 function feedback_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
392     global $CFG, $OUTPUT;
394     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
396     echo "<tr><td class=\"userpicture\" valign=\"top\">";
397     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
398     echo "</td><td>";
400     if ($detail) {
401         $modname = $modnames[$activity->type];
402         echo '<div class="title">';
403         echo "<img src=\"" . $OUTPUT->pix_url('icon', $activity->type) . "\" ".
404              "class=\"icon\" alt=\"$modname\" />";
405         echo "<a href=\"$CFG->wwwroot/mod/feedback/view.php?id={$activity->cmid}\">{$activity->name}</a>";
406         echo '</div>';
407     }
409     echo '<div class="title">';
410     echo '</div>';
412     echo '<div class="user">';
413     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->userid}&amp;course=$courseid\">"
414          ."{$activity->user->fullname}</a> - ".userdate($activity->timestamp);
415     echo '</div>';
417     echo "</td></tr></table>";
419     return;
422 /**
423  * Obtains the automatic completion state for this feedback based on the condition
424  * in feedback settings.
425  *
426  * @param object $course Course
427  * @param object $cm Course-module
428  * @param int $userid User ID
429  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
430  * @return bool True if completed, false if not, $type if conditions not set.
431  */
432 function feedback_get_completion_state($course, $cm, $userid, $type) {
433     global $CFG, $DB;
435     // Get feedback details
436     $feedback = $DB->get_record('feedback', array('id'=>$cm->instance), '*', MUST_EXIST);
438     // If completion option is enabled, evaluate it and return true/false
439     if($feedback->completionsubmit) {
440         return $DB->record_exists('feedback_tracking', array('userid'=>$userid, 'feedback'=>$feedback->id));
441     } else {
442         // Completion option is not enabled so just return $type
443         return $type;
444     }
448 /**
449  * Print a detailed representation of what a  user has done with
450  * a given particular instance of this module, for user activity reports.
451  *
452  * @param object $course
453  * @param object $user
454  * @param object $mod
455  * @param object $feedback
456  * @return bool
457  */
458 function feedback_user_complete($course, $user, $mod, $feedback) {
459     return true;
462 /**
463  * @return bool true
464  */
465 function feedback_cron () {
466     return true;
469 /**
470  * @todo: deprecated - to be deleted in 2.2
471  * @return bool false
472  */
473 function feedback_get_participants($feedbackid) {
474     return false;
478 /**
479  * @return bool false
480  */
481 function feedback_scale_used ($feedbackid,$scaleid) {
482     return false;
485 /**
486  * Checks if scale is being used by any instance of feedback
487  *
488  * This is used to find out if scale used anywhere
489  * @param $scaleid int
490  * @return boolean True if the scale is used by any assignment
491  */
492 function feedback_scale_used_anywhere($scaleid) {
493     return false;
496 /**
497  * This function is used by the reset_course_userdata function in moodlelib.
498  * This function will remove all responses from the specified feedback
499  * and clean up any related data.
500  *
501  * @global object
502  * @global object
503  * @uses FEEDBACK_RESETFORM_RESET
504  * @uses FEEDBACK_RESETFORM_DROP
505  * @param object $data the data submitted from the reset course.
506  * @return array status array
507  */
508 function feedback_reset_userdata($data) {
509     global $CFG, $DB;
511     $resetfeedbacks = array();
512     $dropfeedbacks = array();
513     $status = array();
514     $componentstr = get_string('modulenameplural', 'feedback');
516     //get the relevant entries from $data
517     foreach($data as $key => $value) {
518         switch(true) {
519             case substr($key, 0, strlen(FEEDBACK_RESETFORM_RESET)) == FEEDBACK_RESETFORM_RESET:
520                 if($value == 1) {
521                     $templist = explode('_', $key);
522                     if(isset($templist[3]))$resetfeedbacks[] = intval($templist[3]);
523                 }
524             break;
525             case substr($key, 0, strlen(FEEDBACK_RESETFORM_DROP)) == FEEDBACK_RESETFORM_DROP:
526                 if($value == 1) {
527                     $templist = explode('_', $key);
528                     if(isset($templist[3]))$dropfeedbacks[] = intval($templist[3]);
529                 }
530             break;
531         }
532     }
534     //reset the selected feedbacks
535     foreach($resetfeedbacks as $id) {
536         $feedback = $DB->get_record('feedback', array('id'=>$id));
537         feedback_delete_all_completeds($id);
538         $status[] = array('component'=>$componentstr.':'.$feedback->name, 'item'=>get_string('resetting_data','feedback'), 'error'=>false);
539     }
541     //drop the selected feedbacks
542     // foreach($dropfeedbacks as $id) {
543         // $cm = get_coursemodule_from_instance('feedback', $id);
544         // feedback_delete_instance($id);
545         // feedback_delete_course_module($cm->id);
546         // $status[] = array('component'=>$componentstr, 'item'=>get_string('drop_feedback','feedback'), 'error'=>false);
547     // }
548     return $status;
551 /**
552  * Called by course/reset.php
553  *
554  * @global object
555  * @uses FEEDBACK_RESETFORM_RESET
556  * @param object $mform form passed by reference
557  */
558 function feedback_reset_course_form_definition(&$mform) {
559     global $COURSE, $DB;
561     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
563     if(!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')){
564         return;
565     }
567     $mform->addElement('static', 'hint', get_string('resetting_data','feedback'));
568     foreach($feedbacks as $feedback) {
569         $mform->addElement('checkbox', FEEDBACK_RESETFORM_RESET.$feedback->id, $feedback->name);
570         // $mform->addElement('checkbox', FEEDBACK_RESETFORM_DROP.$feedback->id, get_string('drop_feedback','feedback'));
571     }
574 /**
575  * Course reset form defaults.
576  *
577  * @global object
578  * @uses FEEDBACK_RESETFORM_RESET
579  * @param object $course
580  */
581 function feedback_reset_course_form_defaults($course) {
582     global $DB;
584     $return = array();
585     if(!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')){
586         return;
587     }
588     foreach($feedbacks as $feedback) {
589         $return[FEEDBACK_RESETFORM_RESET.$feedback->id] = true;
590         // $return[FEEDBACK_RESETFORM_DROP.$feedback->id] = false;
591     }
592     return $return;
595 /**
596  * Called by course/reset.php and shows the formdata by coursereset.
597  * it prints checkboxes for each feedback available at the given course
598  * there are two checkboxes: 1) delete userdata and keep the feedback 2) delete userdata and drop the feedback
599  *
600  * @global object
601  * @uses FEEDBACK_RESETFORM_RESET
602  * @uses FEEDBACK_RESETFORM_DROP
603  * @param object $course
604  * @return void
605  */
606 function feedback_reset_course_form($course) {
607     global $DB, $OUTPUT;
609     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
610     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
611         return;
612     }
614     foreach($feedbacks as $feedback) {
615         echo '<p>';
616         echo get_string('name','feedback').': '.$feedback->name.'<br />';
617         echo html_writer::checkbox(FEEDBACK_RESETFORM_RESET.$feedback->id, 1, true, get_string('resetting_data','feedback'));
618         echo '<br />';
619         echo html_writer::checkbox(FEEDBACK_RESETFORM_DROP.$feedback->id, 1, false, get_string('drop_feedback','feedback'));
620         echo '</p>';
621     }
624 /**
625  * This creates new events given as timeopen and closeopen by $feedback.
626  *
627  * @global object
628  * @param object $feedback
629  * @return void
630  */
631 function feedback_set_events($feedback) {
632     global $DB;
634     // adding the feedback to the eventtable (I have seen this at quiz-module)
635     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$feedback->id));
637     if (!isset($feedback->coursemodule)) {
638         $cm = get_coursemodule_from_id('feedback', $feedback->id);
639         $feedback->coursemodule = $cm->id;
640     }
642     // the open-event
643     if($feedback->timeopen > 0) {
644         $event = NULL;
645         $event->name         = get_string('start', 'feedback').' '.$feedback->name;
646         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
647         $event->courseid     = $feedback->course;
648         $event->groupid      = 0;
649         $event->userid       = 0;
650         $event->modulename   = 'feedback';
651         $event->instance     = $feedback->id;
652         $event->eventtype    = 'open';
653         $event->timestart    = $feedback->timeopen;
654         $event->visible      = instance_is_visible('feedback', $feedback);
655         if($feedback->timeclose > 0) {
656             $event->timeduration = ($feedback->timeclose - $feedback->timeopen);
657         } else {
658             $event->timeduration = 0;
659         }
661         calendar_event::create($event);
662     }
664     // the close-event
665     if($feedback->timeclose > 0) {
666         $event = NULL;
667         $event->name         = get_string('stop', 'feedback').' '.$feedback->name;
668         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
669         $event->courseid     = $feedback->course;
670         $event->groupid      = 0;
671         $event->userid       = 0;
672         $event->modulename   = 'feedback';
673         $event->instance     = $feedback->id;
674         $event->eventtype    = 'close';
675         $event->timestart    = $feedback->timeclose;
676         $event->visible      = instance_is_visible('feedback', $feedback);
677         $event->timeduration = 0;
679         calendar_event::create($event);
680     }
683 /**
684  *  this function is called by {@link feedback_delete_userdata()}
685  *  it drops the feedback-instance from the course_module table
686  *
687  * @global object
688  *  @param int $id the id from the coursemodule
689  *  @return boolean
690  */
691 function feedback_delete_course_module($id) {
692     global $DB;
694     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
695         return true;
696     }
697     return $DB->delete_records('course_modules', array('id'=>$cm->id));
702 ////////////////////////////////////////////////
703 //functions to handle capabilities
704 ////////////////////////////////////////////////
706 /**
707  *  returns the context-id related to the given coursemodule-id
708  *
709  * @staticvar object $context
710  *  @param int $cmid the coursemodule-id
711  *  @return object $context
712  */
713 function feedback_get_context($cmid) {
714     static $context;
716     if(isset($context)) return $context;
718     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
719             print_error('badcontext');
720     }
721     return $context;
724 /**
725  *  returns true if the current role is faked by switching role feature
726  *
727  * @global object
728  *  @return boolean
729  */
730 function feedback_check_is_switchrole(){
731     global $USER;
732     if(isset($USER->switchrole) AND is_array($USER->switchrole) AND count($USER->switchrole) > 0) {
733         return true;
734     }
735     return false;
738 /**
739  * count users which have not completed the feedback
740  *
741  * @global object
742  * @uses CONTEXT_MODULE
743  * @param object $cm
744  * @param int $group single groupid
745  * @param string $sort
746  * @param int $startpage
747  * @param int $pagecount
748  * @return object the userrecords
749  */
750 function feedback_get_incomplete_users($cm, $group = false, $sort = '', $startpage = false, $pagecount = false) {
751     global $DB;
753     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
755     //first get all user who can complete this feedback
756     $cap = 'mod/feedback:complete';
757     $fields = 'u.id, u.username';
758     if(!$allusers = get_users_by_capability($context, $cap, $fields, $sort, '', '', $group, '', true)) {
759         return false;
760     }
761     $allusers = array_keys($allusers);
763     //now get all completeds
764     if(!$completedusers = $DB->get_records_menu('feedback_completed', array('feedback'=>$cm->instance), '', 'userid,id')){
765         return $allusers;
766     }
767     $completedusers = array_keys($completedusers);
769     //now strike all completedusers from allusers
770     $allusers = array_diff($allusers, $completedusers);
772     //for paging I use array_slice()
773     if($startpage !== false AND $pagecount !== false) {
774         $allusers = array_slice($allusers, $startpage, $pagecount);
775     }
777     return $allusers;
780 /**
781  * count users which have not completed the feedback
782  *
783  * @global object
784  * @param object $cm
785  * @param int $group single groupid
786  * @return int count of userrecords
787  */
788 function feedback_count_incomplete_users($cm, $group = false) {
789     if($allusers = feedback_get_incomplete_users($cm, $group)) {
790         return count($allusers);
791     }
792     return 0;
795 /**
796  * count users which have completed a feedback
797  *
798  * @global object
799  * @uses FEEDBACK_ANONYMOUS_NO
800  * @param object $cm
801  * @param int $group single groupid
802  * @return int count of userrecords
803  */
804 function feedback_count_complete_users($cm, $group = false) {
805     global $DB;
807     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
809     $fromgroup = '';
810     $wheregroup = '';
811     if($group) {
812         $fromgroup = ', {groups_members} g';
813         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
814         $params[] = $group;
815     }
817     $sql = 'SELECT COUNT(u.id) FROM {user} u, {feedback_completed} c'.$fromgroup.'
818               WHERE anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
819               '.$wheregroup;
820               ;
822     return $DB->count_records_sql($sql, $params);
826 /**
827  * get users which have completed a feedback
828  *
829  * @global object
830  * @uses CONTEXT_MODULE
831  * @uses FEEDBACK_ANONYMOUS_NO
832  * @param object $cm
833  * @param int $group single groupid
834  * @param string $where a sql where condition (must end with " AND ")
835  * @param array parameters used in $where
836  * @param string $sort a table field
837  * @param int $startpage
838  * @param int $pagecount
839  * @return object the userrecords
840  */
841 function feedback_get_complete_users($cm, $group = false, $where = '', array $params = NULL, $sort = '', $startpage = false, $pagecount = false) {
842     global $DB;
844     if (!$context = get_context_instance(CONTEXT_MODULE, $cm->id)) {
845             print_error('badcontext');
846     }
848     $params = (array)$params;
850     $params['anon'] = FEEDBACK_ANONYMOUS_NO;
851     $params['instance'] = $cm->instance;
853     $fromgroup = '';
854     $wheregroup = '';
855     if ($group) {
856         $fromgroup = ', {groups_members} g';
857         $wheregroup = ' AND g.groupid = :group AND g.userid = c.userid';
858         $params['group'] = $group;
859     }
861     if ($sort) {
862         $sortsql = ' ORDER BY '.$sort;
863     } else {
864         $sortsql = '';
865     }
867     $ufields = user_picture::fields('u');
868     $sql = 'SELECT DISTINCT '.$ufields.' FROM {user} u, {feedback_completed} c '.$fromgroup.'
869               WHERE '.$where.' anonymous_response = :anon AND u.id = c.userid AND c.feedback = :instance
870               '.$wheregroup.$sortsql;
872     if ($startpage === false OR $pagecount === false) {
873         $startpage = false;
874         $pagecount = false;
875     }
876     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
879 /**
880  * get users which have the viewreports-capability
881  *
882  * @uses CONTEXT_MODULE
883  * @param int $cmid
884  * @param mixed $groups single groupid or array of groupids - group(s) user is in
885  * @return object the userrecords
886  */
887 function feedback_get_viewreports_users($cmid, $groups = false) {
889     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
890             print_error('badcontext');
891     }
893     //description of the call below: get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='', $limitnum='', $groups='', $exceptions='', $doanything=true)
894     return get_users_by_capability($context, 'mod/feedback:viewreports', '', 'lastname', '', '', $groups, '', false);
897 /**
898  * get users which have the receivemail-capability
899  *
900  * @uses CONTEXT_MODULE
901  * @param int $cmid
902  * @param mixed $groups single groupid or array of groupids - group(s) user is in
903  * @return object the userrecords
904  */
905 function feedback_get_receivemail_users($cmid, $groups = false) {
907     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
908             print_error('badcontext');
909     }
911     //description of the call below: get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='', $limitnum='', $groups='', $exceptions='', $doanything=true)
912     return get_users_by_capability($context, 'mod/feedback:receivemail', '', 'lastname', '', '', $groups, '', false);
915 ////////////////////////////////////////////////
916 //functions to handle the templates
917 ////////////////////////////////////////////////
918 ////////////////////////////////////////////////
920 /**
921  * creates a new template-record.
922  *
923  * @global object
924  * @param int $courseid
925  * @param string $name the name of template shown in the templatelist
926  * @param int $ispublic 0:privat 1:public
927  * @return int the new templateid
928  */
929 function feedback_create_template($courseid, $name, $ispublic = 0) {
930     global $DB;
932     $templ = new stdClass();
933     $templ->course   = $courseid;
934     $templ->name     = $name;
935     $templ->ispublic = $ispublic;
937     $templid = $DB->insert_record('feedback_template', $templ);
938     return $DB->get_record('feedback_template', array('id'=>$templid));
941 /**
942  * creates new template items.
943  * all items will be copied and the attribute feedback will be set to 0
944  * and the attribute template will be set to the new templateid
945  *
946  * @global object
947  * @uses CONTEXT_MODULE
948  * @uses CONTEXT_COURSE
949  * @param object $feedback
950  * @param string $name the name of template shown in the templatelist
951  * @param int $ispublic 0:privat 1:public
952  * @return boolean
953  */
954 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
955     global $DB;
956     $fs = get_file_storage();
958     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
959         return false;
960     }
962     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
963         return false;
964     }
966     //files in the template_item are in the context of the current course
967     //files in the feedback_item are in the feedback_context of the feedback
968     $c_context = get_context_instance(CONTEXT_COURSE, $newtempl->course);
969     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
970     $f_context = get_context_instance(CONTEXT_MODULE, $cm->id);
972     //create items of this new template
973     //depend items we are storing temporary in an mapping list array(new id => dependitem)
974     //we also store a mapping of all items array(oldid => newid)
975     $dependitemsmap = array();
976     $itembackup = array();
977     foreach($feedbackitems as $item) {
979         $t_item = clone($item);
981         unset($t_item->id);
982         $t_item->feedback = 0;
983         $t_item->template     = $newtempl->id;
984         $t_item->id = $DB->insert_record('feedback_item', $t_item);
985         //copy all included files to the feedback_template filearea
986         if ($itemfiles = $fs->get_area_files($f_context->id, 'mod_feedback', 'item', $item->id, "id", false)) {
987             foreach($itemfiles as $ifile) {
988                 $file_record = new stdClass();
989                 $file_record->contextid = $c_context->id;
990                 $file_record->component = 'mod_feedback';
991                 $file_record->filearea = 'template';
992                 $file_record->itemid = $t_item->id;
993                 $fs->create_file_from_storedfile($file_record, $ifile);
994             }
995         }
997         $itembackup[$item->id] = $t_item->id;
998         if($t_item->dependitem) {
999             $dependitemsmap[$t_item->id] = $t_item->dependitem;
1000         }
1002     }
1004     //remapping the dependency
1005     foreach($dependitemsmap as $key => $dependitem) {
1006         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1007         $newitem->dependitem = $itembackup[$newitem->dependitem];
1008         $DB->update_record('feedback_item', $newitem);
1009     }
1011     return true;
1014 /**
1015  * deletes all feedback_items related to the given template id
1016  *
1017  * @global object
1018  * @uses CONTEXT_COURSE
1019  * @param int $id the templateid
1020  * @return void
1021  */
1022 function feedback_delete_template($id) {
1023     global $DB;
1025     $template = $DB->get_record("feedback_template", array("id"=>$id));
1027     //deleting the files from the item
1028     $fs = get_file_storage();
1029     $context = get_context_instance(CONTEXT_COURSE, $template->course);
1032     if($t_items = $DB->get_records("feedback_item", array("template"=>$id))) {
1033         foreach($t_items as $t_item) {
1034             if ($templatefiles = $fs->get_area_files($context->id, 'mod_feedback', 'template', $t_item->id, "id", false)) {
1035                 $fs->delete_area_files($context->id, 'mod_feedback', 'template', $t_item->id);
1036             }
1037         }
1038     }
1039     $DB->delete_records("feedback_template", array("id"=>$id));
1042 /**
1043  * creates new feedback_item-records from template.
1044  * if $deleteold is set true so the existing items of the given feedback will be deleted
1045  * if $deleteold is set false so the new items will be appanded to the old items
1046  *
1047  * @global object
1048  * @uses CONTEXT_COURSE
1049  * @uses CONTEXT_MODULE
1050  * @param object $feedback
1051  * @param int $templateid
1052  * @param boolean $deleteold
1053  */
1054 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1055     global $DB, $CFG;
1057     require_once($CFG->libdir.'/completionlib.php');
1059     $fs = get_file_storage();
1061     //get all templateitems
1062     if(!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1063         return false;
1064     }
1066     //files in the template_item are in the context of the current course
1067     //files in the feedback_item are in the feedback_context of the feedback
1068     $c_context = get_context_instance(CONTEXT_COURSE, $feedback->course);
1069     $course = $DB->get_record('course', array('id'=>$feedback->course));
1070     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1071     $f_context = get_context_instance(CONTEXT_MODULE, $cm->id);
1073     //if deleteold then delete all old items before
1074     //get all items
1075     if($deleteold) {
1076         if($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1077             //delete all items of this feedback
1078             foreach($feedbackitems as $item) {
1079                 feedback_delete_item($item->id, false);
1080             }
1081             //delete tracking-data
1082             $DB->delete_records('feedback_tracking', array('feedback'=>$feedback->id));
1084             if($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1085                 $completion = new completion_info($course);
1086                 foreach($completeds as $completed) {
1087                     // Update completion state
1088                     if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
1089                         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1090                     }
1091                     $DB->delete_records('feedback_completed', array('id'=>$completed->id));
1092                 }
1093             }
1094             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1095         }
1096         $positionoffset = 0;
1097     } else {
1098         //if the old items are kept the new items will be appended
1099         //therefor the new position has an offset
1100         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1101     }
1103     //create items of this new template
1104     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1105     //we also store a mapping of all items array(oldid => newid)
1106     $dependitemsmap = array();
1107     $itembackup = array();
1108     foreach($templitems as $t_item) {
1109         $item = clone($t_item);
1110         unset($item->id);
1111         $item->feedback = $feedback->id;
1112         $item->template = 0;
1113         $item->position = $item->position + $positionoffset;
1115         $item->id = $DB->insert_record('feedback_item', $item);
1117         //TODO: moving the files to the new items
1118         if ($templatefiles = $fs->get_area_files($c_context->id, 'mod_feedback', 'template', $t_item->id, "id", false)) {
1119             foreach($templatefiles as $tfile) {
1120                 $file_record = new stdClass();
1121                 $file_record->contextid = $f_context->id;
1122                 $file_record->component = 'mod_feedback';
1123                 $file_record->filearea = 'item';
1124                 $file_record->itemid = $item->id;
1125                 $fs->create_file_from_storedfile($file_record, $tfile);
1126             }
1127         }
1129         $itembackup[$t_item->id] = $item->id;
1130         if($item->dependitem) {
1131             $dependitemsmap[$item->id] = $item->dependitem;
1132         }
1133     }
1135     //remapping the dependency
1136     foreach($dependitemsmap as $key => $dependitem) {
1137         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1138         $newitem->dependitem = $itembackup[$newitem->dependitem];
1139         $DB->update_record('feedback_item', $newitem);
1140     }
1143 /**
1144  * get the list of available templates.
1145  * if the $onlyown param is set true so only templates from own course will be served
1146  * this is important for droping templates
1147  *
1148  * @global object
1149  * @param object $course
1150  * @param boolean $onlyown
1151  * @return array the template recordsets
1152  */
1153 function feedback_get_template_list($course, $onlyown = false) {
1154     global $DB;
1156     if ($onlyown) {
1157         $templates = $DB->get_records('feedback_template', array('course'=>$course->id));
1158     } else {
1159         $templates = $DB->get_records_select('feedback_template', 'course = ? OR ispublic = 1', array($course->id));
1160     }
1161     return $templates;
1164 ////////////////////////////////////////////////
1165 //Handling der Items
1166 ////////////////////////////////////////////////
1167 ////////////////////////////////////////////////
1169 /**
1170  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1171  *
1172  * @global object
1173  * @param object $item
1174  * @return object the instanz of itemclass
1175  */
1176 function feedback_get_item_class($typ) {
1177     global $CFG;
1179     //get the class of item-typ
1180     $itemclass = 'feedback_item_'.$typ;
1181     //get the instance of item-class
1182     if (!class_exists($itemclass)) {
1183         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1184     }
1185     return new $itemclass();
1188 /**
1189  * load the available item plugins from given subdirectory of $CFG->dirroot
1190  * the default is "mod/feedback/item"
1191  *
1192  * @global object
1193  * @param string $dir the subdir
1194  * @return array pluginnames as string
1195  */
1196 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1197     global $CFG;
1198     $names = get_list_of_plugins($dir);
1199     $ret_names = array();
1201     foreach($names as $name) {
1202         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1203         if(class_exists('feedback_item_'.$name)) {
1204           $ret_names[] = $name;
1205         }
1206     }
1207     return $ret_names;
1210 /**
1211  * load the available item plugins to use as dropdown-options
1212  *
1213  * @global object
1214  * @return array pluginnames as string
1215  */
1216 function feedback_load_feedback_items_options() {
1217     global $CFG;
1219     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1221     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1222         return array();
1223     }
1225     foreach($feedback_names as $fn) {
1226         $feedback_options[$fn] = get_string($fn,'feedback');
1227     }
1228     asort($feedback_options);
1229     $feedback_options = array_merge( array(' ' => get_string('select')), $feedback_options );
1230     return $feedback_options;
1233 /**
1234  * load the available items for the depend item dropdown list shown in the edit_item form
1235  *
1236  * @global object
1237  * @param object $feedback
1238  * @param object $item the item of the edit_item form
1239  * @return array all items except the item $item, labels and pagebreaks
1240  */
1241 function feedback_get_depend_candidates_for_item($feedback, $item) {
1242     global $DB;
1243     //all items for dependitem
1244     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1245     $params = array($feedback->id);
1246     if(isset($item->id) AND $item->id) {
1247         $where .= ' AND id != ?';
1248         $params[] = $item->id;
1249     }
1250     $dependitems = array(0 => get_string('choose'));
1251     if(!$feedbackitems = $DB->get_records_select_menu('feedback_item', $where, $params, 'position', 'id, label')) {
1252         return $dependitems;
1253     }
1254     //adding the choose-option
1255     foreach($feedbackitems as $key=>$val) {
1256         $dependitems[$key] = $val;
1257     }
1258     return $dependitems;
1261 /**
1262  * creates a new item-record
1263  *
1264  * @global object
1265  * @param object $data the data from edit_item_form
1266  * @return int the new itemid
1267  */
1268 function feedback_create_item($data) {
1269     global $DB;
1271     $item = new stdClass();
1272     $item->feedback = $data->feedbackid;
1274     $item->template=0;
1275     if (isset($data->templateid)) {
1276             $item->template = intval($data->templateid);
1277     }
1279     $itemname = trim($data->itemname);
1280     $item->name = ($itemname ? $data->itemname : get_string('no_itemname', 'feedback'));
1282     if (!empty($data->itemlabel)) {
1283         $item->label = trim($data->itemlabel);
1284     } else {
1285         $item->label = get_string('no_itemlabel', 'feedback');
1286     }
1288     $itemobj = feedback_get_item_class($data->typ);
1289     // $item->presentation = $itemobj->get_presentation($data);
1290     $item->presentation = ''; //the date comes from postupdate() of the itemobj
1292     $item->hasvalue = $itemobj->get_hasvalue();
1294     $item->typ = $data->typ;
1295     $item->position = $data->position;
1297     $item->required=0;
1298     if (!empty($data->required)) {
1299         $item->required = $data->required;
1300     }
1302     $item->id = $DB->insert_record('feedback_item', $item);
1304     //move all itemdata to the data
1305     $data->id = $item->id;
1306     $data->feedback = $item->feedback;
1307     $data->name = $item->name;
1308     $data->label = $item->label;
1309     $data->required = $item->required;
1310     return $itemobj->postupdate($data);
1313 /**
1314  * save the changes of a given item.
1315  *
1316  * @global object
1317  * @param object $item
1318  * @return boolean
1319  */
1320 function feedback_update_item($item){
1321     global $DB;
1322     return $DB->update_record("feedback_item", $item);
1325 /**
1326  * deletes an item and also deletes all related values
1327  *
1328  * @global object
1329  * @uses CONTEXT_MODULE
1330  * @param int $itemid
1331  * @param boolean $renumber should the kept items renumbered Yes/No
1332  * @return void
1333  */
1334 function feedback_delete_item($itemid, $renumber = true){
1335     global $DB;
1338     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1340     //deleting the files from the item
1341     $fs = get_file_storage();
1342     if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1343         return false;
1344     }
1345     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
1347     if ($itemfiles = $fs->get_area_files($context->id, 'mod_feedback', 'item', $item->id, "id", false)) {
1348         $fs->delete_area_files($context->id, 'mod_feedback', 'item', $item->id);
1349     }
1351     $DB->delete_records("feedback_value", array("item"=>$itemid));
1352     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1354     //remove all depends
1355     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1356     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1358     $DB->delete_records("feedback_item", array("id"=>$itemid));
1359     if($renumber) {
1360         feedback_renumber_items($item->feedback);
1361     }
1364 /**
1365  * deletes all items of the given feedbackid
1366  *
1367  * @global object
1368  * @param int $feedbackid
1369  * @return void
1370  */
1371 function feedback_delete_all_items($feedbackid){
1372     global $DB, $CFG;
1373     require_once($CFG->libdir.'/completionlib.php');
1375     if(!$feedback = $DB->get_record('feedback', array('id'=>$feedbackid))) {
1376         return false;
1377     }
1379     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
1380         return false;
1381     }
1383     if(!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
1384         return false;
1385     }
1387     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1388         return;
1389     }
1390     foreach($items as $item) {
1391         feedback_delete_item($item->id, false);
1392     }
1393     // $DB->delete_records('feedback_completed', array('feedback'=>$feedbackid));
1394     if($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1395         $completion = new completion_info($course);
1396         foreach($completeds as $completed) {
1397             // Update completion state
1398             if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
1399                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1400             }
1401             $DB->delete_records('feedback_completed', array('id'=>$completed->id));
1402         }
1403     }
1405     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1409 /**
1410  * this function toggled the item-attribute required (yes/no)
1411  *
1412  * @global object
1413  * @param object $item
1414  * @return boolean
1415  */
1416 function feedback_switch_item_required($item) {
1417     global $DB, $CFG;
1419     $itemobj = feedback_get_item_class($item->typ);
1421     if($itemobj->can_switch_require()) {
1422         $DB->set_field('feedback_item', 'required', (int)!(bool)$item->required, array('id'=>$item->id));
1423     }
1424     return true;
1427 /**
1428  * renumbers all items of the given feedbackid
1429  *
1430  * @global object
1431  * @param int $feedbackid
1432  * @return void
1433  */
1434 function feedback_renumber_items($feedbackid){
1435     global $DB;
1437     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1438     $pos = 1;
1439     if($items) {
1440         foreach($items as $item){
1441             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1442             $pos++;
1443         }
1444     }
1447 /**
1448  * this decreases the position of the given item
1449  *
1450  * @global object
1451  * @param object $item
1452  * @return bool
1453  */
1454 function feedback_moveup_item($item){
1455     global $DB;
1457     if($item->position == 1) {
1458         return true;
1459     }
1461     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$item->feedback), 'position')) {
1462         return false;
1463     }
1465     $itembefore = null;
1466     foreach($items as $i) {
1467         if($i->id == $item->id) {
1468             if(is_null($itembefore)) {
1469                 return true;
1470             }
1471             $itembefore->position = $item->position;
1472             $item->position--;
1473             feedback_update_item($itembefore);
1474             feedback_update_item($item);
1475             feedback_renumber_items($item->feedback);
1476             return true;
1477         }
1478         $itembefore = $i;
1479     }
1480     return false;
1483 /**
1484  * this increased the position of the given item
1485  *
1486  * @global object
1487  * @param object $item
1488  * @return bool
1489  */
1490 function feedback_movedown_item($item){
1491     global $DB;
1493     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$item->feedback), 'position')) {
1494         return false;
1495     }
1497     $movedownitem = null;
1498     foreach($items as $i) {
1499         if(!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1500             $movedownitem->position = $i->position;
1501             $i->position--;
1502             feedback_update_item($movedownitem);
1503             feedback_update_item($i);
1504             feedback_renumber_items($item->feedback);
1505             return true;
1506         }
1507         $movedownitem = $i;
1508     }
1509     return false;
1512 /**
1513  * here the position of the given item will be set to the value in $pos
1514  *
1515  * @global object
1516  * @param object $moveitem
1517  * @param int $pos
1518  * @return boolean
1519  */
1520 function feedback_move_item($moveitem, $pos){
1521     global $DB;
1523     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$moveitem->feedback), 'position')) {
1524         return false;
1525     }
1526     if (is_array($allitems)) {
1527         $index = 1;
1528         foreach($allitems as $item) {
1529             if($index == $pos) {
1530                 $index++;
1531             }
1532             if($item->id == $moveitem->id) {
1533                 $moveitem->position = $pos;
1534                 feedback_update_item($moveitem);
1535                 continue;
1536             }
1537             $item->position = $index;
1538             feedback_update_item($item);
1539             $index++;
1540         }
1541         return true;
1542     }
1543     return false;
1546 /**
1547  * prints the given item as a preview.
1548  * each item-class has an own print_item_preview function implemented.
1549  *
1550  * @global object
1551  * @param object $item the item what we want to print out
1552  * @return void
1553  */
1554 function feedback_print_item_preview($item){
1555     global $CFG;
1556     if($item->typ == 'pagebreak') {
1557         return;
1558     }
1559     //get the instance of the item-class
1560     $itemobj = feedback_get_item_class($item->typ);
1561     $itemobj->print_item_preview($item);
1564 /**
1565  * prints the given item in the completion form.
1566  * each item-class has an own print_item_complete function implemented.
1567  *
1568  * @param object $item the item what we want to print out
1569  * @param mixed $value the value
1570  * @param boolean $highlightrequire if this set true and the value are false on completing so the item will be highlighted
1571  * @return void
1572  */
1573 function feedback_print_item_complete($item, $value = false, $highlightrequire = false){
1574     global $CFG;
1575     if($item->typ == 'pagebreak') {
1576         return;
1577     }
1579     //get the instance of the item-class
1580     $itemobj = feedback_get_item_class($item->typ);
1581     $itemobj->print_item_complete($item, $value, $highlightrequire);
1584 /**
1585  * prints the given item in the show entries page.
1586  * each item-class has an own print_item_show_value function implemented.
1587  *
1588  * @param object $item the item what we want to print out
1589  * @param mixed $value
1590  * @return void
1591  */
1592 function feedback_print_item_show_value($item, $value = false){
1593     global $CFG;
1594     if($item->typ == 'pagebreak') {
1595         return;
1596     }
1598     //get the instance of the item-class
1599     $itemobj = feedback_get_item_class($item->typ);
1600     $itemobj->print_item_show_value($item, $value);
1603 /**
1604  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1605  * the values are not saved permanently until the user click on save button
1606  *
1607  * @global object
1608  * @param object $feedbackcompleted
1609  * @return object temporary saved completed-record
1610  */
1611 function feedback_set_tmp_values($feedbackcompleted) {
1612     global $DB;
1614     //first we create a completedtmp
1615     $tmpcpl = new stdClass();
1616     foreach($feedbackcompleted as $key => $value) {
1617         $tmpcpl->{$key} = $value;
1618     }
1619     // $tmpcpl = $feedbackcompleted;
1620     unset($tmpcpl->id);
1621     $tmpcpl->timemodified = time();
1622     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1623     //get all values of original-completed
1624     if(!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1625         return;
1626     }
1627     foreach($values as $value) {
1628         unset($value->id);
1629         $value->completed = $tmpcpl->id;
1630         $DB->insert_record('feedback_valuetmp', $value);
1631     }
1632     return $tmpcpl;
1635 /**
1636  * this saves the temporary saved values permanently
1637  *
1638  * @global object
1639  * @param object $feedbackcompletedtmp the temporary completed
1640  * @param object $feedbackcompleted the target completed
1641  * @param int $userid
1642  * @return int the id of the completed
1643  */
1644 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted, $userid) {
1645     global $DB;
1647     $tmpcplid = $feedbackcompletedtmp->id;
1648     if($feedbackcompleted) {
1649         //first drop all existing values
1650         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1651         //update the current completed
1652         $feedbackcompleted->timemodified = time();
1653         $DB->update_record('feedback_completed', $feedbackcompleted);
1654     }else {
1655         $feedbackcompleted = clone($feedbackcompletedtmp);
1656         $feedbackcompleted->id = '';
1657         $feedbackcompleted->userid = $userid;
1658         $feedbackcompleted->timemodified = time();
1659         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
1660     }
1662     //save all the new values from feedback_valuetmp
1663     //get all values of tmp-completed
1664     if(!$values = $DB->get_records('feedback_valuetmp', array('completed'=>$feedbackcompletedtmp->id))) {
1665         return false;
1666     }
1667     foreach($values as $value) {
1668         //check if there are depend items
1669         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
1670         if($item->dependitem > 0) {
1671             $check = feedback_compare_item_value($tmpcplid, $item->dependitem, $item->dependvalue, true);
1672         }else {
1673             $check = true;
1674         }
1675         if($check) {
1676             unset($value->id);
1677             $value->completed = $feedbackcompleted->id;
1678             $DB->insert_record('feedback_value', $value);
1679         }
1680     }
1681     //drop all the tmpvalues
1682     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1683     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1684     return $feedbackcompleted->id;
1688 /**
1689  * deletes the given temporary completed and all related temporary values
1690  *
1691  * @global object
1692  * @param int $tmpcplid
1693  * @return void
1694  */
1695 function feedback_delete_completedtmp($tmpcplid) {
1696     global $DB;
1698     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1699     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1702 ////////////////////////////////////////////////
1703 ////////////////////////////////////////////////
1704 ////////////////////////////////////////////////
1705 //functions to handle the pagebreaks
1706 ////////////////////////////////////////////////
1708 /**
1709  * this creates a pagebreak.
1710  * a pagebreak is a special kind of item
1711  *
1712  * @global object
1713  * @param int $feedbackid
1714  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
1715  */
1716 function feedback_create_pagebreak($feedbackid) {
1717     global $DB;
1719     //check if there already is a pagebreak on the last position
1720     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
1721     if($lastposition == feedback_get_last_break_position($feedbackid)) {
1722         return false;
1723     }
1725     $item = new stdClass();
1726     $item->feedback = $feedbackid;
1728     $item->template=0;
1730     $item->name = '';
1732     $item->presentation = '';
1733     $item->hasvalue = 0;
1735     $item->typ = 'pagebreak';
1736     $item->position = $lastposition + 1;
1738     $item->required=0;
1740     return $DB->insert_record('feedback_item', $item);
1743 /**
1744  * get all positions of pagebreaks in the given feedback
1745  *
1746  * @global object
1747  * @param int $feedbackid
1748  * @return array all ordered pagebreak positions
1749  */
1750 function feedback_get_all_break_positions($feedbackid) {
1751     global $DB;
1753     if(!$allbreaks = $DB->get_records_menu('feedback_item', array('typ'=>'pagebreak', 'feedback'=>$feedbackid), 'position', 'id, position')) return false;
1754     return array_values($allbreaks);
1757 /**
1758  * get the position of the last pagebreak
1759  *
1760  * @param int $feedbackid
1761  * @return int the position of the last pagebreak
1762  */
1763 function feedback_get_last_break_position($feedbackid) {
1764     if(!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
1765         return false;
1766     }
1767     return $allbreaks[count($allbreaks) - 1];
1770 /**
1771  * this returns the position where the user can continue the completing.
1772  *
1773  * @global object
1774  * @global object
1775  * @global object
1776  * @param int $feedbackid
1777  * @param int $courseid
1778  * @param string $guestid this id will be saved temporary and is unique
1779  * @return int the position to continue
1780  */
1781 function feedback_get_page_to_continue($feedbackid, $courseid = false, $guestid = false) {
1782     global $CFG, $USER, $DB;
1784     //is there any break?
1786     if(!$allbreaks = feedback_get_all_break_positions($feedbackid)) return false;
1788     $params = array();
1789     if($courseid) {
1790         $courseselect = "AND fv.course_id = :courseid";
1791         $params['courseid'] = $courseid;
1792     }else {
1793         $courseselect = '';
1794     }
1796     if($guestid) {
1797         $userselect = "AND fc.guestid = :guestid";
1798         $usergroup = "GROUP BY fc.guestid";
1799         $params['guestid'] = $guestid;
1800     }else {
1801         $userselect = "AND fc.userid = :userid";
1802         $usergroup = "GROUP BY fc.userid";
1803         $params['userid'] = $USER->id;
1804     }
1806     $sql =  "SELECT MAX(fi.position)
1807                FROM {feedback_completedtmp} fc, {feedback_valuetmp} fv, {feedback_item} fi
1808               WHERE fc.id = fv.completed
1809                     $userselect
1810                     AND fc.feedback = :feedbackid
1811                     $courseselect
1812                     AND fi.id = fv.item
1813          $usergroup";
1814     $params['feedbackid'] = $feedbackid;
1816     $lastpos = $DB->get_field_sql($sql, $params);
1818     //the index of found pagebreak is the searched pagenumber
1819     foreach($allbreaks as $pagenr => $br) {
1820         if($lastpos < $br) return $pagenr;
1821     }
1822     return count($allbreaks);
1825 ////////////////////////////////////////////////
1826 ////////////////////////////////////////////////
1827 ////////////////////////////////////////////////
1828 //functions to handle the values
1829 ////////////////////////////////////////////////
1831 /**
1832  * this saves the values of an completed.
1833  * if the param $tmp is set true so the values are saved temporary in table feedback_valuetmp.
1834  * if there is already a completed and the userid is set so the values are updated.
1835  * on all other things new value records will be created.
1836  *
1837  * @global object
1838  * @param int $userid
1839  * @param boolean $tmp
1840  * @return mixed false on error or the completeid
1841  */
1842 function feedback_save_values($usrid, $tmp = false) {
1843     global $DB;
1845     $completedid = optional_param('completedid', false, PARAM_INT);
1847     $tmpstr = $tmp ? 'tmp' : '';
1848     $time = time();
1849     $timemodified = mktime(0, 0, 0, date('m', $time),date('d', $time),date('Y', $time));
1851     if($usrid == 0) {
1852         return feedback_create_values($usrid, $timemodified, $tmp);
1853     }
1854     if(!$completedid or !$completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid))) {
1855         return feedback_create_values($usrid, $timemodified, $tmp);
1856     }else{
1857         $completed->timemodified = $timemodified;
1858         return feedback_update_values($completed, $tmp);
1859     }
1862 /**
1863  * this saves the values from anonymous user such as guest on the main-site
1864  *
1865  * @global object
1866  * @param string $guestid the unique guestidentifier
1867  * @return mixed false on error or the completeid
1868  */
1869 function feedback_save_guest_values($guestid) {
1870     global $DB;
1872     $completedid = optional_param('completedid', false, PARAM_INT);
1874     $timemodified = time();
1875     if(!$completed = $DB->get_record('feedback_completedtmp', array('id'=>$completedid))) {
1876         return feedback_create_values(0, $timemodified, true, $guestid);
1877     }else {
1878         $completed->timemodified = $timemodified;
1879         return feedback_update_values($completed, true);
1880     }
1883 /**
1884  * get the value from the given item related to the given completed.
1885  * the value can come as temporary or as permanently value. the deciding is done by $tmp
1886  *
1887  * @global object
1888  * @param int $completeid
1889  * @param int $itemid
1890  * @param boolean $tmp
1891  * @return mixed the value, the type depends on plugin-definition
1892  */
1893 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
1894     global $DB;
1896     $tmpstr = $tmp ? 'tmp' : '';
1897     return $DB->get_field('feedback_value'.$tmpstr, 'value', array('completed'=>$completedid, 'item'=>$itemid));
1900 /**
1901  * compares the value of the itemid related to the completedid with the dependvalue.
1902  * this is used if a depend item is set.
1903  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
1904  *
1905  * @global object
1906  * @global object
1907  * @param int $completeid
1908  * @param int $itemid
1909  * @param mixed $dependvalue
1910  * @param boolean $tmp
1911  * @return bool
1912  */
1913 function feedback_compare_item_value($completedid, $itemid, $dependvalue, $tmp = false) {
1914     global $DB, $CFG;
1916     $dbvalue = feedback_get_item_value($completedid, $itemid, $tmp);
1918     //get the class of the given item-typ
1919     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1921     //get the instance of the item-class
1922     $itemobj = feedback_get_item_class($item->typ);
1923     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
1926 /**
1927  * this function checks the correctness of values.
1928  * the rules for this are implemented in the class of each item.
1929  * it can be the required attribute or the value self e.g. numeric.
1930  * the params first/lastitem are given to determine the visible range between pagebreaks.
1931  *
1932  * @global object
1933  * @param int $firstitem the position of firstitem for checking
1934  * @param int $lastitem the position of lastitem for checking
1935  * @return boolean
1936  */
1937 function feedback_check_values($firstitem, $lastitem) {
1938     global $DB, $CFG;
1940     $feedbackid = optional_param('feedbackid', 0, PARAM_INT);
1942     //get all items between the first- and lastitem
1943     $select = "feedback = ?
1944                     AND position >= ?
1945                     AND position <= ?
1946                     AND hasvalue = 1";
1947     $params = array($feedbackid, $firstitem, $lastitem);
1948     if(!$feedbackitems = $DB->get_records_select('feedback_item', $select, $params)) {
1949         //if no values are given so no values can be wrong ;-)
1950         return true;
1951     }
1953     foreach($feedbackitems as $item) {
1954         //the name of the input field of the completeform is given in a special form:
1955         //<item-typ>_<item-id> eg. numeric_234
1956         //this is the key to get the value for the correct item
1957         $formvalname = $item->typ . '_' . $item->id;
1959         $value = optional_param($formvalname, NULL, PARAM_RAW);
1961         //check if the value is set
1962         if(is_null($value) AND $item->required == 1) {
1963             return false;
1964         }
1966         //get the instance of the item-class
1967         $itemobj = feedback_get_item_class($item->typ);
1969         //now we let check the value by the item-class
1970         if(!$itemobj->check_value($value, $item)) {
1971             return false;
1972         }
1973     }
1974     //if no wrong values so we can return true
1975     return true;
1978 /**
1979  * this function create a complete-record and the related value-records.
1980  * depending on the $tmp (true/false) the values are saved temporary or permanently
1981  *
1982  * @global object
1983  * @param int $userid
1984  * @param int $timemodified
1985  * @param boolean $tmp
1986  * @param string $guestid a unique identifier to save temporary data
1987  * @return mixed false on error or the completedid
1988  */
1989 function feedback_create_values($usrid, $timemodified, $tmp = false, $guestid = false){
1990     global $DB;
1992     $feedbackid = optional_param('feedbackid', false, PARAM_INT);
1993     $anonymous_response = optional_param('anonymous_response', false, PARAM_INT);
1994     $courseid = optional_param('courseid', false, PARAM_INT);
1996     $tmpstr = $tmp ? 'tmp' : '';
1997     //first we create a new completed record
1998     $completed = new stdClass();
1999     $completed->feedback           = $feedbackid;
2000     $completed->userid             = $usrid;
2001     $completed->guestid            = $guestid;
2002     $completed->timemodified       = $timemodified;
2003     $completed->anonymous_response = $anonymous_response;
2005     $completedid = $DB->insert_record('feedback_completed'.$tmpstr, $completed);
2007     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2009     //the keys are in the form like abc_xxx
2010     //with explode we make an array with(abc, xxx) and (abc=typ und xxx=itemnr)
2012     //get the items of the feedback
2013     if(!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2014         return false;
2015     }
2016     foreach($allitems as $item) {
2017         $keyname = $item->typ.'_'.$item->id;
2018         $itemvalue = optional_param($keyname, NULL, PARAM_RAW);
2019         if(is_null($itemvalue)) {
2020             continue;
2021         }
2022         $value = new stdClass();
2023         $value->item = $item->id;
2024         $value->completed = $completed->id;
2025         $value->course_id = $courseid;
2027         //get the class of item-typ
2028         $itemobj = feedback_get_item_class($item->typ);
2030         //the kind of values can be absolutely different so we run create_value directly by the item-class
2031         $value->value = $itemobj->create_value($itemvalue);
2032         $DB->insert_record('feedback_value'.$tmpstr, $value);
2033     }
2034     return $completed->id;
2037 /**
2038  * this function updates a complete-record and the related value-records.
2039  * depending on the $tmp (true/false) the values are saved temporary or permanently
2040  *
2041  * @global object
2042  * @param object $completed
2043  * @param boolean $tmp
2044  * @return int the completedid
2045  */
2046 function feedback_update_values($completed, $tmp = false) {
2047     global $DB;
2048     $courseid = optional_param('courseid', false, PARAM_INT);
2050     $tmpstr = $tmp ? 'tmp' : '';
2052     $DB->update_record('feedback_completed'.$tmpstr, $completed);
2053     //get the values of this completed
2054     $values = $DB->get_records('feedback_value'.$tmpstr, array('completed'=>$completed->id));
2056     //get the items of the feedback
2057     if(!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2058         return false;
2059     }
2060     foreach($allitems as $item) {
2061         $keyname = $item->typ.'_'.$item->id;
2062         $itemvalue = optional_param($keyname, NULL, PARAM_RAW);
2063         //is the itemvalue set (could be a subset of items because pagebreak)?
2064         if(is_null($itemvalue)) {
2065             continue;
2066         }
2068         $newvalue = new stdClass();
2069         $newvalue->item = $item->id;
2070         $newvalue->completed = $completed->id;
2071         $newvalue->course_id = $courseid;
2073         //get the class of item-typ
2074         $itemobj = feedback_get_item_class($item->typ);
2075         //the kind of values can be absolutely different so we run create_value directly by the item-class
2076         $newvalue->value = $itemobj->create_value($itemvalue);
2078         //check, if we have to create or update the value
2079         $exist = false;
2080         foreach($values as $value){
2081             if($value->item == $newvalue->item){
2082                 $newvalue->id = $value->id;
2083                 $exist = true;
2084                 break;
2085             }
2086         }
2087         if($exist){
2088             $DB->update_record('feedback_value'.$tmpstr, $newvalue);
2089         }else {
2090             $DB->insert_record('feedback_value'.$tmpstr, $newvalue);
2091         }
2092     }
2094     return $completed->id;
2097 /**
2098  * get the values of an item depending on the given groupid.
2099  * if the feedback is anonymous so the values are shuffled
2100  *
2101  * @global object
2102  * @global object
2103  * @param object $item
2104  * @param int $groupid
2105  * @param int $courseid
2106  * @param bool $ignore_empty if this is set true so empty values are not delivered
2107  * @return array the value-records
2108  */
2109 function feedback_get_group_values($item, $groupid = false, $courseid = false, $ignore_empty = false){
2110     global $CFG, $DB;
2112     //if the groupid is given?
2113     if (intval($groupid) > 0) {
2114         if($ignore_empty) {
2115             $ignore_empty_select = "AND fbv.value != ''";
2116         }
2117         else {
2118             $ignore_empty_select = "";
2119         }
2121         $query = 'SELECT fbv .  *
2122                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2123                    WHERE fbv.item = ?
2124                          AND fbv.completed = fbc.id
2125                          AND fbc.userid = gm.userid
2126                          '.$ignore_empty_select.'
2127                          AND gm.groupid = ?
2128                 ORDER BY fbc.timemodified';
2129         $values = $DB->get_records_sql($query, array($item->id, $groupid));
2131     } else {
2132         if($ignore_empty) {
2133             $ignore_empty_select = "AND value != ''";
2134         }
2135         else {
2136             $ignore_empty_select = "";
2137         }
2139         if ($courseid) {
2140             $values = $DB->get_records_select('feedback_value', "item = ? AND course_id = ? ".$ignore_empty_select, array($item->id, $courseid));
2141         } else {
2142             $values = $DB->get_records_select('feedback_value', "item = ? ".$ignore_empty_select, array($item->id));
2143         }
2144     }
2145     if ($DB->get_field('feedback', 'anonymous', array('id'=>$item->feedback)) == FEEDBACK_ANONYMOUS_YES) {
2146         if(is_array($values))
2147             shuffle($values);
2148     }
2149     return $values;
2152 /**
2153  * check for multiple_submit = false.
2154  * if the feedback is global so the courseid must be given
2155  *
2156  * @global object
2157  * @global object
2158  * @param int $feedbackid
2159  * @param int $courseid
2160  * @return boolean true if the feedback already is submitted otherwise false
2161  */
2162 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2163     global $USER, $DB;
2165     if (!$trackings = $DB->get_records_menu('feedback_tracking', array('userid'=>$USER->id, 'feedback'=>$feedbackid), '', 'id, completed')) {
2166         return false;
2167     }
2169     if($courseid) {
2170         $select = 'completed IN ('.implode(',',$trackings).') AND course_id = ?';
2171         if(!$values = $DB->get_records_select('feedback_value', $select, array($courseid))) {
2172             return false;
2173         }
2174     }
2176     return true;
2179 /**
2180  * if the completion of a feedback will be continued eg. by pagebreak or by multiple submit so the complete must be found.
2181  * if the param $tmp is set true so all things are related to temporary completeds
2182  *
2183  * @global object
2184  * @global object
2185  * @global object
2186  * @param int $feedbackid
2187  * @param boolean $tmp
2188  * @param int $courseid
2189  * @param string $guestid
2190  * @return int the id of the found completed
2191  */
2192 function feedback_get_current_completed($feedbackid, $tmp = false, $courseid = false, $guestid = false) {
2193     global $USER, $CFG, $DB;
2195     $tmpstr = $tmp ? 'tmp' : '';
2197     if(!$courseid) {
2198         if($guestid) {
2199             return $DB->get_record('feedback_completed'.$tmpstr, array('feedback'=>$feedbackid, 'guestid'=>$guestid));
2200         }else {
2201             return $DB->get_record('feedback_completed'.$tmpstr, array('feedback'=>$feedbackid, 'userid'=>$USER->id));
2202         }
2203     }
2205     $params = array();
2207     if ($guestid) {
2208         $userselect = "AND fc.guestid = :guestid";
2209         $params['guestid'] = $guestid;
2210     }else {
2211         $userselect = "AND fc.userid = :userid";
2212         $params['userid'] = $USER->id;
2213     }
2214     //if courseid is set the feedback is global. there can be more than one completed on one feedback
2215     $sql =  "SELECT DISTINCT fc.*
2216                FROM {feedback_value{$tmpstr}} fv, {feedback_completed{$tmpstr}} fc
2217               WHERE fv.course_id = :courseid
2218                     AND fv.completed = fc.id
2219                     $userselect
2220                     AND fc.feedback = :feedbackid";
2221     $params['courseid']   = intval($courseid);
2222     $params['feedbackid'] = $feedbackid;
2224     if (!$sqlresult = $DB->get_records_sql($sql, $params)) {
2225         return false;
2226     }
2227     foreach($sqlresult as $r) {
2228         return $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$r->id));
2229     }
2232 /**
2233  * get the completeds depending on the given groupid.
2234  *
2235  * @global object
2236  * @global object
2237  * @param object $feedback
2238  * @param int $groupid
2239  * @param int $courseid
2240  * @return mixed array of found completeds otherwise false
2241  */
2242 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2243     global $CFG, $DB;
2245     if (intval($groupid) > 0){
2246         $query = "SELECT fbc.*
2247                     FROM {feedback_completed} fbc, {groups_members} gm
2248                    WHERE fbc.feedback = ?
2249                          AND gm.groupid = ?
2250                          AND fbc.userid = gm.userid";
2251         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2252             return $values;
2253         } else {
2254             return false;
2255         }
2256     } else {
2257         if($courseid) {
2258             $query = "SELECT DISTINCT fbc.*
2259                         FROM {feedback_completed} fbc, {feedback_value} fbv
2260                         WHERE fbc.id = fbv.completed
2261                             AND fbc.feedback = ?
2262                             AND fbv.course_id = ?
2263                         ORDER BY random_response";
2264             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2265                 return $values;
2266             } else {
2267                 return false;
2268             }
2269         }else {
2270             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2271                 return $values;
2272             } else {
2273                 return false;
2274             }
2275         }
2276     }
2279 /**
2280  * get the count of completeds depending on the given groupid.
2281  *
2282  * @global object
2283  * @global object
2284  * @param object $feedback
2285  * @param int $groupid
2286  * @param int $courseid
2287  * @return mixed count of completeds or false
2288  */
2289 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2290     global $CFG, $DB;
2292     if ($courseid > 0 AND !$groupid <= 0) {
2293         $sql = "SELECT id, COUNT(item) AS ci
2294                   FROM {feedback_value}
2295                  WHERE course_id  = ?
2296               GROUP BY item ORDER BY ci DESC";
2297         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2298             $foundrecs = array_values($foundrecs);
2299             return $foundrecs[0]->ci;
2300         }
2301         return false;
2302     }
2303     if($values = feedback_get_completeds_group($feedback, $groupid)) {
2304         return sizeof($values);
2305     }else {
2306         return false;
2307     }
2310 /**
2311  * deletes all completed-recordsets from a feedback.
2312  * all related data such as values also will be deleted
2313  *
2314  * @global object
2315  * @param int $feedbackid
2316  * @return void
2317  */
2318 function feedback_delete_all_completeds($feedbackid) {
2319     global $DB;
2321     if (!$completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedbackid))) {
2322         return;
2323     }
2324     foreach($completeds as $completed) {
2325         feedback_delete_completed($completed->id);
2326     }
2329 /**
2330  * deletes a completed given by completedid.
2331  * all related data such values or tracking data also will be deleted
2332  *
2333  * @global object
2334  * @param int $completedid
2335  * @return boolean
2336  */
2337 function feedback_delete_completed($completedid) {
2338     global $DB, $CFG;
2339     require_once($CFG->libdir.'/completionlib.php');
2341     if (!$completed = $DB->get_record('feedback_completed', array('id'=>$completedid))) {
2342         return false;
2343     }
2345     if (!$feedback = $DB->get_record('feedback', array('id'=>$completed->feedback))) {
2346         return false;
2347     }
2349     if (!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
2350         return false;
2351     }
2353     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
2354         return false;
2355     }
2357     //first we delete all related values
2358     $DB->delete_records('feedback_value', array('completed'=>$completed->id));
2360     //now we delete all tracking data
2361     if($tracking = $DB->get_record('feedback_tracking', array('completed'=>$completed->id, 'feedback'=>$completed->feedback))) {
2362         $DB->delete_records('feedback_tracking', array('completed'=>$completed->id));
2363     }
2365     // Update completion state
2366     $completion = new completion_info($course);
2367     if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
2368         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
2369     }
2370     //last we delete the completed-record
2371     return $DB->delete_records('feedback_completed', array('id'=>$completed->id));
2374 ////////////////////////////////////////////////
2375 ////////////////////////////////////////////////
2376 ////////////////////////////////////////////////
2377 //functions to handle sitecourse mapping
2378 ////////////////////////////////////////////////
2380 /**
2381  * checks if the course and the feedback is in the table feedback_sitecourse_map.
2382  *
2383  * @global object
2384  * @param int $feedbackid
2385  * @param int $courseid
2386  * @return int the count of records
2387  */
2388 function feedback_is_course_in_sitecourse_map($feedbackid, $courseid) {
2389     global $DB;
2390     return $DB->count_records('feedback_sitecourse_map', array('feedbackid'=>$feedbackid, 'courseid'=>$courseid));
2393 /**
2394  * checks if the feedback is in the table feedback_sitecourse_map.
2395  *
2396  * @global object
2397  * @param int $feedbackid
2398  * @return boolean
2399  */
2400 function feedback_is_feedback_in_sitecourse_map($feedbackid) {
2401     global $DB;
2402     return $DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$feedbackid));
2405 /**
2406  * gets the feedbacks from table feedback_sitecourse_map.
2407  * this is used to show the global feedbacks on the feedback block
2408  * all feedbacks with the following criteria will be selected:<br />
2409  *
2410  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2411  * 2) all feedbacks which not are listed in sitecoursemap
2412  *
2413  * @global object
2414  * @param int $courseid
2415  * @return array the feedback-records
2416  */
2417 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2418     global $DB;
2420     //first get all feedbacks listed in sitecourse_map with named courseid
2421     $sql = "SELECT f.id AS id, cm.id AS cmid, f.name AS name, f.timeopen AS timeopen, f.timeclose AS timeclose
2422               FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2423              WHERE f.id = cm.instance
2424                    AND f.course = '".SITEID."'
2425                    AND m.id = cm.module
2426                    AND m.name = 'feedback'
2427                    AND sm.courseid = ?
2428                    AND sm.feedbackid = f.id";
2430     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2431         $feedbacks1 = array();
2432     }
2434     //second get all feedbacks not listed in sitecourse_map
2435     $feedbacks2 = array();
2436     $sql = "SELECT f.id AS id, cm.id AS cmid, f.name AS name, f.timeopen AS timeopen, f.timeclose AS timeclose
2437               FROM {feedback} f, {course_modules} cm, {modules} m
2438              WHERE f.id = cm.instance
2439                    AND f.course = '".SITEID."'
2440                    AND m.id = cm.module
2441                    AND m.name = 'feedback'";
2442     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2443         $allfeedbacks = array();
2444     }
2445     foreach($allfeedbacks as $a) {
2446         if(!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2447             $feedbacks2[] = $a;
2448         }
2449     }
2451     return array_merge($feedbacks1, $feedbacks2);
2455 /**
2456  * gets the courses from table feedback_sitecourse_map.
2457  *
2458  * @global object
2459  * @param int $feedbackid
2460  * @return array the course-records
2461  */
2462 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2463     global $DB;
2465     $sql = "SELECT f.id, f.courseid, c.fullname, c.shortname
2466               FROM {feedback_sitecourse_map} f, {course} c
2467              WHERE c.id = f.courseid
2468                    AND f.feedbackid = ?
2469           ORDER BY c.fullname";
2471     return $DB->get_records_sql($sql, array($feedbackid));
2475 /**
2476  * removes non existing courses or feedbacks from sitecourse_map.
2477  * it shouldn't be called all too often
2478  * a good place for it could be the mapcourse.php or unmapcourse.php
2479  *
2480  * @global object
2481  * @return void
2482  */
2483 function feedback_clean_up_sitecourse_map() {
2484     global $DB;
2486     $maps = $DB->get_records('feedback_sitecourse_map');
2487     foreach($maps as $map) {
2488         if (!$DB->get_record('course', array('id'=>$map->courseid))) {
2489             $DB->delete_records('feedback_sitecourse_map', array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid));
2490             continue;
2491         }
2492         if (!$DB->get_record('feedback', array('id'=>$map->feedbackid))) {
2493             $DB->delete_records('feedback_sitecourse_map', array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid));
2494             continue;
2495         }
2497     }
2500 ////////////////////////////////////////////////
2501 ////////////////////////////////////////////////
2502 ////////////////////////////////////////////////
2503 //not relatable functions
2504 ////////////////////////////////////////////////
2506 /**
2507  * prints the option items of a selection-input item (dropdownlist).
2508  * @param int $startval the first value of the list
2509  * @param int $endval the last value of the list
2510  * @param int $selectval which item should be selected
2511  * @param int $interval the stepsize from the first to the last value
2512  * @return void
2513  */
2514 function feedback_print_numeric_option_list($startval, $endval, $selectval = '', $interval = 1){
2515     for($i = $startval; $i <= $endval; $i += $interval){
2516         if($selectval == ($i)){
2517             $selected = 'selected="selected"';
2518         }else{
2519             $selected = '';
2520         }
2521         echo '<option '.$selected.'>'.$i.'</option>';
2522     }
2525 /**
2526  * sends an email to the teachers of the course where the given feedback is placed.
2527  *
2528  * @global object
2529  * @global object
2530  * @uses FEEDBACK_ANONYMOUS_NO
2531  * @uses FORMAT_PLAIN
2532  * @param object $cm the coursemodule-record
2533  * @param object $feedback
2534  * @param object $course
2535  * @param int $userid
2536  * @return void
2537  */
2538 function feedback_send_email($cm, $feedback, $course, $userid) {
2539     global $CFG, $DB;
2541     if ($feedback->email_notification == 0) {  // No need to do anything
2542         return;
2543     }
2545     $user = $DB->get_record('user', array('id'=>$userid));
2547     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
2548         $groupmode =  $cm->groupmode;
2549     } else {
2550         $groupmode = $course->groupmode;
2551     }
2553     if ($groupmode == SEPARATEGROUPS) {
2554         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
2555                                                FROM {groups} g, {groups_members} m
2556                                               WHERE g.courseid = ?
2557                                                     AND g.id = m.groupid
2558                                                     AND m.userid = ?
2559                                            ORDER BY name ASC", array($course->id, $userid));
2560         $groups = array_values($groups);
2562         $teachers = feedback_get_receivemail_users($cm->id, $groups);
2563     } else {
2564         $teachers = feedback_get_receivemail_users($cm->id);
2565     }
2567     if ($teachers) {
2569         $strfeedbacks = get_string('modulenameplural', 'feedback');
2570         $strfeedback  = get_string('modulename', 'feedback');
2571         $strcompleted  = get_string('completed', 'feedback');
2572         $printusername = $feedback->anonymous == FEEDBACK_ANONYMOUS_NO ? fullname($user) : get_string('anonymous_user', 'feedback');
2574         foreach ($teachers as $teacher) {
2575             $info = new stdClass();
2576             $info->username = $printusername;
2577             $info->feedback = format_string($feedback->name,true);
2578             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?id='.$cm->id.'&userid='.$userid.'&do_show=showentries';
2580             $postsubject = $strcompleted.': '.$info->username.' -> '.$feedback->name;
2581             $posttext = feedback_send_email_text($info, $course);
2582             $posthtml = ($teacher->mailformat == 1) ? feedback_send_email_html($info, $course, $cm) : '';
2584             if($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2585                 $eventdata = new stdClass();
2586                 $eventdata->name             = 'submission';
2587                 $eventdata->component        = 'mod_feedback';
2588                 $eventdata->userfrom         = $user;
2589                 $eventdata->userto           = $teacher;
2590                 $eventdata->subject          = $postsubject;
2591                 $eventdata->fullmessage      = $posttext;
2592                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2593                 $eventdata->fullmessagehtml  = $posthtml;
2594                 $eventdata->smallmessage     = '';
2595                 message_send($eventdata);
2596             }else {
2597                 $eventdata = new stdClass();
2598                 $eventdata->name             = 'submission';
2599                 $eventdata->component        = 'mod_feedback';
2600                 $eventdata->userfrom         = $teacher;
2601                 $eventdata->userto           = $teacher;
2602                 $eventdata->subject          = $postsubject;
2603                 $eventdata->fullmessage      = $posttext;
2604                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2605                 $eventdata->fullmessagehtml  = $posthtml;
2606                 $eventdata->smallmessage     = '';
2607                 message_send($eventdata);
2608             }
2609         }
2610     }
2613 /**
2614  * sends an email to the teachers of the course where the given feedback is placed.
2615  *
2616  * @global object
2617  * @uses FORMAT_PLAIN
2618  * @param object $cm the coursemodule-record
2619  * @param object $feedback
2620  * @param object $course
2621  * @return void
2622  */
2623 function feedback_send_email_anonym($cm, $feedback, $course) {
2624     global $CFG;
2626     if ($feedback->email_notification == 0) {             // No need to do anything
2627         return;
2628     }
2630     $teachers = feedback_get_receivemail_users($cm->id);
2632     if ($teachers) {
2634         $strfeedbacks = get_string('modulenameplural', 'feedback');
2635         $strfeedback  = get_string('modulename', 'feedback');
2636         $strcompleted  = get_string('completed', 'feedback');
2637         $printusername = get_string('anonymous_user', 'feedback');
2639         foreach ($teachers as $teacher) {
2640             $info = new stdClass();
2641             $info->username = $printusername;
2642             $info->feedback = format_string($feedback->name,true);
2643             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries_anonym.php?id='.$cm->id;
2645             $postsubject = $strcompleted.': '.$info->username.' -> '.$feedback->name;
2646             $posttext = feedback_send_email_text($info, $course);
2647             $posthtml = ($teacher->mailformat == 1) ? feedback_send_email_html($info, $course, $cm) : '';
2649             $eventdata = new stdClass();
2650             $eventdata->name             = 'submission';
2651             $eventdata->component        = 'mod_feedback';
2652             $eventdata->userfrom         = $teacher;
2653             $eventdata->userto           = $teacher;
2654             $eventdata->subject          = $postsubject;
2655             $eventdata->fullmessage      = $posttext;
2656             $eventdata->fullmessageformat = FORMAT_PLAIN;
2657             $eventdata->fullmessagehtml  = $posthtml;
2658             $eventdata->smallmessage     = '';
2659             message_send($eventdata);
2660         }
2661     }
2664 /**
2665  * send the text-part of the email
2666  *
2667  * @param object $info includes some infos about the feedback you want to send
2668  * @param object $course
2669  * @return string the text you want to post
2670  */
2671 function feedback_send_email_text($info, $course) {
2672     $posttext  = $course->shortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
2673                     $info->feedback."\n";
2674     $posttext .= '---------------------------------------------------------------------'."\n";
2675     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
2676     $posttext .= '---------------------------------------------------------------------'."\n";
2677     return $posttext;
2681 /**
2682  * send the html-part of the email
2683  *
2684  * @global object
2685  * @param object $info includes some infos about the feedback you want to send
2686  * @param object $course
2687  * @return string the text you want to post
2688  */
2689 function feedback_send_email_html($info, $course, $cm) {
2690     global $CFG;
2691     $posthtml  = '<p><font face="sans-serif">'.
2692                 '<a href="'.$CFG->wwwroot.'/course/view.php?id='.$course->id.'">'.$course->shortname.'</a> ->'.
2693                 '<a href="'.$CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
2694                 '<a href="'.$CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id.'">'.$info->feedback.'</a></font></p>';
2695     $posthtml .= '<hr /><font face="sans-serif">';
2696     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
2697     $posthtml .= '</font><hr />';
2698     return $posthtml;
2701 /**
2702  * print some errors to inform users about this.
2703  *
2704  * @global object
2705  * @return void
2706  */
2707 function feedback_print_errors() {
2709     global $SESSION, $OUTPUT;
2711     feedback_init_feedback_session();
2713     if(empty($SESSION->feedback->errors)) {
2714         return;
2715     }
2717     echo $OUTPUT->box_start('generalbox errorboxcontent boxaligncenter boxwidthnormal');
2718     echo $OUTPUT->heading(get_string('handling_error', 'feedback'));
2720     echo '<p align="center"><b><font color="black"><pre>';
2721     print_r($SESSION->feedback->errors) . "\n";
2722     echo '</pre></font></b></p>';
2724     echo $OUTPUT->box_end();
2725     echo '<br /><br />';
2726     $SESSION->feedback->errors = array(); //remove errors
2729 /**
2730  * @param string $url
2731  * @return string
2732  */
2733 function feedback_encode_target_url($url) {
2734     if (strpos($url, '?')) {
2735         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
2736         return $part1 . '?' . htmlentities($part2);
2737     } else {
2738         return $url;
2739     }
2742 /**
2743  * Adds module specific settings to the settings block
2744  *
2745  * @param settings_navigation $settings The settings navigation object
2746  * @param navigation_node $feedbacknode The node to add module settings to
2747  */
2748 function feedback_extend_settings_navigation(settings_navigation $settings, navigation_node $feedbacknode) {
2749     global $PAGE, $DB;
2751     if (!$context = get_context_instance(CONTEXT_MODULE, $PAGE->cm->id)) {
2752         print_error('badcontext');
2753     }
2755     if (has_capability('mod/feedback:edititems', $context)) {
2756         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
2757         $questionnode->add(get_string('edit_items', 'feedback'), new moodle_url('/mod/feedback/edit.php', array('id'=>$PAGE->cm->id, 'do_show'=>'edit')));
2758         $questionnode->add(get_string('export_questions', 'feedback'), new moodle_url('/mod/feedback/export.php', array('id'=>$PAGE->cm->id, 'action'=>'exportfile')));
2759         $questionnode->add(get_string('import_questions', 'feedback'), new moodle_url('/mod/feedback/import.php', array('id'=>$PAGE->cm->id)));
2760         $questionnode->add(get_string('templates', 'feedback'), new moodle_url('/mod/feedback/edit.php', array('id'=>$PAGE->cm->id, 'do_show'=>'templates')));
2761     }
2763     if (has_capability('mod/feedback:viewreports', $context)) {
2764         $feedback = $DB->get_record('feedback', array('id'=>$PAGE->cm->instance));
2765         if($feedback->course == SITEID){
2766             $feedbacknode->add(get_string('analysis', 'feedback'), new moodle_url('/mod/feedback/analysis_course.php', array('id'=>$PAGE->cm->id, 'course'=>$PAGE->course->id,'do_show'=>'analysis')));
2767         }else {
2768             $feedbacknode->add(get_string('analysis', 'feedback'), new moodle_url('/mod/feedback/analysis.php', array('id'=>$PAGE->cm->id, 'course'=>$PAGE->course->id,'do_show'=>'analysis')));
2769         }
2771         $feedbacknode->add(get_string('show_entries', 'feedback'), new moodle_url('/mod/feedback/show_entries.php', array('id'=>$PAGE->cm->id, 'do_show'=>'showentries')));
2772     }
2775 function feedback_init_feedback_session() {
2776     //initialize the feedback-Session - not nice at all!!
2777     global $SESSION;
2778     if (!empty($SESSION)) {
2779         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
2780             $SESSION->feedback = new stdClass();
2781         }
2782     }
2785 /**
2786  * Return a list of page types
2787  * @param string $pagetype current page type
2788  * @param stdClass $parentcontext Block's parent context
2789  * @param stdClass $currentcontext Current context of block
2790  */
2791 function feedback_pagetypelist($pagetype, $parentcontext, $currentcontext) {
2792     $module_pagetype = array('mod-feedback-*'=>get_string('page-mod-feedback-x', 'feedback'));
2793     return $module_pagetype;