← Back to branch summary

~ubuntu-branches/ubuntu/trusty/moodle/trusty-proposed

« back to all changes in this revision

Viewing changes to lib/grouplib.php

  • Committer: Package Import Robot
  • Author(s): Thijs Kinkhorst
  • Date: 2013-07-19 08:52:46 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20130719085246-yebwditc2exoap2r
Tags: 2.5.1-1
http://bugs.debian.org/429339
http://bugs.debian.org/716972
http://bugs.debian.org/716986
http://bugs.debian.org/717080
http://bugs.debian.org/717108
http://bugs.debian.org/717278
* New upstream version: 2.5.1.
  - Fixes security issues:
    CVE-2013-2242 CVE-2013-2243 CVE-2013-2244 CVE-2013-2245
    CVE-2013-2246
* Depend on apache2 instead of obsolete apache2-mpm-prefork.
* Use packaged libphp-phpmailer (closes: #429339), adodb,
  HTMLPurifier, PclZip.
* Update debconf translations, thanks Salvatore Merone, Pietro Tollot,
  Joe Hansen, Yuri Kozlov, Holger Wansing, Américo Monteiro,
  Adriano Rafael Gomes, victory, Michał Kułach.
  (closes: #716972, #716986, #717080, #717108, #717278)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/grouplib.php
18
18
/**
19
19
 * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
20
20
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
21
 
 * @package    core
22
 
 * @subpackage group
 
21
 * @package    core_group
23
22
 */
24
23
 
25
24
defined('MOODLE_INTERNAL') || die();
43
42
/**
44
43
 * Determines if a group with a given groupid exists.
45
44
 *
46
 
 * @global object
 
45
 * @category group
47
46
 * @param int $groupid The groupid to check for
48
 
 * @return boolean True if the group exists, false otherwise or if an error
 
47
 * @return bool True if the group exists, false otherwise or if an error
49
48
 * occurred.
50
49
 */
51
50
function groups_group_exists($groupid) {
56
55
/**
57
56
 * Gets the name of a group with a specified id
58
57
 *
59
 
 * @global object
 
58
 * @category group
60
59
 * @param int $groupid The id of the group
61
60
 * @return string The name of the group
62
61
 */
68
67
/**
69
68
 * Gets the name of a grouping with a specified id
70
69
 *
71
 
 * @global object
 
70
 * @category group
72
71
 * @param int $groupingid The id of the grouping
73
72
 * @return string The name of the grouping
74
73
 */
81
80
 * Returns the groupid of a group with the name specified for the course.
82
81
 * Group names should be unique in course
83
82
 *
84
 
 * @global object
 
83
 * @category group
85
84
 * @param int $courseid The id of the course
86
85
 * @param string $name name of group (without magic quotes)
87
86
 * @return int $groupid
88
87
 */
89
88
function groups_get_group_by_name($courseid, $name) {
90
 
    global $DB;
91
 
    if ($groups = $DB->get_records('groups', array('courseid'=>$courseid, 'name'=>$name))) {
92
 
        return key($groups);
 
89
    $data = groups_get_course_data($courseid);
 
90
    foreach ($data->groups as $group) {
 
91
        if ($group->name == $name) {
 
92
            return $group->id;
 
93
        }
 
94
    }
 
95
    return false;
 
96
}
 
97
 
 
98
/**
 
99
 * Returns the groupid of a group with the idnumber specified for the course.
 
100
 * Group idnumbers should be unique within course
 
101
 *
 
102
 * @category group
 
103
 * @param int $courseid The id of the course
 
104
 * @param string $idnumber idnumber of group
 
105
 * @return group object
 
106
 */
 
107
function groups_get_group_by_idnumber($courseid, $idnumber) {
 
108
    if (empty($idnumber)) {
 
109
        return false;
 
110
    }
 
111
    $data = groups_get_course_data($courseid);
 
112
    foreach ($data->groups as $group) {
 
113
        if ($group->idnumber == $idnumber) {
 
114
            return $group;
 
115
        }
93
116
    }
94
117
    return false;
95
118
}
98
121
 * Returns the groupingid of a grouping with the name specified for the course.
99
122
 * Grouping names should be unique in course
100
123
 *
101
 
 * @global object
 
124
 * @category group
102
125
 * @param int $courseid The id of the course
103
126
 * @param string $name name of group (without magic quotes)
104
127
 * @return int $groupid
105
128
 */
106
129
function groups_get_grouping_by_name($courseid, $name) {
107
 
    global $DB;
108
 
    if ($groupings = $DB->get_records('groupings', array('courseid'=>$courseid, 'name'=>$name))) {
109
 
        return key($groupings);
 
130
    $data = groups_get_course_data($courseid);
 
131
    foreach ($data->groupings as $grouping) {
 
132
        if ($grouping->name == $name) {
 
133
            return $grouping->id;
 
134
        }
 
135
    }
 
136
    return false;
 
137
}
 
138
 
 
139
/**
 
140
 * Returns the groupingid of a grouping with the idnumber specified for the course.
 
141
 * Grouping names should be unique within course
 
142
 *
 
143
 * @category group
 
144
 * @param int $courseid The id of the course
 
145
 * @param string $idnumber idnumber of the group
 
146
 * @return grouping object
 
147
 */
 
148
function groups_get_grouping_by_idnumber($courseid, $idnumber) {
 
149
    if (empty($idnumber)) {
 
150
        return false;
 
151
    }
 
152
    $data = groups_get_course_data($courseid);
 
153
    foreach ($data->groupings as $grouping) {
 
154
        if ($grouping->idnumber == $idnumber) {
 
155
            return $grouping;
 
156
        }
110
157
    }
111
158
    return false;
112
159
}
114
161
/**
115
162
 * Get the group object
116
163
 *
 
164
 * @category group
117
165
 * @param int $groupid ID of the group.
118
 
 * @return object group object
 
166
 * @param string $fields (default is all fields)
 
167
 * @param int $strictness (IGNORE_MISSING - default)
 
168
 * @return stdGlass group object
119
169
 */
120
170
function groups_get_group($groupid, $fields='*', $strictness=IGNORE_MISSING) {
121
171
    global $DB;
125
175
/**
126
176
 * Get the grouping object
127
177
 *
 
178
 * @category group
128
179
 * @param int $groupingid ID of the group.
129
180
 * @param string $fields
130
 
 * @return object group object
 
181
 * @param int $strictness (IGNORE_MISSING - default)
 
182
 * @return stdClass group object
131
183
 */
132
184
function groups_get_grouping($groupingid, $fields='*', $strictness=IGNORE_MISSING) {
133
185
    global $DB;
137
189
/**
138
190
 * Gets array of all groups in a specified course.
139
191
 *
 
192
 * @category group
140
193
 * @param int $courseid The id of the course.
141
194
 * @param mixed $userid optional user id or array of ids, returns only groups of the user.
142
195
 * @param int $groupingid optional returns only groups in the specified grouping.
146
199
function groups_get_all_groups($courseid, $userid=0, $groupingid=0, $fields='g.*') {
147
200
    global $DB;
148
201
 
 
202
    // We need to check that we each field in the fields list belongs to the group table and that it has not being
 
203
    // aliased. If its something else we need to avoid the cache and run the query as who knows whats going on.
 
204
    $knownfields = true;
 
205
    if ($fields !== 'g.*') {
 
206
        $fieldbits = explode(',', $fields);
 
207
        foreach ($fieldbits as $bit) {
 
208
            $bit = trim($bit);
 
209
            if (strpos($bit, 'g.') !== 0 or stripos($bit, ' AS ') !== false) {
 
210
                $knownfields = false;
 
211
                break;
 
212
            }
 
213
        }
 
214
    }
 
215
 
 
216
    if (empty($userid) && $knownfields) {
 
217
        // We can use the cache.
 
218
        $data = groups_get_course_data($courseid);
 
219
        if (empty($groupingid)) {
 
220
            // All groups.. Easy!
 
221
            $groups = $data->groups;
 
222
        } else {
 
223
            $groups = array();
 
224
            foreach ($data->mappings as $mapping) {
 
225
                if ($mapping->groupingid != $groupingid) {
 
226
                    continue;
 
227
                }
 
228
                if (isset($data->groups[$mapping->groupid])) {
 
229
                    $groups[$mapping->groupid] = $data->groups[$mapping->groupid];
 
230
                }
 
231
            }
 
232
        }
 
233
        // Yay! We could use the cache. One more query saved.
 
234
        return $groups;
 
235
    }
 
236
 
 
237
 
149
238
    if (empty($userid)) {
150
239
        $userfrom  = "";
151
240
        $userwhere = "";
174
263
                               ORDER BY name ASC", $params);
175
264
}
176
265
 
 
266
 
 
267
/**
 
268
 * Gets array of all groups in current user.
 
269
 *
 
270
 * @since Moodle 2.5
 
271
 * @category group
 
272
 * @return array Returns an array of the group objects.
 
273
 */
 
274
function groups_get_my_groups() {
 
275
    global $DB, $USER;
 
276
    return $DB->get_records_sql("SELECT *
 
277
                                   FROM {groups_members} gm
 
278
                                   JOIN {groups} g
 
279
                                    ON g.id = gm.groupid
 
280
                                  WHERE gm.userid = ?
 
281
                                   ORDER BY name ASC", array($USER->id));
 
282
}
 
283
 
177
284
/**
178
285
 * Returns info about user's groups in course.
179
286
 *
 
287
 * @category group
180
288
 * @param int $courseid
181
289
 * @param int $userid $USER if not specified
182
290
 * @return array Array[groupingid][groupid] including grouping id 0 which means all groups
223
331
}
224
332
 
225
333
/**
226
 
 * Gets array of all groupings in a specified course.
 
334
 * Gets an array of all groupings in a specified course. This value is cached
 
335
 * for a single course (so you can call it repeatedly for the same course
 
336
 * without a performance penalty).
227
337
 *
228
 
 * @global object
229
 
 * @global object
230
 
 * @param int $courseid return only groupings in this with this courseid
231
 
 * @return array|bool Returns an array of the grouping objects or false if no records
232
 
 * or an error occurred.
 
338
 * @category group
 
339
 * @param int $courseid return all groupings from course with this courseid
 
340
 * @return array Returns an array of the grouping objects (empty if none)
233
341
 */
234
342
function groups_get_all_groupings($courseid) {
235
 
    global $CFG, $DB;
236
 
 
237
 
    return $DB->get_records_sql("SELECT *
238
 
                                   FROM {groupings}
239
 
                                  WHERE courseid = ?
240
 
                               ORDER BY name ASC", array($courseid));
 
343
    $data = groups_get_course_data($courseid);
 
344
    return $data->groupings;
241
345
}
242
346
 
243
 
 
244
 
 
245
347
/**
246
348
 * Determines if the user is a member of the given group.
247
349
 *
248
350
 * If $userid is null, use the global object.
249
351
 *
250
 
 * @global object
251
 
 * @global object
 
352
 * @category group
252
353
 * @param int $groupid The group to check for membership.
253
354
 * @param int $userid The user to check against the group.
254
 
 * @return boolean True if the user is a member, false otherwise.
 
355
 * @return bool True if the user is a member, false otherwise.
255
356
 */
256
357
function groups_is_member($groupid, $userid=null) {
257
358
    global $USER, $DB;
266
367
/**
267
368
 * Determines if current or specified is member of any active group in activity
268
369
 *
269
 
 * @global object
270
 
 * @global object
271
 
 * @global object
 
370
 * @category group
272
371
 * @staticvar array $cache
273
 
 * @param object $cm coruse module object
274
 
 * @param int $userid id of user, null menas $USER->id
275
 
 * @return booelan true if user member of at least one group used in activity
 
372
 * @param cm_info $cm course module object
 
373
 * @param int $userid id of user, null means $USER->id
 
374
 * @return bool true if user member of at least one group used in activity
276
375
 */
277
376
function groups_has_membership($cm, $userid=null) {
278
377
    global $CFG, $USER, $DB;
311
410
/**
312
411
 * Returns the users in the specified group.
313
412
 *
314
 
 * @global object
 
413
 * @category group
315
414
 * @param int $groupid The groupid to get the users for
316
415
 * @param int $fields The fields to return
317
416
 * @param int $sort optional sorting of returned users
331
430
/**
332
431
 * Returns the users in the specified grouping.
333
432
 *
334
 
 * @global object
 
433
 * @category group
335
434
 * @param int $groupingid The groupingid to get the users for
336
 
 * @param int $fields The fields to return
337
 
 * @param int $sort optional sorting of returned users
 
435
 * @param string $fields The fields to return
 
436
 * @param string $sort optional sorting of returned users
338
437
 * @return array|bool Returns an array of the users for the specified
339
438
 * group or false if no users or an error returned.
340
439
 */
352
451
/**
353
452
 * Returns effective groupmode used in course
354
453
 *
355
 
 * @return integer group mode
 
454
 * @category group
 
455
 * @param stdClass $course course object.
 
456
 * @return int group mode
356
457
 */
357
458
function groups_get_course_groupmode($course) {
358
459
    return $course->groupmode;
362
463
 * Returns effective groupmode used in activity, course setting
363
464
 * overrides activity setting if groupmodeforce enabled.
364
465
 *
365
 
 * @global object
366
 
 * @global object
367
 
 * @param object $cm the course module object. Only the ->course and ->groupmode need to be set.
368
 
 * @param object $course object optional course object to improve perf
369
 
 * @return integer group mode
 
466
 * @category group
 
467
 * @param cm_info $cm the course module object. Only the ->course and ->groupmode need to be set.
 
468
 * @param stdClass $course object optional course object to improve perf
 
469
 * @return int group mode
370
470
 */
371
471
function groups_get_activity_groupmode($cm, $course=null) {
372
472
    global $COURSE, $DB;
388
488
/**
389
489
 * Print group menu selector for course level.
390
490
 *
 
491
 * @category group
391
492
 * @param stdClass $course course object
392
 
 * @param string|moodle_url $urlroot return address
393
 
 * @param boolean $return return as string instead of printing
 
493
 * @param mixed $urlroot return address. Accepts either a string or a moodle_url
 
494
 * @param bool $return return as string instead of printing
394
495
 * @return mixed void or string depending on $return param
395
496
 */
396
497
function groups_print_course_menu($course, $urlroot, $return=false) {
404
505
        }
405
506
    }
406
507
 
407
 
    $context = get_context_instance(CONTEXT_COURSE, $course->id);
 
508
    $context = context_course::instance($course->id);
408
509
    $aag = has_capability('moodle/site:accessallgroups', $context);
409
510
 
410
511
    if ($groupmode == VISIBLEGROUPS or $aag) {
459
560
/**
460
561
 * Print group menu selector for activity.
461
562
 *
 
563
 * @category group
462
564
 * @param stdClass $cm course module object
463
565
 * @param string|moodle_url $urlroot return address that users get to if they choose an option;
464
566
 *   should include any parameters needed, e.g. "$CFG->wwwroot/mod/forum/view.php?id=34"
465
 
 * @param boolean $return return as string instead of printing
466
 
 * @param boolean $hideallparticipants If true, this prevents the 'All participants'
 
567
 * @param bool $return return as string instead of printing
 
568
 * @param bool $hideallparticipants If true, this prevents the 'All participants'
467
569
 *   option from appearing in cases where it normally would. This is intended for
468
570
 *   use only by activities that cannot display all groups together. (Note that
469
571
 *   selecting this option does not prevent groups_get_activity_group from
496
598
        }
497
599
    }
498
600
 
499
 
    $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 
601
    $context = context_module::instance($cm->id);
500
602
    $aag = has_capability('moodle/site:accessallgroups', $context);
501
603
 
502
604
    if ($groupmode == VISIBLEGROUPS or $aag) {
551
653
/**
552
654
 * Returns group active in course, changes the group by default if 'group' page param present
553
655
 *
 
656
 * @category group
554
657
 * @param stdClass $course course bject
555
 
 * @param boolean $update change active group if group param submitted
 
658
 * @param bool $update change active group if group param submitted
556
659
 * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_course_menu())
557
660
 * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
558
661
 */
564
667
        return false;
565
668
    }
566
669
 
567
 
    $context = get_context_instance(CONTEXT_COURSE, $course->id);
 
670
    $context = context_course::instance($course->id);
568
671
    if (has_capability('moodle/site:accessallgroups', $context)) {
569
672
        $groupmode = 'aag';
570
673
    }
602
705
/**
603
706
 * Returns group active in activity, changes the group by default if 'group' page param present
604
707
 *
 
708
 * @category group
605
709
 * @param stdClass $cm course module object
606
 
 * @param boolean $update change active group if group param submitted
 
710
 * @param bool $update change active group if group param submitted
607
711
 * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_activity_menu())
608
712
 * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
609
713
 */
615
719
        return false;
616
720
    }
617
721
 
618
 
    $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 
722
    $context = context_module::instance($cm->id);
619
723
    if (has_capability('moodle/site:accessallgroups', $context)) {
620
724
        $groupmode = 'aag';
621
725
    }
654
758
 * Gets a list of groups that the user is allowed to access within the
655
759
 * specified activity.
656
760
 *
657
 
 * @param object $cm Course-module
 
761
 * @category group
 
762
 * @param stdClass $cm Course-module
658
763
 * @param int $userid User ID (defaults to current user)
659
764
 * @return array An array of group objects, or false if none
660
765
 */
670
775
 
671
776
    // If visible groups mode, or user has the accessallgroups capability,
672
777
    // then they can access all groups for the activity...
673
 
    $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 
778
    $context = context_module::instance($cm->id);
674
779
    if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context)) {
675
780
        return groups_get_all_groups($cm->course, 0, $cm->groupingid);
676
781
    } else {
684
789
 *
685
790
 * $USER If $userid is null, use the global object.
686
791
 *
687
 
 * @param int $cm The course module
 
792
 * @category group
 
793
 * @param stdClass $cm The course module
688
794
 * @param int $userid The user to check against the group.
689
 
 * @return boolean True if the user can view the course module, false otherwise.
 
795
 * @return bool True if the user can view the course module, false otherwise.
690
796
 */
691
797
function groups_course_module_visible($cm, $userid=null) {
692
798
    global $CFG, $USER;
700
806
    if (empty($cm->groupmembersonly)) {
701
807
        return true;
702
808
    }
703
 
    if (has_capability('moodle/site:accessallgroups', get_context_instance(CONTEXT_MODULE, $cm->id), $userid) or groups_has_membership($cm, $userid)) {
 
809
    if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id), $userid) or groups_has_membership($cm, $userid)) {
704
810
        return true;
705
811
    }
706
812
    return false;
709
815
/**
710
816
 * Internal method, sets up $SESSION->activegroup and verifies previous value
711
817
 *
712
 
 * @private
713
818
 * @param int $courseid
714
819
 * @param int|string $groupmode SEPARATEGROUPS, VISIBLEGROUPS or 'aag' (access all groups)
715
820
 * @param int $groupingid 0 means all groups
716
 
 * @param all $allowedgroups list of groups user can see
717
 
 * @return void
 
821
 * @param array $allowedgroups list of groups user can see
718
822
 */
719
823
function _group_verify_activegroup($courseid, $groupmode, $groupingid, array $allowedgroups) {
720
824
    global $SESSION, $USER;
755
859
            $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0;
756
860
        }
757
861
    }
758
 
}
 
 
b'\\ No newline at end of file'
 
862
}
 
863
 
 
864
/**
 
865
 * Caches group data for a particular course to speed up subsequent requests.
 
866
 *
 
867
 * @param int $courseid The course id to cache data for.
 
868
 * @param cache $cache The cache if it has already been initialised. If not a new one will be created.
 
869
 * @return stdClass A data object containing groups, groupings, and mappings.
 
870
 */
 
871
function groups_cache_groupdata($courseid, cache $cache = null) {
 
872
    global $DB;
 
873
 
 
874
    if ($cache === null) {
 
875
        // Initialise a cache if we wern't given one.
 
876
        $cache = cache::make('core', 'groupdata');
 
877
    }
 
878
 
 
879
    // Get the groups that belong to the course.
 
880
    $groups = $DB->get_records('groups', array('courseid' => $courseid), 'name ASC');
 
881
    // Get the groupings that belong to the course.
 
882
    $groupings = $DB->get_records('groupings', array('courseid' => $courseid), 'name ASC');
 
883
 
 
884
    if (!is_array($groups)) {
 
885
        $groups = array();
 
886
    }
 
887
 
 
888
    if (!is_array($groupings)) {
 
889
        $groupings = array();
 
890
    }
 
891
 
 
892
    if (!empty($groupings)) {
 
893
        // Finally get the mappings between the two.
 
894
        $mappings = $DB->get_records_list('groupings_groups', 'groupingid', array_keys($groupings), '', 'id,groupingid,groupid');
 
895
    } else {
 
896
        $mappings = array();
 
897
    }
 
898
 
 
899
    // Prepare the data array.
 
900
    $data = new stdClass;
 
901
    $data->groups = $groups;
 
902
    $data->groupings = $groupings;
 
903
    $data->mappings = $mappings;
 
904
    // Cache the data.
 
905
    $cache->set($courseid, $data);
 
906
    // Finally return it so it can be used if desired.
 
907
    return $data;
 
908
}
 
909
 
 
910
/**
 
911
 * Gets group data for a course.
 
912
 *
 
913
 * This returns an object with the following properties:
 
914
 *   - groups : An array of all the groups in the course.
 
915
 *   - groupings : An array of all the groupings within the course.
 
916
 *   - mappings : An array of group to grouping mappings.
 
917
 *
 
918
 * @param int $courseid The course id to get data for.
 
919
 * @param cache $cache The cache if it has already been initialised. If not a new one will be created.
 
920
 * @return stdClass
 
921
 */
 
922
function groups_get_course_data($courseid, cache $cache = null) {
 
923
    if ($cache === null) {
 
924
        // Initialise a cache if we wern't given one.
 
925
        $cache = cache::make('core', 'groupdata');
 
926
    }
 
927
    // Try to retrieve it from the cache.
 
928
    $data = $cache->get($courseid);
 
929
    if ($data === false) {
 
930
        $data = groups_cache_groupdata($courseid, $cache);
 
931
    }
 
932
    return $data;
 
933
}