0a76beee04d391b4083401f114e87d52bb11b60a
[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');
31 /** Include completionlib.php */
32 require_once($CFG->libdir . '/completionlib.php');
35 define('FEEDBACK_ANONYMOUS_YES', 1);
36 define('FEEDBACK_ANONYMOUS_NO', 2);
37 define('FEEDBACK_MIN_ANONYMOUS_COUNT_IN_GROUP', 2);
38 define('FEEDBACK_DECIMAL', '.');
39 define('FEEDBACK_THOUSAND', ',');
40 define('FEEDBACK_RESETFORM_RESET', 'feedback_reset_data_');
41 define('FEEDBACK_RESETFORM_DROP', 'feedback_drop_feedback_');
42 define('FEEDBACK_MAX_PIX_LENGTH', '400'); //max. Breite des grafischen Balkens in der Auswertung
43 define('FEEDBACK_DEFAULT_PAGE_COUNT', 20);
45 /**
46  * @uses FEATURE_GROUPS
47  * @uses FEATURE_GROUPINGS
48  * @uses FEATURE_GROUPMEMBERSONLY
49  * @uses FEATURE_MOD_INTRO
50  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
51  * @uses FEATURE_GRADE_HAS_GRADE
52  * @uses FEATURE_GRADE_OUTCOMES
53  * @param string $feature FEATURE_xx constant for requested feature
54  * @return mixed True if module supports feature, null if doesn't know
55  */
56 function feedback_supports($feature) {
57     switch($feature) {
58         case FEATURE_GROUPS:                  return true;
59         case FEATURE_GROUPINGS:               return true;
60         case FEATURE_GROUPMEMBERSONLY:        return true;
61         case FEATURE_MOD_INTRO:               return true;
62         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
63         case FEATURE_COMPLETION_HAS_RULES:    return true;
64         case FEATURE_GRADE_HAS_GRADE:         return false;
65         case FEATURE_GRADE_OUTCOMES:          return false;
66         case FEATURE_BACKUP_MOODLE2:          return true;
68         default: return null;
69     }
70 }
72 /**
73  * this will create a new instance and return the id number
74  * of the new instance.
75  *
76  * @global object
77  * @param object $feedback the object given by mod_feedback_mod_form
78  * @return int
79  */
80 function feedback_add_instance($feedback) {
81     global $DB;
83     $feedback->timemodified = time();
84     $feedback->id = '';
86     //check if openenable and/or closeenable is set and set correctly to save in db
87     if(empty($feedback->openenable)) {
88         $feedback->timeopen = 0;
89     }
90     if(empty($feedback->closeenable)) {
91         $feedback->timeclose = 0;
92     }
93     if(empty($feedback->site_after_submit)) {
94         $feedback->site_after_submit = '';
95     }
97     //saving the feedback in db
98     $feedbackid = $DB->insert_record("feedback", $feedback);
100     $feedback->id = $feedbackid;
102     feedback_set_events($feedback);
104     return $feedbackid;
107 /**
108  * this will update a given instance
109  *
110  * @global object
111  * @param object $feedback the object given by mod_feedback_mod_form
112  * @return boolean
113  */
114 function feedback_update_instance($feedback) {
115     global $DB;
117     $feedback->timemodified = time();
118     $feedback->id = $feedback->instance;
120     //check if openenable and/or closeenable is set and set correctly to save in db
121     if(empty($feedback->openenable)) {
122         $feedback->timeopen = 0;
123     }
124     if(empty($feedback->closeenable)) {
125         $feedback->timeclose = 0;
126     }
127     if(empty($feedback->site_after_submit)) {
128         $feedback->site_after_submit = '';
129     }
131     //save the feedback into the db
132     $DB->update_record("feedback", $feedback);
134     //create or update the new events
135     feedback_set_events($feedback);
137     return true;
140 /**
141  * Serves the files included in feedback items like label. Implements needed access control ;-)
142  *
143  * @param object $course
144  * @param object $cm
145  * @param object $context
146  * @param string $filearea
147  * @param array $args
148  * @param bool $forcedownload
149  * @return bool false if file not found, does not return if found - justsend the file
150  */
151 function feedback_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload) {
152     global $CFG, $DB;
154     require_login($course, false, $cm);
156     $itemid = (int)array_shift($args);
158     require_course_login($course, true, $cm);
160     if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
161         return false;
162     }
164     if (!has_capability('mod/feedback:view', $context)) {
165         return false;
166     }
168     if ($context->contextlevel == CONTEXT_MODULE) {
169         if ($filearea !== 'item') {
170             return false;
171         }
173         if ($item->feedback == $cm->instance) {
174             $filecontext = $context;
175         } else {
176             return false;
177         }
178     }
180     if ($context->contextlevel == CONTEXT_COURSE) {
181         if ($filearea !== 'template') {
182             return false;
183         }
184     }
186     $relativepath = implode('/', $args);
187     $fullpath = "/$context->id/mod_feedback/$filearea/$itemid/$relativepath";
189     $fs = get_file_storage();
190     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
191         return false;
192     }
194     // finally send the file
195     send_stored_file($file, 0, 0, true); // download MUST be forced - security!
197     return false;
201 /**
202  * this will delete a given instance.
203  * all referenced data also will be deleted
204  *
205  * @global object
206  * @param int $id the instanceid of feedback
207  * @return boolean
208  */
209 function feedback_delete_instance($id) {
210     global $DB;
212     //get all referenced items
213     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
215     //deleting all referenced items and values
216     if (is_array($feedbackitems)){
217         foreach($feedbackitems as $feedbackitem){
218             $DB->delete_records("feedback_value", array("item"=>$feedbackitem->id));
219             $DB->delete_records("feedback_valuetmp", array("item"=>$feedbackitem->id));
220         }
221         if($delitems = $DB->get_records("feedback_item", array("feedback"=>$id))) {
222             foreach($delitems as $delitem) {
223                 feedback_delete_item($delitem->id, false);
224             }
225         }
226     }
228     //deleting the referenced tracking data
229     $DB->delete_records('feedback_tracking', array('feedback'=>$id));
231     //deleting the completeds
232     $DB->delete_records("feedback_completed", array("feedback"=>$id));
234     //deleting the unfinished completeds
235     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
237     //deleting old events
238     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
239     return $DB->delete_records("feedback", array("id"=>$id));
242 /**
243  * this is called after deleting all instances if the course will be deleted.
244  * only templates have to be deleted
245  *
246  * @global object
247  * @param object $course
248  * @return boolean
249  */
250 function feedback_delete_course($course) {
251     global $DB;
253     //delete all templates of given course
254     return $DB->delete_records('feedback_template', array('course'=>$course->id));
257 /**
258  * Return a small object with summary information about what a
259  * user has done with a given particular instance of this module
260  * Used for user activity reports.
261  * $return->time = the time they did it
262  * $return->info = a short text description
263  *
264  * @param object $course
265  * @param object $user
266  * @param object $mod
267  * @param object $feedback
268  * @return object
269  */
270 function feedback_user_outline($course, $user, $mod, $feedback) {
271     return null;
274 /**
275  * Returns all users who has completed a specified feedback since a given time
276  * many thanks to Manolescu Dorel, who contributed these two functions
277  *
278  * @global object
279  * @global object
280  * @global object
281  * @global object
282  * @uses CONTEXT_MODULE
283  * @param array $activities Passed by reference
284  * @param int $index Passed by reference
285  * @param int $timemodified Timestamp
286  * @param int $courseid
287  * @param int $cmid
288  * @param int $userid
289  * @param int $groupid
290  * @return void
291  */
292 function feedback_get_recent_mod_activity(&$activities, &$index, $timemodified, $courseid, $cmid, $userid="", $groupid="")  {
293     global $CFG, $COURSE, $USER, $DB;
295     if ($COURSE->id == $courseid) {
296         $course = $COURSE;
297     } else {
298         $course = $DB->get_record('course', array('id'=>$courseid));
299     }
301     $modinfo =& get_fast_modinfo($course);
303     $cm = $modinfo->cms[$cmid];
305     $sqlargs = array();
307     //TODO: user user_picture::fields;
308     $sql = " SELECT fk . * , fc . * , u.firstname, u.lastname, u.email, u.picture, u.email
309                                             FROM {feedback_completed} fc
310                                                 JOIN {feedback} fk ON fk.id = fc.feedback
311                                                 JOIN {user} u ON u.id = fc.userid ";
313     if ($groupid) {
314         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
315     }
317     $sql .= " WHERE fc.timemodified > ? AND fk.id = ? ";
318     $sqlargs[] = $timemodified;
319     $sqlargs[] = $cm->instace;
321     if ($userid) {
322         $sql .= " AND u.id = ? ";
323         $sqlargs[] = $userid;
324     }
326     if ($groupid) {
327         $sql .= " AND gm.groupid = ? ";
328         $sqlargs[] = $groupid;
329     }
331     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
332         return;
333     }
335     $cm_context      = get_context_instance(CONTEXT_MODULE, $cm->id);
336     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
337     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cm_context);
338     $groupmode       = groups_get_activity_groupmode($cm, $course);
340     if (is_null($modinfo->groups)) {
341         $modinfo->groups = groups_get_user_groups($course->id); // load all my groups and cache it in modinfo
342     }
344     $aname = format_string($cm->name,true);
345     foreach ($feedbackitems as $feedbackitem) {
346         if ($feedbackitem->userid != $USER->id) {
348             if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
349                 $usersgroups = groups_get_all_groups($course->id, $feedbackitem->userid, $cm->groupingid);
350                 if (!is_array($usersgroups)) {
351                     continue;
352                 }
353                 $usersgroups = array_keys($usersgroups);
354                 $intersect = array_intersect($usersgroups, $modinfo->groups[$cm->id]);
355                 if (empty($intersect)) {
356                     continue;
357                 }
358             }
359        }
361         $tmpactivity = new stdClass();
363         $tmpactivity->type      = 'feedback';
364         $tmpactivity->cmid      = $cm->id;
365         $tmpactivity->name      = $aname;
366         $tmpactivity->sectionnum= $cm->sectionnum;
367         $tmpactivity->timestamp = $feedbackitem->timemodified;
369         $tmpactivity->content->feedbackid = $feedbackitem->id;
370         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
372         //TODO: add all necessary user fields, this is not enough for user_picture
373         $tmpactivity->user->userid   = $feedbackitem->userid;
374         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
375         $tmpactivity->user->picture  = $feedbackitem->picture;
377         $activities[$index++] = $tmpactivity;
378     }
380   return;
383 /**
384  * Prints all users who has completed a specified feedback since a given time
385  * many thanks to Manolescu Dorel, who contributed these two functions
386  *
387  * @global object
388  * @param object $activity
389  * @param int $courseid
390  * @param string $detail
391  * @param array $modnames
392  * @return void Output is echo'd
393  */
394 function feedback_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
395     global $CFG, $OUTPUT;
397     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
399     echo "<tr><td class=\"userpicture\" valign=\"top\">";
400     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
401     echo "</td><td>";
403     if ($detail) {
404         $modname = $modnames[$activity->type];
405         echo '<div class="title">';
406         echo "<img src=\"" . $OUTPUT->pix_url('icon', $activity->type) . "\" ".
407              "class=\"icon\" alt=\"$modname\" />";
408         echo "<a href=\"$CFG->wwwroot/mod/feedback/view.php?id={$activity->cmid}\">{$activity->name}</a>";
409         echo '</div>';
410     }
412     echo '<div class="title">';
413     echo '</div>';
415     echo '<div class="user">';
416     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->userid}&amp;course=$courseid\">"
417          ."{$activity->user->fullname}</a> - ".userdate($activity->timestamp);
418     echo '</div>';
420     echo "</td></tr></table>";
422     return;
425 /**
426  * Obtains the automatic completion state for this feedback based on the condition
427  * in feedback settings.
428  *
429  * @param object $course Course
430  * @param object $cm Course-module
431  * @param int $userid User ID
432  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
433  * @return bool True if completed, false if not, $type if conditions not set.
434  */
435 function feedback_get_completion_state($course, $cm, $userid, $type) {
436     global $CFG, $DB;
438     // Get feedback details
439     $feedback = $DB->get_record('feedback', array('id'=>$cm->instance), '*', MUST_EXIST);
441     // If completion option is enabled, evaluate it and return true/false 
442     if($feedback->completionsubmit) {
443         return $DB->record_exists('feedback_tracking', array('userid'=>$userid, 'feedback'=>$feedback->id));
444     } else {
445         // Completion option is not enabled so just return $type
446         return $type;
447     }
451 /**
452  * Print a detailed representation of what a  user has done with
453  * a given particular instance of this module, for user activity reports.
454  *
455  * @param object $course
456  * @param object $user
457  * @param object $mod
458  * @param object $feedback
459  * @return bool
460  */
461 function feedback_user_complete($course, $user, $mod, $feedback) {
462     return true;
465 /**
466  * @return bool true
467  */
468 function feedback_cron () {
469     return true;
472 /**
473  * @return bool false
474  */
475 function feedback_get_participants($feedbackid) {
476     return false;
480 /**
481  * @return bool false
482  */
483 function feedback_scale_used ($feedbackid,$scaleid) {
484     return false;
487 /**
488  * Checks if scale is being used by any instance of feedback
489  *
490  * This is used to find out if scale used anywhere
491  * @param $scaleid int
492  * @return boolean True if the scale is used by any assignment
493  */
494 function feedback_scale_used_anywhere($scaleid) {
495     return false;
498 /**
499  * This function is used by the reset_course_userdata function in moodlelib.
500  * This function will remove all responses from the specified feedback
501  * and clean up any related data.
502  *
503  * @global object
504  * @global object
505  * @uses FEEDBACK_RESETFORM_RESET
506  * @uses FEEDBACK_RESETFORM_DROP
507  * @param object $data the data submitted from the reset course.
508  * @return array status array
509  */
510 function feedback_reset_userdata($data) {
511     global $CFG, $DB;
513     $resetfeedbacks = array();
514     $dropfeedbacks = array();
515     $status = array();
516     $componentstr = get_string('modulenameplural', 'feedback');
518     //get the relevant entries from $data
519     foreach($data as $key => $value) {
520         switch(true) {
521             case substr($key, 0, strlen(FEEDBACK_RESETFORM_RESET)) == FEEDBACK_RESETFORM_RESET:
522                 if($value == 1) {
523                     $templist = explode('_', $key);
524                     if(isset($templist[3]))$resetfeedbacks[] = intval($templist[3]);
525                 }
526             break;
527             case substr($key, 0, strlen(FEEDBACK_RESETFORM_DROP)) == FEEDBACK_RESETFORM_DROP:
528                 if($value == 1) {
529                     $templist = explode('_', $key);
530                     if(isset($templist[3]))$dropfeedbacks[] = intval($templist[3]);
531                 }
532             break;
533         }
534     }
536     //reset the selected feedbacks
537     foreach($resetfeedbacks as $id) {
538         $feedback = $DB->get_record('feedback', array('id'=>$id));
539         feedback_delete_all_completeds($id);
540         $status[] = array('component'=>$componentstr.':'.$feedback->name, 'item'=>get_string('resetting_data','feedback'), 'error'=>false);
541     }
543     //drop the selected feedbacks
544     // foreach($dropfeedbacks as $id) {
545         // $cm = get_coursemodule_from_instance('feedback', $id);
546         // feedback_delete_instance($id);
547         // feedback_delete_course_module($cm->id);
548         // $status[] = array('component'=>$componentstr, 'item'=>get_string('drop_feedback','feedback'), 'error'=>false);
549     // }
550     return $status;
553 /**
554  * Called by course/reset.php
555  *
556  * @global object
557  * @uses FEEDBACK_RESETFORM_RESET
558  * @param object $mform form passed by reference
559  */
560 function feedback_reset_course_form_definition(&$mform) {
561     global $COURSE, $DB;
563     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
565     if(!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')){
566         return;
567     }
569     $mform->addElement('static', 'hint', get_string('resetting_data','feedback'));
570     foreach($feedbacks as $feedback) {
571         $mform->addElement('checkbox', FEEDBACK_RESETFORM_RESET.$feedback->id, $feedback->name);
572         // $mform->addElement('checkbox', FEEDBACK_RESETFORM_DROP.$feedback->id, get_string('drop_feedback','feedback'));
573     }
576 /**
577  * Course reset form defaults.
578  *
579  * @global object
580  * @uses FEEDBACK_RESETFORM_RESET
581  * @param object $course
582  */
583 function feedback_reset_course_form_defaults($course) {
584     global $DB;
586     $return = array();
587     if(!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')){
588         return;
589     }
590     foreach($feedbacks as $feedback) {
591         $return[FEEDBACK_RESETFORM_RESET.$feedback->id] = true;
592         // $return[FEEDBACK_RESETFORM_DROP.$feedback->id] = false;
593     }
594     return $return;
597 /**
598  * Called by course/reset.php and shows the formdata by coursereset.
599  * it prints checkboxes for each feedback available at the given course
600  * there are two checkboxes: 1) delete userdata and keep the feedback 2) delete userdata and drop the feedback
601  *
602  * @global object
603  * @uses FEEDBACK_RESETFORM_RESET
604  * @uses FEEDBACK_RESETFORM_DROP
605  * @param object $course
606  * @return void
607  */
608 function feedback_reset_course_form($course) {
609     global $DB, $OUTPUT;
611     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
612     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
613         return;
614     }
616     foreach($feedbacks as $feedback) {
617         echo '<p>';
618         echo get_string('name','feedback').': '.$feedback->name.'<br />';
619         echo html_writer::checkbox(FEEDBACK_RESETFORM_RESET.$feedback->id, 1, true, get_string('resetting_data','feedback'));
620         echo '<br />';
621         echo html_writer::checkbox(FEEDBACK_RESETFORM_DROP.$feedback->id, 1, false, get_string('drop_feedback','feedback'));
622         echo '</p>';
623     }
626 /**
627  * This creates new events given as timeopen and closeopen by $feedback.
628  *
629  * @global object
630  * @param object $feedback
631  * @return void
632  */
633 function feedback_set_events($feedback) {
634     global $DB;
636     // adding the feedback to the eventtable (I have seen this at quiz-module)
637     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$feedback->id));
639     if (!isset($feedback->coursemodule)) {
640         $cm = get_coursemodule_from_id('feedback', $feedback->id);
641         $feedback->coursemodule = $cm->id;
642     }
644     // the open-event
645     if($feedback->timeopen > 0) {
646         $event = NULL;
647         $event->name         = get_string('start', 'feedback').' '.$feedback->name;
648         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
649         $event->courseid     = $feedback->course;
650         $event->groupid      = 0;
651         $event->userid       = 0;
652         $event->modulename   = 'feedback';
653         $event->instance     = $feedback->id;
654         $event->eventtype    = 'open';
655         $event->timestart    = $feedback->timeopen;
656         $event->visible      = instance_is_visible('feedback', $feedback);
657         if($feedback->timeclose > 0) {
658             $event->timeduration = ($feedback->timeclose - $feedback->timeopen);
659         } else {
660             $event->timeduration = 0;
661         }
663         calendar_event::create($event);
664     }
666     // the close-event
667     if($feedback->timeclose > 0) {
668         $event = NULL;
669         $event->name         = get_string('stop', 'feedback').' '.$feedback->name;
670         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
671         $event->courseid     = $feedback->course;
672         $event->groupid      = 0;
673         $event->userid       = 0;
674         $event->modulename   = 'feedback';
675         $event->instance     = $feedback->id;
676         $event->eventtype    = 'close';
677         $event->timestart    = $feedback->timeclose;
678         $event->visible      = instance_is_visible('feedback', $feedback);
679         $event->timeduration = 0;
681         calendar_event::create($event);
682     }
685 /**
686  *  this function is called by {@link feedback_delete_userdata()}
687  *  it drops the feedback-instance from the course_module table
688  *
689  * @global object
690  *  @param int $id the id from the coursemodule
691  *  @return boolean
692  */
693 function feedback_delete_course_module($id) {
694     global $DB;
696     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
697         return true;
698     }
699     return $DB->delete_records('course_modules', array('id'=>$cm->id));
704 ////////////////////////////////////////////////
705 //functions to handle capabilities
706 ////////////////////////////////////////////////
708 /**
709  *  returns the context-id related to the given coursemodule-id
710  *
711  * @staticvar object $context
712  *  @param int $cmid the coursemodule-id
713  *  @return object $context
714  */
715 function feedback_get_context($cmid) {
716     static $context;
718     if(isset($context)) return $context;
720     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
721             print_error('badcontext');
722     }
723     return $context;
726 /**
727  *  returns true if the current role is faked by switching role feature
728  *
729  * @global object
730  *  @return boolean
731  */
732 function feedback_check_is_switchrole(){
733     global $USER;
734     if(isset($USER->switchrole) AND is_array($USER->switchrole) AND count($USER->switchrole) > 0) {
735         return true;
736     }
737     return false;
740 /**
741  * count users which have not completed the feedback
742  *
743  * @global object
744  * @uses CONTEXT_MODULE
745  * @param object $cm
746  * @param int $group single groupid
747  * @param string $sort
748  * @param int $startpage
749  * @param int $pagecount
750  * @return object the userrecords
751  */
752 function feedback_get_incomplete_users($cm, $group = false, $sort = '', $startpage = false, $pagecount = false) {
753     global $DB;
755     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
757     //first get all user who can complete this feedback
758     $cap = 'mod/feedback:complete';
759     $fields = 'u.id, u.username';
760     if(!$allusers = get_users_by_capability($context, $cap, $fields, $sort, '', '', $group, '', true)) {
761         return false;
762     }
763     $allusers = array_keys($allusers);
765     //now get all completeds
766     if(!$completedusers = $DB->get_records_menu('feedback_completed', array('feedback'=>$cm->instance), '', 'userid,id')){
767         return $allusers;
768     }
769     $completedusers = array_keys($completedusers);
771     //now strike all completedusers from allusers
772     $allusers = array_diff($allusers, $completedusers);
774     //for paging I use array_slice()
775     if($startpage !== false AND $pagecount !== false) {
776         $allusers = array_slice($allusers, $startpage, $pagecount);
777     }
779     return $allusers;
782 /**
783  * count users which have not completed the feedback
784  *
785  * @global object
786  * @param object $cm
787  * @param int $group single groupid
788  * @return int count of userrecords
789  */
790 function feedback_count_incomplete_users($cm, $group = false) {
791     if($allusers = feedback_get_incomplete_users($cm, $group)) {
792         return count($allusers);
793     }
794     return 0;
797 /**
798  * count users which have completed a feedback
799  *
800  * @global object
801  * @uses FEEDBACK_ANONYMOUS_NO
802  * @param object $cm
803  * @param int $group single groupid
804  * @return int count of userrecords
805  */
806 function feedback_count_complete_users($cm, $group = false) {
807     global $DB;
809     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
811     $fromgroup = '';
812     $wheregroup = '';
813     if($group) {
814         $fromgroup = ', {groups_members} g';
815         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
816         $params[] = $group;
817     }
819     $sql = 'SELECT COUNT(u.id) FROM {user} u, {feedback_completed} c'.$fromgroup.'
820               WHERE anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
821               '.$wheregroup;
822               ;
824     return $DB->count_records_sql($sql, $params);
828 /**
829  * get users which have completed a feedback
830  *
831  * @global object
832  * @uses CONTEXT_MODULE
833  * @uses FEEDBACK_ANONYMOUS_NO
834  * @param object $cm
835  * @param int $group single groupid
836  * @param string $where a sql where condition (must end with " AND ")
837  * @param array parameters used in $where
838  * @param string $sort a table field
839  * @param int $startpage
840  * @param int $pagecount
841  * @return object the userrecords
842  */
843 function feedback_get_complete_users($cm, $group = false, $where = '', array $params = NULL, $sort = '', $startpage = false, $pagecount = false) {
844     global $DB;
846     if (!$context = get_context_instance(CONTEXT_MODULE, $cm->id)) {
847             print_error('badcontext');
848     }
850     $params = (array)$params;
852     $params['anon'] = FEEDBACK_ANONYMOUS_NO;
853     $params['instance'] = $cm->instance;
855     $fromgroup = '';
856     $wheregroup = '';
857     if ($group) {
858         $fromgroup = ', {groups_members} g';
859         $wheregroup = ' AND g.groupid = :group AND g.userid = c.userid';
860         $params['group'] = $group;
861     }
863     if ($sort) {
864         $sortsql = ' ORDER BY '.$sort;
865     } else {
866         $sortsql = '';
867     }
869     $ufields = user_picture::fields('u');
870     $sql = 'SELECT DISTINCT '.$ufields.' FROM {user} u, {feedback_completed} c '.$fromgroup.'
871               WHERE '.$where.' anonymous_response = :anon AND u.id = c.userid AND c.feedback = :instance
872               '.$wheregroup.$sortsql;
874     if ($startpage === false OR $pagecount === false) {
875         $startpage = false;
876         $pagecount = false;
877     }
878     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
881 /**
882  * get users which have the viewreports-capability
883  *
884  * @uses CONTEXT_MODULE
885  * @param int $cmid
886  * @param mixed $groups single groupid or array of groupids - group(s) user is in
887  * @return object the userrecords
888  */
889 function feedback_get_viewreports_users($cmid, $groups = false) {
891     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
892             print_error('badcontext');
893     }
895     //description of the call below: get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='', $limitnum='', $groups='', $exceptions='', $doanything=true)
896     return get_users_by_capability($context, 'mod/feedback:viewreports', '', 'lastname', '', '', $groups, '', false);
899 /**
900  * get users which have the receivemail-capability
901  *
902  * @uses CONTEXT_MODULE
903  * @param int $cmid
904  * @param mixed $groups single groupid or array of groupids - group(s) user is in
905  * @return object the userrecords
906  */
907 function feedback_get_receivemail_users($cmid, $groups = false) {
909     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
910             print_error('badcontext');
911     }
913     //description of the call below: get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='', $limitnum='', $groups='', $exceptions='', $doanything=true)
914     return get_users_by_capability($context, 'mod/feedback:receivemail', '', 'lastname', '', '', $groups, '', false);
917 ////////////////////////////////////////////////
918 //functions to handle the templates
919 ////////////////////////////////////////////////
920 ////////////////////////////////////////////////
922 /**
923  * creates a new template-record.
924  *
925  * @global object
926  * @param int $courseid
927  * @param string $name the name of template shown in the templatelist
928  * @param int $ispublic 0:privat 1:public
929  * @return int the new templateid
930  */
931 function feedback_create_template($courseid, $name, $ispublic = 0) {
932     global $DB;
934     $templ = new stdClass();
935     $templ->course   = $courseid;
936     $templ->name     = $name;
937     $templ->ispublic = $ispublic;
939     $templid = $DB->insert_record('feedback_template', $templ);
940     return $DB->get_record('feedback_template', array('id'=>$templid));
943 /**
944  * creates new template items.
945  * all items will be copied and the attribute feedback will be set to 0
946  * and the attribute template will be set to the new templateid
947  *
948  * @global object
949  * @uses CONTEXT_MODULE
950  * @uses CONTEXT_COURSE
951  * @param object $feedback
952  * @param string $name the name of template shown in the templatelist
953  * @param int $ispublic 0:privat 1:public
954  * @return boolean
955  */
956 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
957     global $DB;
958     $fs = get_file_storage();
960     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
961         return false;
962     }
964     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
965         return false;
966     }
968     //files in the template_item are in the context of the current course
969     //files in the feedback_item are in the feedback_context of the feedback
970     $c_context = get_context_instance(CONTEXT_COURSE, $newtempl->course);
971     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
972     $f_context = get_context_instance(CONTEXT_MODULE, $cm->id);
974     //create items of this new template
975     //depend items we are storing temporary in an mapping list array(new id => dependitem)
976     //we also store a mapping of all items array(oldid => newid)
977     $dependitemsmap = array();
978     $itembackup = array();
979     foreach($feedbackitems as $item) {
981         $t_item = clone($item);
983         unset($t_item->id);
984         $t_item->feedback = 0;
985         $t_item->template     = $newtempl->id;
986         $t_item->id = $DB->insert_record('feedback_item', $t_item);
987         //copy all included files to the feedback_template filearea
988         if ($itemfiles = $fs->get_area_files($f_context->id, 'mod_feedback', 'item', $item->id, "id", false)) {
989             foreach($itemfiles as $ifile) {
990                 $file_record = new stdClass();
991                 $file_record->contextid = $c_context->id;
992                 $file_record->component = 'mod_feedback';
993                 $file_record->filearea = 'template';
994                 $file_record->itemid = $t_item->id;
995                 $fs->create_file_from_storedfile($file_record, $ifile);
996             }
997         }
999         $itembackup[$item->id] = $t_item->id;
1000         if($t_item->dependitem) {
1001             $dependitemsmap[$t_item->id] = $t_item->dependitem;
1002         }
1004     }
1006     //remapping the dependency
1007     foreach($dependitemsmap as $key => $dependitem) {
1008         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1009         $newitem->dependitem = $itembackup[$newitem->dependitem];
1010         $DB->update_record('feedback_item', $newitem);
1011     }
1013     return true;
1016 /**
1017  * deletes all feedback_items related to the given template id
1018  *
1019  * @global object
1020  * @uses CONTEXT_COURSE
1021  * @param int $id the templateid
1022  * @return void
1023  */
1024 function feedback_delete_template($id) {
1025     global $DB;
1027     $template = $DB->get_record("feedback_template", array("id"=>$id));
1029     //deleting the files from the item
1030     $fs = get_file_storage();
1031     $context = get_context_instance(CONTEXT_COURSE, $template->course);
1034     if($t_items = $DB->get_records("feedback_item", array("template"=>$id))) {
1035         foreach($t_items as $t_item) {
1036             if ($templatefiles = $fs->get_area_files($context->id, 'mod_feedback', 'template', $t_item->id, "id", false)) {
1037                 $fs->delete_area_files($context->id, 'mod_feedback', 'template', $t_item->id);
1038             }
1039         }
1040     }
1041     $DB->delete_records("feedback_template", array("id"=>$id));
1044 /**
1045  * creates new feedback_item-records from template.
1046  * if $deleteold is set true so the existing items of the given feedback will be deleted
1047  * if $deleteold is set false so the new items will be appanded to the old items
1048  *
1049  * @global object
1050  * @uses CONTEXT_COURSE
1051  * @uses CONTEXT_MODULE
1052  * @param object $feedback
1053  * @param int $templateid
1054  * @param boolean $deleteold
1055  */
1056 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1057     global $DB;
1058     $fs = get_file_storage();
1060     //get all templateitems
1061     if(!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1062         return false;
1063     }
1065     //files in the template_item are in the context of the current course
1066     //files in the feedback_item are in the feedback_context of the feedback
1067     $c_context = get_context_instance(CONTEXT_COURSE, $feedback->course);
1068     $course = $DB->get_record('course', array('id'=>$feedback->course));
1069     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1070     $f_context = get_context_instance(CONTEXT_MODULE, $cm->id);
1072     //if deleteold then delete all old items before
1073     //get all items
1074     if($deleteold) {
1075         if($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1076             //delete all items of this feedback
1077             foreach($feedbackitems as $item) {
1078                 feedback_delete_item($item->id, false);
1079             }
1080             //delete tracking-data
1081             $DB->delete_records('feedback_tracking', array('feedback'=>$feedback->id));
1082             
1083             if($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1084                 $completion = new completion_info($course);
1085                 foreach($completeds as $completed) {
1086                     // Update completion state
1087                     if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
1088                         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1089                     }
1090                     $DB->delete_records('feedback_completed', array('id'=>$completed->id));
1091                 }
1092             }
1093             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1094         }
1095         $positionoffset = 0;
1096     } else {
1097         //if the old items are kept the new items will be appended
1098         //therefor the new position has an offset
1099         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1100     }
1102     //create items of this new template
1103     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1104     //we also store a mapping of all items array(oldid => newid)
1105     $dependitemsmap = array();
1106     $itembackup = array();
1107     foreach($templitems as $t_item) {
1108         $item = clone($t_item);
1109         unset($item->id);
1110         $item->feedback = $feedback->id;
1111         $item->template = 0;
1112         $item->position = $item->position + $positionoffset;
1114         $item->id = $DB->insert_record('feedback_item', $item);
1116         //TODO: moving the files to the new items
1117         if ($templatefiles = $fs->get_area_files($c_context->id, 'mod_feedback', 'template', $t_item->id, "id", false)) {
1118             foreach($templatefiles as $tfile) {
1119                 $file_record = new stdClass();
1120                 $file_record->contextid = $f_context->id;
1121                 $file_record->component = 'mod_feedback';
1122                 $file_record->filearea = 'item';
1123                 $file_record->itemid = $item->id;
1124                 $fs->create_file_from_storedfile($file_record, $tfile);
1125             }
1126         }
1128         $itembackup[$t_item->id] = $item->id;
1129         if($item->dependitem) {
1130             $dependitemsmap[$item->id] = $item->dependitem;
1131         }
1132     }
1134     //remapping the dependency
1135     foreach($dependitemsmap as $key => $dependitem) {
1136         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1137         $newitem->dependitem = $itembackup[$newitem->dependitem];
1138         $DB->update_record('feedback_item', $newitem);
1139     }
1142 /**
1143  * get the list of available templates.
1144  * if the $onlyown param is set true so only templates from own course will be served
1145  * this is important for droping templates
1146  *
1147  * @global object
1148  * @param object $course
1149  * @param boolean $onlyown
1150  * @return array the template recordsets
1151  */
1152 function feedback_get_template_list($course, $onlyown = false) {
1153     global $DB;
1155     if ($onlyown) {
1156         $templates = $DB->get_records('feedback_template', array('course'=>$course->id));
1157     } else {
1158         $templates = $DB->get_records_select('feedback_template', 'course = ? OR ispublic = 1', array($course->id));
1159     }
1160     return $templates;
1163 ////////////////////////////////////////////////
1164 //Handling der Items
1165 ////////////////////////////////////////////////
1166 ////////////////////////////////////////////////
1168 /**
1169  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1170  *
1171  * @global object
1172  * @param object $item
1173  * @return object the instanz of itemclass
1174  */
1175 function feedback_get_item_class($typ) {
1176     global $CFG;
1178     //get the class of item-typ
1179     $itemclass = 'feedback_item_'.$typ;
1180     //get the instance of item-class
1181     if (!class_exists($itemclass)) {
1182         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1183     }
1184     return new $itemclass();
1187 /**
1188  * load the available item plugins from given subdirectory of $CFG->dirroot
1189  * the default is "mod/feedback/item"
1190  *
1191  * @global object
1192  * @param string $dir the subdir
1193  * @return array pluginnames as string
1194  */
1195 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1196     global $CFG;
1197     $names = get_list_of_plugins($dir);
1198     $ret_names = array();
1200     foreach($names as $name) {
1201         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1202         if(class_exists('feedback_item_'.$name)) {
1203           $ret_names[] = $name;
1204         }
1205     }
1206     return $ret_names;
1209 /**
1210  * load the available item plugins to use as dropdown-options
1211  *
1212  * @global object
1213  * @return array pluginnames as string
1214  */
1215 function feedback_load_feedback_items_options() {
1216     global $CFG;
1218     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1220     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1221         return array();
1222     }
1224     foreach($feedback_names as $fn) {
1225         $feedback_options[$fn] = get_string($fn,'feedback');
1226     }
1227     asort($feedback_options);
1228     $feedback_options = array_merge( array(' ' => get_string('select')), $feedback_options );
1229     return $feedback_options;
1232 /**
1233  * load the available items for the depend item dropdown list shown in the edit_item form
1234  *
1235  * @global object
1236  * @param object $feedback
1237  * @param object $item the item of the edit_item form
1238  * @return array all items except the item $item, labels and pagebreaks
1239  */
1240 function feedback_get_depend_candidates_for_item($feedback, $item) {
1241     global $DB;
1242     //all items for dependitem
1243     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1244     $params = array($feedback->id);
1245     if(isset($item->id) AND $item->id) {
1246         $where .= ' AND id != ?';
1247         $params[] = $item->id;
1248     }
1249     $dependitems = array(0 => get_string('choose'));
1250     if(!$feedbackitems = $DB->get_records_select_menu('feedback_item', $where, $params, 'position', 'id, label')) {
1251         return $dependitems;
1252     }
1253     //adding the choose-option
1254     foreach($feedbackitems as $key=>$val) {
1255         $dependitems[$key] = $val;
1256     }
1257     return $dependitems;
1260 /**
1261  * creates a new item-record
1262  *
1263  * @global object
1264  * @param object $data the data from edit_item_form
1265  * @return int the new itemid
1266  */
1267 function feedback_create_item($data) {
1268     global $DB;
1270     $item = new stdClass();
1271     $item->feedback = $data->feedbackid;
1273     $item->template=0;
1274     if (isset($data->templateid)) {
1275             $item->template = intval($data->templateid);
1276     }
1278     $itemname = trim($data->itemname);
1279     $item->name = ($itemname ? $data->itemname : get_string('no_itemname', 'feedback'));
1281     if (!empty($data->itemlabel)) {
1282         $item->label = trim($data->itemlabel);
1283     } else {
1284         $item->label = get_string('no_itemlabel', 'feedback');
1285     }
1287     $itemobj = feedback_get_item_class($data->typ);
1288     // $item->presentation = $itemobj->get_presentation($data);
1289     $item->presentation = ''; //the date comes from postupdate() of the itemobj
1291     $item->hasvalue = $itemobj->get_hasvalue();
1293     $item->typ = $data->typ;
1294     $item->position = $data->position;
1296     $item->required=0;
1297     if (!empty($data->required)) {
1298         $item->required = $data->required;
1299     }
1301     $item->id = $DB->insert_record('feedback_item', $item);
1303     //move all itemdata to the data
1304     $data->id = $item->id;
1305     $data->feedback = $item->feedback;
1306     $data->name = $item->name;
1307     $data->label = $item->label;
1308     $data->required = $item->required;
1309     return $itemobj->postupdate($data);
1312 /**
1313  * save the changes of a given item.
1314  *
1315  * @global object
1316  * @param object $item
1317  * @return boolean
1318  */
1319 function feedback_update_item($item){
1320     global $DB;
1321     return $DB->update_record("feedback_item", $item);
1324 /**
1325  * deletes an item and also deletes all related values
1326  *
1327  * @global object
1328  * @uses CONTEXT_MODULE
1329  * @param int $itemid
1330  * @param boolean $renumber should the kept items renumbered Yes/No
1331  * @return void
1332  */
1333 function feedback_delete_item($itemid, $renumber = true){
1334     global $DB;
1337     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1339     //deleting the files from the item
1340     $fs = get_file_storage();
1341     if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1342         return false;
1343     }
1344     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
1346     if ($itemfiles = $fs->get_area_files($context->id, 'mod_feedback', 'item', $item->id, "id", false)) {
1347         $fs->delete_area_files($context->id, 'mod_feedback', 'item', $item->id);
1348     }
1350     $DB->delete_records("feedback_value", array("item"=>$itemid));
1351     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1353     //remove all depends
1354     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1355     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1357     $DB->delete_records("feedback_item", array("id"=>$itemid));
1358     if($renumber) {
1359         feedback_renumber_items($item->feedback);
1360     }
1363 /**
1364  * deletes all items of the given feedbackid
1365  *
1366  * @global object
1367  * @param int $feedbackid
1368  * @return void
1369  */
1370 function feedback_delete_all_items($feedbackid){
1371     global $DB;
1373     if(!$feedback = $DB->get_record('feedback', array('id'=>$feedbackid))) {
1374         return false;
1375     }
1376     
1377     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
1378         return false;
1379     }
1380     
1381     if(!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
1382         return false;
1383     }
1384     
1385     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1386         return;
1387     }
1388     foreach($items as $item) {
1389         feedback_delete_item($item->id, false);
1390     }
1391     // $DB->delete_records('feedback_completed', array('feedback'=>$feedbackid));
1392     if($completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
1393         $completion = new completion_info($course);
1394         foreach($completeds as $completed) {
1395             // Update completion state
1396             if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
1397                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
1398             }
1399             $DB->delete_records('feedback_completed', array('id'=>$completed->id));
1400         }
1401     }
1402     
1403     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1404     
1407 /**
1408  * this function toggled the item-attribute required (yes/no)
1409  *
1410  * @global object
1411  * @param object $item
1412  * @return boolean
1413  */
1414 function feedback_switch_item_required($item) {
1415     global $DB, $CFG;
1417     $itemobj = feedback_get_item_class($item->typ);
1419     if($itemobj->can_switch_require()) {
1420         $DB->set_field('feedback_item', 'required', (int)!(bool)$item->required, array('id'=>$item->id));
1421     }
1422     return true;
1425 /**
1426  * renumbers all items of the given feedbackid
1427  *
1428  * @global object
1429  * @param int $feedbackid
1430  * @return void
1431  */
1432 function feedback_renumber_items($feedbackid){
1433     global $DB;
1435     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1436     $pos = 1;
1437     if($items) {
1438         foreach($items as $item){
1439             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1440             $pos++;
1441         }
1442     }
1445 /**
1446  * this decreases the position of the given item
1447  *
1448  * @global object
1449  * @param object $item
1450  * @return bool
1451  */
1452 function feedback_moveup_item($item){
1453     global $DB;
1455     if($item->position == 1) {
1456         return true;
1457     }
1459     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$item->feedback), 'position')) {
1460         return false;
1461     }
1463     $itembefore = null;
1464     foreach($items as $i) {
1465         if($i->id == $item->id) {
1466             if(is_null($itembefore)) {
1467                 return true;
1468             }
1469             $itembefore->position = $item->position;
1470             $item->position--;
1471             feedback_update_item($itembefore);
1472             feedback_update_item($item);
1473             feedback_renumber_items($item->feedback);
1474             return true;
1475         }
1476         $itembefore = $i;
1477     }
1478     return false;
1481 /**
1482  * this increased the position of the given item
1483  *
1484  * @global object
1485  * @param object $item
1486  * @return bool
1487  */
1488 function feedback_movedown_item($item){
1489     global $DB;
1491     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$item->feedback), 'position')) {
1492         return false;
1493     }
1495     $movedownitem = null;
1496     foreach($items as $i) {
1497         if(!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1498             $movedownitem->position = $i->position;
1499             $i->position--;
1500             feedback_update_item($movedownitem);
1501             feedback_update_item($i);
1502             feedback_renumber_items($item->feedback);
1503             return true;
1504         }
1505         $movedownitem = $i;
1506     }
1507     return false;
1510 /**
1511  * here the position of the given item will be set to the value in $pos
1512  *
1513  * @global object
1514  * @param object $moveitem
1515  * @param int $pos
1516  * @return boolean
1517  */
1518 function feedback_move_item($moveitem, $pos){
1519     global $DB;
1521     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$moveitem->feedback), 'position')) {
1522         return false;
1523     }
1524     if (is_array($allitems)) {
1525         $index = 1;
1526         foreach($allitems as $item) {
1527             if($index == $pos) {
1528                 $index++;
1529             }
1530             if($item->id == $moveitem->id) {
1531                 $moveitem->position = $pos;
1532                 feedback_update_item($moveitem);
1533                 continue;
1534             }
1535             $item->position = $index;
1536             feedback_update_item($item);
1537             $index++;
1538         }
1539         return true;
1540     }
1541     return false;
1544 /**
1545  * prints the given item as a preview.
1546  * each item-class has an own print_item_preview function implemented.
1547  *
1548  * @global object
1549  * @param object $item the item what we want to print out
1550  * @return void
1551  */
1552 function feedback_print_item_preview($item){
1553     global $CFG;
1554     if($item->typ == 'pagebreak') {
1555         return;
1556     }
1557     //get the instance of the item-class
1558     $itemobj = feedback_get_item_class($item->typ);
1559     $itemobj->print_item_preview($item);
1562 /**
1563  * prints the given item in the completion form.
1564  * each item-class has an own print_item_complete function implemented.
1565  *
1566  * @param object $item the item what we want to print out
1567  * @param mixed $value the value
1568  * @param boolean $highlightrequire if this set true and the value are false on completing so the item will be highlighted
1569  * @return void
1570  */
1571 function feedback_print_item_complete($item, $value = false, $highlightrequire = false){
1572     global $CFG;
1573     if($item->typ == 'pagebreak') {
1574         return;
1575     }
1577     //get the instance of the item-class
1578     $itemobj = feedback_get_item_class($item->typ);
1579     $itemobj->print_item_complete($item, $value, $highlightrequire);
1582 /**
1583  * prints the given item in the show entries page.
1584  * each item-class has an own print_item_show_value function implemented.
1585  *
1586  * @param object $item the item what we want to print out
1587  * @param mixed $value
1588  * @return void
1589  */
1590 function feedback_print_item_show_value($item, $value = false){
1591     global $CFG;
1592     if($item->typ == 'pagebreak') {
1593         return;
1594     }
1596     //get the instance of the item-class
1597     $itemobj = feedback_get_item_class($item->typ);
1598     $itemobj->print_item_show_value($item, $value);
1601 /**
1602  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1603  * the values are not saved permanently until the user click on save button
1604  *
1605  * @global object
1606  * @param object $feedbackcompleted
1607  * @return object temporary saved completed-record
1608  */
1609 function feedback_set_tmp_values($feedbackcompleted) {
1610     global $DB;
1612     //first we create a completedtmp
1613     $tmpcpl = new stdClass();
1614     foreach($feedbackcompleted as $key => $value) {
1615         $tmpcpl->{$key} = $value;
1616     }
1617     // $tmpcpl = $feedbackcompleted;
1618     unset($tmpcpl->id);
1619     $tmpcpl->timemodified = time();
1620     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1621     //get all values of original-completed
1622     if(!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1623         return;
1624     }
1625     foreach($values as $value) {
1626         unset($value->id);
1627         $value->completed = $tmpcpl->id;
1628         $DB->insert_record('feedback_valuetmp', $value);
1629     }
1630     return $tmpcpl;
1633 /**
1634  * this saves the temporary saved values permanently
1635  *
1636  * @global object
1637  * @param object $feedbackcompletedtmp the temporary completed
1638  * @param object $feedbackcompleted the target completed
1639  * @param int $userid
1640  * @return int the id of the completed
1641  */
1642 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted, $userid) {
1643     global $DB;
1645     $tmpcplid = $feedbackcompletedtmp->id;
1646     if($feedbackcompleted) {
1647         //first drop all existing values
1648         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1649         //update the current completed
1650         $feedbackcompleted->timemodified = time();
1651         $DB->update_record('feedback_completed', $feedbackcompleted);
1652     }else {
1653         $feedbackcompleted = clone($feedbackcompletedtmp);
1654         $feedbackcompleted->id = '';
1655         $feedbackcompleted->userid = $userid;
1656         $feedbackcompleted->timemodified = time();
1657         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
1658     }
1660     //save all the new values from feedback_valuetmp
1661     //get all values of tmp-completed
1662     if(!$values = $DB->get_records('feedback_valuetmp', array('completed'=>$feedbackcompletedtmp->id))) {
1663         return false;
1664     }
1665     foreach($values as $value) {
1666         //check if there are depend items
1667         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
1668         if($item->dependitem > 0) {
1669             $check = feedback_compare_item_value($tmpcplid, $item->dependitem, $item->dependvalue, true);
1670         }else {
1671             $check = true;
1672         }
1673         if($check) {
1674             unset($value->id);
1675             $value->completed = $feedbackcompleted->id;
1676             $DB->insert_record('feedback_value', $value);
1677         }
1678     }
1679     //drop all the tmpvalues
1680     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1681     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1682     return $feedbackcompleted->id;
1686 /**
1687  * deletes the given temporary completed and all related temporary values
1688  *
1689  * @global object
1690  * @param int $tmpcplid
1691  * @return void
1692  */
1693 function feedback_delete_completedtmp($tmpcplid) {
1694     global $DB;
1696     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1697     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1700 ////////////////////////////////////////////////
1701 ////////////////////////////////////////////////
1702 ////////////////////////////////////////////////
1703 //functions to handle the pagebreaks
1704 ////////////////////////////////////////////////
1706 /**
1707  * this creates a pagebreak.
1708  * a pagebreak is a special kind of item
1709  *
1710  * @global object
1711  * @param int $feedbackid
1712  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
1713  */
1714 function feedback_create_pagebreak($feedbackid) {
1715     global $DB;
1717     //check if there already is a pagebreak on the last position
1718     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
1719     if($lastposition == feedback_get_last_break_position($feedbackid)) {
1720         return false;
1721     }
1723     $item = new stdClass();
1724     $item->feedback = $feedbackid;
1726     $item->template=0;
1728     $item->name = '';
1730     $item->presentation = '';
1731     $item->hasvalue = 0;
1733     $item->typ = 'pagebreak';
1734     $item->position = $lastposition + 1;
1736     $item->required=0;
1738     return $DB->insert_record('feedback_item', $item);
1741 /**
1742  * get all positions of pagebreaks in the given feedback
1743  *
1744  * @global object
1745  * @param int $feedbackid
1746  * @return array all ordered pagebreak positions
1747  */
1748 function feedback_get_all_break_positions($feedbackid) {
1749     global $DB;
1751     if(!$allbreaks = $DB->get_records_menu('feedback_item', array('typ'=>'pagebreak', 'feedback'=>$feedbackid), 'position', 'id, position')) return false;
1752     return array_values($allbreaks);
1755 /**
1756  * get the position of the last pagebreak
1757  *
1758  * @param int $feedbackid
1759  * @return int the position of the last pagebreak
1760  */
1761 function feedback_get_last_break_position($feedbackid) {
1762     if(!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
1763         return false;
1764     }
1765     return $allbreaks[count($allbreaks) - 1];
1768 /**
1769  * this returns the position where the user can continue the completing.
1770  *
1771  * @global object
1772  * @global object
1773  * @global object
1774  * @param int $feedbackid
1775  * @param int $courseid
1776  * @param string $guestid this id will be saved temporary and is unique
1777  * @return int the position to continue
1778  */
1779 function feedback_get_page_to_continue($feedbackid, $courseid = false, $guestid = false) {
1780     global $CFG, $USER, $DB;
1782     //is there any break?
1784     if(!$allbreaks = feedback_get_all_break_positions($feedbackid)) return false;
1786     $params = array();
1787     if($courseid) {
1788         $courseselect = "fv.course_id = :courseid";
1789         $params['courseid'] = $courseid;
1790     }else {
1791         $courseselect = "1";
1792     }
1794     if($guestid) {
1795         $userselect = "AND fc.guestid = :guestid";
1796         $usergroup = "GROUP BY fc.guestid";
1797         $params['guestid'] = $guestid;
1798     }else {
1799         $userselect = "AND fc.userid = :userid";
1800         $usergroup = "GROUP BY fc.userid";
1801         $params['userid'] = $USER->id;
1802     }
1804     $sql =  "SELECT MAX(fi.position)
1805                FROM {feedback_completedtmp} fc, {feedback_valuetmp} fv, {feedback_item} fi
1806               WHERE fc.id = fv.completed
1807                     $userselect
1808                     AND fc.feedback = :feedbackid
1809                     AND $courseselect
1810                     AND fi.id = fv.item
1811          $usergroup";
1812     $params['feedbackid'] = $feedbackid;
1814     $lastpos = $DB->get_field_sql($sql, $params);
1816     //the index of found pagebreak is the searched pagenumber
1817     foreach($allbreaks as $pagenr => $br) {
1818         if($lastpos < $br) return $pagenr;
1819     }
1820     return count($allbreaks);
1823 ////////////////////////////////////////////////
1824 ////////////////////////////////////////////////
1825 ////////////////////////////////////////////////
1826 //functions to handle the values
1827 ////////////////////////////////////////////////
1829 /**
1830  * this saves the values of an completed.
1831  * if the param $tmp is set true so the values are saved temporary in table feedback_valuetmp.
1832  * if there is already a completed and the userid is set so the values are updated.
1833  * on all other things new value records will be created.
1834  *
1835  * @global object
1836  * @param int $userid
1837  * @param boolean $tmp
1838  * @return mixed false on error or the completeid
1839  */
1840 function feedback_save_values($usrid, $tmp = false) {
1841     global $DB;
1843     $completedid = optional_param('completedid', false, PARAM_INT);
1845     $tmpstr = $tmp ? 'tmp' : '';
1846     $time = time();
1847     $timemodified = mktime(0, 0, 0, date('m', $time),date('d', $time),date('Y', $time));
1849     if($usrid == 0) {
1850         return feedback_create_values($usrid, $timemodified, $tmp);
1851     }
1852     if(!$completedid or !$completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid))) {
1853         return feedback_create_values($usrid, $timemodified, $tmp);
1854     }else{
1855         $completed->timemodified = $timemodified;
1856         return feedback_update_values($completed, $tmp);
1857     }
1860 /**
1861  * this saves the values from anonymous user such as guest on the main-site
1862  *
1863  * @global object
1864  * @param string $guestid the unique guestidentifier
1865  * @return mixed false on error or the completeid
1866  */
1867 function feedback_save_guest_values($guestid) {
1868     global $DB;
1870     $completedid = optional_param('completedid', false, PARAM_INT);
1872     $timemodified = time();
1873     if(!$completed = $DB->get_record('feedback_completedtmp', array('id'=>$completedid))) {
1874         return feedback_create_values(0, $timemodified, true, $guestid);
1875     }else {
1876         $completed->timemodified = $timemodified;
1877         return feedback_update_values($completed, true);
1878     }
1881 /**
1882  * get the value from the given item related to the given completed.
1883  * the value can come as temporary or as permanently value. the deciding is done by $tmp
1884  *
1885  * @global object
1886  * @param int $completeid
1887  * @param int $itemid
1888  * @param boolean $tmp
1889  * @return mixed the value, the type depends on plugin-definition
1890  */
1891 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
1892     global $DB;
1894     $tmpstr = $tmp ? 'tmp' : '';
1895     return $DB->get_field('feedback_value'.$tmpstr, 'value', array('completed'=>$completedid, 'item'=>$itemid));
1898 /**
1899  * compares the value of the itemid related to the completedid with the dependvalue.
1900  * this is used if a depend item is set.
1901  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
1902  *
1903  * @global object
1904  * @global object
1905  * @param int $completeid
1906  * @param int $itemid
1907  * @param mixed $dependvalue
1908  * @param boolean $tmp
1909  * @return bool
1910  */
1911 function feedback_compare_item_value($completedid, $itemid, $dependvalue, $tmp = false) {
1912     global $DB, $CFG;
1914     $dbvalue = feedback_get_item_value($completedid, $itemid, $tmp);
1916     //get the class of the given item-typ
1917     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1919     //get the instance of the item-class
1920     $itemobj = feedback_get_item_class($item->typ);
1921     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
1924 /**
1925  * this function checks the correctness of values.
1926  * the rules for this are implemented in the class of each item.
1927  * it can be the required attribute or the value self e.g. numeric.
1928  * the params first/lastitem are given to determine the visible range between pagebreaks.
1929  *
1930  * @global object
1931  * @param int $firstitem the position of firstitem for checking
1932  * @param int $lastitem the position of lastitem for checking
1933  * @return boolean
1934  */
1935 function feedback_check_values($firstitem, $lastitem) {
1936     global $DB, $CFG;
1938     $feedbackid = optional_param('feedbackid', 0, PARAM_INT);
1940     //get all items between the first- and lastitem
1941     $select = "feedback = ?
1942                     AND position >= ?
1943                     AND position <= ?
1944                     AND hasvalue = 1";
1945     $params = array($feedbackid, $firstitem, $lastitem);
1946     if(!$feedbackitems = $DB->get_records_select('feedback_item', $select, $params)) {
1947         //if no values are given so no values can be wrong ;-)
1948         return true;
1949     }
1951     foreach($feedbackitems as $item) {
1952         //the name of the input field of the completeform is given in a special form:
1953         //<item-typ>_<item-id> eg. numeric_234
1954         //this is the key to get the value for the correct item
1955         $formvalname = $item->typ . '_' . $item->id;
1957         $value = optional_param($formvalname, NULL, PARAM_RAW);
1959         //check if the value is set
1960         if(is_null($value) AND $item->required == 1) {
1961             return false;
1962         }
1964         //get the instance of the item-class
1965         $itemobj = feedback_get_item_class($item->typ);
1967         //now we let check the value by the item-class
1968         if(!$itemobj->check_value($value, $item)) {
1969             return false;
1970         }
1971     }
1972     //if no wrong values so we can return true
1973     return true;
1976 /**
1977  * this function create a complete-record and the related value-records.
1978  * depending on the $tmp (true/false) the values are saved temporary or permanently
1979  *
1980  * @global object
1981  * @param int $userid
1982  * @param int $timemodified
1983  * @param boolean $tmp
1984  * @param string $guestid a unique identifier to save temporary data
1985  * @return mixed false on error or the completedid
1986  */
1987 function feedback_create_values($usrid, $timemodified, $tmp = false, $guestid = false){
1988     global $DB;
1990     $feedbackid = optional_param('feedbackid', false, PARAM_INT);
1991     $anonymous_response = optional_param('anonymous_response', false, PARAM_INT);
1992     $courseid = optional_param('courseid', false, PARAM_INT);
1994     $tmpstr = $tmp ? 'tmp' : '';
1995     //first we create a new completed record
1996     $completed = new stdClass();
1997     $completed->feedback           = $feedbackid;
1998     $completed->userid             = $usrid;
1999     $completed->guestid            = $guestid;
2000     $completed->timemodified       = $timemodified;
2001     $completed->anonymous_response = $anonymous_response;
2003     $completedid = $DB->insert_record('feedback_completed'.$tmpstr, $completed);
2005     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
2007     //the keys are in the form like abc_xxx
2008     //with explode we make an array with(abc, xxx) and (abc=typ und xxx=itemnr)
2010     //get the items of the feedback
2011     if(!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2012         return false;
2013     }
2014     foreach($allitems as $item) {
2015         $keyname = $item->typ.'_'.$item->id;
2016         $itemvalue = optional_param($keyname, NULL, PARAM_RAW);
2017         if(is_null($itemvalue)) {
2018             continue;
2019         }
2020         $value = new stdClass();
2021         $value->item = $item->id;
2022         $value->completed = $completed->id;
2023         $value->course_id = $courseid;
2025         //get the class of item-typ
2026         $itemobj = feedback_get_item_class($item->typ);
2028         //the kind of values can be absolutely different so we run create_value directly by the item-class
2029         $value->value = $itemobj->create_value($itemvalue);
2030         $DB->insert_record('feedback_value'.$tmpstr, $value);
2031     }
2032     return $completed->id;
2035 /**
2036  * this function updates a complete-record and the related value-records.
2037  * depending on the $tmp (true/false) the values are saved temporary or permanently
2038  *
2039  * @global object
2040  * @param object $completed
2041  * @param boolean $tmp
2042  * @return int the completedid
2043  */
2044 function feedback_update_values($completed, $tmp = false) {
2045     global $DB;
2046     $courseid = optional_param('courseid', false, PARAM_INT);
2048     $tmpstr = $tmp ? 'tmp' : '';
2050     $DB->update_record('feedback_completed'.$tmpstr, $completed);
2051     //get the values of this completed
2052     $values = $DB->get_records('feedback_value'.$tmpstr, array('completed'=>$completed->id));
2054     //get the items of the feedback
2055     if(!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
2056         return false;
2057     }
2058     foreach($allitems as $item) {
2059         $keyname = $item->typ.'_'.$item->id;
2060         $itemvalue = optional_param($keyname, NULL, PARAM_RAW);
2061         //is the itemvalue set (could be a subset of items because pagebreak)?
2062         if(is_null($itemvalue)) {
2063             continue;
2064         }
2066         $newvalue = new stdClass();
2067         $newvalue->item = $item->id;
2068         $newvalue->completed = $completed->id;
2069         $newvalue->course_id = $courseid;
2071         //get the class of item-typ
2072         $itemobj = feedback_get_item_class($item->typ);
2073         //the kind of values can be absolutely different so we run create_value directly by the item-class
2074         $newvalue->value = $itemobj->create_value($itemvalue);
2076         //check, if we have to create or update the value
2077         $exist = false;
2078         foreach($values as $value){
2079             if($value->item == $newvalue->item){
2080                 $newvalue->id = $value->id;
2081                 $exist = true;
2082                 break;
2083             }
2084         }
2085         if($exist){
2086             $DB->update_record('feedback_value'.$tmpstr, $newvalue);
2087         }else {
2088             $DB->insert_record('feedback_value'.$tmpstr, $newvalue);
2089         }
2090     }
2092     return $completed->id;
2095 /**
2096  * get the values of an item depending on the given groupid.
2097  * if the feedback is anonymous so the values are shuffled
2098  *
2099  * @global object
2100  * @global object
2101  * @param object $item
2102  * @param int $groupid
2103  * @param int $courseid
2104  * @param bool $ignore_empty if this is set true so empty values are not delivered
2105  * @return array the value-records
2106  */
2107 function feedback_get_group_values($item, $groupid = false, $courseid = false, $ignore_empty = false){
2108     global $CFG, $DB;
2110     //if the groupid is given?
2111     if (intval($groupid) > 0) {
2112         if($ignore_empty) {
2113             $ignore_empty_select = "AND fbc.value != ''";
2114         }
2115         else {
2116             $ignore_empty_select = "";
2117         }
2119         $query = 'SELECT fbv .  *
2120                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2121                    WHERE fbv.item = ?
2122                          AND fbv.completed = fbc.id
2123                          AND fbc.userid = gm.userid
2124                          '.$ignore_empty_select.'
2125                          AND gm.groupid = ?
2126                 ORDER BY fbc.timemodified';
2127         $values = $DB->get_records_sql($query, array($item->id, $groupid));
2129     } else {
2130         if($ignore_empty) {
2131             $ignore_empty_select = "AND value != ''";
2132         }
2133         else {
2134             $ignore_empty_select = "";
2135         }
2137         if ($courseid) {
2138             $values = $DB->get_records_select('feedback_value', "item = ? AND course_id = ? ".$ignore_empty_select, array($item->id, $courseid));
2139         } else {
2140             $values = $DB->get_records_select('feedback_value', "item = ? ".$ignore_empty_select, array($item->id));
2141         }
2142     }
2143     if ($DB->get_field('feedback', 'anonymous', array('id'=>$item->feedback)) == FEEDBACK_ANONYMOUS_YES) {
2144         if(is_array($values))
2145             shuffle($values);
2146     }
2147     return $values;
2150 /**
2151  * check for multiple_submit = false.
2152  * if the feedback is global so the courseid must be given
2153  *
2154  * @global object
2155  * @global object
2156  * @param int $feedbackid
2157  * @param int $courseid
2158  * @return boolean true if the feedback already is submitted otherwise false
2159  */
2160 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2161     global $USER, $DB;
2163     if (!$trackings = $DB->get_records_menu('feedback_tracking', array('userid'=>$USER->id, 'feedback'=>$feedbackid), '', 'id, completed')) {
2164         return false;
2165     }
2167     if($courseid) {
2168         $select = 'completed IN ('.implode(',',$trackings).') AND course_id = ?';
2169         if(!$values = $DB->get_records_select('feedback_value', $select, array($courseid))) {
2170             return false;
2171         }
2172     }
2174     return true;
2177 /**
2178  * if the completion of a feedback will be continued eg. by pagebreak or by multiple submit so the complete must be found.
2179  * if the param $tmp is set true so all things are related to temporary completeds
2180  *
2181  * @global object
2182  * @global object
2183  * @global object
2184  * @param int $feedbackid
2185  * @param boolean $tmp
2186  * @param int $courseid
2187  * @param string $guestid
2188  * @return int the id of the found completed
2189  */
2190 function feedback_get_current_completed($feedbackid, $tmp = false, $courseid = false, $guestid = false) {
2191     global $USER, $CFG, $DB;
2193     $tmpstr = $tmp ? 'tmp' : '';
2195     if(!$courseid) {
2196         if($guestid) {
2197             return $DB->get_record('feedback_completed'.$tmpstr, array('feedback'=>$feedbackid, 'guestid'=>$guestid));
2198         }else {
2199             return $DB->get_record('feedback_completed'.$tmpstr, array('feedback'=>$feedbackid, 'userid'=>$USER->id));
2200         }
2201     }
2203     $params = array();
2205     if ($guestid) {
2206         $userselect = "AND fc.guestid = :guestid";
2207         $params['guestid'] = $guestid;
2208     }else {
2209         $userselect = "AND fc.userid = :userid";
2210         $params['userid'] = $USER->id;
2211     }
2212     //if courseid is set the feedback is global. there can be more than one completed on one feedback
2213     $sql =  "SELECT DISTINCT fc.*
2214                FROM {feedback_value{$tmpstr}} fv, {feedback_completed{$tmpstr}} fc
2215               WHERE fv.course_id = :courseid
2216                     AND fv.completed = fc.id
2217                     $userselect
2218                     AND fc.feedback = :feedbackid";
2219     $params['courseid']   = intval($courseid);
2220     $params['feedbackid'] = $feedbackid;
2222     if (!$sqlresult = $DB->get_records_sql($sql, $params)) {
2223         return false;
2224     }
2225     foreach($sqlresult as $r) {
2226         return $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$r->id));
2227     }
2230 /**
2231  * get the completeds depending on the given groupid.
2232  *
2233  * @global object
2234  * @global object
2235  * @param object $feedback
2236  * @param int $groupid
2237  * @param int $courseid
2238  * @return mixed array of found completeds otherwise false
2239  */
2240 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2241     global $CFG, $DB;
2243     if (intval($groupid) > 0){
2244         $query = "SELECT fbc.*
2245                     FROM {feedback_completed} fbc, {groups_members} gm
2246                    WHERE fbc.feedback = ?
2247                          AND gm.groupid = ?
2248                          AND fbc.userid = gm.userid";
2249         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2250             return $values;
2251         } else {
2252             return false;
2253         }
2254     } else {
2255         if($courseid) {
2256             $query = "SELECT DISTINCT fbc.*
2257                         FROM {feedback_completed} fbc, {feedback_value} fbv
2258                         WHERE fbc.id = fbv.completed
2259                             AND fbc.feedback = ?
2260                             AND fbv.course_id = ?
2261                         ORDER BY random_response";
2262             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2263                 return $values;
2264             } else {
2265                 return false;
2266             }
2267         }else {
2268             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2269                 return $values;
2270             } else {
2271                 return false;
2272             }
2273         }
2274     }
2277 /**
2278  * get the count of completeds depending on the given groupid.
2279  *
2280  * @global object
2281  * @global object
2282  * @param object $feedback
2283  * @param int $groupid
2284  * @param int $courseid
2285  * @return mixed count of completeds or false
2286  */
2287 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2288     global $CFG, $DB;
2290     if ($courseid > 0 AND !$groupid <= 0) {
2291         $sql = "SELECT id, COUNT(item) AS ci
2292                   FROM {feedback_value}
2293                  WHERE course_id  = ?
2294               GROUP BY item ORDER BY ci DESC";
2295         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2296             $foundrecs = array_values($foundrecs);
2297             return $foundrecs[0]->ci;
2298         }
2299         return false;
2300     }
2301     if($values = feedback_get_completeds_group($feedback, $groupid)) {
2302         return sizeof($values);
2303     }else {
2304         return false;
2305     }
2308 /**
2309  * deletes all completed-recordsets from a feedback.
2310  * all related data such as values also will be deleted
2311  *
2312  * @global object
2313  * @param int $feedbackid
2314  * @return void
2315  */
2316 function feedback_delete_all_completeds($feedbackid) {
2317     global $DB;
2319     if (!$completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedbackid))) {
2320         return;
2321     }
2322     foreach($completeds as $completed) {
2323         feedback_delete_completed($completed->id);
2324     }
2327 /**
2328  * deletes a completed given by completedid.
2329  * all related data such values or tracking data also will be deleted
2330  *
2331  * @global object
2332  * @param int $completedid
2333  * @return boolean
2334  */
2335 function feedback_delete_completed($completedid) {
2336     global $DB;
2338     if (!$completed = $DB->get_record('feedback_completed', array('id'=>$completedid))) {
2339         return false;
2340     }
2341     
2342     if (!$feedback = $DB->get_record('feedback', array('id'=>$completed->feedback))) {
2343         return false;
2344     }
2345     
2346     if (!$course = $DB->get_record('course', array('id'=>$feedback->course))) {
2347         return false;
2348     }
2349     
2350     if (!$cm = get_coursemodule_from_instance('feedback', $feedback->id)) {
2351         return false;
2352     }
2354     //first we delete all related values
2355     $DB->delete_records('feedback_value', array('completed'=>$completed->id));
2357     //now we delete all tracking data
2358     if($tracking = $DB->get_record('feedback_tracking', array('completed'=>$completed->id, 'feedback'=>$completed->feedback))) {
2359         $DB->delete_records('feedback_tracking', array('completed'=>$completed->id));
2360     }
2362     // Update completion state
2363     $completion = new completion_info($course);
2364     if ($completion->is_enabled($cm) && $feedback->completionsubmit) {
2365         $completion->update_state($cm, COMPLETION_INCOMPLETE, $completed->userid);
2366     }
2367     //last we delete the completed-record
2368     return $DB->delete_records('feedback_completed', array('id'=>$completed->id));
2371 ////////////////////////////////////////////////
2372 ////////////////////////////////////////////////
2373 ////////////////////////////////////////////////
2374 //functions to handle sitecourse mapping
2375 ////////////////////////////////////////////////
2377 /**
2378  * checks if the course and the feedback is in the table feedback_sitecourse_map.
2379  *
2380  * @global object
2381  * @param int $feedbackid
2382  * @param int $courseid
2383  * @return int the count of records
2384  */
2385 function feedback_is_course_in_sitecourse_map($feedbackid, $courseid) {
2386     global $DB;
2387     return $DB->count_records('feedback_sitecourse_map', array('feedbackid'=>$feedbackid, 'courseid'=>$courseid));
2390 /**
2391  * checks if the feedback is in the table feedback_sitecourse_map.
2392  *
2393  * @global object
2394  * @param int $feedbackid
2395  * @return boolean
2396  */
2397 function feedback_is_feedback_in_sitecourse_map($feedbackid) {
2398     global $DB;
2399     return $DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$feedbackid));
2402 /**
2403  * gets the feedbacks from table feedback_sitecourse_map.
2404  * this is used to show the global feedbacks on the feedback block
2405  * all feedbacks with the following criteria will be selected:<br />
2406  *
2407  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2408  * 2) all feedbacks which not are listed in sitecoursemap
2409  *
2410  * @global object
2411  * @param int $courseid
2412  * @return array the feedback-records
2413  */
2414 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2415     global $DB;
2417     //first get all feedbacks listed in sitecourse_map with named courseid
2418     $sql = "SELECT f.id AS id, cm.id AS cmid, f.name AS name, f.timeopen AS timeopen, f.timeclose AS timeclose
2419               FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2420              WHERE f.id = cm.instance
2421                    AND f.course = '".SITEID."'
2422                    AND m.id = cm.module
2423                    AND m.name = 'feedback'
2424                    AND sm.courseid = ?
2425                    AND sm.feedbackid = f.id";
2427     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2428         $feedbacks1 = array();
2429     }
2431     //second get all feedbacks not listed in sitecourse_map
2432     $feedbacks2 = array();
2433     $sql = "SELECT f.id AS id, cm.id AS cmid, f.name AS name, f.timeopen AS timeopen, f.timeclose AS timeclose
2434               FROM {feedback} f, {course_modules} cm, {modules} m
2435              WHERE f.id = cm.instance
2436                    AND f.course = '".SITEID."'
2437                    AND m.id = cm.module
2438                    AND m.name = 'feedback'";
2439     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2440         $allfeedbacks = array();
2441     }
2442     foreach($allfeedbacks as $a) {
2443         if(!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2444             $feedbacks2[] = $a;
2445         }
2446     }
2448     return array_merge($feedbacks1, $feedbacks2);
2452 /**
2453  * gets the courses from table feedback_sitecourse_map.
2454  *
2455  * @global object
2456  * @param int $feedbackid
2457  * @return array the course-records
2458  */
2459 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2460     global $DB;
2462     $sql = "SELECT f.id, f.courseid, c.fullname, c.shortname
2463               FROM {feedback_sitecourse_map} f, {course} c
2464              WHERE c.id = f.courseid
2465                    AND f.feedbackid = ?
2466           ORDER BY c.fullname";
2468     return $DB->get_records_sql($sql, array($feedbackid));
2472 /**
2473  * removes non existing courses or feedbacks from sitecourse_map.
2474  * it shouldn't be called all too often
2475  * a good place for it could be the mapcourse.php or unmapcourse.php
2476  *
2477  * @global object
2478  * @return void
2479  */
2480 function feedback_clean_up_sitecourse_map() {
2481     global $DB;
2483     $maps = $DB->get_records('feedback_sitecourse_map');
2484     foreach($maps as $map) {
2485         if (!$DB->get_record('course', array('id'=>$map->courseid))) {
2486             $DB->delete_records('feedback_sitecourse_map', array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid));
2487             continue;
2488         }
2489         if (!$DB->get_record('feedback', array('id'=>$map->feedbackid))) {
2490             $DB->delete_records('feedback_sitecourse_map', array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid));
2491             continue;
2492         }
2494     }
2497 ////////////////////////////////////////////////
2498 ////////////////////////////////////////////////
2499 ////////////////////////////////////////////////
2500 //not relatable functions
2501 ////////////////////////////////////////////////
2503 /**
2504  * prints the option items of a selection-input item (dropdownlist).
2505  * @param int $startval the first value of the list
2506  * @param int $endval the last value of the list
2507  * @param int $selectval which item should be selected
2508  * @param int $interval the stepsize from the first to the last value
2509  * @return void
2510  */
2511 function feedback_print_numeric_option_list($startval, $endval, $selectval = '', $interval = 1){
2512     for($i = $startval; $i <= $endval; $i += $interval){
2513         if($selectval == ($i)){
2514             $selected = 'selected="selected"';
2515         }else{
2516             $selected = '';
2517         }
2518         echo '<option '.$selected.'>'.$i.'</option>';
2519     }
2522 /**
2523  * sends an email to the teachers of the course where the given feedback is placed.
2524  *
2525  * @global object
2526  * @global object
2527  * @uses FEEDBACK_ANONYMOUS_NO
2528  * @uses FORMAT_PLAIN
2529  * @param object $cm the coursemodule-record
2530  * @param object $feedback
2531  * @param object $course
2532  * @param int $userid
2533  * @return void
2534  */
2535 function feedback_send_email($cm, $feedback, $course, $userid) {
2536     global $CFG, $DB;
2538     if ($feedback->email_notification == 0) {  // No need to do anything
2539         return;
2540     }
2542     $user = $DB->get_record('user', array('id'=>$userid));
2544     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
2545         $groupmode =  $cm->groupmode;
2546     } else {
2547         $groupmode = $course->groupmode;
2548     }
2550     if ($groupmode == SEPARATEGROUPS) {
2551         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
2552                                                FROM {groups} g, {groups_members} m
2553                                               WHERE g.courseid = ?
2554                                                     AND g.id = m.groupid
2555                                                     AND m.userid = ?
2556                                            ORDER BY name ASC", array($course->id, $userid));
2557         $groups = array_values($groups);
2559         $teachers = feedback_get_receivemail_users($cm->id, $groups);
2560     } else {
2561         $teachers = feedback_get_receivemail_users($cm->id);
2562     }
2564     if ($teachers) {
2566         $strfeedbacks = get_string('modulenameplural', 'feedback');
2567         $strfeedback  = get_string('modulename', 'feedback');
2568         $strcompleted  = get_string('completed', 'feedback');
2569         $printusername = $feedback->anonymous == FEEDBACK_ANONYMOUS_NO ? fullname($user) : get_string('anonymous_user', 'feedback');
2571         foreach ($teachers as $teacher) {
2572             $info = new stdClass();
2573             $info->username = $printusername;
2574             $info->feedback = format_string($feedback->name,true);
2575             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?id='.$cm->id.'&userid='.$userid.'&do_show=showentries';
2577             $postsubject = $strcompleted.': '.$info->username.' -> '.$feedback->name;
2578             $posttext = feedback_send_email_text($info, $course);
2579             $posthtml = ($teacher->mailformat == 1) ? feedback_send_email_html($info, $course, $cm) : '';
2581             if($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2582                 $eventdata = new stdClass();
2583                 $eventdata->name             = 'feedback';
2584                 $eventdata->component        = 'mod';
2585                 $eventdata->userfrom         = $user;
2586                 $eventdata->userto           = $teacher;
2587                 $eventdata->subject          = $postsubject;
2588                 $eventdata->fullmessage      = $posttext;
2589                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2590                 $eventdata->fullmessagehtml  = $posthtml;
2591                 $eventdata->smallmessage     = '';
2592                 message_send($eventdata);
2593             }else {
2594                 $eventdata = new stdClass();
2595                 $eventdata->name             = 'feedback';
2596                 $eventdata->component        = 'mod';
2597                 $eventdata->userfrom         = $teacher;
2598                 $eventdata->userto           = $teacher;
2599                 $eventdata->subject          = $postsubject;
2600                 $eventdata->fullmessage      = $posttext;
2601                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2602                 $eventdata->fullmessagehtml  = $posthtml;
2603                 $eventdata->smallmessage     = '';
2604                 message_send($eventdata);
2605             }
2606         }
2607     }
2610 /**
2611  * sends an email to the teachers of the course where the given feedback is placed.
2612  *
2613  * @global object
2614  * @uses FORMAT_PLAIN
2615  * @param object $cm the coursemodule-record
2616  * @param object $feedback
2617  * @param object $course
2618  * @return void
2619  */
2620 function feedback_send_email_anonym($cm, $feedback, $course) {
2621     global $CFG;
2623     if ($feedback->email_notification == 0) {             // No need to do anything
2624         return;
2625     }
2627     $teachers = feedback_get_receivemail_users($cm->id);
2629     if ($teachers) {
2631         $strfeedbacks = get_string('modulenameplural', 'feedback');
2632         $strfeedback  = get_string('modulename', 'feedback');
2633         $strcompleted  = get_string('completed', 'feedback');
2634         $printusername = get_string('anonymous_user', 'feedback');
2636         foreach ($teachers as $teacher) {
2637             $info = new stdClass();
2638             $info->username = $printusername;
2639             $info->feedback = format_string($feedback->name,true);
2640             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries_anonym.php?id='.$cm->id;
2642             $postsubject = $strcompleted.': '.$info->username.' -> '.$feedback->name;
2643             $posttext = feedback_send_email_text($info, $course);
2644             $posthtml = ($teacher->mailformat == 1) ? feedback_send_email_html($info, $course, $cm) : '';
2646             $eventdata = new stdClass();
2647             $eventdata->name             = 'feedback';
2648             $eventdata->component        = 'mod';
2649             $eventdata->userfrom         = $teacher;
2650             $eventdata->userto           = $teacher;
2651             $eventdata->subject          = $postsubject;
2652             $eventdata->fullmessage      = $posttext;
2653             $eventdata->fullmessageformat = FORMAT_PLAIN;
2654             $eventdata->fullmessagehtml  = $posthtml;
2655             $eventdata->smallmessage     = '';
2656             message_send($eventdata);
2657         }
2658     }
2661 /**
2662  * send the text-part of the email
2663  *
2664  * @param object $info includes some infos about the feedback you want to send
2665  * @param object $course
2666  * @return string the text you want to post
2667  */
2668 function feedback_send_email_text($info, $course) {
2669     $posttext  = $course->shortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
2670                     $info->feedback."\n";
2671     $posttext .= '---------------------------------------------------------------------'."\n";
2672     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
2673     $posttext .= '---------------------------------------------------------------------'."\n";
2674     return $posttext;
2678 /**
2679  * send the html-part of the email
2680  *
2681  * @global object
2682  * @param object $info includes some infos about the feedback you want to send
2683  * @param object $course
2684  * @return string the text you want to post
2685  */
2686 function feedback_send_email_html($info, $course, $cm) {
2687     global $CFG;
2688     $posthtml  = '<p><font face="sans-serif">'.
2689                 '<a href="'.$CFG->wwwroot.'/course/view.php?id='.$course->id.'">'.$course->shortname.'</a> ->'.
2690                 '<a href="'.$CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
2691                 '<a href="'.$CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id.'">'.$info->feedback.'</a></font></p>';
2692     $posthtml .= '<hr /><font face="sans-serif">';
2693     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
2694     $posthtml .= '</font><hr />';
2695     return $posthtml;
2698 /**
2699  * print some errors to inform users about this.
2700  *
2701  * @global object
2702  * @return void
2703  */
2704 function feedback_print_errors() {
2706     global $SESSION, $OUTPUT;
2708     feedback_init_feedback_session();
2710     if(empty($SESSION->feedback->errors)) {
2711         return;
2712     }
2714     echo $OUTPUT->box_start('generalbox errorboxcontent boxaligncenter boxwidthnormal');
2715     echo $OUTPUT->heading(get_string('handling_error', 'feedback'));
2717     echo '<p align="center"><b><font color="black"><pre>';
2718     print_r($SESSION->feedback->errors) . "\n";
2719     echo '</pre></font></b></p>';
2721     echo $OUTPUT->box_end();
2722     echo '<br /><br />';
2723     $SESSION->feedback->errors = array(); //remove errors
2726 /**
2727  * @param string $url
2728  * @return string
2729  */
2730 function feedback_encode_target_url($url) {
2731     if (strpos($url, '?')) {
2732         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
2733         return $part1 . '?' . htmlentities($part2);
2734     } else {
2735         return $url;
2736     }
2739 /**
2740  * Adds module specific settings to the settings block
2741  *
2742  * @param settings_navigation $settings The settings navigation object
2743  * @param navigation_node $feedbacknode The node to add module settings to
2744  */
2745 function feedback_extend_settings_navigation(settings_navigation $settings, navigation_node $feedbacknode) {
2746     global $PAGE, $DB;
2748     if (!$context = get_context_instance(CONTEXT_MODULE, $PAGE->cm->id)) {
2749         print_error('badcontext');
2750     }
2752     if (has_capability('mod/feedback:edititems', $context)) {
2753         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
2754         $questionnode->add(get_string('edit_items', 'feedback'), new moodle_url('/mod/feedback/edit.php', array('id'=>$PAGE->cm->id, 'do_show'=>'edit')));
2755         $questionnode->add(get_string('export_questions', 'feedback'), new moodle_url('/mod/feedback/export.php', array('id'=>$PAGE->cm->id, 'action'=>'exportfile')));
2756         $questionnode->add(get_string('import_questions', 'feedback'), new moodle_url('/mod/feedback/import.php', array('id'=>$PAGE->cm->id)));
2757         $questionnode->add(get_string('templates', 'feedback'), new moodle_url('/mod/feedback/edit.php', array('id'=>$PAGE->cm->id, 'do_show'=>'templates')));
2758     }
2760     if (has_capability('mod/feedback:viewreports', $context)) {
2761         $feedback = $DB->get_record('feedback', array('id'=>$PAGE->cm->instance));
2762         if($feedback->course == SITEID){
2763             $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')));
2764         }else {
2765             $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')));
2766         }
2768         $feedbacknode->add(get_string('show_entries', 'feedback'), new moodle_url('/mod/feedback/show_entries.php', array('id'=>$PAGE->cm->id, 'do_show'=>'showentries')));
2769     }
2772 function feedback_init_feedback_session() {
2773     //initialize the feedback-Session - not nice at all!!
2774     global $SESSION;
2775     if (!empty($SESSION)) {
2776         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
2777             $SESSION->feedback = new stdClass();
2778         }
2779     }