source: moodle/trunk/fuentes/blocks/activity_results/block_activity_results.php @ 1331

Last change on this file since 1331 was 1331, checked in by jrpelegrina, 3 years ago

Updated to moodle 3.0.3

File size: 31.8 KB
RevLine 
[1331]1<?php
2// This file is part of Moodle - http://moodle.org/
3//
4// Moodle is free software: you can redistribute it and/or modify
5// it under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
8//
9// Moodle is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12// GNU General Public License for more details.
13//
14// You should have received a copy of the GNU General Public License
15// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
16
17/**
18 * Classes to enforce the various access rules that can apply to a activity.
19 *
20 * @package    block_activity_results
21 * @copyright  2009 Tim Hunt
22 * @copyright  2015 Stephen Bourget
23 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24 */
25
26defined('MOODLE_INTERNAL') || die();
27
28require_once($CFG->dirroot . '/lib/grade/constants.php');
29
30define('B_ACTIVITYRESULTS_NAME_FORMAT_FULL', 1);
31define('B_ACTIVITYRESULTS_NAME_FORMAT_ID',   2);
32define('B_ACTIVITYRESULTS_NAME_FORMAT_ANON', 3);
33define('B_ACTIVITYRESULTS_GRADE_FORMAT_PCT', 1);
34define('B_ACTIVITYRESULTS_GRADE_FORMAT_FRA', 2);
35define('B_ACTIVITYRESULTS_GRADE_FORMAT_ABS', 3);
36define('B_ACTIVITYRESULTS_GRADE_FORMAT_SCALE', 4);
37
38/**
39 * Block activity_results class definition.
40 *
41 * This block can be added to a course page or a activity page to display of list of
42 * the best/worst students/groups in a particular activity.
43 *
44 * @package    block_activity_results
45 * @copyright  2009 Tim Hunt
46 * @copyright  2015 Stephen Bourget
47 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
48 */
49class block_activity_results extends block_base {
50
51    /**
52     * Core function used to initialize the block.
53     */
54    public function init() {
55        $this->title = get_string('pluginname', 'block_activity_results');
56    }
57
58    /**
59     * Core function, specifies where the block can be used.
60     * @return array
61     */
62    public function applicable_formats() {
63        return array('course-view' => true, 'mod' => true);
64    }
65
66    /**
67     * If this block belongs to a activity context, then return that activity's id.
68     * Otherwise, return 0.
69     * @return stdclass the activity record.
70     */
71    public function get_owning_activity() {
72        global $DB;
73
74        // Set some defaults.
75        $result = new stdClass();
76        $result->id = 0;
77
78        if (empty($this->instance->parentcontextid)) {
79            return $result;
80        }
81        $parentcontext = context::instance_by_id($this->instance->parentcontextid);
82        if ($parentcontext->contextlevel != CONTEXT_MODULE) {
83            return $result;
84        }
85        $cm = get_coursemodule_from_id($this->page->cm->modname, $parentcontext->instanceid);
86        if (!$cm) {
87            return $result;
88        }
89        // Get the grade_items id.
90        $rec = $DB->get_record('grade_items', array('iteminstance' => $cm->instance, 'itemmodule' => $this->page->cm->modname));
91        if (!$rec) {
92            return $result;
93        }
94        // See if it is a gradable activity.
95        if (($rec->gradetype != GRADE_TYPE_VALUE) && ($rec->gradetype != GRADE_TYPE_SCALE)) {
96            return $result;
97        }
98        return $rec;
99    }
100
101    /**
102     * Used to save the form config data
103     * @param stdclass $data
104     * @param bool $nolongerused
105     */
106    public function instance_config_save($data, $nolongerused = false) {
107        global $DB;
108        if (empty($data->activitygradeitemid)) {
109            // Figure out info about parent module.
110            $info = $this->get_owning_activity();
111            $data->activitygradeitemid = $info->id;
112            if ($info->id < 1) {
113                // No activity was selected.
114                $info->itemmodule = '';
115                $info->iteminstance = '';
116            } else {
117                $data->activityparent = $info->itemmodule;
118                $data->activityparentid = $info->iteminstance;
119            }
120        } else {
121            // Lookup info about the parent module (we have the id from mdl_grade_items.
122            $info = $DB->get_record('grade_items', array('id' => $data->activitygradeitemid));
123            $data->activityparent = $info->itemmodule;
124            $data->activityparentid = $info->iteminstance;
125        }
126        parent::instance_config_save($data);
127    }
128
129    /**
130     * Used to generate the content for the block.
131     * @return string
132     */
133    public function get_content() {
134        global $USER, $CFG, $DB;
135
136        if ($this->content !== null) {
137            return $this->content;
138        }
139
140        $this->content = new stdClass;
141        $this->content->text = '';
142        $this->content->footer = '';
143
144        if (empty($this->instance)) {
145            return $this->content;
146        }
147
148        // We are configured so use the configuration.
149        if (!empty($this->config->activitygradeitemid)) {
150            // We are configured.
151            $activitygradeitemid = $this->config->activitygradeitemid;
152
153            // Lookup the module in the grade_items table.
154            $activity = $DB->get_record('grade_items', array('id' => $activitygradeitemid));
155            if (empty($activity)) {
156                // Activity does not exist.
157                $this->content->text = get_string('error_emptyactivityrecord', 'block_activity_results');
158                return $this->content;
159            }
160            $courseid = $activity->courseid;
161            $inactivity = false;
162        } else {
163            // Not configured.
164            $activitygradeitemid = 0;
165        }
166
167        // Check to see if we are in the moule we are displaying results for.
168        if (!empty($this->config->activitygradeitemid)) {
169            if ($this->get_owning_activity()->id == $this->config->activitygradeitemid) {
170                $inactivity = true;
171            } else {
172                $inactivity = false;
173            }
174        }
175
176        // Activity ID is missing.
177        if (empty($activitygradeitemid)) {
178            $this->content->text = get_string('error_emptyactivityid', 'block_activity_results');
179            return $this->content;
180        }
181
182        // Check to see if we are configured.
183        if (empty($this->config->showbest) && empty($this->config->showworst)) {
184            $this->content->text = get_string('configuredtoshownothing', 'block_activity_results');
185            return $this->content;
186        }
187
188        // Check to see if it is a supported grade type.
189        if (empty($activity->gradetype) || ($activity->gradetype != GRADE_TYPE_VALUE && $activity->gradetype != GRADE_TYPE_SCALE)) {
190            $this->content->text = get_string('error_unsupportedgradetype', 'block_activity_results');
191            return $this->content;
192        }
193
194        // Get the grades for this activity.
195        $sql = 'SELECT * FROM {grade_grades}
196                 WHERE itemid = ? AND finalgrade is not NULL
197                 ORDER BY finalgrade, timemodified DESC';
198
199        $grades = $DB->get_records_sql($sql, array( $activitygradeitemid));
200
201        if (empty($grades) || $activity->hidden) {
202            // No grades available, The block will hide itself in this case.
203            return $this->content;
204        }
205
206        // Set up results.
207        $groupmode = NOGROUPS;
208        $best      = array();
209        $worst     = array();
210
211        if (!empty($this->config->nameformat)) {
212            $nameformat = $this->config->nameformat;
213        } else {
214            $nameformat = B_ACTIVITYRESULTS_NAME_FORMAT_FULL;
215        }
216
217        // Get $cm and context.
218        if ($inactivity) {
219            $cm = $this->page->cm;
220            $context = $this->page->context;
221        } else {
222            $cm = get_coursemodule_from_instance($activity->itemmodule, $activity->iteminstance, $courseid);
223            $context = context_module::instance($cm->id);
224        }
225
226        if (!empty($this->config->usegroups)) {
227            $groupmode = groups_get_activity_groupmode($cm);
228
229            if ($groupmode == SEPARATEGROUPS && has_capability('moodle/site:accessallgroups', $context)) {
230                // If you have the ability to see all groups then lets show them.
231                $groupmode = VISIBLEGROUPS;
232            }
233        }
234
235        switch ($groupmode) {
236            case VISIBLEGROUPS:
237                // Display group-mode results.
238                $groups = groups_get_all_groups($courseid);
239
240                if (empty($groups)) {
241                    // No groups exist, sorry.
242                    $this->content->text = get_string('error_nogroupsexist', 'block_activity_results');
243                    return $this->content;
244                }
245
246                // Find out all the userids which have a submitted grade.
247                $userids = array();
248                $gradeforuser = array();
249                foreach ($grades as $grade) {
250                    $userids[] = $grade->userid;
251                    $gradeforuser[$grade->userid] = (float)$grade->finalgrade;
252                }
253
254                // Now find which groups these users belong in.
255                list($usertest, $params) = $DB->get_in_or_equal($userids);
256                $params[] = $courseid;
257                $usergroups = $DB->get_records_sql('
258                        SELECT gm.id, gm.userid, gm.groupid, g.name
259                        FROM {groups} g
260                        LEFT JOIN {groups_members} gm ON g.id = gm.groupid
261                        WHERE gm.userid ' . $usertest . ' AND g.courseid = ?', $params);
262
263                // Now, iterate the grades again and sum them up for each group.
264                $groupgrades = array();
265                foreach ($usergroups as $usergroup) {
266                    if (!isset($groupgrades[$usergroup->groupid])) {
267                        $groupgrades[$usergroup->groupid] = array(
268                                'sum' => (float)$gradeforuser[$usergroup->userid],
269                                'number' => 1,
270                                'group' => $usergroup->name);
271                    } else {
272                        $groupgrades[$usergroup->groupid]['sum'] += $gradeforuser[$usergroup->userid];
273                        $groupgrades[$usergroup->groupid]['number'] += 1;
274                    }
275                }
276
277                foreach ($groupgrades as $groupid => $groupgrade) {
278                    $groupgrades[$groupid]['average'] = $groupgrades[$groupid]['sum'] / $groupgrades[$groupid]['number'];
279                }
280
281                // Sort groupgrades according to average grade, ascending.
282                uasort($groupgrades, create_function('$a, $b',
283                        'if($a["average"] == $b["average"]) return 0; return ($a["average"] > $b["average"] ? 1 : -1);'));
284
285                // How many groups do we have with graded member submissions to show?
286                $numbest  = empty($this->config->showbest) ? 0 : min($this->config->showbest, count($groupgrades));
287                $numworst = empty($this->config->showworst) ? 0 : min($this->config->showworst, count($groupgrades) - $numbest);
288
289                // Collect all the group results we are going to use in $best and $worst.
290                $remaining = $numbest;
291                $groupgrade = end($groupgrades);
292                while ($remaining--) {
293                    $best[key($groupgrades)] = $groupgrade['average'];
294                    $groupgrade = prev($groupgrades);
295                }
296
297                $remaining = $numworst;
298                $groupgrade = reset($groupgrades);
299                while ($remaining--) {
300                    $worst[key($groupgrades)] = $groupgrade['average'];
301                    $groupgrade = next($groupgrades);
302                }
303
304                // Ready for output!
305                if ($activity->gradetype == GRADE_TYPE_SCALE) {
306                    // We must display the results using scales.
307                    $gradeformat = B_ACTIVITYRESULTS_GRADE_FORMAT_SCALE;
308                    // Preload the scale.
309                    $scale = $this->get_scale($activity->scaleid);
310                } else if (intval(empty($this->config->gradeformat))) {
311                    $gradeformat = B_ACTIVITYRESULTS_GRADE_FORMAT_PCT;
312                } else {
313                    $gradeformat = $this->config->gradeformat;
314                }
315
316                // Generate the header.
317                $this->content->text .= $this->activity_link($activity, $cm);
318
319                if ($nameformat == B_ACTIVITYRESULTS_NAME_FORMAT_FULL) {
320                    if (has_capability('moodle/course:managegroups', $context)) {
321                        $grouplink = $CFG->wwwroot.'/group/overview.php?id='.$courseid.'&amp;group=';
322                    } else if (has_capability('moodle/course:viewparticipants', $context)) {
323                        $grouplink = $CFG->wwwroot.'/user/index.php?id='.$courseid.'&amp;group=';
324                    } else {
325                        $grouplink = '';
326                    }
327                }
328
329                $rank = 0;
330                if (!empty($best)) {
331                    $this->content->text .= '<table class="grades"><caption>';
332                    if ($numbest == 1) {
333                        $this->content->text .= get_string('bestgroupgrade', 'block_activity_results');
334                    } else {
335                        $this->content->text .= get_string('bestgroupgrades', 'block_activity_results', $numbest);
336                    }
337                    $this->content->text .= '</caption><colgroup class="number" />';
338                    $this->content->text .= '<colgroup class="name" /><colgroup class="grade" /><tbody>';
339                    foreach ($best as $groupid => $averagegrade) {
340                        switch ($nameformat) {
341                            case B_ACTIVITYRESULTS_NAME_FORMAT_ANON:
342                            case B_ACTIVITYRESULTS_NAME_FORMAT_ID:
343                                $thisname = get_string('group');
344                            break;
345                            default:
346                            case B_ACTIVITYRESULTS_NAME_FORMAT_FULL:
347                                if ($grouplink) {
348                                    $thisname = '<a href="'.$grouplink.$groupid.'">'.$groupgrades[$groupid]['group'].'</a>';
349                                } else {
350                                    $thisname = $groupgrades[$groupid]['group'];
351                                }
352                            break;
353                        }
354                        $this->content->text .= '<tr><td>'.(++$rank).'.</td><td>'.$thisname.'</td><td>';
355                        switch ($gradeformat) {
356                            case B_ACTIVITYRESULTS_GRADE_FORMAT_SCALE:
357                                // Round answer up and locate appropriate scale.
358                                $answer = (round($averagegrade, 0, PHP_ROUND_HALF_UP) - 1);
359                                if (isset($scale[$answer])) {
360                                    $this->content->text .= $scale[$answer];
361                                } else {
362                                    // Value is not in the scale.
363                                    $this->content->text .= get_string('unknown', 'block_activity_results');
364                                }
365                            break;
366                            case B_ACTIVITYRESULTS_GRADE_FORMAT_FRA:
367                                $this->content->text .= $this->activity_format_grade($averagegrade)
368                                    . '/' . $this->activity_format_grade($activity->grademax);
369                            break;
370                            case B_ACTIVITYRESULTS_GRADE_FORMAT_ABS:
371                                $this->content->text .= $this->activity_format_grade($averagegrade);
372                            break;
373                            default:
374                            case B_ACTIVITYRESULTS_GRADE_FORMAT_PCT:
375                                $this->content->text .= $this->activity_format_grade((float)$averagegrade /
376                                        (float)$activity->grademax * 100).'%';
377                            break;
378                        }
379                        $this->content->text .= '</td></tr>';
380                    }
381                    $this->content->text .= '</tbody></table>';
382                }
383
384                $rank = 0;
385                if (!empty($worst)) {
386                    $worst = array_reverse($worst, true);
387                    $this->content->text .= '<table class="grades"><caption>';
388                    if ($numworst == 1) {
389                        $this->content->text .= get_string('worstgroupgrade', 'block_activity_results');
390                    } else {
391                        $this->content->text .= get_string('worstgroupgrades', 'block_activity_results', $numworst);
392                    }
393                    $this->content->text .= '</caption><colgroup class="number" />';
394                    $this->content->text .= '<colgroup class="name" /><colgroup class="grade" /><tbody>';
395                    foreach ($worst as $groupid => $averagegrade) {
396                        switch ($nameformat) {
397                            case B_ACTIVITYRESULTS_NAME_FORMAT_ANON:
398                            case B_ACTIVITYRESULTS_NAME_FORMAT_ID:
399                                $thisname = get_string('group');
400                            break;
401                            default:
402                            case B_ACTIVITYRESULTS_NAME_FORMAT_FULL:
403                                if ($grouplink) {
404                                    $thisname = '<a href="'.$grouplink.$groupid.'">'.$groupgrades[$groupid]['group'].'</a>';
405                                } else {
406                                    $thisname = $groupgrades[$groupid]['group'];
407                                }
408                            break;
409                        }
410                        $this->content->text .= '<tr><td>'.(++$rank).'.</td><td>'.$thisname.'</td><td>';
411                        switch ($gradeformat) {
412                            case B_ACTIVITYRESULTS_GRADE_FORMAT_SCALE:
413                                // Round answer up and locate appropriate scale.
414                                $answer = (round($averagegrade, 0, PHP_ROUND_HALF_UP) - 1);
415                                if (isset($scale[$answer])) {
416                                    $this->content->text .= $scale[$answer];
417                                } else {
418                                    // Value is not in the scale.
419                                    $this->content->text .= get_string('unknown', 'block_activity_results');
420                                }
421                            break;
422                            case B_ACTIVITYRESULTS_GRADE_FORMAT_FRA:
423                                $this->content->text .= $this->activity_format_grade($averagegrade)
424                                    . '/' . $this->activity_format_grade($activity->grademax);
425                            break;
426                            case B_ACTIVITYRESULTS_GRADE_FORMAT_ABS:
427                                $this->content->text .= $this->activity_format_grade($averagegrade);
428                            break;
429                            default:
430                            case B_ACTIVITYRESULTS_GRADE_FORMAT_PCT:
431                                $this->content->text .= $this->activity_format_grade((float)$averagegrade /
432                                        (float)$activity->grademax * 100).'%';
433                            break;
434                        }
435                        $this->content->text .= '</td></tr>';
436                    }
437                    $this->content->text .= '</tbody></table>';
438                }
439            break;
440
441            case SEPARATEGROUPS:
442                // This is going to be just like no-groups mode, only we 'll filter
443                // out the grades from people not in our group.
444                if (!isloggedin()) {
445                    // Not logged in, so show nothing.
446                    return $this->content;
447                }
448
449                $mygroups = groups_get_all_groups($courseid, $USER->id);
450                if (empty($mygroups)) {
451                    // Not member of a group, show nothing.
452                    return $this->content;
453                }
454
455                // Get users from the same groups as me.
456                list($grouptest, $params) = $DB->get_in_or_equal(array_keys($mygroups));
457                $mygroupsusers = $DB->get_records_sql_menu(
458                        'SELECT DISTINCT userid, 1 FROM {groups_members} WHERE groupid ' . $grouptest,
459                        $params);
460
461                // Filter out the grades belonging to other users, and proceed as if there were no groups.
462                foreach ($grades as $key => $grade) {
463                    if (!isset($mygroupsusers[$grade->userid])) {
464                        unset($grades[$key]);
465                    }
466                }
467
468                // No break, fall through to the default case now we have filtered the $grades array.
469            default:
470            case NOGROUPS:
471                // Single user mode.
472                $numbest  = empty($this->config->showbest) ? 0 : min($this->config->showbest, count($grades));
473                $numworst = empty($this->config->showworst) ? 0 : min($this->config->showworst, count($grades) - $numbest);
474
475                // Collect all the usernames we are going to need.
476                $remaining = $numbest;
477                $grade = end($grades);
478                while ($remaining--) {
479                    $best[$grade->userid] = $grade->id;
480                    $grade = prev($grades);
481                }
482
483                $remaining = $numworst;
484                $grade = reset($grades);
485                while ($remaining--) {
486                    $worst[$grade->userid] = $grade->id;
487                    $grade = next($grades);
488                }
489
490                if (empty($best) && empty($worst)) {
491                    // Nothing to show, for some reason...
492                    return $this->content;
493                }
494
495                // Now grab all the users from the database.
496                $userids = array_merge(array_keys($best), array_keys($worst));
497                $fields = array_merge(array('id', 'idnumber'), get_all_user_name_fields());
498                $fields = implode(',', $fields);
499                $users = $DB->get_records_list('user', 'id', $userids, '', $fields);
500
501                // Ready for output!
502                if ($activity->gradetype == GRADE_TYPE_SCALE) {
503                    // We must display the results using scales.
504                    $gradeformat = B_ACTIVITYRESULTS_GRADE_FORMAT_SCALE;
505                    // Preload the scale.
506                    $scale = $this->get_scale($activity->scaleid);
507                } else if (intval(empty($this->config->gradeformat))) {
508                    $gradeformat = B_ACTIVITYRESULTS_GRADE_FORMAT_PCT;
509                } else {
510                    $gradeformat = $this->config->gradeformat;
511                }
512
513                // Generate the header.
514                $this->content->text .= $this->activity_link($activity, $cm);
515
516                $rank = 0;
517                if (!empty($best)) {
518                    $this->content->text .= '<table class="grades"><caption>';
519                    if ($numbest == 1) {
520                        $this->content->text .= get_string('bestgrade', 'block_activity_results');
521                    } else {
522                        $this->content->text .= get_string('bestgrades', 'block_activity_results', $numbest);
523                    }
524                    $this->content->text .= '</caption><colgroup class="number" />';
525                    $this->content->text .= '<colgroup class="name" /><colgroup class="grade" /><tbody>';
526                    foreach ($best as $userid => $gradeid) {
527                        switch ($nameformat) {
528                            case B_ACTIVITYRESULTS_NAME_FORMAT_ID:
529                                $thisname = get_string('user').' '.$users[$userid]->idnumber;
530                            break;
531                            case B_ACTIVITYRESULTS_NAME_FORMAT_ANON:
532                                $thisname = get_string('user');
533                            break;
534                            default:
535                            case B_ACTIVITYRESULTS_NAME_FORMAT_FULL:
536                                if (has_capability('moodle/user:viewdetails', $context)) {
537                                    $thisname = html_writer::link(new moodle_url('/user/view.php',
538                                        array('id' => $userid, 'course' => $courseid)), fullname($users[$userid]));
539                                } else {
540                                    $thisname = fullname($users[$userid]);
541                                }
542                            break;
543                        }
544                        $this->content->text .= '<tr><td>'.(++$rank).'.</td><td>'.$thisname.'</td><td>';
545                        switch ($gradeformat) {
546                            case B_ACTIVITYRESULTS_GRADE_FORMAT_SCALE:
547                                // Round answer up and locate appropriate scale.
548                                $answer = (round($grades[$gradeid]->finalgrade, 0, PHP_ROUND_HALF_UP) - 1);
549                                if (isset($scale[$answer])) {
550                                    $this->content->text .= $scale[$answer];
551                                } else {
552                                    // Value is not in the scale.
553                                    $this->content->text .= get_string('unknown', 'block_activity_results');
554                                }
555                            break;
556                            case B_ACTIVITYRESULTS_GRADE_FORMAT_FRA:
557                                $this->content->text .= $this->activity_format_grade($grades[$gradeid]->finalgrade);
558                                $this->content->text .= '/'.$this->activity_format_grade($activity->grademax);
559                            break;
560                            case B_ACTIVITYRESULTS_GRADE_FORMAT_ABS:
561                                $this->content->text .= $this->activity_format_grade($grades[$gradeid]->finalgrade);
562                            break;
563                            default:
564                            case B_ACTIVITYRESULTS_GRADE_FORMAT_PCT:
565                                if ($activity->grademax) {
566                                    $this->content->text .= $this->activity_format_grade((float)$grades[$gradeid]->finalgrade /
567                                            (float)$activity->grademax * 100).'%';
568                                } else {
569                                    $this->content->text .= '--%';
570                                }
571                            break;
572                        }
573                        $this->content->text .= '</td></tr>';
574                    }
575                    $this->content->text .= '</tbody></table>';
576                }
577
578                $rank = 0;
579                if (!empty($worst)) {
580                    $worst = array_reverse($worst, true);
581                    $this->content->text .= '<table class="grades"><caption>';
582                    if ($numbest == 1) {
583                        $this->content->text .= get_string('worstgrade', 'block_activity_results');
584                    } else {
585                        $this->content->text .= get_string('worstgrades', 'block_activity_results', $numworst);
586                    }
587                    $this->content->text .= '</caption><colgroup class="number" />';
588                    $this->content->text .= '<colgroup class="name" /><colgroup class="grade" /><tbody>';
589                    foreach ($worst as $userid => $gradeid) {
590                        switch ($nameformat) {
591                            case B_ACTIVITYRESULTS_NAME_FORMAT_ID:
592                                $thisname = get_string('user').' '.$users[$userid]->idnumber;
593                            break;
594                            case B_ACTIVITYRESULTS_NAME_FORMAT_ANON:
595                                $thisname = get_string('user');
596                            break;
597                            default:
598                            case B_ACTIVITYRESULTS_NAME_FORMAT_FULL:
599                                if (has_capability('moodle/user:viewdetails', $context)) {
600                                    $thisname = html_writer::link(new moodle_url('/user/view.php',
601                                        array('id' => $userid, 'course' => $courseid)), fullname($users[$userid]));
602                                } else {
603                                    $thisname = fullname($users[$userid]);
604                                }
605                            break;
606                        }
607                        $this->content->text .= '<tr><td>'.(++$rank).'.</td><td>'.$thisname.'</td><td>';
608                        switch ($gradeformat) {
609                            case B_ACTIVITYRESULTS_GRADE_FORMAT_SCALE:
610                                // Round answer up and locate appropriate scale.
611                                $answer = (round($grades[$gradeid]->finalgrade, 0, PHP_ROUND_HALF_UP) - 1);
612                                if (isset($scale[$answer])) {
613                                    $this->content->text .= $scale[$answer];
614                                } else {
615                                    // Value is not in the scale.
616                                    $this->content->text .= get_string('unknown', 'block_activity_results');
617                                }
618                            break;
619                            case B_ACTIVITYRESULTS_GRADE_FORMAT_FRA:
620                                $this->content->text .= $this->activity_format_grade($grades[$gradeid]->finalgrade);
621                                $this->content->text .= '/'.$this->activity_format_grade($activity->grademax);
622                            break;
623                            case B_ACTIVITYRESULTS_GRADE_FORMAT_ABS:
624                                $this->content->text .= $this->activity_format_grade($grades[$gradeid]->finalgrade);
625                            break;
626                            default:
627                            case B_ACTIVITYRESULTS_GRADE_FORMAT_PCT:
628                                if ($activity->grademax) {
629                                    $this->content->text .= $this->activity_format_grade((float)$grades[$gradeid]->finalgrade /
630                                            (float)$activity->grademax * 100).'%';
631                                } else {
632                                    $this->content->text .= '--%';
633                                }
634                            break;
635                        }
636                        $this->content->text .= '</td></tr>';
637                    }
638                    $this->content->text .= '</tbody></table>';
639                }
640            break;
641        }
642
643        return $this->content;
644    }
645
646    /**
647     * Allows the block to be added multiple times to a single page
648     * @return boolean
649     */
650    public function instance_allow_multiple() {
651        return true;
652    }
653
654    /**
655     * Formats the grade to the specified decimal points
656     * @param float $grade
657     * @return string
658     */
659    private function activity_format_grade($grade) {
660        if (is_null($grade)) {
661            return get_string('notyetgraded', 'block_activity_results');
662        }
663        return format_float($grade, $this->config->decimalpoints);
664    }
665
666    /**
667     * Generates the Link to the activity module when displaed outside of the module
668     * @param stdclass $activity
669     * @param stdclass $cm
670     * @return string
671     */
672    private function activity_link($activity, $cm) {
673
674        $o = html_writer::start_tag('h3');
675        $o .= html_writer::link(new moodle_url('/mod/'.$activity->itemmodule.'/view.php',
676        array('id' => $cm->id)), $activity->itemname);
677        $o .= html_writer::end_tag('h3');
678        return $o;
679    }
680
681    /**
682     * Generates a numeric array of scale entries
683     * @param int $scaleid
684     * @return array
685     */
686    private function get_scale($scaleid) {
687        global $DB;
688        $scaletext = $DB->get_field('scale', 'scale', array('id' => $scaleid), IGNORE_MISSING);
689        $scale = explode ( ',', $scaletext);
690        return $scale;
691
692    }
693}
Note: See TracBrowser for help on using the repository browser.