f82f8f7159b0e84b3234d833f14a046fa92223ab
[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');
33 define('FEEDBACK_ANONYMOUS_YES', 1);
34 define('FEEDBACK_ANONYMOUS_NO', 2);
35 define('FEEDBACK_MIN_ANONYMOUS_COUNT_IN_GROUP', 2);
36 define('FEEDBACK_DECIMAL', '.');
37 define('FEEDBACK_THOUSAND', ',');
38 define('FEEDBACK_RESETFORM_RESET', 'feedback_reset_data_');
39 define('FEEDBACK_RESETFORM_DROP', 'feedback_drop_feedback_');
40 define('FEEDBACK_MAX_PIX_LENGTH', '400'); //max. Breite des grafischen Balkens in der Auswertung
41 define('FEEDBACK_DEFAULT_PAGE_COUNT', 20);
43 /**
44  * @uses FEATURE_GROUPS
45  * @uses FEATURE_GROUPINGS
46  * @uses FEATURE_GROUPMEMBERSONLY
47  * @uses FEATURE_MOD_INTRO
48  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
49  * @uses FEATURE_GRADE_HAS_GRADE
50  * @uses FEATURE_GRADE_OUTCOMES
51  * @param string $feature FEATURE_xx constant for requested feature
52  * @return mixed True if module supports feature, null if doesn't know
53  */
54 function feedback_supports($feature) {
55     switch($feature) {
56         case FEATURE_GROUPS:                  return true;
57         case FEATURE_GROUPINGS:               return true;
58         case FEATURE_GROUPMEMBERSONLY:        return true;
59         case FEATURE_MOD_INTRO:               return true;
60         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
61         case FEATURE_GRADE_HAS_GRADE:         return false;
62         case FEATURE_GRADE_OUTCOMES:          return false;
63         case FEATURE_BACKUP_MOODLE2:          return true;
65         default: return null;
66     }
67 }
69 /**
70  * this will create a new instance and return the id number
71  * of the new instance.
72  *
73  * @global object
74  * @param object $feedback the object given by mod_feedback_mod_form
75  * @return int
76  */
77 function feedback_add_instance($feedback) {
78     global $DB;
80     $feedback->timemodified = time();
81     $feedback->id = '';
83     //check if openenable and/or closeenable is set and set correctly to save in db
84     if(empty($feedback->openenable)) {
85         $feedback->timeopen = 0;
86     }
87     if(empty($feedback->closeenable)) {
88         $feedback->timeclose = 0;
89     }
90     if(empty($feedback->site_after_submit)) {
91         $feedback->site_after_submit = '';
92     }
94     //saving the feedback in db
95     $feedbackid = $DB->insert_record("feedback", $feedback);
97     $feedback->id = $feedbackid;
99     feedback_set_events($feedback);
101     return $feedbackid;
104 /**
105  * this will update a given instance
106  *
107  * @global object
108  * @param object $feedback the object given by mod_feedback_mod_form
109  * @return boolean
110  */
111 function feedback_update_instance($feedback) {
112     global $DB;
114     $feedback->timemodified = time();
115     $feedback->id = $feedback->instance;
117     //check if openenable and/or closeenable is set and set correctly to save in db
118     if(empty($feedback->openenable)) {
119         $feedback->timeopen = 0;
120     }
121     if(empty($feedback->closeenable)) {
122         $feedback->timeclose = 0;
123     }
124     if(empty($feedback->site_after_submit)) {
125         $feedback->site_after_submit = '';
126     }
128     //save the feedback into the db
129     $DB->update_record("feedback", $feedback);
131     //create or update the new events
132     feedback_set_events($feedback);
134     return true;
137 /**
138  * Serves the files included in feedback items like label. Implements needed access control ;-)
139  *
140  * @param object $course
141  * @param object $cminfo
142  * @param object $context
143  * @param string $filearea
144  * @param array $args
145  * @param bool $forcedownload
146  * @return bool false if file not found, does not return if found - justsend the file
147  */
148 function feedback_pluginfile($course, $cminfo, $context, $filearea, $args, $forcedownload) {
149     global $CFG, $DB;
151     if (!$cminfo->uservisible) {
152         return false;
153     }
155     if($filearea === 'feedback_template') {
156         $usedcontext = get_context_instance(CONTEXT_COURSE, $course->id);
157     }else {
158         $usedcontext = $context;
159     }
161     if ($filearea === 'feedback_item' OR $filearea === 'feedback_template') {
162         $itemid = (int)array_shift($args);
164         if (!$cm = get_coursemodule_from_instance('feedback', $cminfo->instance, $course->id)) {
165             return false;
166         }
168         require_course_login($course, true, $cm);
170         if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
171             return false;
172         }
174         if (!$feedback = $DB->get_record('feedback', array('id'=>$cminfo->instance))) {
175             return false;
176         }
178         if (!has_capability('mod/feedback:view', $context)) {
179             return false;
180         }
182         if ($item->feedback == $cminfo->instance) {
183             $filecontext = $usedcontext;
184         } else {
185             return false;
186         }
188         $relativepath = '/'.implode('/', $args);
189         $fullpath = $filecontext->id.$filearea.$itemid.$relativepath;
191         $fs = get_file_storage();
192         if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
193             return false;
194         }
196         // finally send the file
197         send_stored_file($file, 0, 0, true); // download MUST be forced - security!
198     }
200     return false;
204 /**
205  * this will delete a given instance.
206  * all referenced data also will be deleted
207  *
208  * @global object
209  * @param int $id the instanceid of feedback
210  * @return boolean
211  */
212 function feedback_delete_instance($id) {
213     global $DB;
215     //get all referenced items
216     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
218     //deleting all referenced items and values
219     if (is_array($feedbackitems)){
220         foreach($feedbackitems as $feedbackitem){
221             $DB->delete_records("feedback_value", array("item"=>$feedbackitem->id));
222             $DB->delete_records("feedback_valuetmp", array("item"=>$feedbackitem->id));
223         }
224         if($delitems = $DB->get_records("feedback_item", array("feedback"=>$id))) {
225             foreach($delitems as $delitem) {
226                 feedback_delete_item($delitem->id, false);
227             }
228         }
229     }
231     //deleting the referenced tracking data
232     $DB->delete_records('feedback_tracking', array('feedback'=>$id));
234     //deleting the completeds
235     $DB->delete_records("feedback_completed", array("feedback"=>$id));
237     //deleting the unfinished completeds
238     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
240     //deleting old events
241     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
242     return $DB->delete_records("feedback", array("id"=>$id));
245 /**
246  * this is called after deleting all instances if the course will be deleted.
247  * only templates have to be deleted
248  *
249  * @global object
250  * @param object $course
251  * @return boolean
252  */
253 function feedback_delete_course($course) {
254     global $DB;
256     //delete all templates of given course
257     return $DB->delete_records('feedback_template', array('course'=>$course->id));
260 /**
261  * Return a small object with summary information about what a
262  * user has done with a given particular instance of this module
263  * Used for user activity reports.
264  * $return->time = the time they did it
265  * $return->info = a short text description
266  *
267  * @param object $course
268  * @param object $user
269  * @param object $mod
270  * @param object $feedback
271  * @return object
272  */
273 function feedback_user_outline($course, $user, $mod, $feedback) {
274     return null;
277 /**
278  * Returns all users who has completed a specified feedback since a given time
279  * many thanks to Manolescu Dorel, who contributed these two functions
280  *
281  * @global object
282  * @global object
283  * @global object
284  * @global object
285  * @uses CONTEXT_MODULE
286  * @param array $activities Passed by reference
287  * @param int $index Passed by reference
288  * @param int $timemodified Timestamp
289  * @param int $courseid
290  * @param int $cmid
291  * @param int $userid
292  * @param int $groupid
293  * @return void
294  */
295 function feedback_get_recent_mod_activity(&$activities, &$index, $timemodified, $courseid, $cmid, $userid="", $groupid="")  {
296     global $CFG, $COURSE, $USER, $DB;
298     if ($COURSE->id == $courseid) {
299         $course = $COURSE;
300     } else {
301         $course = $DB->get_record('course', array('id'=>$courseid));
302     }
304     $modinfo =& get_fast_modinfo($course);
306     $cm = $modinfo->cms[$cmid];
308     $sqlargs = array();
310     $sql = " SELECT fk . * , fc . * , u.firstname, u.lastname, u.email, u.picture
311                                             FROM {feedback_completed} fc
312                                                 JOIN {feedback} fk ON fk.id = fc.feedback
313                                                 JOIN {user} u ON u.id = fc.userid ";
315     if ($groupid) {
316         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
317     }
319     $sql .= " WHERE fc.timemodified > ? AND fk.id = ? ";
320     $sqlargs[] = $timemodified;
321     $sqlargs[] = $cm->instace;
323     if ($userid) {
324         $sql .= " AND u.id = ? ";
325         $sqlargs[] = $userid;
326     }
328     if ($groupid) {
329         $sql .= " AND gm.groupid = ? ";
330         $sqlargs[] = $groupid;
331     }
333     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
334         return;
335     }
337     $cm_context      = get_context_instance(CONTEXT_MODULE, $cm->id);
338     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
339     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cm_context);
340     $groupmode       = groups_get_activity_groupmode($cm, $course);
342     if (is_null($modinfo->groups)) {
343         $modinfo->groups = groups_get_user_groups($course->id); // load all my groups and cache it in modinfo
344     }
346     $aname = format_string($cm->name,true);
347     foreach ($feedbackitems as $feedbackitem) {
348         if ($feedbackitem->userid != $USER->id) {
350             if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
351                 $usersgroups = groups_get_all_groups($course->id, $feedbackitem->userid, $cm->groupingid);
352                 if (!is_array($usersgroups)) {
353                     continue;
354                 }
355                 $usersgroups = array_keys($usersgroups);
356                 $interset = array_intersect($usersgroups, $modinfo->groups[$cm->id]);
357                 if (empty($intersect)) {
358                     continue;
359                 }
360             }
361        }
363         $tmpactivity = new object();
365         $tmpactivity->type      = 'feedback';
366         $tmpactivity->cmid      = $cm->id;
367         $tmpactivity->name      = $aname;
368         $tmpactivity->sectionnum= $cm->sectionnum;
369         $tmpactivity->timestamp = $feedbackitem->timemodified;
371         $tmpactivity->content->feedbackid = $feedbackitem->id;
372         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
374         $tmpactivity->user->userid   = $feedbackitem->userid;
375         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
376         $tmpactivity->user->picture  = $feedbackitem->picture;
378         $activities[$index++] = $tmpactivity;
379     }
381   return;
384 /**
385  * Prints all users who has completed a specified feedback since a given time
386  * many thanks to Manolescu Dorel, who contributed these two functions
387  *
388  * @global object
389  * @param object $activity
390  * @param int $courseid
391  * @param string $detail
392  * @param array $modnames
393  * @return void Output is echo'd
394  */
395 function feedback_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
396     global $CFG, $OUTPUT;
398     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
400     echo "<tr><td class=\"userpicture\" valign=\"top\">";
401     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
402     echo "</td><td>";
404     if ($detail) {
405         $modname = $modnames[$activity->type];
406         echo '<div class="title">';
407         echo "<img src=\"" . $OUTPUT->pix_url('icon', $activity->type) . "\" ".
408              "class=\"icon\" alt=\"$modname\" />";
409         echo "<a href=\"$CFG->wwwroot/mod/feedback/view.php?id={$activity->cmid}\">{$activity->name}</a>";
410         echo '</div>';
411     }
413     echo '<div class="title">';
414     echo '</div>';
416     echo '<div class="user">';
417     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->userid}&amp;course=$courseid\">"
418          ."{$activity->user->fullname}</a> - ".userdate($activity->timestamp);
419     echo '</div>';
421     echo "</td></tr></table>";
423     return;
427 /**
428  * Print a detailed representation of what a  user has done with
429  * a given particular instance of this module, for user activity reports.
430  *
431  * @param object $course
432  * @param object $user
433  * @param object $mod
434  * @param object $feedback
435  * @return bool
436  */
437 function feedback_user_complete($course, $user, $mod, $feedback) {
438     return true;
441 /**
442  * @return bool true
443  */
444 function feedback_cron () {
445     return true;
448 /**
449  * @return bool false
450  */
451 function feedback_get_participants($feedbackid) {
452     return false;
456 /**
457  * @return bool false
458  */
459 function feedback_scale_used ($feedbackid,$scaleid) {
460     return false;
463 /**
464  * This function is used by the reset_course_userdata function in moodlelib.
465  * This function will remove all responses from the specified feedback
466  * and clean up any related data.
467  *
468  * @global object
469  * @global object
470  * @uses FEEDBACK_RESETFORM_RESET
471  * @uses FEEDBACK_RESETFORM_DROP
472  * @param object $data the data submitted from the reset course.
473  * @return array status array
474  */
475 function feedback_reset_userdata($data) {
476     global $CFG, $DB;
478     $resetfeedbacks = array();
479     $dropfeedbacks = array();
480     $status = array();
481     $componentstr = get_string('modulenameplural', 'feedback');
483     //get the relevant entries from $data
484     foreach($data as $key => $value) {
485         switch(true) {
486             case substr($key, 0, strlen(FEEDBACK_RESETFORM_RESET)) == FEEDBACK_RESETFORM_RESET:
487                 if($value == 1) {
488                     $templist = explode('_', $key);
489                     if(isset($templist[3]))$resetfeedbacks[] = intval($templist[3]);
490                 }
491             break;
492             case substr($key, 0, strlen(FEEDBACK_RESETFORM_DROP)) == FEEDBACK_RESETFORM_DROP:
493                 if($value == 1) {
494                     $templist = explode('_', $key);
495                     if(isset($templist[3]))$dropfeedbacks[] = intval($templist[3]);
496                 }
497             break;
498         }
499     }
501     //reset the selected feedbacks
502     foreach($resetfeedbacks as $id) {
503         $feedback = $DB->get_record('feedback', array('id'=>$id));
504         feedback_delete_all_completeds($id);
505         $status[] = array('component'=>$componentstr.':'.$feedback->name, 'item'=>get_string('resetting_data','feedback'), 'error'=>false);
506     }
508     //drop the selected feedbacks
509     // foreach($dropfeedbacks as $id) {
510         // $cm = get_coursemodule_from_instance('feedback', $id);
511         // feedback_delete_instance($id);
512         // feedback_delete_course_module($cm->id);
513         // $status[] = array('component'=>$componentstr, 'item'=>get_string('drop_feedback','feedback'), 'error'=>false);
514     // }
515     return $status;
518 /**
519  * Called by course/reset.php
520  *
521  * @global object
522  * @uses FEEDBACK_RESETFORM_RESET
523  * @param object $mform form passed by reference
524  */
525 function feedback_reset_course_form_definition(&$mform) {
526     global $COURSE, $DB;
528     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
530     if(!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')){
531         return;
532     }
534     $mform->addElement('static', 'hint', get_string('resetting_data','feedback'));
535     foreach($feedbacks as $feedback) {
536         $mform->addElement('checkbox', FEEDBACK_RESETFORM_RESET.$feedback->id, $feedback->name);
537         // $mform->addElement('checkbox', FEEDBACK_RESETFORM_DROP.$feedback->id, get_string('drop_feedback','feedback'));
538     }
541 /**
542  * Course reset form defaults.
543  *
544  * @global object
545  * @uses FEEDBACK_RESETFORM_RESET
546  * @param object $course
547  */
548 function feedback_reset_course_form_defaults($course) {
549     global $DB;
551     $return = array();
552     if(!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')){
553         return;
554     }
555     foreach($feedbacks as $feedback) {
556         $return[FEEDBACK_RESETFORM_RESET.$feedback->id] = true;
557         // $return[FEEDBACK_RESETFORM_DROP.$feedback->id] = false;
558     }
559     return $return;
562 /**
563  * Called by course/reset.php and shows the formdata by coursereset.
564  * it prints checkboxes for each feedback available at the given course
565  * there are two checkboxes: 1) delete userdata and keep the feedback 2) delete userdata and drop the feedback
566  *
567  * @global object
568  * @uses FEEDBACK_RESETFORM_RESET
569  * @uses FEEDBACK_RESETFORM_DROP
570  * @param object $course
571  * @return void
572  */
573 function feedback_reset_course_form($course) {
574     global $DB, $OUTPUT;
576     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
577     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
578         return;
579     }
581     foreach($feedbacks as $feedback) {
582         echo '<p>';
583         echo get_string('name','feedback').': '.$feedback->name.'<br />';
584         echo html_writer::checkbox(FEEDBACK_RESETFORM_RESET.$feedback->id, 1, true, get_string('resetting_data','feedback'));
585         echo '<br />';
586         echo html_writer::checkbox(FEEDBACK_RESETFORM_DROP.$feedback->id, 1, false, get_string('drop_feedback','feedback'));
587         echo '</p>';
588     }
591 /**
592  * This creates new events given as timeopen and closeopen by $feedback.
593  *
594  * @global object
595  * @param object $feedback
596  * @return void
597  */
598 function feedback_set_events($feedback) {
599     global $DB;
601     // adding the feedback to the eventtable (I have seen this at quiz-module)
602     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$feedback->id));
604     if (!isset($feedback->coursemodule)) {
605         $cm = get_coursemodule_from_id('feedback', $feedback->id);
606         $feedback->coursemodule = $cm->id;
607     }
609     // the open-event
610     if($feedback->timeopen > 0) {
611         $event = NULL;
612         $event->name         = get_string('start', 'feedback').' '.$feedback->name;
613         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
614         $event->courseid     = $feedback->course;
615         $event->groupid      = 0;
616         $event->userid       = 0;
617         $event->modulename   = 'feedback';
618         $event->instance     = $feedback->id;
619         $event->eventtype    = 'open';
620         $event->timestart    = $feedback->timeopen;
621         $event->visible      = instance_is_visible('feedback', $feedback);
622         if($feedback->timeclose > 0) {
623             $event->timeduration = ($feedback->timeclose - $feedback->timeopen);
624         } else {
625             $event->timeduration = 0;
626         }
628         calendar_event::create($event);
629     }
631     // the close-event
632     if($feedback->timeclose > 0) {
633         $event = NULL;
634         $event->name         = get_string('stop', 'feedback').' '.$feedback->name;
635         $event->description  = format_module_intro('feedback', $feedback, $feedback->coursemodule);
636         $event->courseid     = $feedback->course;
637         $event->groupid      = 0;
638         $event->userid       = 0;
639         $event->modulename   = 'feedback';
640         $event->instance     = $feedback->id;
641         $event->eventtype    = 'close';
642         $event->timestart    = $feedback->timeclose;
643         $event->visible      = instance_is_visible('feedback', $feedback);
644         $event->timeduration = 0;
646         calendar_event::create($event);
647     }
650 /**
651  *  this function is called by {@link feedback_delete_userdata()}
652  *  it drops the feedback-instance from the course_module table
653  *
654  * @global object
655  *  @param int $id the id from the coursemodule
656  *  @return boolean
657  */
658 function feedback_delete_course_module($id) {
659     global $DB;
661     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
662         return true;
663     }
664     return $DB->delete_records('course_modules', array('id'=>$cm->id));
669 ////////////////////////////////////////////////
670 //functions to handle capabilities
671 ////////////////////////////////////////////////
673 /**
674  *  returns the context-id related to the given coursemodule-id
675  *
676  * @staticvar object $context
677  *  @param int $cmid the coursemodule-id
678  *  @return object $context
679  */
680 function feedback_get_context($cmid) {
681     static $context;
683     if(isset($context)) return $context;
685     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
686             print_error('badcontext');
687     }
688     return $context;
691 /**
692  *  returns true if the current role is faked by switching role feature
693  *
694  * @global object
695  *  @return boolean
696  */
697 function feedback_check_is_switchrole(){
698     global $USER;
699     if(isset($USER->switchrole) AND is_array($USER->switchrole) AND count($USER->switchrole) > 0) {
700         return true;
701     }
702     return false;
705 /**
706  * count users which have not completed the feedback
707  *
708  * @global object
709  * @uses CONTEXT_MODULE
710  * @param object $cm
711  * @param int $group single groupid
712  * @param string $sort
713  * @param int $startpage
714  * @param int $pagecount
715  * @return object the userrecords
716  */
717 function feedback_get_incomplete_users($cm, $group = false, $sort = '', $startpage = false, $pagecount = false) {
718     global $DB;
720     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
722     //first get all user who can complete this feedback
723     $cap = 'mod/feedback:complete';
724     $fields = 'u.id, u.username';
725     if(!$allusers = get_users_by_capability($context, $cap, $fields, $sort, '', '', $group, '', true)) {
726         return false;
727     }
728     $allusers = array_keys($allusers);
730     //now get all completeds
731     if(!$completedusers = $DB->get_records_menu('feedback_completed', array('feedback'=>$cm->instance), '', 'userid,id')){
732         return false;
733     }
734     $completedusers = array_keys($completedusers);
736     //now strike all completedusers from allusers
737     $allusers = array_diff($allusers, $completedusers);
739     //for paging I use array_slice()
740     if($startpage !== false AND $pagecount !== false) {
741         $allusers = array_slice($allusers, $startpage, $pagecount);
742     }
744     return $allusers;
747 /**
748  * count users which have not completed the feedback
749  *
750  * @global object
751  * @param object $cm
752  * @param int $group single groupid
753  * @return int count of userrecords
754  */
755 function feedback_count_incomplete_users($cm, $group = false) {
756     if($allusers = feedback_get_incomplete_users($cm, $group)) {
757         return count($allusers);
758     }
759     return 0;
762 /**
763  * count users which have completed a feedback
764  *
765  * @global object
766  * @uses FEEDBACK_ANONYMOUS_NO
767  * @param object $cm
768  * @param int $group single groupid
769  * @return int count of userrecords
770  */
771 function feedback_count_complete_users($cm, $group = false) {
772     global $DB;
774     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
776     $fromgroup = '';
777     $wheregroup = '';
778     if($group) {
779         $fromgroup = ', {groups_members} g';
780         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
781         $params[] = $group;
782     }
784     $sql = 'SELECT COUNT(u.id) FROM {user} u, {feedback_completed} c'.$fromgroup.'
785               WHERE anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
786               '.$wheregroup;
787               ;
789     return $DB->count_records_sql($sql, $params);
793 /**
794  * get users which have completed a feedback
795  *
796  * @global object
797  * @uses CONTEXT_MODULE
798  * @uses FEEDBACK_ANONYMOUS_NO
799  * @param object $cm
800  * @param int $group single groupid
801  * @param string $where a sql where condition
802  * @param string $sort a table field
803  * @param int $startpage
804  * @param int $pagecount
805  * @return object the userrecords
806  */
807 function feedback_get_complete_users($cm, $group = false, $where, $sort = '', $startpage = false, $pagecount = false) {
808     global $DB;
810     if (!$context = get_context_instance(CONTEXT_MODULE, $cm->id)) {
811             print_error('badcontext');
812     }
814     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
816     $fromgroup = '';
817     $wheregroup = '';
818     if($group) {
819         $fromgroup = ', {groups_members} g';
820         $wheregroup = ' AND g.groupid = ? AND g.userid = c.userid';
821         $params[] = $group;
822     }
824     if($sort) {
825         $sortsql = ' ORDER BY '.$sort;
826     }else {
827         $sortsql = '';
828     }
830     $sql = 'SELECT DISTINCT u.* FROM {user} u, {feedback_completed} c'.$fromgroup.'
831               WHERE '.$where.' anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
832               '.$wheregroup.$sortsql;
833               ;
835     if($startpage === false OR $pagecount === false) {
836         $startpage = false;
837         $pagecount = false;
838     }
839     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
842 /**
843  * get users which have the viewreports-capability
844  *
845  * @uses CONTEXT_MODULE
846  * @param int $cmid
847  * @param mixed $groups single groupid or array of groupids - group(s) user is in
848  * @return object the userrecords
849  */
850 function feedback_get_viewreports_users($cmid, $groups = false) {
852     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
853             print_error('badcontext');
854     }
856     //description of the call below: get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='', $limitnum='', $groups='', $exceptions='', $doanything=true)
857     return get_users_by_capability($context, 'mod/feedback:viewreports', '', 'lastname', '', '', $groups, '', false);
860 /**
861  * get users which have the receivemail-capability
862  *
863  * @uses CONTEXT_MODULE
864  * @param int $cmid
865  * @param mixed $groups single groupid or array of groupids - group(s) user is in
866  * @return object the userrecords
867  */
868 function feedback_get_receivemail_users($cmid, $groups = false) {
870     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
871             print_error('badcontext');
872     }
874     //description of the call below: get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='', $limitnum='', $groups='', $exceptions='', $doanything=true)
875     return get_users_by_capability($context, 'mod/feedback:receivemail', '', 'lastname', '', '', $groups, '', false);
878 ////////////////////////////////////////////////
879 //functions to handle the templates
880 ////////////////////////////////////////////////
881 ////////////////////////////////////////////////
883 /**
884  * creates a new template-record.
885  *
886  * @global object
887  * @param int $courseid
888  * @param string $name the name of template shown in the templatelist
889  * @param int $ispublic 0:privat 1:public
890  * @return int the new templateid
891  */
892 function feedback_create_template($courseid, $name, $ispublic = 0) {
893     global $DB;
895     $templ = new object();
896     $templ->course   = $courseid;
897     $templ->name     = $name;
898     $templ->ispublic = $ispublic;
900     $templid = $DB->insert_record('feedback_template', $templ);
901     return $DB->get_record('feedback_template', array('id'=>$templid));
904 /**
905  * creates new template items.
906  * all items will be copied and the attribute feedback will be set to 0
907  * and the attribute template will be set to the new templateid
908  *
909  * @global object
910  * @uses CONTEXT_MODULE
911  * @uses CONTEXT_COURSE
912  * @param object $feedback
913  * @param string $name the name of template shown in the templatelist
914  * @param int $ispublic 0:privat 1:public
915  * @return boolean
916  */
917 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
918     global $DB;
919     $fs = get_file_storage();
921 die('TODO: MDL-21227 feedback code must not touch course summary files, code needs to be fixed, sorry');
922     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
923         return false;
924     }
926     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
927         return false;
928     }
930     //files in the template_item are in the context of the current course
931     //files in the feedback_item are in the feedback_context of the feedback
932     $c_context = get_context_instance(CONTEXT_COURSE, $newtempl->course);
933     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
934     $f_context = get_context_instance(CONTEXT_MODULE, $cm->id);
936     //create items of this new template
937     //depend items we are storing temporary in an mapping list array(new id => dependitem)
938     //we also store a mapping of all items array(oldid => newid)
939     $dependitemsmap = array();
940     $itembackup = array();
941     foreach($feedbackitems as $item) {
943         $t_item = clone($item);
945         unset($t_item->id);
946         $t_item->feedback = 0;
947         $t_item->template     = $newtempl->id;
948         $t_item->id = $DB->insert_record('feedback_item', $t_item);
949         //copy all included files to the feedback_template filearea
950         if ($itemfiles = $fs->get_area_files($f_context->id, 'feedback_item', $item->id, "id", false)) {
951             foreach($itemfiles as $ifile) {
952                 $file_record = new object();
953                 $file_record->contextid = $c_context->id;
954                 $file_record->filearea = 'course_summary';
955                 $file_record->itemid = $t_item->id;
956                 $fs->create_file_from_storedfile($file_record, $ifile);
957             }
958         }
960         $itembackup[$item->id] = $t_item->id;
961         if($t_item->dependitem) {
962             $dependitemsmap[$t_item->id] = $t_item->dependitem;
963         }
965     }
967     //remapping the dependency
968     foreach($dependitemsmap as $key => $dependitem) {
969         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
970         $newitem->dependitem = $itembackup[$newitem->dependitem];
971         $DB->update_record('feedback_item', $newitem);
972     }
974     return true;
977 /**
978  * deletes all feedback_items related to the given template id
979  *
980  * @global object
981  * @uses CONTEXT_COURSE
982  * @param int $id the templateid
983  * @return void
984  */
985 function feedback_delete_template($id) {
986     global $DB;
988 die('TODO: MDL-21227 feedback code must not touch course summary files, code needs to be fixed, sorry');
989     $template = $DB->get_record("feedback_template", array("id"=>$id));
991     //deleting the files from the item
992     $fs = get_file_storage();
993     $context = get_context_instance(CONTEXT_COURSE, $template->course);
996     if($t_items = $DB->get_records("feedback_item", array("template"=>$id))) {
997         foreach($t_items as $t_item) {
998             if ($templatefiles = $fs->get_area_files($context->id, 'course_summary', $t_item->id, "id", false)) {
999                 $fs->delete_area_files($context->id, 'course_summary', $t_item->id);
1000             }
1001         }
1002     }
1003     $DB->delete_records("feedback_template", array("id"=>$id));
1006 /**
1007  * creates new feedback_item-records from template.
1008  * if $deleteold is set true so the existing items of the given feedback will be deleted
1009  * if $deleteold is set false so the new items will be appanded to the old items
1010  *
1011  * @global object
1012  * @uses CONTEXT_COURSE
1013  * @uses CONTEXT_MODULE
1014  * @param object $feedback
1015  * @param int $templateid
1016  * @param boolean $deleteold
1017  */
1018 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1019     global $DB;
1020     $fs = get_file_storage();
1022 die('TODO: MDL-21227 feedback code must not touch course summary files, code needs to be fixed, sorry');
1024     //get all templateitems
1025     if(!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1026         return false;
1027     }
1029     //files in the template_item are in the context of the current course
1030     //files in the feedback_item are in the feedback_context of the feedback
1031     $c_context = get_context_instance(CONTEXT_COURSE, $feedback->course);
1032     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1033     $f_context = get_context_instance(CONTEXT_MODULE, $cm->id);
1035     //if deleteold then delete all old items before
1036     //get all items
1037     if($deleteold) {
1038         if($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1039             //delete all items of this feedback
1040             foreach($feedbackitems as $item) {
1041                 feedback_delete_item($item->id, false);
1042             }
1043             //delete tracking-data
1044             $DB->delete_records('feedback_tracking', array('feedback'=>$feedback->id));
1045             $DB->delete_records('feedback_completed', array('feedback'=>$feedback->id));
1046             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1047         }
1048         $positionoffset = 0;
1049     } else {
1050         //if the old items are kept the new items will be appended
1051         //therefor the new position has an offset
1052         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1053     }
1055     //create items of this new template
1056     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1057     //we also store a mapping of all items array(oldid => newid)
1058     $dependitemsmap = array();
1059     $itembackup = array();
1060     foreach($templitems as $t_item) {
1061         $item = clone($t_item);
1062         unset($item->id);
1063         $item->feedback = $feedback->id;
1064         $item->template = 0;
1065         $item->position = $item->position + $positionoffset;
1067         $item->id = $DB->insert_record('feedback_item', $item);
1069         //TODO: moving the files to the new items
1070         if ($templatefiles = $fs->get_area_files($c_context->id, 'course_summary', $t_item->id, "id", false)) {
1071             foreach($templatefiles as $tfile) {
1072                 $file_record = new object();
1073                 $file_record->contextid = $f_context->id;
1074                 $file_record->filearea = 'feedback_item';
1075                 $file_record->itemid = $item->id;
1076                 $fs->create_file_from_storedfile($file_record, $tfile);
1077             }
1078         }
1080         $itembackup[$t_item->id] = $item->id;
1081         if($item->dependitem) {
1082             $dependitemsmap[$item->id] = $item->dependitem;
1083         }
1084     }
1086     //remapping the dependency
1087     foreach($dependitemsmap as $key => $dependitem) {
1088         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1089         $newitem->dependitem = $itembackup[$newitem->dependitem];
1090         $DB->update_record('feedback_item', $newitem);
1091     }
1094 /**
1095  * get the list of available templates.
1096  * if the $onlyown param is set true so only templates from own course will be served
1097  * this is important for droping templates
1098  *
1099  * @global object
1100  * @param object $course
1101  * @param boolean $onlyown
1102  * @return array the template recordsets
1103  */
1104 function feedback_get_template_list($course, $onlyown = false) {
1105     global $DB;
1107     if ($onlyown) {
1108         $templates = $DB->get_records('feedback_template', array('course'=>$course->id));
1109     } else {
1110         $templates = $DB->get_records_select('feedback_template', 'course = ? OR ispublic = 1', array($course->id));
1111     }
1112     return $templates;
1115 ////////////////////////////////////////////////
1116 //Handling der Items
1117 ////////////////////////////////////////////////
1118 ////////////////////////////////////////////////
1120 /**
1121  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1122  *
1123  * @global object
1124  * @param object $item
1125  * @return object the instanz of itemclass
1126  */
1127 function feedback_get_item_class($typ) {
1128     global $CFG;
1130     //get the class of item-typ
1131     $itemclass = 'feedback_item_'.$typ;
1132     //get the instance of item-class
1133     if (!class_exists($itemclass)) {
1134         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1135     }
1136     return new $itemclass();
1139 /**
1140  * load the available item plugins from given subdirectory of $CFG->dirroot
1141  * the default is "mod/feedback/item"
1142  *
1143  * @global object
1144  * @param string $dir the subdir
1145  * @return array pluginnames as string
1146  */
1147 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1148     global $CFG;
1149     $names = get_list_of_plugins($dir);
1150     $ret_names = array();
1152     foreach($names as $name) {
1153         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1154         if(class_exists('feedback_item_'.$name)) {
1155           $ret_names[] = $name;
1156         }
1157     }
1158     return $ret_names;
1161 /**
1162  * load the available item plugins to use as dropdown-options
1163  *
1164  * @global object
1165  * @return array pluginnames as string
1166  */
1167 function feedback_load_feedback_items_options() {
1168     global $CFG;
1170     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1172     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1173         return array();
1174     }
1176     foreach($feedback_names as $fn) {
1177         $feedback_options[$fn] = get_string($fn,'feedback');
1178     }
1179     asort($feedback_options);
1180     $feedback_options = array_merge( array(' ' => get_string('select')), $feedback_options );
1181     return $feedback_options;
1184 /**
1185  * load the available items for the depend item dropdown list shown in the edit_item form
1186  *
1187  * @global object
1188  * @param object $feedback
1189  * @param object $item the item of the edit_item form
1190  * @return array all items except the item $item, labels and pagebreaks
1191  */
1192 function feedback_get_depend_candidates_for_item($feedback, $item) {
1193     global $DB;
1194     //all items for dependitem
1195     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1196     $params = array($feedback->id);
1197     if(isset($item->id) AND $item->id) {
1198         $where .= ' AND id != ?';
1199         $params[] = $item->id;
1200     }
1201     $dependitems = array(0 => get_string('choose'));
1202     if(!$feedbackitems = $DB->get_records_select_menu('feedback_item', $where, $params, 'position', 'id, label')) {
1203         return $dependitems;
1204     }
1205     //adding the choose-option
1206     foreach($feedbackitems as $key=>$val) {
1207         $dependitems[$key] = $val;
1208     }
1209     return $dependitems;
1212 /**
1213  * creates a new item-record
1214  *
1215  * @global object
1216  * @param object $data the data from edit_item_form
1217  * @return int the new itemid
1218  */
1219 function feedback_create_item($data) {
1220     global $DB;
1222     $item = new object;
1223     $item->feedback = $data->feedbackid;
1225     $item->template=0;
1226     if (isset($data->templateid)) {
1227             $item->template = intval($data->templateid);
1228     }
1230     $itemname = trim($data->itemname);
1231     $item->name = ($itemname ? $data->itemname : get_string('no_itemname', 'feedback'));
1233     if (!empty($data->itemlabel)) {
1234         $item->label = trim($data->itemlabel);
1235     } else {
1236         $item->label = get_string('no_itemlabel', 'feedback');
1237     }
1239     $itemobj = feedback_get_item_class($data->typ);
1240     // $item->presentation = $itemobj->get_presentation($data);
1241     $item->presentation = ''; //the date comes from postupdate() of the itemobj
1243     $item->hasvalue = $itemobj->get_hasvalue();
1245     $item->typ = $data->typ;
1246     $item->position = $data->position;
1248     $item->required=0;
1249     if (!empty($data->required)) {
1250         $item->required = $data->required;
1251     }
1253     $item->id = $DB->insert_record('feedback_item', $item);
1255     //move all itemdata to the data
1256     $data->id = $item->id;
1257     $data->feedback = $item->feedback;
1258     $data->name = $item->name;
1259     $data->label = $item->label;
1260     $data->required = $item->required;
1261     return $itemobj->postupdate($data);
1264 /**
1265  * save the changes of a given item.
1266  *
1267  * @global object
1268  * @param object $item
1269  * @return boolean
1270  */
1271 function feedback_update_item($item){
1272     global $DB;
1273     return $DB->update_record("feedback_item", $item);
1276 /**
1277  * deletes an item and also deletes all related values
1278  *
1279  * @global object
1280  * @uses CONTEXT_MODULE
1281  * @param int $itemid
1282  * @param boolean $renumber should the kept items renumbered Yes/No
1283  * @return void
1284  */
1285 function feedback_delete_item($itemid, $renumber = true){
1286     global $DB;
1289     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1291     //deleting the files from the item
1292     $fs = get_file_storage();
1293     if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1294         return false;
1295     }
1296     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
1298     if ($itemfiles = $fs->get_area_files($context->id, 'feedback_item', $item->id, "id", false)) {
1299         $fs->delete_area_files($context->id, 'feedback_item', $item->id);
1300     }
1302     $DB->delete_records("feedback_value", array("item"=>$itemid));
1303     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1305     //remove all depends
1306     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1307     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1309     $DB->delete_records("feedback_item", array("id"=>$itemid));
1310     if($renumber) {
1311         feedback_renumber_items($item->feedback);
1312     }
1315 /**
1316  * deletes all items of the given feedbackid
1317  *
1318  * @global object
1319  * @param int $feedbackid
1320  * @return void
1321  */
1322 function feedback_delete_all_items($feedbackid){
1323     global $DB;
1325     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1326         return;
1327     }
1328     foreach($items as $item) {
1329         feedback_delete_item($item->id, false);
1330     }
1331     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1332     $DB->delete_records('feedback_completed', array('feedback'=>$feedbackid));
1335 /**
1336  * this function toggled the item-attribute required (yes/no)
1337  *
1338  * @global object
1339  * @param object $item
1340  * @return boolean
1341  */
1342 function feedback_switch_item_required($item) {
1343     global $DB, $CFG;
1345     $itemobj = feedback_get_item_class($item->typ);
1347     if($itemobj->can_switch_require()) {
1348         $DB->set_field('feedback_item', 'required', (int)!(bool)$item->required, array('id'=>$item->id));
1349     }
1350     return true;
1353 /**
1354  * renumbers all items of the given feedbackid
1355  *
1356  * @global object
1357  * @param int $feedbackid
1358  * @return void
1359  */
1360 function feedback_renumber_items($feedbackid){
1361     global $DB;
1363     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1364     $pos = 1;
1365     if($items) {
1366         foreach($items as $item){
1367             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1368             $pos++;
1369         }
1370     }
1373 /**
1374  * this decreases the position of the given item
1375  *
1376  * @global object
1377  * @param object $item
1378  * @return bool
1379  */
1380 function feedback_moveup_item($item){
1381     global $DB;
1383     if($item->position == 1) {
1384         return true;
1385     }
1387     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$item->feedback), 'position')) {
1388         return false;
1389     }
1391     $itembefore = null;
1392     foreach($items as $i) {
1393         if($i->id == $item->id) {
1394             if(is_null($itembefore)) {
1395                 return true;
1396             }
1397             $itembefore->position = $item->position;
1398             $item->position--;
1399             feedback_update_item($itembefore);
1400             feedback_update_item($item);
1401             feedback_renumber_items($item->feedback);
1402             return true;
1403         }
1404         $itembefore = $i;
1405     }
1406     return false;
1409 /**
1410  * this increased the position of the given item
1411  *
1412  * @global object
1413  * @param object $item
1414  * @return bool
1415  */
1416 function feedback_movedown_item($item){
1417     global $DB;
1419     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$item->feedback), 'position')) {
1420         return false;
1421     }
1423     $movedownitem = null;
1424     foreach($items as $i) {
1425         if(!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1426             $movedownitem->position = $i->position;
1427             $i->position--;
1428             feedback_update_item($movedownitem);
1429             feedback_update_item($i);
1430             feedback_renumber_items($item->feedback);
1431             return true;
1432         }
1433         $movedownitem = $i;
1434     }
1435     return false;
1438 /**
1439  * here the position of the given item will be set to the value in $pos
1440  *
1441  * @global object
1442  * @param object $moveitem
1443  * @param int $pos
1444  * @return boolean
1445  */
1446 function feedback_move_item($moveitem, $pos){
1447     global $DB;
1449     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$moveitem->feedback), 'position')) {
1450         return false;
1451     }
1452     if (is_array($allitems)) {
1453         $index = 1;
1454         foreach($allitems as $item) {
1455             if($index == $pos) {
1456                 $index++;
1457             }
1458             if($item->id == $moveitem->id) {
1459                 $moveitem->position = $pos;
1460                 feedback_update_item($moveitem);
1461                 continue;
1462             }
1463             $item->position = $index;
1464             feedback_update_item($item);
1465             $index++;
1466         }
1467         return true;
1468     }
1469     return false;
1472 /**
1473  * prints the given item as a preview.
1474  * each item-class has an own print_item_preview function implemented.
1475  *
1476  * @global object
1477  * @param object $item the item what we want to print out
1478  * @return void
1479  */
1480 function feedback_print_item_preview($item){
1481     global $CFG;
1482     if($item->typ == 'pagebreak') {
1483         return;
1484     }
1485     //get the instance of the item-class
1486     $itemobj = feedback_get_item_class($item->typ);
1487     $itemobj->print_item_preview($item);
1490 /**
1491  * prints the given item in the completion form.
1492  * each item-class has an own print_item_complete function implemented.
1493  *
1494  * @param object $item the item what we want to print out
1495  * @param mixed $value the value
1496  * @param boolean $highlightrequire if this set true and the value are false on completing so the item will be highlighted
1497  * @return void
1498  */
1499 function feedback_print_item_complete($item, $value = false, $highlightrequire = false){
1500     global $CFG;
1501     if($item->typ == 'pagebreak') {
1502         return;
1503     }
1505     //get the instance of the item-class
1506     $itemobj = feedback_get_item_class($item->typ);
1507     $itemobj->print_item_complete($item, $value, $highlightrequire);
1510 /**
1511  * prints the given item in the show entries page.
1512  * each item-class has an own print_item_show_value function implemented.
1513  *
1514  * @param object $item the item what we want to print out
1515  * @param mixed $value
1516  * @return void
1517  */
1518 function feedback_print_item_show_value($item, $value = false){
1519     global $CFG;
1520     if($item->typ == 'pagebreak') {
1521         return;
1522     }
1524     //get the instance of the item-class
1525     $itemobj = feedback_get_item_class($item->typ);
1526     $itemobj->print_item_show_value($item, $value);
1529 /**
1530  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1531  * the values are not saved permanently until the user click on save button
1532  *
1533  * @global object
1534  * @param object $feedbackcompleted
1535  * @return object temporary saved completed-record
1536  */
1537 function feedback_set_tmp_values($feedbackcompleted) {
1538     global $DB;
1540     //first we create a completedtmp
1541     $tmpcpl = new object();
1542     foreach($feedbackcompleted as $key => $value) {
1543         $tmpcpl->{$key} = $value;
1544     }
1545     // $tmpcpl = $feedbackcompleted;
1546     unset($tmpcpl->id);
1547     $tmpcpl->timemodified = time();
1548     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1549     //get all values of original-completed
1550     if(!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1551         return;
1552     }
1553     foreach($values as $value) {
1554         unset($value->id);
1555         $value->completed = $tmpcpl->id;
1556         $DB->insert_record('feedback_valuetmp', $value);
1557     }
1558     return $tmpcpl;
1561 /**
1562  * this saves the temporary saved values permanently
1563  *
1564  * @global object
1565  * @param object $feedbackcompletedtmp the temporary completed
1566  * @param object $feedbackcompleted the target completed
1567  * @param int $userid
1568  * @return int the id of the completed
1569  */
1570 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted, $userid) {
1571     global $DB;
1573     $tmpcplid = $feedbackcompletedtmp->id;
1574     if($feedbackcompleted) {
1575         //first drop all existing values
1576         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1577         //update the current completed
1578         $feedbackcompleted->timemodified = time();
1579         $DB->update_record('feedback_completed', $feedbackcompleted);
1580     }else {
1581         $feedbackcompleted = clone($feedbackcompletedtmp);
1582         $feedbackcompleted->id = '';
1583         $feedbackcompleted->userid = $userid;
1584         $feedbackcompleted->timemodified = time();
1585         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
1586     }
1588     //save all the new values from feedback_valuetmp
1589     //get all values of tmp-completed
1590     if(!$values = $DB->get_records('feedback_valuetmp', array('completed'=>$feedbackcompletedtmp->id))) {
1591         return false;
1592     }
1593     foreach($values as $value) {
1594         //check if there are depend items
1595         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
1596         if($item->dependitem > 0) {
1597             $check = feedback_compare_item_value($tmpcplid, $item->dependitem, $item->dependvalue, true);
1598         }else {
1599             $check = true;
1600         }
1601         if($check) {
1602             unset($value->id);
1603             $value->completed = $feedbackcompleted->id;
1604             $DB->insert_record('feedback_value', $value);
1605         }
1606     }
1607     //drop all the tmpvalues
1608     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1609     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1610     return $feedbackcompleted->id;
1614 /**
1615  * deletes the given temporary completed and all related temporary values
1616  *
1617  * @global object
1618  * @param int $tmpcplid
1619  * @return void
1620  */
1621 function feedback_delete_completedtmp($tmpcplid) {
1622     global $DB;
1624     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1625     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1628 ////////////////////////////////////////////////
1629 ////////////////////////////////////////////////
1630 ////////////////////////////////////////////////
1631 //functions to handle the pagebreaks
1632 ////////////////////////////////////////////////
1634 /**
1635  * this creates a pagebreak.
1636  * a pagebreak is a special kind of item
1637  *
1638  * @global object
1639  * @param int $feedbackid
1640  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
1641  */
1642 function feedback_create_pagebreak($feedbackid) {
1643     global $DB;
1645     //check if there already is a pagebreak on the last position
1646     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
1647     if($lastposition == feedback_get_last_break_position($feedbackid)) {
1648         return false;
1649     }
1651     $item = new object();
1652     $item->feedback = $feedbackid;
1654     $item->template=0;
1656     $item->name = '';
1658     $item->presentation = '';
1659     $item->hasvalue = 0;
1661     $item->typ = 'pagebreak';
1662     $item->position = $lastposition + 1;
1664     $item->required=0;
1666     return $DB->insert_record('feedback_item', $item);
1669 /**
1670  * get all positions of pagebreaks in the given feedback
1671  *
1672  * @global object
1673  * @param int $feedbackid
1674  * @return array all ordered pagebreak positions
1675  */
1676 function feedback_get_all_break_positions($feedbackid) {
1677     global $DB;
1679     if(!$allbreaks = $DB->get_records_menu('feedback_item', array('typ'=>'pagebreak', 'feedback'=>$feedbackid), 'position', 'id, position')) return false;
1680     return array_values($allbreaks);
1683 /**
1684  * get the position of the last pagebreak
1685  *
1686  * @param int $feedbackid
1687  * @return int the position of the last pagebreak
1688  */
1689 function feedback_get_last_break_position($feedbackid) {
1690     if(!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
1691         return false;
1692     }
1693     return $allbreaks[count($allbreaks) - 1];
1696 /**
1697  * this returns the position where the user can continue the completing.
1698  *
1699  * @global object
1700  * @global object
1701  * @global object
1702  * @param int $feedbackid
1703  * @param int $courseid
1704  * @param string $guestid this id will be saved temporary and is unique
1705  * @return int the position to continue
1706  */
1707 function feedback_get_page_to_continue($feedbackid, $courseid = false, $guestid = false) {
1708     global $CFG, $USER, $DB;
1710     //is there any break?
1712     if(!$allbreaks = feedback_get_all_break_positions($feedbackid)) return false;
1714     $params = array();
1715     if($courseid) {
1716         $courseselect = "fv.course_id = :courseid";
1717         $params['courseid'] = $courseid;
1718     }else {
1719         $courseselect = "1";
1720     }
1722     if($guestid) {
1723         $userselect = "AND fc.guestid = :guestid";
1724         $usergroup = "GROUP BY fc.guestid";
1725         $params['guestid'] = $guestid;
1726     }else {
1727         $userselect = "AND fc.userid = :userid";
1728         $usergroup = "GROUP BY fc.userid";
1729         $params['userid'] = $USER->id;
1730     }
1732     $sql =  "SELECT MAX(fi.position)
1733                FROM {feedback_completedtmp} fc, {feedback_valuetmp} fv, {feedback_item} fi
1734               WHERE fc.id = fv.completed
1735                     $userselect
1736                     AND fc.feedback = :feedbackid
1737                     AND $courseselect
1738                     AND fi.id = fv.item
1739          $usergroup";
1740     $params['feedbackid'] = $feedbackid;
1742     $lastpos = $DB->get_field_sql($sql, $params);
1744     //the index of found pagebreak is the searched pagenumber
1745     foreach($allbreaks as $pagenr => $br) {
1746         if($lastpos < $br) return $pagenr;
1747     }
1748     return count($allbreaks);
1751 ////////////////////////////////////////////////
1752 ////////////////////////////////////////////////
1753 ////////////////////////////////////////////////
1754 //functions to handle the values
1755 ////////////////////////////////////////////////
1757 /**
1758  * this saves the values of an completed.
1759  * if the param $tmp is set true so the values are saved temporary in table feedback_valuetmp.
1760  * if there is already a completed and the userid is set so the values are updated.
1761  * on all other things new value records will be created.
1762  *
1763  * @global object
1764  * @param int $userid
1765  * @param boolean $tmp
1766  * @return mixed false on error or the completeid
1767  */
1768 function feedback_save_values($usrid, $tmp = false) {
1769     global $DB;
1771     $completedid = optional_param('completedid', false, PARAM_INT);
1773     $tmpstr = $tmp ? 'tmp' : '';
1774     $time = time();
1775     $timemodified = mktime(0, 0, 0, date('m', $time),date('d', $time),date('Y', $time));
1777     if($usrid == 0) {
1778         return feedback_create_values($usrid, $timemodified, $tmp);
1779     }
1780     if(!$completedid or !$completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid))) {
1781         return feedback_create_values($usrid, $timemodified, $tmp);
1782     }else{
1783         $completed->timemodified = $timemodified;
1784         return feedback_update_values($completed, $tmp);
1785     }
1788 /**
1789  * this saves the values from anonymous user such as guest on the main-site
1790  *
1791  * @global object
1792  * @param string $guestid the unique guestidentifier
1793  * @return mixed false on error or the completeid
1794  */
1795 function feedback_save_guest_values($guestid) {
1796     global $DB;
1798     $completedid = optional_param('completedid', false, PARAM_INT);
1800     $timemodified = time();
1801     if(!$completed = $DB->get_record('feedback_completedtmp', array('id'=>$completedid))) {
1802         return feedback_create_values(0, $timemodified, true, $guestid);
1803     }else {
1804         $completed->timemodified = $timemodified;
1805         return feedback_update_values($completed, true);
1806     }
1809 /**
1810  * get the value from the given item related to the given completed.
1811  * the value can come as temporary or as permanently value. the deciding is done by $tmp
1812  *
1813  * @global object
1814  * @param int $completeid
1815  * @param int $itemid
1816  * @param boolean $tmp
1817  * @return mixed the value, the type depends on plugin-definition
1818  */
1819 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
1820     global $DB;
1822     $tmpstr = $tmp ? 'tmp' : '';
1823     return $DB->get_field('feedback_value'.$tmpstr, 'value', array('completed'=>$completedid, 'item'=>$itemid));
1826 /**
1827  * compares the value of the itemid related to the completedid with the dependvalue.
1828  * this is used if a depend item is set.
1829  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
1830  *
1831  * @global object
1832  * @global object
1833  * @param int $completeid
1834  * @param int $itemid
1835  * @param mixed $dependvalue
1836  * @param boolean $tmp
1837  * @return bool
1838  */
1839 function feedback_compare_item_value($completedid, $itemid, $dependvalue, $tmp = false) {
1840     global $DB, $CFG;
1842     $dbvalue = feedback_get_item_value($completedid, $itemid, $tmp);
1844     //get the class of the given item-typ
1845     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1847     //get the instance of the item-class
1848     $itemobj = feedback_get_item_class($item->typ);
1849     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
1852 /**
1853  * this function checks the correctness of values.
1854  * the rules for this are implemented in the class of each item.
1855  * it can be the required attribute or the value self e.g. numeric.
1856  * the params first/lastitem are given to determine the visible range between pagebreaks.
1857  *
1858  * @global object
1859  * @param int $firstitem the position of firstitem for checking
1860  * @param int $lastitem the position of lastitem for checking
1861  * @return boolean
1862  */
1863 function feedback_check_values($firstitem, $lastitem) {
1864     global $DB, $CFG;
1866     $feedbackid = optional_param('feedbackid', 0, PARAM_INT);
1868     //get all items between the first- and lastitem
1869     $select = "feedback = ?
1870                     AND position >= ?
1871                     AND position <= ?
1872                     AND hasvalue = 1";
1873     $params = array($feedbackid, $firstitem, $lastitem);
1874     if(!$feedbackitems = $DB->get_records_select('feedback_item', $select, $params)) {
1875         //if no values are given so no values can be wrong ;-)
1876         return true;
1877     }
1879     foreach($feedbackitems as $item) {
1880         //the name of the input field of the completeform is given in a special form:
1881         //<item-typ>_<item-id> eg. numeric_234
1882         //this is the key to get the value for the correct item
1883         $formvalname = $item->typ . '_' . $item->id;
1885         $value = optional_param($formvalname, NULL, PARAM_RAW);
1887         //check if the value is set
1888         if(is_null($value) AND $item->required == 1) {
1889             return false;
1890         }
1892         //get the instance of the item-class
1893         $itemobj = feedback_get_item_class($item->typ);
1895         //now we let check the value by the item-class
1896         if(!$itemobj->check_value($value, $item)) {
1897             return false;
1898         }
1899     }
1900     //if no wrong values so we can return true
1901     return true;
1904 /**
1905  * this function create a complete-record and the related value-records.
1906  * depending on the $tmp (true/false) the values are saved temporary or permanently
1907  *
1908  * @global object
1909  * @param int $userid
1910  * @param int $timemodified
1911  * @param boolean $tmp
1912  * @param string $guestid a unique identifier to save temporary data
1913  * @return mixed false on error or the completedid
1914  */
1915 function feedback_create_values($usrid, $timemodified, $tmp = false, $guestid = false){
1916     global $DB;
1918     $feedbackid = optional_param('feedbackid', false, PARAM_INT);
1919     $anonymous_response = optional_param('anonymous_response', false, PARAM_INT);
1920     $courseid = optional_param('courseid', false, PARAM_INT);
1922     $tmpstr = $tmp ? 'tmp' : '';
1923     //first we create a new completed record
1924     $completed = new object();
1925     $completed->feedback           = $feedbackid;
1926     $completed->userid             = $usrid;
1927     $completed->guestid            = $guestid;
1928     $completed->timemodified       = $timemodified;
1929     $completed->anonymous_response = $anonymous_response;
1931     $completedid = $DB->insert_record('feedback_completed'.$tmpstr, $completed);
1933     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
1935     //the keys are in the form like abc_xxx
1936     //with explode we make an array with(abc, xxx) and (abc=typ und xxx=itemnr)
1938     //get the items of the feedback
1939     if(!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
1940         return false;
1941     }
1942     foreach($allitems as $item) {
1943         $keyname = $item->typ.'_'.$item->id;
1944         $itemvalue = optional_param($keyname, NULL, PARAM_RAW);
1945         if(is_null($itemvalue)) {
1946             continue;
1947         }
1948         $value = new object();
1949         $value->item = $item->id;
1950         $value->completed = $completed->id;
1951         $value->course_id = $courseid;
1953         //get the class of item-typ
1954         $itemobj = feedback_get_item_class($item->typ);
1956         //the kind of values can be absolutely different so we run create_value directly by the item-class
1957         $value->value = $itemobj->create_value($itemvalue);
1958         $DB->insert_record('feedback_value'.$tmpstr, $value);
1959     }
1960     return $completed->id;
1963 /**
1964  * this function updates a complete-record and the related value-records.
1965  * depending on the $tmp (true/false) the values are saved temporary or permanently
1966  *
1967  * @global object
1968  * @param object $completed
1969  * @param boolean $tmp
1970  * @return int the completedid
1971  */
1972 function feedback_update_values($completed, $tmp = false) {
1973     global $DB;
1974     $courseid = optional_param('courseid', false, PARAM_INT);
1976     $tmpstr = $tmp ? 'tmp' : '';
1978     $DB->update_record('feedback_completed'.$tmpstr, $completed);
1979     //get the values of this completed
1980     $values = $DB->get_records('feedback_value'.$tmpstr, array('completed'=>$completed->id));
1982     //get the items of the feedback
1983     if(!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
1984         return false;
1985     }
1986     foreach($allitems as $item) {
1987         $keyname = $item->typ.'_'.$item->id;
1988         $itemvalue = optional_param($keyname, NULL, PARAM_RAW);
1989         //is the itemvalue set (could be a subset of items because pagebreak)?
1990         if(is_null($itemvalue)) {
1991             continue;
1992         }
1994         $newvalue = new object();
1995         $newvalue->item = $item->id;
1996         $newvalue->completed = $completed->id;
1997         $newvalue->course_id = $courseid;
1999         //get the class of item-typ
2000         $itemobj = feedback_get_item_class($item->typ);
2001         //the kind of values can be absolutely different so we run create_value directly by the item-class
2002         $newvalue->value = $itemobj->create_value($itemvalue);
2004         //check, if we have to create or update the value
2005         $exist = false;
2006         foreach($values as $value){
2007             if($value->item == $newvalue->item){
2008                 $newvalue->id = $value->id;
2009                 $exist = true;
2010                 break;
2011             }
2012         }
2013         if($exist){
2014             $DB->update_record('feedback_value'.$tmpstr, $newvalue);
2015         }else {
2016             $DB->insert_record('feedback_value'.$tmpstr, $newvalue);
2017         }
2018     }
2020     return $completed->id;
2023 /**
2024  * get the values of an item depending on the given groupid.
2025  * if the feedback is anonymous so the values are shuffled
2026  *
2027  * @global object
2028  * @global object
2029  * @param object $item
2030  * @param int $groupid
2031  * @param int $courseid
2032  * @param bool $ignore_empty if this is set true so empty values are not delivered
2033  * @return array the value-records
2034  */
2035 function feedback_get_group_values($item, $groupid = false, $courseid = false, $ignore_empty = false){
2036     global $CFG, $DB;
2038     //if the groupid is given?
2039     if (intval($groupid) > 0) {
2040         if($ignore_empty) {
2041             $ignore_empty_select = "AND fbc.value != ''";
2042         }
2043         else {
2044             $ignore_empty_select = "";
2045         }
2047         $query = 'SELECT fbv .  *
2048                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2049                    WHERE fbv.item = ?
2050                          AND fbv.completed = fbc.id
2051                          AND fbc.userid = gm.userid
2052                          '.$ignore_empty_select.'
2053                          AND gm.groupid = ?
2054                 ORDER BY fbc.timemodified';
2055         $values = $DB->get_records_sql($query, array($item->id, $groupid));
2057     } else {
2058         if($ignore_empty) {
2059             $ignore_empty_select = "AND value != ''";
2060         }
2061         else {
2062             $ignore_empty_select = "";
2063         }
2065         if ($courseid) {
2066             $values = $DB->get_records_select('feedback_value', "item = ? AND course_id = ? ".$ignore_empty_select, array($item->id, $courseid));
2067         } else {
2068             $values = $DB->get_records_select('feedback_value', "item = ? ".$ignore_empty_select, array($item->id));
2069         }
2070     }
2071     if ($DB->get_field('feedback', 'anonymous', array('id'=>$item->feedback)) == FEEDBACK_ANONYMOUS_YES) {
2072         if(is_array($values))
2073             shuffle($values);
2074     }
2075     return $values;
2078 /**
2079  * check for multiple_submit = false.
2080  * if the feedback is global so the courseid must be given
2081  *
2082  * @global object
2083  * @global object
2084  * @param int $feedbackid
2085  * @param int $courseid
2086  * @return boolean true if the feedback already is submitted otherwise false
2087  */
2088 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2089     global $USER, $DB;
2091     if (!$trackings = $DB->get_records_menu('feedback_tracking', array('userid'=>$USER->id, 'feedback'=>$feedbackid), '', 'id, completed')) {
2092         return false;
2093     }
2095     if($courseid) {
2096         $select = 'completed IN ('.implode(',',$trackings).') AND course_id = ?';
2097         if(!$values = $DB->get_records_select('feedback_value', $select, array($courseid))) {
2098             return false;
2099         }
2100     }
2102     return true;
2105 /**
2106  * if the completion of a feedback will be continued eg. by pagebreak or by multiple submit so the complete must be found.
2107  * if the param $tmp is set true so all things are related to temporary completeds
2108  *
2109  * @global object
2110  * @global object
2111  * @global object
2112  * @param int $feedbackid
2113  * @param boolean $tmp
2114  * @param int $courseid
2115  * @param string $guestid
2116  * @return int the id of the found completed
2117  */
2118 function feedback_get_current_completed($feedbackid, $tmp = false, $courseid = false, $guestid = false) {
2119     global $USER, $CFG, $DB;
2121     $tmpstr = $tmp ? 'tmp' : '';
2123     if(!$courseid) {
2124         if($guestid) {
2125             return $DB->get_record('feedback_completed'.$tmpstr, array('feedback'=>$feedbackid, 'guestid'=>$guestid));
2126         }else {
2127             return $DB->get_record('feedback_completed'.$tmpstr, array('feedback'=>$feedbackid, 'userid'=>$USER->id));
2128         }
2129     }
2131     $params = array();
2133     if ($guestid) {
2134         $userselect = "AND fc.guestid = :guestid";
2135         $params['guestid'] = $guestid;
2136     }else {
2137         $userselect = "AND fc.userid = :userid";
2138         $params['userid'] = $USER->id;
2139     }
2140     //if courseid is set the feedback is global. there can be more than one completed on one feedback
2141     $sql =  "SELECT DISTINCT fc.*
2142                FROM {feedback_value{$tmpstr}} fv, {feedback_completed{$tmpstr}} fc
2143               WHERE fv.course_id = :courseid
2144                     AND fv.completed = fc.id
2145                     $userselect
2146                     AND fc.feedback = :feedbackid";
2147     $params['courseid']   = intval($courseid);
2148     $params['feedbackid'] = $feedbackid;
2150     if (!$sqlresult = $DB->get_records_sql($sql, $params)) {
2151         return false;
2152     }
2153     foreach($sqlresult as $r) {
2154         return $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$r->id));
2155     }
2158 /**
2159  * get the completeds depending on the given groupid.
2160  *
2161  * @global object
2162  * @global object
2163  * @param object $feedback
2164  * @param int $groupid
2165  * @param int $courseid
2166  * @return mixed array of found completeds otherwise false
2167  */
2168 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2169     global $CFG, $DB;
2171     if (intval($groupid) > 0){
2172         $query = "SELECT fbc.*
2173                     FROM {feedback_completed} fbc, {groups_members} gm
2174                    WHERE fbc.feedback = ?
2175                          AND gm.groupid = ?
2176                          AND fbc.userid = gm.userid";
2177         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2178             return $values;
2179         } else {
2180             return false;
2181         }
2182     } else {
2183         if($courseid) {
2184             $query = "SELECT DISTINCT fbc.*
2185                         FROM {feedback_completed} fbc, {feedback_value} fbv
2186                         WHERE fbc.id = fbv.completed
2187                             AND fbc.feedback = ?
2188                             AND fbv.course_id = ?
2189                         ORDER BY random_response";
2190             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2191                 return $values;
2192             } else {
2193                 return false;
2194             }
2195         }else {
2196             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2197                 return $values;
2198             } else {
2199                 return false;
2200             }
2201         }
2202     }
2205 /**
2206  * get the count of completeds depending on the given groupid.
2207  *
2208  * @global object
2209  * @global object
2210  * @param object $feedback
2211  * @param int $groupid
2212  * @param int $courseid
2213  * @return mixed count of completeds or false
2214  */
2215 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2216     global $CFG, $DB;
2218     if ($courseid > 0 AND !$groupid <= 0) {
2219         $sql = "SELECT id, COUNT(item) AS ci
2220                   FROM {feedback_value}
2221                  WHERE course_id  = ?
2222               GROUP BY item ORDER BY ci DESC";
2223         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2224             $foundrecs = array_values($foundrecs);
2225             return $foundrecs[0]->ci;
2226         }
2227         return false;
2228     }
2229     if($values = feedback_get_completeds_group($feedback, $groupid)) {
2230         return sizeof($values);
2231     }else {
2232         return false;
2233     }
2236 /**
2237  * deletes all completed-recordsets from a feedback.
2238  * all related data such as values also will be deleted
2239  *
2240  * @global object
2241  * @param int $feedbackid
2242  * @return void
2243  */
2244 function feedback_delete_all_completeds($feedbackid) {
2245     global $DB;
2247     if (!$completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedbackid))) {
2248         return;
2249     }
2250     foreach($completeds as $completed) {
2251         feedback_delete_completed($completed->id);
2252     }
2255 /**
2256  * deletes a completed given by completedid.
2257  * all related data such values or tracking data also will be deleted
2258  *
2259  * @global object
2260  * @param int $completedid
2261  * @return boolean
2262  */
2263 function feedback_delete_completed($completedid) {
2264     global $DB;
2266     if (!$completed = $DB->get_record('feedback_completed', array('id'=>$completedid))) {
2267         return false;
2268     }
2269     //first we delete all related values
2270     $DB->delete_records('feedback_value', array('completed'=>$completed->id));
2272     //now we delete all tracking data
2273     if($tracking = $DB->get_record('feedback_tracking', array('completed'=>$completed->id, 'feedback'=>$completed->feedback))) {
2274         $DB->delete_records('feedback_tracking', array('completed'=>$completed->id));
2275     }
2277     //last we delete the completed-record
2278     return $DB->delete_records('feedback_completed', array('id'=>$completed->id));
2281 ////////////////////////////////////////////////
2282 ////////////////////////////////////////////////
2283 ////////////////////////////////////////////////
2284 //functions to handle sitecourse mapping
2285 ////////////////////////////////////////////////
2287 /**
2288  * checks if the course and the feedback is in the table feedback_sitecourse_map.
2289  *
2290  * @global object
2291  * @param int $feedbackid
2292  * @param int $courseid
2293  * @return int the count of records
2294  */
2295 function feedback_is_course_in_sitecourse_map($feedbackid, $courseid) {
2296     global $DB;
2297     return $DB->count_records('feedback_sitecourse_map', array('feedbackid'=>$feedbackid, 'courseid'=>$courseid));
2300 /**
2301  * checks if the feedback is in the table feedback_sitecourse_map.
2302  *
2303  * @global object
2304  * @param int $feedbackid
2305  * @return boolean
2306  */
2307 function feedback_is_feedback_in_sitecourse_map($feedbackid) {
2308     global $Db;
2309     return $DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$feedbackid));
2312 /**
2313  * gets the feedbacks from table feedback_sitecourse_map.
2314  * this is used to show the global feedbacks on the feedback block
2315  * all feedbacks with the following criteria will be selected:<br />
2316  *
2317  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2318  * 2) all feedbacks which not are listed in sitecoursemap
2319  *
2320  * @global object
2321  * @param int $courseid
2322  * @return array the feedback-records
2323  */
2324 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2325     global $DB;
2327     //first get all feedbacks listed in sitecourse_map with named courseid
2328     $sql = "SELECT f.id AS id, cm.id AS cmid, f.name AS name, f.timeopen AS timeopen, f.timeclose AS timeclose
2329               FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2330              WHERE f.id = cm.instance
2331                    AND f.course = '".SITEID."'
2332                    AND m.id = cm.module
2333                    AND m.name = 'feedback'
2334                    AND sm.courseid = ?
2335                    AND sm.feedbackid = f.id";
2337     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2338         $feedbacks1 = array();
2339     }
2341     //second get all feedbacks not listed in sitecourse_map
2342     $feedbacks2 = array();
2343     $sql = "SELECT f.id AS id, cm.id AS cmid, f.name AS name, f.timeopen AS timeopen, f.timeclose AS timeclose
2344               FROM {feedback} f, {course_modules} cm, {modules} m
2345              WHERE f.id = cm.instance
2346                    AND f.course = '".SITEID."'
2347                    AND m.id = cm.module
2348                    AND m.name = 'feedback'";
2349     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2350         $allfeedbacks = array();
2351     }
2352     foreach($allfeedbacks as $a) {
2353         if(!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2354             $feedbacks2[] = $a;
2355         }
2356     }
2358     return array_merge($feedbacks1, $feedbacks2);
2362 /**
2363  * gets the courses from table feedback_sitecourse_map.
2364  *
2365  * @global object
2366  * @param int $feedbackid
2367  * @return array the course-records
2368  */
2369 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2370     global $DB;
2372     $sql = "SELECT f.id, f.courseid, c.fullname, c.shortname
2373               FROM {feedback_sitecourse_map} f, {course} c
2374              WHERE c.id = f.courseid
2375                    AND f.feedbackid = ?
2376           ORDER BY c.fullname";
2378     return $DB->get_records_sql($sql, array($feedbackid));
2382 /**
2383  * removes non existing courses or feedbacks from sitecourse_map.
2384  * it shouldn't be called all too often
2385  * a good place for it could be the mapcourse.php or unmapcourse.php
2386  *
2387  * @global object
2388  * @return void
2389  */
2390 function feedback_clean_up_sitecourse_map() {
2391     global $DB;
2393     $maps = $DB->get_records('feedback_sitecourse_map');
2394     foreach($maps as $map) {
2395         if (!$DB->get_record('course', array('id'=>$map->courseid))) {
2396             $DB->delete_records('feedback_sitecourse_map', array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid));
2397             continue;
2398         }
2399         if (!$DB->get_record('feedback', array('id'=>$map->feedbackid))) {
2400             $DB->delete_records('feedback_sitecourse_map', array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid));
2401             continue;
2402         }
2404     }
2407 ////////////////////////////////////////////////
2408 ////////////////////////////////////////////////
2409 ////////////////////////////////////////////////
2410 //not relatable functions
2411 ////////////////////////////////////////////////
2413 /**
2414  * prints the option items of a selection-input item (dropdownlist).
2415  * @param int $startval the first value of the list
2416  * @param int $endval the last value of the list
2417  * @param int $selectval which item should be selected
2418  * @param int $interval the stepsize from the first to the last value
2419  * @return void
2420  */
2421 function feedback_print_numeric_option_list($startval, $endval, $selectval = '', $interval = 1){
2422     for($i = $startval; $i <= $endval; $i += $interval){
2423         if($selectval == ($i)){
2424             $selected = 'selected="selected"';
2425         }else{
2426             $selected = '';
2427         }
2428         echo '<option '.$selected.'>'.$i.'</option>';
2429     }
2432 /**
2433  * sends an email to the teachers of the course where the given feedback is placed.
2434  *
2435  * @global object
2436  * @global object
2437  * @uses FEEDBACK_ANONYMOUS_NO
2438  * @uses FORMAT_PLAIN
2439  * @param object $cm the coursemodule-record
2440  * @param object $feedback
2441  * @param object $course
2442  * @param int $userid
2443  * @return void
2444  */
2445 function feedback_send_email($cm, $feedback, $course, $userid) {
2446     global $CFG, $DB;
2448     if ($feedback->email_notification == 0) {  // No need to do anything
2449         return;
2450     }
2452     $user = $DB->get_record('user', array('id'=>$userid));
2454     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
2455         $groupmode =  $cm->groupmode;
2456     } else {
2457         $groupmode = $course->groupmode;
2458     }
2460     if ($groupmode == SEPARATEGROUPS) {
2461         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
2462                                                FROM {groups} g, {groups_members} m
2463                                               WHERE g.courseid = ?
2464                                                     AND g.id = m.groupid
2465                                                     AND m.userid = ?
2466                                            ORDER BY name ASC", array($course->id, $userid));
2467         $groups = array_values($groups);
2469         $teachers = feedback_get_receivemail_users($cm->id, $groups);
2470     } else {
2471         $teachers = feedback_get_receivemail_users($cm->id);
2472     }
2474     if ($teachers) {
2476         $strfeedbacks = get_string('modulenameplural', 'feedback');
2477         $strfeedback  = get_string('modulename', 'feedback');
2478         $strcompleted  = get_string('completed', 'feedback');
2479         $printusername = $feedback->anonymous == FEEDBACK_ANONYMOUS_NO ? fullname($user) : get_string('anonymous_user', 'feedback');
2481         foreach ($teachers as $teacher) {
2482             $info = new object();
2483             $info->username = $printusername;
2484             $info->feedback = format_string($feedback->name,true);
2485             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?id='.$cm->id.'&userid='.$userid.'&do_show=showentries';
2487             $postsubject = $strcompleted.': '.$info->username.' -> '.$feedback->name;
2488             $posttext = feedback_send_email_text($info, $course);
2489             $posthtml = ($teacher->mailformat == 1) ? feedback_send_email_html($info, $course, $cm) : '';
2491             if($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2492                 $eventdata = new object();
2493                 $eventdata->name             = 'feedback';
2494                 $eventdata->component        = 'mod';
2495                 $eventdata->userfrom         = $user;
2496                 $eventdata->userto           = $teacher;
2497                 $eventdata->subject          = $postsubject;
2498                 $eventdata->fullmessage      = $posttext;
2499                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2500                 $eventdata->fullmessagehtml  = $posthtml;
2501                 $eventdata->smallmessage     = '';
2502                 message_send($eventdata);
2503             }else {
2504                 $eventdata = new object();
2505                 $eventdata->name             = 'feedback';
2506                 $eventdata->component        = 'mod';
2507                 $eventdata->userfrom         = $teacher;
2508                 $eventdata->userto           = $teacher;
2509                 $eventdata->subject          = $postsubject;
2510                 $eventdata->fullmessage      = $posttext;
2511                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2512                 $eventdata->fullmessagehtml  = $posthtml;
2513                 $eventdata->smallmessage     = '';
2514                 message_send($eventdata);
2515             }
2516         }
2517     }
2520 /**
2521  * sends an email to the teachers of the course where the given feedback is placed.
2522  *
2523  * @global object
2524  * @uses FORMAT_PLAIN
2525  * @param object $cm the coursemodule-record
2526  * @param object $feedback
2527  * @param object $course
2528  * @return void
2529  */
2530 function feedback_send_email_anonym($cm, $feedback, $course) {
2531     global $CFG;
2533     if ($feedback->email_notification == 0) {             // No need to do anything
2534         return;
2535     }
2537     $teachers = feedback_get_receivemail_users($cm->id);
2539     if ($teachers) {
2541         $strfeedbacks = get_string('modulenameplural', 'feedback');
2542         $strfeedback  = get_string('modulename', 'feedback');
2543         $strcompleted  = get_string('completed', 'feedback');
2544         $printusername = get_string('anonymous_user', 'feedback');
2546         foreach ($teachers as $teacher) {
2547             $info = new object();
2548             $info->username = $printusername;
2549             $info->feedback = format_string($feedback->name,true);
2550             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries_anonym.php?id='.$cm->id;
2552             $postsubject = $strcompleted.': '.$info->username.' -> '.$feedback->name;
2553             $posttext = feedback_send_email_text($info, $course);
2554             $posthtml = ($teacher->mailformat == 1) ? feedback_send_email_html($info, $course, $cm) : '';
2556             $eventdata = new object();
2557             $eventdata->name             = 'feedback';
2558             $eventdata->component        = 'mod';
2559             $eventdata->userfrom         = $teacher;
2560             $eventdata->userto           = $teacher;
2561             $eventdata->subject          = $postsubject;
2562             $eventdata->fullmessage      = $posttext;
2563             $eventdata->fullmessageformat = FORMAT_PLAIN;
2564             $eventdata->fullmessagehtml  = $posthtml;
2565             $eventdata->smallmessage     = '';
2566             message_send($eventdata);
2567         }
2568     }
2571 /**
2572  * send the text-part of the email
2573  *
2574  * @param object $info includes some infos about the feedback you want to send
2575  * @param object $course
2576  * @return string the text you want to post
2577  */
2578 function feedback_send_email_text($info, $course) {
2579     $posttext  = $course->shortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
2580                     $info->feedback."\n";
2581     $posttext .= '---------------------------------------------------------------------'."\n";
2582     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
2583     $posttext .= '---------------------------------------------------------------------'."\n";
2584     return $posttext;
2588 /**
2589  * send the html-part of the email
2590  *
2591  * @global object
2592  * @param object $info includes some infos about the feedback you want to send
2593  * @param object $course
2594  * @return string the text you want to post
2595  */
2596 function feedback_send_email_html($info, $course, $cm) {
2597     global $CFG;
2598     $posthtml  = '<p><font face="sans-serif">'.
2599                 '<a href="'.$CFG->wwwroot.'/course/view.php?id='.$course->id.'">'.$course->shortname.'</a> ->'.
2600                 '<a href="'.$CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
2601                 '<a href="'.$CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id.'">'.$info->feedback.'</a></font></p>';
2602     $posthtml .= '<hr /><font face="sans-serif">';
2603     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
2604     $posthtml .= '</font><hr />';
2605     return $posthtml;
2608 /**
2609  * print some errors to inform users about this.
2610  *
2611  * @global object
2612  * @return void
2613  */
2614 function feedback_print_errors() {
2616     global $SESSION, $OUTPUT;
2618     feedback_init_feedback_session();
2620     if(empty($SESSION->feedback->errors)) {
2621         return;
2622     }
2624     echo $OUTPUT->box_start('generalbox errorboxcontent boxaligncenter boxwidthnormal');
2625     echo $OUTPUT->heading(get_string('handling_error', 'feedback'));
2627     echo '<p align="center"><b><font color="black"><pre>';
2628     print_r($SESSION->feedback->errors) . "\n";
2629     echo '</pre></font></b></p>';
2631     echo $OUTPUT->box_end();
2632     echo '<br /><br />';
2633     $SESSION->feedback->errors = array(); //remove errors
2636 /**
2637  * @param string $url
2638  * @return string
2639  */
2640 function feedback_encode_target_url($url) {
2641     if (strpos($url, '?')) {
2642         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
2643         return $part1 . '?' . htmlentities($part2);
2644     } else {
2645         return $url;
2646     }
2649 /**
2650  * Adds module specific settings to the settings block
2651  *
2652  * @param settings_navigation $settings The settings navigation object
2653  * @param navigation_node $feedbacknode The node to add module settings to
2654  */
2655 function feedback_extend_settings_navigation(settings_navigation $settings, navigation_node $feedbacknode) {
2656     global $PAGE, $DB;
2658     if (!$context = get_context_instance(CONTEXT_MODULE, $PAGE->cm->id)) {
2659         print_error('badcontext');
2660     }
2662     if (has_capability('mod/feedback:edititems', $context)) {
2663         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
2664         $questionnode->add(get_string('edit_items', 'feedback'), new moodle_url('/mod/feedback/edit.php', array('id'=>$PAGE->cm->id, 'do_show'=>'edit')));
2665         $questionnode->add(get_string('export_questions', 'feedback'), new moodle_url('/mod/feedback/export.php', array('id'=>$PAGE->cm->id, 'action'=>'exportfile')));
2666         $questionnode->add(get_string('import_questions', 'feedback'), new moodle_url('/mod/feedback/import.php', array('id'=>$PAGE->cm->id)));
2667         $questionnode->add(get_string('templates', 'feedback'), new moodle_url('/mod/feedback/edit.php', array('id'=>$PAGE->cm->id, 'do_show'=>'templates')));
2668     }
2670     if (has_capability('mod/feedback:viewreports', $context)) {
2671         $feedback = $DB->get_record('feedback', array('id'=>$PAGE->cm->instance));
2672         if($feedback->course == SITEID){
2673             $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')));
2674         }else {
2675             $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')));
2676         }
2678         $feedbacknode->add(get_string('show_entries', 'feedback'), new moodle_url('/mod/feedback/show_entries.php', array('id'=>$PAGE->cm->id, 'do_show'=>'showentries')));
2679     }
2682 function feedback_init_feedback_session() {
2683     //initialize the feedback-Session - not nice at all!!
2684     global $SESSION;
2685     if (!empty($SESSION)) {
2686         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
2687             $SESSION->feedback = new object();
2688         }
2689     }