mod/feedback/lib.php

   1 <?php
   2
   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/>.
  17
  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  */
  26
  27 /** Include eventslib.php */
  28 require_once($CFG->libdir.'/eventslib.php');
  29 /** Include calendar/lib.php */
  30 require_once($CFG->dirroot.'/calendar/lib.php');
  31
  32
  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);
  42
  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;
  64
  65         default: return null;
  66     }
  67 }
  68
  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;
  79
  80     $feedback->timemodified = time();
  81     $feedback->id = '';
  82
  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     }
  93
  94     //saving the feedback in db
  95     $feedbackid = $DB->insert_record("feedback", $feedback);
  96
  97     $feedback->id = $feedbackid;
  98
  99     feedback_set_events($feedback);
 100
 101     return $feedbackid;
 102 }
 103
 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;
 113
 114     $feedback->timemodified = time();
 115     $feedback->id = $feedback->instance;
 116
 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     }
 127
 128     //save the feedback into the db
 129     $DB->update_record("feedback", $feedback);
 130
 131     //create or update the new events
 132     feedback_set_events($feedback);
 133
 134     return true;
 135 }
 136
 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;
 150
 151     if (!$cminfo->uservisible) {
 152         return false;
 153     }
 154
 155     if($filearea === 'feedback_template') {
 156         $usedcontext = get_context_instance(CONTEXT_COURSE, $course->id);
 157     }else {
 158         $usedcontext = $context;
 159     }
 160
 161     if ($filearea === 'feedback_item' OR $filearea === 'feedback_template') {
 162         $itemid = (int)array_shift($args);
 163
 164         if (!$cm = get_coursemodule_from_instance('feedback', $cminfo->instance, $course->id)) {
 165             return false;
 166         }
 167
 168         require_course_login($course, true, $cm);
 169
 170         if (!$item = $DB->get_record('feedback_item', array('id'=>$itemid))) {
 171             return false;
 172         }
 173
 174         if (!$feedback = $DB->get_record('feedback', array('id'=>$cminfo->instance))) {
 175             return false;
 176         }
 177
 178         if (!has_capability('mod/feedback:view', $context)) {
 179             return false;
 180         }
 181
 182         if ($item->feedback == $cminfo->instance) {
 183             $filecontext = $usedcontext;
 184         } else {
 185             return false;
 186         }
 187
 188         $relativepath = '/'.implode('/', $args);
 189         $fullpath = $filecontext->id.$filearea.$itemid.$relativepath;
 190
 191         $fs = get_file_storage();
 192         if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
 193             return false;
 194         }
 195
 196         // finally send the file
 197         send_stored_file($file, 0, 0, true); // download MUST be forced - security!
 198     }
 199
 200     return false;
 201 }
 202
 203
 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;
 214
 215     //get all referenced items
 216     $feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$id));
 217
 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     }
 230
 231     //deleting the referenced tracking data
 232     $DB->delete_records('feedback_tracking', array('feedback'=>$id));
 233
 234     //deleting the completeds
 235     $DB->delete_records("feedback_completed", array("feedback"=>$id));
 236
 237     //deleting the unfinished completeds
 238     $DB->delete_records("feedback_completedtmp", array("feedback"=>$id));
 239
 240     //deleting old events
 241     $DB->delete_records('event', array('modulename'=>'feedback', 'instance'=>$id));
 242     return $DB->delete_records("feedback", array("id"=>$id));
 243 }
 244
 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;
 255
 256     //delete all templates of given course
 257     return $DB->delete_records('feedback_template', array('course'=>$course->id));
 258 }
 259
 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;
 275 }
 276
 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;
 297
 298     if ($COURSE->id == $courseid) {
 299         $course = $COURSE;
 300     } else {
 301         $course = $DB->get_record('course', array('id'=>$courseid));
 302     }
 303
 304     $modinfo =& get_fast_modinfo($course);
 305
 306     $cm = $modinfo->cms[$cmid];
 307
 308     $sqlargs = array();
 309
 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 ";
 314
 315     if ($groupid) {
 316         $sql .= " JOIN {groups_members} gm ON  gm.userid=u.id ";
 317     }
 318
 319     $sql .= " WHERE fc.timemodified > ? AND fk.id = ? ";
 320     $sqlargs[] = $timemodified;
 321     $sqlargs[] = $cm->instace;
 322
 323     if ($userid) {
 324         $sql .= " AND u.id = ? ";
 325         $sqlargs[] = $userid;
 326     }
 327
 328     if ($groupid) {
 329         $sql .= " AND gm.groupid = ? ";
 330         $sqlargs[] = $groupid;
 331     }
 332
 333     if (!$feedbackitems = $DB->get_records_sql($sql, $sqlargs)) {
 334         return;
 335     }
 336
 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);
 341
 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     }
 345
 346     $aname = format_string($cm->name,true);
 347     foreach ($feedbackitems as $feedbackitem) {
 348         if ($feedbackitem->userid != $USER->id) {
 349
 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        }
 362
 363         $tmpactivity = new object();
 364
 365         $tmpactivity->type      = 'feedback';
 366         $tmpactivity->cmid      = $cm->id;
 367         $tmpactivity->name      = $aname;
 368         $tmpactivity->sectionnum= $cm->sectionnum;
 369         $tmpactivity->timestamp = $feedbackitem->timemodified;
 370
 371         $tmpactivity->content->feedbackid = $feedbackitem->id;
 372         $tmpactivity->content->feedbackuserid = $feedbackitem->userid;
 373
 374         $tmpactivity->user->userid   = $feedbackitem->userid;
 375         $tmpactivity->user->fullname = fullname($feedbackitem, $viewfullnames);
 376         $tmpactivity->user->picture  = $feedbackitem->picture;
 377
 378         $activities[$index++] = $tmpactivity;
 379     }
 380
 381   return;
 382 }
 383
 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;
 397
 398     echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
 399
 400     echo "<tr><td class=\"userpicture\" valign=\"top\">";
 401     echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
 402     echo "</td><td>";
 403
 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     }
 412
 413     echo '<div class="title">';
 414     echo '</div>';
 415
 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>';
 420
 421     echo "</td></tr></table>";
 422
 423     return;
 424 }
 425
 426
 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;
 439 }
 440
 441 /**
 442  * @return bool true
 443  */
 444 function feedback_cron () {
 445     return true;
 446 }
 447
 448 /**
 449  * @return bool false
 450  */
 451 function feedback_get_participants($feedbackid) {
 452     return false;
 453 }
 454
 455
 456 /**
 457  * @return bool false
 458  */
 459 function feedback_scale_used ($feedbackid,$scaleid) {
 460     return false;
 461 }
 462
 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;
 477
 478     $resetfeedbacks = array();
 479     $dropfeedbacks = array();
 480     $status = array();
 481     $componentstr = get_string('modulenameplural', 'feedback');
 482
 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     }
 500
 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     }
 507
 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;
 516 }
 517
 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;
 527
 528     $mform->addElement('header', 'feedbackheader', get_string('modulenameplural', 'feedback'));
 529
 530     if(!$feedbacks = $DB->get_records('feedback', array('course'=>$COURSE->id), 'name')){
 531         return;
 532     }
 533
 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     }
 539 }
 540
 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;
 550
 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;
 560 }
 561
 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;
 575
 576     echo get_string('resetting_feedbacks', 'feedback'); echo ':<br />';
 577     if (!$feedbacks = $DB->get_records('feedback', array('course'=>$course->id), 'name')) {
 578         return;
 579     }
 580
 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     }
 589 }
 590
 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;
 600
 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));
 603
 604     if (!isset($feedback->coursemodule)) {
 605         $cm = get_coursemodule_from_id('feedback', $feedback->id);
 606         $feedback->coursemodule = $cm->id;
 607     }
 608
 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         }
 627
 628         calendar_event::create($event);
 629     }
 630
 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;
 645
 646         calendar_event::create($event);
 647     }
 648 }
 649
 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;
 660
 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));
 665 }
 666
 667
 668
 669 ////////////////////////////////////////////////
 670 //functions to handle capabilities
 671 ////////////////////////////////////////////////
 672
 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;
 682
 683     if(isset($context)) return $context;
 684
 685     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
 686             print_error('badcontext');
 687     }
 688     return $context;
 689 }
 690
 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;
 703 }
 704
 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;
 719
 720     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 721
 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);
 729
 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);
 735
 736     //now strike all completedusers from allusers
 737     $allusers = array_diff($allusers, $completedusers);
 738
 739     //for paging I use array_slice()
 740     if($startpage !== false AND $pagecount !== false) {
 741         $allusers = array_slice($allusers, $startpage, $pagecount);
 742     }
 743
 744     return $allusers;
 745 }
 746
 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;
 760 }
 761
 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;
 773
 774     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
 775
 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     }
 783
 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               ;
 788
 789     return $DB->count_records_sql($sql, $params);
 790
 791 }
 792
 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;
 809
 810     if (!$context = get_context_instance(CONTEXT_MODULE, $cm->id)) {
 811             print_error('badcontext');
 812     }
 813
 814     $params = array(FEEDBACK_ANONYMOUS_NO, $cm->instance);
 815
 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     }
 823
 824     if($sort) {
 825         $sortsql = ' ORDER BY '.$sort;
 826     }else {
 827         $sortsql = '';
 828     }
 829
 830     $ufields = user_picture::fields('u');
 831     $sql = 'SELECT DISTINCT '.$ufields.' FROM {user} u, {feedback_completed} c'.$fromgroup.'
 832               WHERE '.$where.' anonymous_response = ? AND u.id = c.userid AND c.feedback = ?
 833               '.$wheregroup.$sortsql;
 834               ;
 835
 836     if($startpage === false OR $pagecount === false) {
 837         $startpage = false;
 838         $pagecount = false;
 839     }
 840     return $DB->get_records_sql($sql, $params, $startpage, $pagecount);
 841 }
 842
 843 /**
 844  * get users which have the viewreports-capability
 845  *
 846  * @uses CONTEXT_MODULE
 847  * @param int $cmid
 848  * @param mixed $groups single groupid or array of groupids - group(s) user is in
 849  * @return object the userrecords
 850  */
 851 function feedback_get_viewreports_users($cmid, $groups = false) {
 852
 853     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
 854             print_error('badcontext');
 855     }
 856
 857     //description of the call below: get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='', $limitnum='', $groups='', $exceptions='', $doanything=true)
 858     return get_users_by_capability($context, 'mod/feedback:viewreports', '', 'lastname', '', '', $groups, '', false);
 859 }
 860
 861 /**
 862  * get users which have the receivemail-capability
 863  *
 864  * @uses CONTEXT_MODULE
 865  * @param int $cmid
 866  * @param mixed $groups single groupid or array of groupids - group(s) user is in
 867  * @return object the userrecords
 868  */
 869 function feedback_get_receivemail_users($cmid, $groups = false) {
 870
 871     if (!$context = get_context_instance(CONTEXT_MODULE, $cmid)) {
 872             print_error('badcontext');
 873     }
 874
 875     //description of the call below: get_users_by_capability($context, $capability, $fields='', $sort='', $limitfrom='', $limitnum='', $groups='', $exceptions='', $doanything=true)
 876     return get_users_by_capability($context, 'mod/feedback:receivemail', '', 'lastname', '', '', $groups, '', false);
 877 }
 878
 879 ////////////////////////////////////////////////
 880 //functions to handle the templates
 881 ////////////////////////////////////////////////
 882 ////////////////////////////////////////////////
 883
 884 /**
 885  * creates a new template-record.
 886  *
 887  * @global object
 888  * @param int $courseid
 889  * @param string $name the name of template shown in the templatelist
 890  * @param int $ispublic 0:privat 1:public
 891  * @return int the new templateid
 892  */
 893 function feedback_create_template($courseid, $name, $ispublic = 0) {
 894     global $DB;
 895
 896     $templ = new object();
 897     $templ->course   = $courseid;
 898     $templ->name     = $name;
 899     $templ->ispublic = $ispublic;
 900
 901     $templid = $DB->insert_record('feedback_template', $templ);
 902     return $DB->get_record('feedback_template', array('id'=>$templid));
 903 }
 904
 905 /**
 906  * creates new template items.
 907  * all items will be copied and the attribute feedback will be set to 0
 908  * and the attribute template will be set to the new templateid
 909  *
 910  * @global object
 911  * @uses CONTEXT_MODULE
 912  * @uses CONTEXT_COURSE
 913  * @param object $feedback
 914  * @param string $name the name of template shown in the templatelist
 915  * @param int $ispublic 0:privat 1:public
 916  * @return boolean
 917  */
 918 function feedback_save_as_template($feedback, $name, $ispublic = 0) {
 919     global $DB;
 920     $fs = get_file_storage();
 921
 922 die('TODO: MDL-21227 feedback code must not touch course summary files, code needs to be fixed, sorry');
 923     if (!$feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
 924         return false;
 925     }
 926
 927     if (!$newtempl = feedback_create_template($feedback->course, $name, $ispublic)) {
 928         return false;
 929     }
 930
 931     //files in the template_item are in the context of the current course
 932     //files in the feedback_item are in the feedback_context of the feedback
 933     $c_context = get_context_instance(CONTEXT_COURSE, $newtempl->course);
 934     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
 935     $f_context = get_context_instance(CONTEXT_MODULE, $cm->id);
 936
 937     //create items of this new template
 938     //depend items we are storing temporary in an mapping list array(new id => dependitem)
 939     //we also store a mapping of all items array(oldid => newid)
 940     $dependitemsmap = array();
 941     $itembackup = array();
 942     foreach($feedbackitems as $item) {
 943
 944         $t_item = clone($item);
 945
 946         unset($t_item->id);
 947         $t_item->feedback = 0;
 948         $t_item->template     = $newtempl->id;
 949         $t_item->id = $DB->insert_record('feedback_item', $t_item);
 950         //copy all included files to the feedback_template filearea
 951         if ($itemfiles = $fs->get_area_files($f_context->id, 'feedback_item', $item->id, "id", false)) {
 952             foreach($itemfiles as $ifile) {
 953                 $file_record = new object();
 954                 $file_record->contextid = $c_context->id;
 955                 $file_record->filearea = 'course_summary';
 956                 $file_record->itemid = $t_item->id;
 957                 $fs->create_file_from_storedfile($file_record, $ifile);
 958             }
 959         }
 960
 961         $itembackup[$item->id] = $t_item->id;
 962         if($t_item->dependitem) {
 963             $dependitemsmap[$t_item->id] = $t_item->dependitem;
 964         }
 965
 966     }
 967
 968     //remapping the dependency
 969     foreach($dependitemsmap as $key => $dependitem) {
 970         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
 971         $newitem->dependitem = $itembackup[$newitem->dependitem];
 972         $DB->update_record('feedback_item', $newitem);
 973     }
 974
 975     return true;
 976 }
 977
 978 /**
 979  * deletes all feedback_items related to the given template id
 980  *
 981  * @global object
 982  * @uses CONTEXT_COURSE
 983  * @param int $id the templateid
 984  * @return void
 985  */
 986 function feedback_delete_template($id) {
 987     global $DB;
 988
 989 die('TODO: MDL-21227 feedback code must not touch course summary files, code needs to be fixed, sorry');
 990     $template = $DB->get_record("feedback_template", array("id"=>$id));
 991
 992     //deleting the files from the item
 993     $fs = get_file_storage();
 994     $context = get_context_instance(CONTEXT_COURSE, $template->course);
 995
 996
 997     if($t_items = $DB->get_records("feedback_item", array("template"=>$id))) {
 998         foreach($t_items as $t_item) {
 999             if ($templatefiles = $fs->get_area_files($context->id, 'course_summary', $t_item->id, "id", false)) {
1000                 $fs->delete_area_files($context->id, 'course_summary', $t_item->id);
1001             }
1002         }
1003     }
1004     $DB->delete_records("feedback_template", array("id"=>$id));
1005 }
1006
1007 /**
1008  * creates new feedback_item-records from template.
1009  * if $deleteold is set true so the existing items of the given feedback will be deleted
1010  * if $deleteold is set false so the new items will be appanded to the old items
1011  *
1012  * @global object
1013  * @uses CONTEXT_COURSE
1014  * @uses CONTEXT_MODULE
1015  * @param object $feedback
1016  * @param int $templateid
1017  * @param boolean $deleteold
1018  */
1019 function feedback_items_from_template($feedback, $templateid, $deleteold = false) {
1020     global $DB;
1021     $fs = get_file_storage();
1022
1023 die('TODO: MDL-21227 feedback code must not touch course summary files, code needs to be fixed, sorry');
1024
1025     //get all templateitems
1026     if(!$templitems = $DB->get_records('feedback_item', array('template'=>$templateid))) {
1027         return false;
1028     }
1029
1030     //files in the template_item are in the context of the current course
1031     //files in the feedback_item are in the feedback_context of the feedback
1032     $c_context = get_context_instance(CONTEXT_COURSE, $feedback->course);
1033     $cm = get_coursemodule_from_instance('feedback', $feedback->id);
1034     $f_context = get_context_instance(CONTEXT_MODULE, $cm->id);
1035
1036     //if deleteold then delete all old items before
1037     //get all items
1038     if($deleteold) {
1039         if($feedbackitems = $DB->get_records('feedback_item', array('feedback'=>$feedback->id))) {
1040             //delete all items of this feedback
1041             foreach($feedbackitems as $item) {
1042                 feedback_delete_item($item->id, false);
1043             }
1044             //delete tracking-data
1045             $DB->delete_records('feedback_tracking', array('feedback'=>$feedback->id));
1046             $DB->delete_records('feedback_completed', array('feedback'=>$feedback->id));
1047             $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedback->id));
1048         }
1049         $positionoffset = 0;
1050     } else {
1051         //if the old items are kept the new items will be appended
1052         //therefor the new position has an offset
1053         $positionoffset = $DB->count_records('feedback_item', array('feedback'=>$feedback->id));
1054     }
1055
1056     //create items of this new template
1057     //depend items we are storing temporary in an mapping list array(new id => dependitem)
1058     //we also store a mapping of all items array(oldid => newid)
1059     $dependitemsmap = array();
1060     $itembackup = array();
1061     foreach($templitems as $t_item) {
1062         $item = clone($t_item);
1063         unset($item->id);
1064         $item->feedback = $feedback->id;
1065         $item->template = 0;
1066         $item->position = $item->position + $positionoffset;
1067
1068         $item->id = $DB->insert_record('feedback_item', $item);
1069
1070         //TODO: moving the files to the new items
1071         if ($templatefiles = $fs->get_area_files($c_context->id, 'course_summary', $t_item->id, "id", false)) {
1072             foreach($templatefiles as $tfile) {
1073                 $file_record = new object();
1074                 $file_record->contextid = $f_context->id;
1075                 $file_record->filearea = 'feedback_item';
1076                 $file_record->itemid = $item->id;
1077                 $fs->create_file_from_storedfile($file_record, $tfile);
1078             }
1079         }
1080
1081         $itembackup[$t_item->id] = $item->id;
1082         if($item->dependitem) {
1083             $dependitemsmap[$item->id] = $item->dependitem;
1084         }
1085     }
1086
1087     //remapping the dependency
1088     foreach($dependitemsmap as $key => $dependitem) {
1089         $newitem = $DB->get_record('feedback_item', array('id'=>$key));
1090         $newitem->dependitem = $itembackup[$newitem->dependitem];
1091         $DB->update_record('feedback_item', $newitem);
1092     }
1093 }
1094
1095 /**
1096  * get the list of available templates.
1097  * if the $onlyown param is set true so only templates from own course will be served
1098  * this is important for droping templates
1099  *
1100  * @global object
1101  * @param object $course
1102  * @param boolean $onlyown
1103  * @return array the template recordsets
1104  */
1105 function feedback_get_template_list($course, $onlyown = false) {
1106     global $DB;
1107
1108     if ($onlyown) {
1109         $templates = $DB->get_records('feedback_template', array('course'=>$course->id));
1110     } else {
1111         $templates = $DB->get_records_select('feedback_template', 'course = ? OR ispublic = 1', array($course->id));
1112     }
1113     return $templates;
1114 }
1115
1116 ////////////////////////////////////////////////
1117 //Handling der Items
1118 ////////////////////////////////////////////////
1119 ////////////////////////////////////////////////
1120
1121 /**
1122  * load the lib.php from item-plugin-dir and returns the instance of the itemclass
1123  *
1124  * @global object
1125  * @param object $item
1126  * @return object the instanz of itemclass
1127  */
1128 function feedback_get_item_class($typ) {
1129     global $CFG;
1130
1131     //get the class of item-typ
1132     $itemclass = 'feedback_item_'.$typ;
1133     //get the instance of item-class
1134     if (!class_exists($itemclass)) {
1135         require_once($CFG->dirroot.'/mod/feedback/item/'.$typ.'/lib.php');
1136     }
1137     return new $itemclass();
1138 }
1139
1140 /**
1141  * load the available item plugins from given subdirectory of $CFG->dirroot
1142  * the default is "mod/feedback/item"
1143  *
1144  * @global object
1145  * @param string $dir the subdir
1146  * @return array pluginnames as string
1147  */
1148 function feedback_load_feedback_items($dir = 'mod/feedback/item') {
1149     global $CFG;
1150     $names = get_list_of_plugins($dir);
1151     $ret_names = array();
1152
1153     foreach($names as $name) {
1154         require_once($CFG->dirroot.'/'.$dir.'/'.$name.'/lib.php');
1155         if(class_exists('feedback_item_'.$name)) {
1156           $ret_names[] = $name;
1157         }
1158     }
1159     return $ret_names;
1160 }
1161
1162 /**
1163  * load the available item plugins to use as dropdown-options
1164  *
1165  * @global object
1166  * @return array pluginnames as string
1167  */
1168 function feedback_load_feedback_items_options() {
1169     global $CFG;
1170
1171     $feedback_options = array("pagebreak" => get_string('add_pagebreak', 'feedback'));
1172
1173     if (!$feedback_names = feedback_load_feedback_items('mod/feedback/item')) {
1174         return array();
1175     }
1176
1177     foreach($feedback_names as $fn) {
1178         $feedback_options[$fn] = get_string($fn,'feedback');
1179     }
1180     asort($feedback_options);
1181     $feedback_options = array_merge( array(' ' => get_string('select')), $feedback_options );
1182     return $feedback_options;
1183 }
1184
1185 /**
1186  * load the available items for the depend item dropdown list shown in the edit_item form
1187  *
1188  * @global object
1189  * @param object $feedback
1190  * @param object $item the item of the edit_item form
1191  * @return array all items except the item $item, labels and pagebreaks
1192  */
1193 function feedback_get_depend_candidates_for_item($feedback, $item) {
1194     global $DB;
1195     //all items for dependitem
1196     $where = "feedback = ? AND typ != 'pagebreak' AND hasvalue = 1";
1197     $params = array($feedback->id);
1198     if(isset($item->id) AND $item->id) {
1199         $where .= ' AND id != ?';
1200         $params[] = $item->id;
1201     }
1202     $dependitems = array(0 => get_string('choose'));
1203     if(!$feedbackitems = $DB->get_records_select_menu('feedback_item', $where, $params, 'position', 'id, label')) {
1204         return $dependitems;
1205     }
1206     //adding the choose-option
1207     foreach($feedbackitems as $key=>$val) {
1208         $dependitems[$key] = $val;
1209     }
1210     return $dependitems;
1211 }
1212
1213 /**
1214  * creates a new item-record
1215  *
1216  * @global object
1217  * @param object $data the data from edit_item_form
1218  * @return int the new itemid
1219  */
1220 function feedback_create_item($data) {
1221     global $DB;
1222
1223     $item = new object;
1224     $item->feedback = $data->feedbackid;
1225
1226     $item->template=0;
1227     if (isset($data->templateid)) {
1228             $item->template = intval($data->templateid);
1229     }
1230
1231     $itemname = trim($data->itemname);
1232     $item->name = ($itemname ? $data->itemname : get_string('no_itemname', 'feedback'));
1233
1234     if (!empty($data->itemlabel)) {
1235         $item->label = trim($data->itemlabel);
1236     } else {
1237         $item->label = get_string('no_itemlabel', 'feedback');
1238     }
1239
1240     $itemobj = feedback_get_item_class($data->typ);
1241     // $item->presentation = $itemobj->get_presentation($data);
1242     $item->presentation = ''; //the date comes from postupdate() of the itemobj
1243
1244     $item->hasvalue = $itemobj->get_hasvalue();
1245
1246     $item->typ = $data->typ;
1247     $item->position = $data->position;
1248
1249     $item->required=0;
1250     if (!empty($data->required)) {
1251         $item->required = $data->required;
1252     }
1253
1254     $item->id = $DB->insert_record('feedback_item', $item);
1255
1256     //move all itemdata to the data
1257     $data->id = $item->id;
1258     $data->feedback = $item->feedback;
1259     $data->name = $item->name;
1260     $data->label = $item->label;
1261     $data->required = $item->required;
1262     return $itemobj->postupdate($data);
1263 }
1264
1265 /**
1266  * save the changes of a given item.
1267  *
1268  * @global object
1269  * @param object $item
1270  * @return boolean
1271  */
1272 function feedback_update_item($item){
1273     global $DB;
1274     return $DB->update_record("feedback_item", $item);
1275 }
1276
1277 /**
1278  * deletes an item and also deletes all related values
1279  *
1280  * @global object
1281  * @uses CONTEXT_MODULE
1282  * @param int $itemid
1283  * @param boolean $renumber should the kept items renumbered Yes/No
1284  * @return void
1285  */
1286 function feedback_delete_item($itemid, $renumber = true){
1287     global $DB;
1288
1289
1290     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1291
1292     //deleting the files from the item
1293     $fs = get_file_storage();
1294     if (!$cm = get_coursemodule_from_instance('feedback', $item->feedback)) {
1295         return false;
1296     }
1297     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
1298
1299     if ($itemfiles = $fs->get_area_files($context->id, 'feedback_item', $item->id, "id", false)) {
1300         $fs->delete_area_files($context->id, 'feedback_item', $item->id);
1301     }
1302
1303     $DB->delete_records("feedback_value", array("item"=>$itemid));
1304     $DB->delete_records("feedback_valuetmp", array("item"=>$itemid));
1305
1306     //remove all depends
1307     $DB->set_field('feedback_item', 'dependvalue', '', array('dependitem'=>$itemid));
1308     $DB->set_field('feedback_item', 'dependitem', 0, array('dependitem'=>$itemid));
1309
1310     $DB->delete_records("feedback_item", array("id"=>$itemid));
1311     if($renumber) {
1312         feedback_renumber_items($item->feedback);
1313     }
1314 }
1315
1316 /**
1317  * deletes all items of the given feedbackid
1318  *
1319  * @global object
1320  * @param int $feedbackid
1321  * @return void
1322  */
1323 function feedback_delete_all_items($feedbackid){
1324     global $DB;
1325
1326     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid))) {
1327         return;
1328     }
1329     foreach($items as $item) {
1330         feedback_delete_item($item->id, false);
1331     }
1332     $DB->delete_records('feedback_completedtmp', array('feedback'=>$feedbackid));
1333     $DB->delete_records('feedback_completed', array('feedback'=>$feedbackid));
1334 }
1335
1336 /**
1337  * this function toggled the item-attribute required (yes/no)
1338  *
1339  * @global object
1340  * @param object $item
1341  * @return boolean
1342  */
1343 function feedback_switch_item_required($item) {
1344     global $DB, $CFG;
1345
1346     $itemobj = feedback_get_item_class($item->typ);
1347
1348     if($itemobj->can_switch_require()) {
1349         $DB->set_field('feedback_item', 'required', (int)!(bool)$item->required, array('id'=>$item->id));
1350     }
1351     return true;
1352 }
1353
1354 /**
1355  * renumbers all items of the given feedbackid
1356  *
1357  * @global object
1358  * @param int $feedbackid
1359  * @return void
1360  */
1361 function feedback_renumber_items($feedbackid){
1362     global $DB;
1363
1364     $items = $DB->get_records('feedback_item', array('feedback'=>$feedbackid), 'position');
1365     $pos = 1;
1366     if($items) {
1367         foreach($items as $item){
1368             $DB->set_field('feedback_item', 'position', $pos, array('id'=>$item->id));
1369             $pos++;
1370         }
1371     }
1372 }
1373
1374 /**
1375  * this decreases the position of the given item
1376  *
1377  * @global object
1378  * @param object $item
1379  * @return bool
1380  */
1381 function feedback_moveup_item($item){
1382     global $DB;
1383
1384     if($item->position == 1) {
1385         return true;
1386     }
1387
1388     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$item->feedback), 'position')) {
1389         return false;
1390     }
1391
1392     $itembefore = null;
1393     foreach($items as $i) {
1394         if($i->id == $item->id) {
1395             if(is_null($itembefore)) {
1396                 return true;
1397             }
1398             $itembefore->position = $item->position;
1399             $item->position--;
1400             feedback_update_item($itembefore);
1401             feedback_update_item($item);
1402             feedback_renumber_items($item->feedback);
1403             return true;
1404         }
1405         $itembefore = $i;
1406     }
1407     return false;
1408 }
1409
1410 /**
1411  * this increased the position of the given item
1412  *
1413  * @global object
1414  * @param object $item
1415  * @return bool
1416  */
1417 function feedback_movedown_item($item){
1418     global $DB;
1419
1420     if(!$items = $DB->get_records('feedback_item', array('feedback'=>$item->feedback), 'position')) {
1421         return false;
1422     }
1423
1424     $movedownitem = null;
1425     foreach($items as $i) {
1426         if(!is_null($movedownitem) AND $movedownitem->id == $item->id) {
1427             $movedownitem->position = $i->position;
1428             $i->position--;
1429             feedback_update_item($movedownitem);
1430             feedback_update_item($i);
1431             feedback_renumber_items($item->feedback);
1432             return true;
1433         }
1434         $movedownitem = $i;
1435     }
1436     return false;
1437 }
1438
1439 /**
1440  * here the position of the given item will be set to the value in $pos
1441  *
1442  * @global object
1443  * @param object $moveitem
1444  * @param int $pos
1445  * @return boolean
1446  */
1447 function feedback_move_item($moveitem, $pos){
1448     global $DB;
1449
1450     if (!$allitems = $DB->get_records('feedback_item', array('feedback'=>$moveitem->feedback), 'position')) {
1451         return false;
1452     }
1453     if (is_array($allitems)) {
1454         $index = 1;
1455         foreach($allitems as $item) {
1456             if($index == $pos) {
1457                 $index++;
1458             }
1459             if($item->id == $moveitem->id) {
1460                 $moveitem->position = $pos;
1461                 feedback_update_item($moveitem);
1462                 continue;
1463             }
1464             $item->position = $index;
1465             feedback_update_item($item);
1466             $index++;
1467         }
1468         return true;
1469     }
1470     return false;
1471 }
1472
1473 /**
1474  * prints the given item as a preview.
1475  * each item-class has an own print_item_preview function implemented.
1476  *
1477  * @global object
1478  * @param object $item the item what we want to print out
1479  * @return void
1480  */
1481 function feedback_print_item_preview($item){
1482     global $CFG;
1483     if($item->typ == 'pagebreak') {
1484         return;
1485     }
1486     //get the instance of the item-class
1487     $itemobj = feedback_get_item_class($item->typ);
1488     $itemobj->print_item_preview($item);
1489 }
1490
1491 /**
1492  * prints the given item in the completion form.
1493  * each item-class has an own print_item_complete function implemented.
1494  *
1495  * @param object $item the item what we want to print out
1496  * @param mixed $value the value
1497  * @param boolean $highlightrequire if this set true and the value are false on completing so the item will be highlighted
1498  * @return void
1499  */
1500 function feedback_print_item_complete($item, $value = false, $highlightrequire = false){
1501     global $CFG;
1502     if($item->typ == 'pagebreak') {
1503         return;
1504     }
1505
1506     //get the instance of the item-class
1507     $itemobj = feedback_get_item_class($item->typ);
1508     $itemobj->print_item_complete($item, $value, $highlightrequire);
1509 }
1510
1511 /**
1512  * prints the given item in the show entries page.
1513  * each item-class has an own print_item_show_value function implemented.
1514  *
1515  * @param object $item the item what we want to print out
1516  * @param mixed $value
1517  * @return void
1518  */
1519 function feedback_print_item_show_value($item, $value = false){
1520     global $CFG;
1521     if($item->typ == 'pagebreak') {
1522         return;
1523     }
1524
1525     //get the instance of the item-class
1526     $itemobj = feedback_get_item_class($item->typ);
1527     $itemobj->print_item_show_value($item, $value);
1528 }
1529
1530 /**
1531  * if the user completes a feedback and there is a pagebreak so the values are saved temporary.
1532  * the values are not saved permanently until the user click on save button
1533  *
1534  * @global object
1535  * @param object $feedbackcompleted
1536  * @return object temporary saved completed-record
1537  */
1538 function feedback_set_tmp_values($feedbackcompleted) {
1539     global $DB;
1540
1541     //first we create a completedtmp
1542     $tmpcpl = new object();
1543     foreach($feedbackcompleted as $key => $value) {
1544         $tmpcpl->{$key} = $value;
1545     }
1546     // $tmpcpl = $feedbackcompleted;
1547     unset($tmpcpl->id);
1548     $tmpcpl->timemodified = time();
1549     $tmpcpl->id = $DB->insert_record('feedback_completedtmp', $tmpcpl);
1550     //get all values of original-completed
1551     if(!$values = $DB->get_records('feedback_value', array('completed'=>$feedbackcompleted->id))) {
1552         return;
1553     }
1554     foreach($values as $value) {
1555         unset($value->id);
1556         $value->completed = $tmpcpl->id;
1557         $DB->insert_record('feedback_valuetmp', $value);
1558     }
1559     return $tmpcpl;
1560 }
1561
1562 /**
1563  * this saves the temporary saved values permanently
1564  *
1565  * @global object
1566  * @param object $feedbackcompletedtmp the temporary completed
1567  * @param object $feedbackcompleted the target completed
1568  * @param int $userid
1569  * @return int the id of the completed
1570  */
1571 function feedback_save_tmp_values($feedbackcompletedtmp, $feedbackcompleted, $userid) {
1572     global $DB;
1573
1574     $tmpcplid = $feedbackcompletedtmp->id;
1575     if($feedbackcompleted) {
1576         //first drop all existing values
1577         $DB->delete_records('feedback_value', array('completed'=>$feedbackcompleted->id));
1578         //update the current completed
1579         $feedbackcompleted->timemodified = time();
1580         $DB->update_record('feedback_completed', $feedbackcompleted);
1581     }else {
1582         $feedbackcompleted = clone($feedbackcompletedtmp);
1583         $feedbackcompleted->id = '';
1584         $feedbackcompleted->userid = $userid;
1585         $feedbackcompleted->timemodified = time();
1586         $feedbackcompleted->id = $DB->insert_record('feedback_completed', $feedbackcompleted);
1587     }
1588
1589     //save all the new values from feedback_valuetmp
1590     //get all values of tmp-completed
1591     if(!$values = $DB->get_records('feedback_valuetmp', array('completed'=>$feedbackcompletedtmp->id))) {
1592         return false;
1593     }
1594     foreach($values as $value) {
1595         //check if there are depend items
1596         $item = $DB->get_record('feedback_item', array('id'=>$value->item));
1597         if($item->dependitem > 0) {
1598             $check = feedback_compare_item_value($tmpcplid, $item->dependitem, $item->dependvalue, true);
1599         }else {
1600             $check = true;
1601         }
1602         if($check) {
1603             unset($value->id);
1604             $value->completed = $feedbackcompleted->id;
1605             $DB->insert_record('feedback_value', $value);
1606         }
1607     }
1608     //drop all the tmpvalues
1609     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1610     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1611     return $feedbackcompleted->id;
1612
1613 }
1614
1615 /**
1616  * deletes the given temporary completed and all related temporary values
1617  *
1618  * @global object
1619  * @param int $tmpcplid
1620  * @return void
1621  */
1622 function feedback_delete_completedtmp($tmpcplid) {
1623     global $DB;
1624
1625     $DB->delete_records('feedback_valuetmp', array('completed'=>$tmpcplid));
1626     $DB->delete_records('feedback_completedtmp', array('id'=>$tmpcplid));
1627 }
1628
1629 ////////////////////////////////////////////////
1630 ////////////////////////////////////////////////
1631 ////////////////////////////////////////////////
1632 //functions to handle the pagebreaks
1633 ////////////////////////////////////////////////
1634
1635 /**
1636  * this creates a pagebreak.
1637  * a pagebreak is a special kind of item
1638  *
1639  * @global object
1640  * @param int $feedbackid
1641  * @return mixed false if there already is a pagebreak on last position or the id of the pagebreak-item
1642  */
1643 function feedback_create_pagebreak($feedbackid) {
1644     global $DB;
1645
1646     //check if there already is a pagebreak on the last position
1647     $lastposition = $DB->count_records('feedback_item', array('feedback'=>$feedbackid));
1648     if($lastposition == feedback_get_last_break_position($feedbackid)) {
1649         return false;
1650     }
1651
1652     $item = new object();
1653     $item->feedback = $feedbackid;
1654
1655     $item->template=0;
1656
1657     $item->name = '';
1658
1659     $item->presentation = '';
1660     $item->hasvalue = 0;
1661
1662     $item->typ = 'pagebreak';
1663     $item->position = $lastposition + 1;
1664
1665     $item->required=0;
1666
1667     return $DB->insert_record('feedback_item', $item);
1668 }
1669
1670 /**
1671  * get all positions of pagebreaks in the given feedback
1672  *
1673  * @global object
1674  * @param int $feedbackid
1675  * @return array all ordered pagebreak positions
1676  */
1677 function feedback_get_all_break_positions($feedbackid) {
1678     global $DB;
1679
1680     if(!$allbreaks = $DB->get_records_menu('feedback_item', array('typ'=>'pagebreak', 'feedback'=>$feedbackid), 'position', 'id, position')) return false;
1681     return array_values($allbreaks);
1682 }
1683
1684 /**
1685  * get the position of the last pagebreak
1686  *
1687  * @param int $feedbackid
1688  * @return int the position of the last pagebreak
1689  */
1690 function feedback_get_last_break_position($feedbackid) {
1691     if(!$allbreaks = feedback_get_all_break_positions($feedbackid)) {
1692         return false;
1693     }
1694     return $allbreaks[count($allbreaks) - 1];
1695 }
1696
1697 /**
1698  * this returns the position where the user can continue the completing.
1699  *
1700  * @global object
1701  * @global object
1702  * @global object
1703  * @param int $feedbackid
1704  * @param int $courseid
1705  * @param string $guestid this id will be saved temporary and is unique
1706  * @return int the position to continue
1707  */
1708 function feedback_get_page_to_continue($feedbackid, $courseid = false, $guestid = false) {
1709     global $CFG, $USER, $DB;
1710
1711     //is there any break?
1712
1713     if(!$allbreaks = feedback_get_all_break_positions($feedbackid)) return false;
1714
1715     $params = array();
1716     if($courseid) {
1717         $courseselect = "fv.course_id = :courseid";
1718         $params['courseid'] = $courseid;
1719     }else {
1720         $courseselect = "1";
1721     }
1722
1723     if($guestid) {
1724         $userselect = "AND fc.guestid = :guestid";
1725         $usergroup = "GROUP BY fc.guestid";
1726         $params['guestid'] = $guestid;
1727     }else {
1728         $userselect = "AND fc.userid = :userid";
1729         $usergroup = "GROUP BY fc.userid";
1730         $params['userid'] = $USER->id;
1731     }
1732
1733     $sql =  "SELECT MAX(fi.position)
1734                FROM {feedback_completedtmp} fc, {feedback_valuetmp} fv, {feedback_item} fi
1735               WHERE fc.id = fv.completed
1736                     $userselect
1737                     AND fc.feedback = :feedbackid
1738                     AND $courseselect
1739                     AND fi.id = fv.item
1740          $usergroup";
1741     $params['feedbackid'] = $feedbackid;
1742
1743     $lastpos = $DB->get_field_sql($sql, $params);
1744
1745     //the index of found pagebreak is the searched pagenumber
1746     foreach($allbreaks as $pagenr => $br) {
1747         if($lastpos < $br) return $pagenr;
1748     }
1749     return count($allbreaks);
1750 }
1751
1752 ////////////////////////////////////////////////
1753 ////////////////////////////////////////////////
1754 ////////////////////////////////////////////////
1755 //functions to handle the values
1756 ////////////////////////////////////////////////
1757
1758 /**
1759  * this saves the values of an completed.
1760  * if the param $tmp is set true so the values are saved temporary in table feedback_valuetmp.
1761  * if there is already a completed and the userid is set so the values are updated.
1762  * on all other things new value records will be created.
1763  *
1764  * @global object
1765  * @param int $userid
1766  * @param boolean $tmp
1767  * @return mixed false on error or the completeid
1768  */
1769 function feedback_save_values($usrid, $tmp = false) {
1770     global $DB;
1771
1772     $completedid = optional_param('completedid', false, PARAM_INT);
1773
1774     $tmpstr = $tmp ? 'tmp' : '';
1775     $time = time();
1776     $timemodified = mktime(0, 0, 0, date('m', $time),date('d', $time),date('Y', $time));
1777
1778     if($usrid == 0) {
1779         return feedback_create_values($usrid, $timemodified, $tmp);
1780     }
1781     if(!$completedid or !$completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid))) {
1782         return feedback_create_values($usrid, $timemodified, $tmp);
1783     }else{
1784         $completed->timemodified = $timemodified;
1785         return feedback_update_values($completed, $tmp);
1786     }
1787 }
1788
1789 /**
1790  * this saves the values from anonymous user such as guest on the main-site
1791  *
1792  * @global object
1793  * @param string $guestid the unique guestidentifier
1794  * @return mixed false on error or the completeid
1795  */
1796 function feedback_save_guest_values($guestid) {
1797     global $DB;
1798
1799     $completedid = optional_param('completedid', false, PARAM_INT);
1800
1801     $timemodified = time();
1802     if(!$completed = $DB->get_record('feedback_completedtmp', array('id'=>$completedid))) {
1803         return feedback_create_values(0, $timemodified, true, $guestid);
1804     }else {
1805         $completed->timemodified = $timemodified;
1806         return feedback_update_values($completed, true);
1807     }
1808 }
1809
1810 /**
1811  * get the value from the given item related to the given completed.
1812  * the value can come as temporary or as permanently value. the deciding is done by $tmp
1813  *
1814  * @global object
1815  * @param int $completeid
1816  * @param int $itemid
1817  * @param boolean $tmp
1818  * @return mixed the value, the type depends on plugin-definition
1819  */
1820 function feedback_get_item_value($completedid, $itemid, $tmp = false) {
1821     global $DB;
1822
1823     $tmpstr = $tmp ? 'tmp' : '';
1824     return $DB->get_field('feedback_value'.$tmpstr, 'value', array('completed'=>$completedid, 'item'=>$itemid));
1825 }
1826
1827 /**
1828  * compares the value of the itemid related to the completedid with the dependvalue.
1829  * this is used if a depend item is set.
1830  * the value can come as temporary or as permanently value. the deciding is done by $tmp.
1831  *
1832  * @global object
1833  * @global object
1834  * @param int $completeid
1835  * @param int $itemid
1836  * @param mixed $dependvalue
1837  * @param boolean $tmp
1838  * @return bool
1839  */
1840 function feedback_compare_item_value($completedid, $itemid, $dependvalue, $tmp = false) {
1841     global $DB, $CFG;
1842
1843     $dbvalue = feedback_get_item_value($completedid, $itemid, $tmp);
1844
1845     //get the class of the given item-typ
1846     $item = $DB->get_record('feedback_item', array('id'=>$itemid));
1847
1848     //get the instance of the item-class
1849     $itemobj = feedback_get_item_class($item->typ);
1850     return $itemobj->compare_value($item, $dbvalue, $dependvalue); //true or false
1851 }
1852
1853 /**
1854  * this function checks the correctness of values.
1855  * the rules for this are implemented in the class of each item.
1856  * it can be the required attribute or the value self e.g. numeric.
1857  * the params first/lastitem are given to determine the visible range between pagebreaks.
1858  *
1859  * @global object
1860  * @param int $firstitem the position of firstitem for checking
1861  * @param int $lastitem the position of lastitem for checking
1862  * @return boolean
1863  */
1864 function feedback_check_values($firstitem, $lastitem) {
1865     global $DB, $CFG;
1866
1867     $feedbackid = optional_param('feedbackid', 0, PARAM_INT);
1868
1869     //get all items between the first- and lastitem
1870     $select = "feedback = ?
1871                     AND position >= ?
1872                     AND position <= ?
1873                     AND hasvalue = 1";
1874     $params = array($feedbackid, $firstitem, $lastitem);
1875     if(!$feedbackitems = $DB->get_records_select('feedback_item', $select, $params)) {
1876         //if no values are given so no values can be wrong ;-)
1877         return true;
1878     }
1879
1880     foreach($feedbackitems as $item) {
1881         //the name of the input field of the completeform is given in a special form:
1882         //<item-typ>_<item-id> eg. numeric_234
1883         //this is the key to get the value for the correct item
1884         $formvalname = $item->typ . '_' . $item->id;
1885
1886         $value = optional_param($formvalname, NULL, PARAM_RAW);
1887
1888         //check if the value is set
1889         if(is_null($value) AND $item->required == 1) {
1890             return false;
1891         }
1892
1893         //get the instance of the item-class
1894         $itemobj = feedback_get_item_class($item->typ);
1895
1896         //now we let check the value by the item-class
1897         if(!$itemobj->check_value($value, $item)) {
1898             return false;
1899         }
1900     }
1901     //if no wrong values so we can return true
1902     return true;
1903 }
1904
1905 /**
1906  * this function create a complete-record and the related value-records.
1907  * depending on the $tmp (true/false) the values are saved temporary or permanently
1908  *
1909  * @global object
1910  * @param int $userid
1911  * @param int $timemodified
1912  * @param boolean $tmp
1913  * @param string $guestid a unique identifier to save temporary data
1914  * @return mixed false on error or the completedid
1915  */
1916 function feedback_create_values($usrid, $timemodified, $tmp = false, $guestid = false){
1917     global $DB;
1918
1919     $feedbackid = optional_param('feedbackid', false, PARAM_INT);
1920     $anonymous_response = optional_param('anonymous_response', false, PARAM_INT);
1921     $courseid = optional_param('courseid', false, PARAM_INT);
1922
1923     $tmpstr = $tmp ? 'tmp' : '';
1924     //first we create a new completed record
1925     $completed = new object();
1926     $completed->feedback           = $feedbackid;
1927     $completed->userid             = $usrid;
1928     $completed->guestid            = $guestid;
1929     $completed->timemodified       = $timemodified;
1930     $completed->anonymous_response = $anonymous_response;
1931
1932     $completedid = $DB->insert_record('feedback_completed'.$tmpstr, $completed);
1933
1934     $completed = $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$completedid));
1935
1936     //the keys are in the form like abc_xxx
1937     //with explode we make an array with(abc, xxx) and (abc=typ und xxx=itemnr)
1938
1939     //get the items of the feedback
1940     if(!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
1941         return false;
1942     }
1943     foreach($allitems as $item) {
1944         $keyname = $item->typ.'_'.$item->id;
1945         $itemvalue = optional_param($keyname, NULL, PARAM_RAW);
1946         if(is_null($itemvalue)) {
1947             continue;
1948         }
1949         $value = new object();
1950         $value->item = $item->id;
1951         $value->completed = $completed->id;
1952         $value->course_id = $courseid;
1953
1954         //get the class of item-typ
1955         $itemobj = feedback_get_item_class($item->typ);
1956
1957         //the kind of values can be absolutely different so we run create_value directly by the item-class
1958         $value->value = $itemobj->create_value($itemvalue);
1959         $DB->insert_record('feedback_value'.$tmpstr, $value);
1960     }
1961     return $completed->id;
1962 }
1963
1964 /**
1965  * this function updates a complete-record and the related value-records.
1966  * depending on the $tmp (true/false) the values are saved temporary or permanently
1967  *
1968  * @global object
1969  * @param object $completed
1970  * @param boolean $tmp
1971  * @return int the completedid
1972  */
1973 function feedback_update_values($completed, $tmp = false) {
1974     global $DB;
1975     $courseid = optional_param('courseid', false, PARAM_INT);
1976
1977     $tmpstr = $tmp ? 'tmp' : '';
1978
1979     $DB->update_record('feedback_completed'.$tmpstr, $completed);
1980     //get the values of this completed
1981     $values = $DB->get_records('feedback_value'.$tmpstr, array('completed'=>$completed->id));
1982
1983     //get the items of the feedback
1984     if(!$allitems = $DB->get_records('feedback_item', array('feedback'=>$completed->feedback))) {
1985         return false;
1986     }
1987     foreach($allitems as $item) {
1988         $keyname = $item->typ.'_'.$item->id;
1989         $itemvalue = optional_param($keyname, NULL, PARAM_RAW);
1990         //is the itemvalue set (could be a subset of items because pagebreak)?
1991         if(is_null($itemvalue)) {
1992             continue;
1993         }
1994
1995         $newvalue = new object();
1996         $newvalue->item = $item->id;
1997         $newvalue->completed = $completed->id;
1998         $newvalue->course_id = $courseid;
1999
2000         //get the class of item-typ
2001         $itemobj = feedback_get_item_class($item->typ);
2002         //the kind of values can be absolutely different so we run create_value directly by the item-class
2003         $newvalue->value = $itemobj->create_value($itemvalue);
2004
2005         //check, if we have to create or update the value
2006         $exist = false;
2007         foreach($values as $value){
2008             if($value->item == $newvalue->item){
2009                 $newvalue->id = $value->id;
2010                 $exist = true;
2011                 break;
2012             }
2013         }
2014         if($exist){
2015             $DB->update_record('feedback_value'.$tmpstr, $newvalue);
2016         }else {
2017             $DB->insert_record('feedback_value'.$tmpstr, $newvalue);
2018         }
2019     }
2020
2021     return $completed->id;
2022 }
2023
2024 /**
2025  * get the values of an item depending on the given groupid.
2026  * if the feedback is anonymous so the values are shuffled
2027  *
2028  * @global object
2029  * @global object
2030  * @param object $item
2031  * @param int $groupid
2032  * @param int $courseid
2033  * @param bool $ignore_empty if this is set true so empty values are not delivered
2034  * @return array the value-records
2035  */
2036 function feedback_get_group_values($item, $groupid = false, $courseid = false, $ignore_empty = false){
2037     global $CFG, $DB;
2038
2039     //if the groupid is given?
2040     if (intval($groupid) > 0) {
2041         if($ignore_empty) {
2042             $ignore_empty_select = "AND fbc.value != ''";
2043         }
2044         else {
2045             $ignore_empty_select = "";
2046         }
2047
2048         $query = 'SELECT fbv .  *
2049                     FROM {feedback_value} fbv, {feedback_completed} fbc, {groups_members} gm
2050                    WHERE fbv.item = ?
2051                          AND fbv.completed = fbc.id
2052                          AND fbc.userid = gm.userid
2053                          '.$ignore_empty_select.'
2054                          AND gm.groupid = ?
2055                 ORDER BY fbc.timemodified';
2056         $values = $DB->get_records_sql($query, array($item->id, $groupid));
2057
2058     } else {
2059         if($ignore_empty) {
2060             $ignore_empty_select = "AND value != ''";
2061         }
2062         else {
2063             $ignore_empty_select = "";
2064         }
2065
2066         if ($courseid) {
2067             $values = $DB->get_records_select('feedback_value', "item = ? AND course_id = ? ".$ignore_empty_select, array($item->id, $courseid));
2068         } else {
2069             $values = $DB->get_records_select('feedback_value', "item = ? ".$ignore_empty_select, array($item->id));
2070         }
2071     }
2072     if ($DB->get_field('feedback', 'anonymous', array('id'=>$item->feedback)) == FEEDBACK_ANONYMOUS_YES) {
2073         if(is_array($values))
2074             shuffle($values);
2075     }
2076     return $values;
2077 }
2078
2079 /**
2080  * check for multiple_submit = false.
2081  * if the feedback is global so the courseid must be given
2082  *
2083  * @global object
2084  * @global object
2085  * @param int $feedbackid
2086  * @param int $courseid
2087  * @return boolean true if the feedback already is submitted otherwise false
2088  */
2089 function feedback_is_already_submitted($feedbackid, $courseid = false) {
2090     global $USER, $DB;
2091
2092     if (!$trackings = $DB->get_records_menu('feedback_tracking', array('userid'=>$USER->id, 'feedback'=>$feedbackid), '', 'id, completed')) {
2093         return false;
2094     }
2095
2096     if($courseid) {
2097         $select = 'completed IN ('.implode(',',$trackings).') AND course_id = ?';
2098         if(!$values = $DB->get_records_select('feedback_value', $select, array($courseid))) {
2099             return false;
2100         }
2101     }
2102
2103     return true;
2104 }
2105
2106 /**
2107  * if the completion of a feedback will be continued eg. by pagebreak or by multiple submit so the complete must be found.
2108  * if the param $tmp is set true so all things are related to temporary completeds
2109  *
2110  * @global object
2111  * @global object
2112  * @global object
2113  * @param int $feedbackid
2114  * @param boolean $tmp
2115  * @param int $courseid
2116  * @param string $guestid
2117  * @return int the id of the found completed
2118  */
2119 function feedback_get_current_completed($feedbackid, $tmp = false, $courseid = false, $guestid = false) {
2120     global $USER, $CFG, $DB;
2121
2122     $tmpstr = $tmp ? 'tmp' : '';
2123
2124     if(!$courseid) {
2125         if($guestid) {
2126             return $DB->get_record('feedback_completed'.$tmpstr, array('feedback'=>$feedbackid, 'guestid'=>$guestid));
2127         }else {
2128             return $DB->get_record('feedback_completed'.$tmpstr, array('feedback'=>$feedbackid, 'userid'=>$USER->id));
2129         }
2130     }
2131
2132     $params = array();
2133
2134     if ($guestid) {
2135         $userselect = "AND fc.guestid = :guestid";
2136         $params['guestid'] = $guestid;
2137     }else {
2138         $userselect = "AND fc.userid = :userid";
2139         $params['userid'] = $USER->id;
2140     }
2141     //if courseid is set the feedback is global. there can be more than one completed on one feedback
2142     $sql =  "SELECT DISTINCT fc.*
2143                FROM {feedback_value{$tmpstr}} fv, {feedback_completed{$tmpstr}} fc
2144               WHERE fv.course_id = :courseid
2145                     AND fv.completed = fc.id
2146                     $userselect
2147                     AND fc.feedback = :feedbackid";
2148     $params['courseid']   = intval($courseid);
2149     $params['feedbackid'] = $feedbackid;
2150
2151     if (!$sqlresult = $DB->get_records_sql($sql, $params)) {
2152         return false;
2153     }
2154     foreach($sqlresult as $r) {
2155         return $DB->get_record('feedback_completed'.$tmpstr, array('id'=>$r->id));
2156     }
2157 }
2158
2159 /**
2160  * get the completeds depending on the given groupid.
2161  *
2162  * @global object
2163  * @global object
2164  * @param object $feedback
2165  * @param int $groupid
2166  * @param int $courseid
2167  * @return mixed array of found completeds otherwise false
2168  */
2169 function feedback_get_completeds_group($feedback, $groupid = false, $courseid = false) {
2170     global $CFG, $DB;
2171
2172     if (intval($groupid) > 0){
2173         $query = "SELECT fbc.*
2174                     FROM {feedback_completed} fbc, {groups_members} gm
2175                    WHERE fbc.feedback = ?
2176                          AND gm.groupid = ?
2177                          AND fbc.userid = gm.userid";
2178         if ($values = $DB->get_records_sql($query, array($feedback->id, $groupid))) {
2179             return $values;
2180         } else {
2181             return false;
2182         }
2183     } else {
2184         if($courseid) {
2185             $query = "SELECT DISTINCT fbc.*
2186                         FROM {feedback_completed} fbc, {feedback_value} fbv
2187                         WHERE fbc.id = fbv.completed
2188                             AND fbc.feedback = ?
2189                             AND fbv.course_id = ?
2190                         ORDER BY random_response";
2191             if ($values = $DB->get_records_sql($query, array($feedback->id, $courseid))) {
2192                 return $values;
2193             } else {
2194                 return false;
2195             }
2196         }else {
2197             if ($values = $DB->get_records('feedback_completed', array('feedback'=>$feedback->id))) {
2198                 return $values;
2199             } else {
2200                 return false;
2201             }
2202         }
2203     }
2204 }
2205
2206 /**
2207  * get the count of completeds depending on the given groupid.
2208  *
2209  * @global object
2210  * @global object
2211  * @param object $feedback
2212  * @param int $groupid
2213  * @param int $courseid
2214  * @return mixed count of completeds or false
2215  */
2216 function feedback_get_completeds_group_count($feedback, $groupid = false, $courseid = false) {
2217     global $CFG, $DB;
2218
2219     if ($courseid > 0 AND !$groupid <= 0) {
2220         $sql = "SELECT id, COUNT(item) AS ci
2221                   FROM {feedback_value}
2222                  WHERE course_id  = ?
2223               GROUP BY item ORDER BY ci DESC";
2224         if ($foundrecs = $DB->get_records_sql($sql, array($courseid))) {
2225             $foundrecs = array_values($foundrecs);
2226             return $foundrecs[0]->ci;
2227         }
2228         return false;
2229     }
2230     if($values = feedback_get_completeds_group($feedback, $groupid)) {
2231         return sizeof($values);
2232     }else {
2233         return false;
2234     }
2235 }
2236
2237 /**
2238  * deletes all completed-recordsets from a feedback.
2239  * all related data such as values also will be deleted
2240  *
2241  * @global object
2242  * @param int $feedbackid
2243  * @return void
2244  */
2245 function feedback_delete_all_completeds($feedbackid) {
2246     global $DB;
2247
2248     if (!$completeds = $DB->get_records('feedback_completed', array('feedback'=>$feedbackid))) {
2249         return;
2250     }
2251     foreach($completeds as $completed) {
2252         feedback_delete_completed($completed->id);
2253     }
2254 }
2255
2256 /**
2257  * deletes a completed given by completedid.
2258  * all related data such values or tracking data also will be deleted
2259  *
2260  * @global object
2261  * @param int $completedid
2262  * @return boolean
2263  */
2264 function feedback_delete_completed($completedid) {
2265     global $DB;
2266
2267     if (!$completed = $DB->get_record('feedback_completed', array('id'=>$completedid))) {
2268         return false;
2269     }
2270     //first we delete all related values
2271     $DB->delete_records('feedback_value', array('completed'=>$completed->id));
2272
2273     //now we delete all tracking data
2274     if($tracking = $DB->get_record('feedback_tracking', array('completed'=>$completed->id, 'feedback'=>$completed->feedback))) {
2275         $DB->delete_records('feedback_tracking', array('completed'=>$completed->id));
2276     }
2277
2278     //last we delete the completed-record
2279     return $DB->delete_records('feedback_completed', array('id'=>$completed->id));
2280 }
2281
2282 ////////////////////////////////////////////////
2283 ////////////////////////////////////////////////
2284 ////////////////////////////////////////////////
2285 //functions to handle sitecourse mapping
2286 ////////////////////////////////////////////////
2287
2288 /**
2289  * checks if the course and the feedback is in the table feedback_sitecourse_map.
2290  *
2291  * @global object
2292  * @param int $feedbackid
2293  * @param int $courseid
2294  * @return int the count of records
2295  */
2296 function feedback_is_course_in_sitecourse_map($feedbackid, $courseid) {
2297     global $DB;
2298     return $DB->count_records('feedback_sitecourse_map', array('feedbackid'=>$feedbackid, 'courseid'=>$courseid));
2299 }
2300
2301 /**
2302  * checks if the feedback is in the table feedback_sitecourse_map.
2303  *
2304  * @global object
2305  * @param int $feedbackid
2306  * @return boolean
2307  */
2308 function feedback_is_feedback_in_sitecourse_map($feedbackid) {
2309     global $Db;
2310     return $DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$feedbackid));
2311 }
2312
2313 /**
2314  * gets the feedbacks from table feedback_sitecourse_map.
2315  * this is used to show the global feedbacks on the feedback block
2316  * all feedbacks with the following criteria will be selected:<br />
2317  *
2318  * 1) all feedbacks which id are listed together with the courseid in sitecoursemap and<br />
2319  * 2) all feedbacks which not are listed in sitecoursemap
2320  *
2321  * @global object
2322  * @param int $courseid
2323  * @return array the feedback-records
2324  */
2325 function feedback_get_feedbacks_from_sitecourse_map($courseid) {
2326     global $DB;
2327
2328     //first get all feedbacks listed in sitecourse_map with named courseid
2329     $sql = "SELECT f.id AS id, cm.id AS cmid, f.name AS name, f.timeopen AS timeopen, f.timeclose AS timeclose
2330               FROM {feedback} f, {course_modules} cm, {feedback_sitecourse_map} sm, {modules} m
2331              WHERE f.id = cm.instance
2332                    AND f.course = '".SITEID."'
2333                    AND m.id = cm.module
2334                    AND m.name = 'feedback'
2335                    AND sm.courseid = ?
2336                    AND sm.feedbackid = f.id";
2337
2338     if (!$feedbacks1 = $DB->get_records_sql($sql, array($courseid))) {
2339         $feedbacks1 = array();
2340     }
2341
2342     //second get all feedbacks not listed in sitecourse_map
2343     $feedbacks2 = array();
2344     $sql = "SELECT f.id AS id, cm.id AS cmid, f.name AS name, f.timeopen AS timeopen, f.timeclose AS timeclose
2345               FROM {feedback} f, {course_modules} cm, {modules} m
2346              WHERE f.id = cm.instance
2347                    AND f.course = '".SITEID."'
2348                    AND m.id = cm.module
2349                    AND m.name = 'feedback'";
2350     if (!$allfeedbacks = $DB->get_records_sql($sql)) {
2351         $allfeedbacks = array();
2352     }
2353     foreach($allfeedbacks as $a) {
2354         if(!$DB->record_exists('feedback_sitecourse_map', array('feedbackid'=>$a->id))) {
2355             $feedbacks2[] = $a;
2356         }
2357     }
2358
2359     return array_merge($feedbacks1, $feedbacks2);
2360
2361 }
2362
2363 /**
2364  * gets the courses from table feedback_sitecourse_map.
2365  *
2366  * @global object
2367  * @param int $feedbackid
2368  * @return array the course-records
2369  */
2370 function feedback_get_courses_from_sitecourse_map($feedbackid) {
2371     global $DB;
2372
2373     $sql = "SELECT f.id, f.courseid, c.fullname, c.shortname
2374               FROM {feedback_sitecourse_map} f, {course} c
2375              WHERE c.id = f.courseid
2376                    AND f.feedbackid = ?
2377           ORDER BY c.fullname";
2378
2379     return $DB->get_records_sql($sql, array($feedbackid));
2380
2381 }
2382
2383 /**
2384  * removes non existing courses or feedbacks from sitecourse_map.
2385  * it shouldn't be called all too often
2386  * a good place for it could be the mapcourse.php or unmapcourse.php
2387  *
2388  * @global object
2389  * @return void
2390  */
2391 function feedback_clean_up_sitecourse_map() {
2392     global $DB;
2393
2394     $maps = $DB->get_records('feedback_sitecourse_map');
2395     foreach($maps as $map) {
2396         if (!$DB->get_record('course', array('id'=>$map->courseid))) {
2397             $DB->delete_records('feedback_sitecourse_map', array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid));
2398             continue;
2399         }
2400         if (!$DB->get_record('feedback', array('id'=>$map->feedbackid))) {
2401             $DB->delete_records('feedback_sitecourse_map', array('courseid'=>$map->courseid, 'feedbackid'=>$map->feedbackid));
2402             continue;
2403         }
2404
2405     }
2406 }
2407
2408 ////////////////////////////////////////////////
2409 ////////////////////////////////////////////////
2410 ////////////////////////////////////////////////
2411 //not relatable functions
2412 ////////////////////////////////////////////////
2413
2414 /**
2415  * prints the option items of a selection-input item (dropdownlist).
2416  * @param int $startval the first value of the list
2417  * @param int $endval the last value of the list
2418  * @param int $selectval which item should be selected
2419  * @param int $interval the stepsize from the first to the last value
2420  * @return void
2421  */
2422 function feedback_print_numeric_option_list($startval, $endval, $selectval = '', $interval = 1){
2423     for($i = $startval; $i <= $endval; $i += $interval){
2424         if($selectval == ($i)){
2425             $selected = 'selected="selected"';
2426         }else{
2427             $selected = '';
2428         }
2429         echo '<option '.$selected.'>'.$i.'</option>';
2430     }
2431 }
2432
2433 /**
2434  * sends an email to the teachers of the course where the given feedback is placed.
2435  *
2436  * @global object
2437  * @global object
2438  * @uses FEEDBACK_ANONYMOUS_NO
2439  * @uses FORMAT_PLAIN
2440  * @param object $cm the coursemodule-record
2441  * @param object $feedback
2442  * @param object $course
2443  * @param int $userid
2444  * @return void
2445  */
2446 function feedback_send_email($cm, $feedback, $course, $userid) {
2447     global $CFG, $DB;
2448
2449     if ($feedback->email_notification == 0) {  // No need to do anything
2450         return;
2451     }
2452
2453     $user = $DB->get_record('user', array('id'=>$userid));
2454
2455     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
2456         $groupmode =  $cm->groupmode;
2457     } else {
2458         $groupmode = $course->groupmode;
2459     }
2460
2461     if ($groupmode == SEPARATEGROUPS) {
2462         $groups = $DB->get_records_sql_menu("SELECT g.name, g.id
2463                                                FROM {groups} g, {groups_members} m
2464                                               WHERE g.courseid = ?
2465                                                     AND g.id = m.groupid
2466                                                     AND m.userid = ?
2467                                            ORDER BY name ASC", array($course->id, $userid));
2468         $groups = array_values($groups);
2469
2470         $teachers = feedback_get_receivemail_users($cm->id, $groups);
2471     } else {
2472         $teachers = feedback_get_receivemail_users($cm->id);
2473     }
2474
2475     if ($teachers) {
2476
2477         $strfeedbacks = get_string('modulenameplural', 'feedback');
2478         $strfeedback  = get_string('modulename', 'feedback');
2479         $strcompleted  = get_string('completed', 'feedback');
2480         $printusername = $feedback->anonymous == FEEDBACK_ANONYMOUS_NO ? fullname($user) : get_string('anonymous_user', 'feedback');
2481
2482         foreach ($teachers as $teacher) {
2483             $info = new object();
2484             $info->username = $printusername;
2485             $info->feedback = format_string($feedback->name,true);
2486             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries.php?id='.$cm->id.'&userid='.$userid.'&do_show=showentries';
2487
2488             $postsubject = $strcompleted.': '.$info->username.' -> '.$feedback->name;
2489             $posttext = feedback_send_email_text($info, $course);
2490             $posthtml = ($teacher->mailformat == 1) ? feedback_send_email_html($info, $course, $cm) : '';
2491
2492             if($feedback->anonymous == FEEDBACK_ANONYMOUS_NO) {
2493                 $eventdata = new object();
2494                 $eventdata->name             = 'feedback';
2495                 $eventdata->component        = 'mod';
2496                 $eventdata->userfrom         = $user;
2497                 $eventdata->userto           = $teacher;
2498                 $eventdata->subject          = $postsubject;
2499                 $eventdata->fullmessage      = $posttext;
2500                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2501                 $eventdata->fullmessagehtml  = $posthtml;
2502                 $eventdata->smallmessage     = '';
2503                 message_send($eventdata);
2504             }else {
2505                 $eventdata = new object();
2506                 $eventdata->name             = 'feedback';
2507                 $eventdata->component        = 'mod';
2508                 $eventdata->userfrom         = $teacher;
2509                 $eventdata->userto           = $teacher;
2510                 $eventdata->subject          = $postsubject;
2511                 $eventdata->fullmessage      = $posttext;
2512                 $eventdata->fullmessageformat = FORMAT_PLAIN;
2513                 $eventdata->fullmessagehtml  = $posthtml;
2514                 $eventdata->smallmessage     = '';
2515                 message_send($eventdata);
2516             }
2517         }
2518     }
2519 }
2520
2521 /**
2522  * sends an email to the teachers of the course where the given feedback is placed.
2523  *
2524  * @global object
2525  * @uses FORMAT_PLAIN
2526  * @param object $cm the coursemodule-record
2527  * @param object $feedback
2528  * @param object $course
2529  * @return void
2530  */
2531 function feedback_send_email_anonym($cm, $feedback, $course) {
2532     global $CFG;
2533
2534     if ($feedback->email_notification == 0) {             // No need to do anything
2535         return;
2536     }
2537
2538     $teachers = feedback_get_receivemail_users($cm->id);
2539
2540     if ($teachers) {
2541
2542         $strfeedbacks = get_string('modulenameplural', 'feedback');
2543         $strfeedback  = get_string('modulename', 'feedback');
2544         $strcompleted  = get_string('completed', 'feedback');
2545         $printusername = get_string('anonymous_user', 'feedback');
2546
2547         foreach ($teachers as $teacher) {
2548             $info = new object();
2549             $info->username = $printusername;
2550             $info->feedback = format_string($feedback->name,true);
2551             $info->url = $CFG->wwwroot.'/mod/feedback/show_entries_anonym.php?id='.$cm->id;
2552
2553             $postsubject = $strcompleted.': '.$info->username.' -> '.$feedback->name;
2554             $posttext = feedback_send_email_text($info, $course);
2555             $posthtml = ($teacher->mailformat == 1) ? feedback_send_email_html($info, $course, $cm) : '';
2556
2557             $eventdata = new object();
2558             $eventdata->name             = 'feedback';
2559             $eventdata->component        = 'mod';
2560             $eventdata->userfrom         = $teacher;
2561             $eventdata->userto           = $teacher;
2562             $eventdata->subject          = $postsubject;
2563             $eventdata->fullmessage      = $posttext;
2564             $eventdata->fullmessageformat = FORMAT_PLAIN;
2565             $eventdata->fullmessagehtml  = $posthtml;
2566             $eventdata->smallmessage     = '';
2567             message_send($eventdata);
2568         }
2569     }
2570 }
2571
2572 /**
2573  * send the text-part of the email
2574  *
2575  * @param object $info includes some infos about the feedback you want to send
2576  * @param object $course
2577  * @return string the text you want to post
2578  */
2579 function feedback_send_email_text($info, $course) {
2580     $posttext  = $course->shortname.' -> '.get_string('modulenameplural', 'feedback').' -> '.
2581                     $info->feedback."\n";
2582     $posttext .= '---------------------------------------------------------------------'."\n";
2583     $posttext .= get_string("emailteachermail", "feedback", $info)."\n";
2584     $posttext .= '---------------------------------------------------------------------'."\n";
2585     return $posttext;
2586 }
2587
2588
2589 /**
2590  * send the html-part of the email
2591  *
2592  * @global object
2593  * @param object $info includes some infos about the feedback you want to send
2594  * @param object $course
2595  * @return string the text you want to post
2596  */
2597 function feedback_send_email_html($info, $course, $cm) {
2598     global $CFG;
2599     $posthtml  = '<p><font face="sans-serif">'.
2600                 '<a href="'.$CFG->wwwroot.'/course/view.php?id='.$course->id.'">'.$course->shortname.'</a> ->'.
2601                 '<a href="'.$CFG->wwwroot.'/mod/feedback/index.php?id='.$course->id.'">'.get_string('modulenameplural', 'feedback').'</a> ->'.
2602                 '<a href="'.$CFG->wwwroot.'/mod/feedback/view.php?id='.$cm->id.'">'.$info->feedback.'</a></font></p>';
2603     $posthtml .= '<hr /><font face="sans-serif">';
2604     $posthtml .= '<p>'.get_string('emailteachermailhtml', 'feedback', $info).'</p>';
2605     $posthtml .= '</font><hr />';
2606     return $posthtml;
2607 }
2608
2609 /**
2610  * print some errors to inform users about this.
2611  *
2612  * @global object
2613  * @return void
2614  */
2615 function feedback_print_errors() {
2616
2617     global $SESSION, $OUTPUT;
2618
2619     feedback_init_feedback_session();
2620
2621     if(empty($SESSION->feedback->errors)) {
2622         return;
2623     }
2624
2625     echo $OUTPUT->box_start('generalbox errorboxcontent boxaligncenter boxwidthnormal');
2626     echo $OUTPUT->heading(get_string('handling_error', 'feedback'));
2627
2628     echo '<p align="center"><b><font color="black"><pre>';
2629     print_r($SESSION->feedback->errors) . "\n";
2630     echo '</pre></font></b></p>';
2631
2632     echo $OUTPUT->box_end();
2633     echo '<br /><br />';
2634     $SESSION->feedback->errors = array(); //remove errors
2635 }
2636
2637 /**
2638  * @param string $url
2639  * @return string
2640  */
2641 function feedback_encode_target_url($url) {
2642     if (strpos($url, '?')) {
2643         list($part1, $part2) = explode('?', $url, 2); //maximal 2 parts
2644         return $part1 . '?' . htmlentities($part2);
2645     } else {
2646         return $url;
2647     }
2648 }
2649
2650 /**
2651  * Adds module specific settings to the settings block
2652  *
2653  * @param settings_navigation $settings The settings navigation object
2654  * @param navigation_node $feedbacknode The node to add module settings to
2655  */
2656 function feedback_extend_settings_navigation(settings_navigation $settings, navigation_node $feedbacknode) {
2657     global $PAGE, $DB;
2658
2659     if (!$context = get_context_instance(CONTEXT_MODULE, $PAGE->cm->id)) {
2660         print_error('badcontext');
2661     }
2662
2663     if (has_capability('mod/feedback:edititems', $context)) {
2664         $questionnode = $feedbacknode->add(get_string('questions', 'feedback'));
2665         $questionnode->add(get_string('edit_items', 'feedback'), new moodle_url('/mod/feedback/edit.php', array('id'=>$PAGE->cm->id, 'do_show'=>'edit')));
2666         $questionnode->add(get_string('export_questions', 'feedback'), new moodle_url('/mod/feedback/export.php', array('id'=>$PAGE->cm->id, 'action'=>'exportfile')));
2667         $questionnode->add(get_string('import_questions', 'feedback'), new moodle_url('/mod/feedback/import.php', array('id'=>$PAGE->cm->id)));
2668         $questionnode->add(get_string('templates', 'feedback'), new moodle_url('/mod/feedback/edit.php', array('id'=>$PAGE->cm->id, 'do_show'=>'templates')));
2669     }
2670
2671     if (has_capability('mod/feedback:viewreports', $context)) {
2672         $feedback = $DB->get_record('feedback', array('id'=>$PAGE->cm->instance));
2673         if($feedback->course == SITEID){
2674             $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')));
2675         }else {
2676             $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')));
2677         }
2678
2679         $feedbacknode->add(get_string('show_entries', 'feedback'), new moodle_url('/mod/feedback/show_entries.php', array('id'=>$PAGE->cm->id, 'do_show'=>'showentries')));
2680     }
2681 }
2682
2683 function feedback_init_feedback_session() {
2684     //initialize the feedback-Session - not nice at all!!
2685     global $SESSION;
2686     if (!empty($SESSION)) {
2687         if (!isset($SESSION->feedback) OR !is_object($SESSION->feedback)) {
2688             $SESSION->feedback = new object();
2689         }
2690     }
2691 }