← Back to branch summary

~ubuntu-branches/ubuntu/utopic/moodle/utopic

« back to all changes in this revision

Viewing changes to group/lib.php

  • Committer: Package Import Robot
  • Author(s): Thijs Kinkhorst
  • Date: 2014-05-12 16:10:38 UTC
  • mfrom: (36.1.3 sid)
  • Revision ID: package-import@ubuntu.com-20140512161038-puyqf65k4e0s8ytz
Tags: 2.6.3-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
group/lib.php
64
64
        $group = $DB->get_record('groups', array('id'=>$groupid), '*', MUST_EXIST);
65
65
    }
66
66
 
67
 
    //check if the user a participant of the group course
68
 
    if (!is_enrolled(context_course::instance($group->courseid), $userid)) {
 
67
    // Check if the user a participant of the group course.
 
68
    $context = context_course::instance($group->courseid);
 
69
    if (!is_enrolled($context, $userid)) {
69
70
        return false;
70
71
    }
71
72
 
82
83
 
83
84
    // Check the component exists if specified
84
85
    if (!empty($component)) {
85
 
        $dir = get_component_directory($component);
 
86
        $dir = core_component::get_component_directory($component);
86
87
        if ($dir && is_dir($dir)) {
87
88
            // Component exists and can be used
88
89
            $member->component = $component;
99
100
 
100
101
    $DB->insert_record('groups_members', $member);
101
102
 
102
 
    //update group info
 
103
    // Update group info, and group object.
103
104
    $DB->set_field('groups', 'timemodified', $member->timeadded, array('id'=>$groupid));
 
105
    $group->timemodified = $member->timeadded;
104
106
 
105
 
    //trigger groups events
106
 
    $eventdata = new stdClass();
107
 
    $eventdata->groupid = $groupid;
108
 
    $eventdata->userid  = $userid;
109
 
    $eventdata->component = $member->component;
110
 
    $eventdata->itemid = $member->itemid;
111
 
    events_trigger('groups_member_added', $eventdata);
 
107
    // Trigger group event.
 
108
    $params = array(
 
109
        'context' => $context,
 
110
        'objectid' => $groupid,
 
111
        'relateduserid' => $userid,
 
112
        'other' => array(
 
113
            'component' => $member->component,
 
114
            'itemid' => $member->itemid
 
115
        )
 
116
    );
 
117
    $event = \core\event\group_member_added::create($params);
 
118
    $event->add_record_snapshot('groups', $group);
 
119
    $event->trigger();
112
120
 
113
121
    return true;
114
122
}
174
182
 
175
183
    if (is_object($userorid)) {
176
184
        $userid = $userorid->id;
177
 
        $user   = $userorid;
178
185
    } else {
179
186
        $userid = $userorid;
180
 
        $user = $DB->get_record('user', array('id'=>$userid), '*', MUST_EXIST);
181
187
    }
182
188
 
183
189
    if (is_object($grouporid)) {
194
200
 
195
201
    $DB->delete_records('groups_members', array('groupid'=>$groupid, 'userid'=>$userid));
196
202
 
197
 
    //update group info
198
 
    $DB->set_field('groups', 'timemodified', time(), array('id'=>$groupid));
 
203
    // Update group info.
 
204
    $time = time();
 
205
    $DB->set_field('groups', 'timemodified', $time, array('id' => $groupid));
 
206
    $group->timemodified = $time;
199
207
 
200
 
    //trigger groups events
201
 
    $eventdata = new stdClass();
202
 
    $eventdata->groupid = $groupid;
203
 
    $eventdata->userid  = $userid;
204
 
    events_trigger('groups_member_removed', $eventdata);
 
208
    // Trigger group event.
 
209
    $params = array(
 
210
        'context' => context_course::instance($group->courseid),
 
211
        'objectid' => $groupid,
 
212
        'relateduserid' => $userid
 
213
    );
 
214
    $event = \core\event\group_member_removed::create($params);
 
215
    $event->add_record_snapshot('groups', $group);
 
216
    $event->trigger();
205
217
 
206
218
    return true;
207
219
}
257
269
    // Invalidate the grouping cache for the course
258
270
    cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($course->id));
259
271
 
260
 
    //trigger groups events
261
 
    events_trigger('groups_group_created', $group);
 
272
    // Trigger group event.
 
273
    $params = array(
 
274
        'context' => $context,
 
275
        'objectid' => $group->id
 
276
    );
 
277
    $event = \core\event\group_created::create($params);
 
278
    $event->add_record_snapshot('groups', $group);
 
279
    $event->trigger();
262
280
 
263
281
    return $group->id;
264
282
}
289
307
    }
290
308
 
291
309
    $id = $DB->insert_record('groupings', $data);
292
 
 
293
 
    //trigger groups events
294
310
    $data->id = $id;
295
311
 
296
312
    if ($editoroptions !== null) {
304
320
    // Invalidate the grouping cache for the course
305
321
    cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($data->courseid));
306
322
 
307
 
    events_trigger('groups_grouping_created', $data);
 
323
    // Trigger group event.
 
324
    $params = array(
 
325
        'context' => context_course::instance($data->courseid),
 
326
        'objectid' => $id
 
327
    );
 
328
    $event = \core\event\grouping_created::create($params);
 
329
    $event->trigger();
308
330
 
309
331
    return $id;
310
332
}
376
398
        groups_update_group_icon($group, $data, $editform);
377
399
    }
378
400
 
379
 
    //trigger groups events
380
 
    events_trigger('groups_group_updated', $group);
381
 
 
 
401
    // Trigger group event.
 
402
    $params = array(
 
403
        'context' => $context,
 
404
        'objectid' => $group->id
 
405
    );
 
406
    $event = \core\event\group_updated::create($params);
 
407
    $event->add_record_snapshot('groups', $group);
 
408
    $event->trigger();
382
409
 
383
410
    return true;
384
411
}
408
435
    // Invalidate the group data.
409
436
    cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($data->courseid));
410
437
 
411
 
    //trigger groups events
412
 
    events_trigger('groups_grouping_updated', $data);
 
438
    // Trigger group event.
 
439
    $params = array(
 
440
        'context' => context_course::instance($data->courseid),
 
441
        'objectid' => $data->id
 
442
    );
 
443
    $event = \core\event\grouping_updated::create($params);
 
444
    $event->trigger();
413
445
 
414
446
    return true;
415
447
}
454
486
    // Invalidate the grouping cache for the course
455
487
    cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($group->courseid));
456
488
 
457
 
    //trigger groups events
458
 
    events_trigger('groups_group_deleted', $group);
 
489
    // Trigger group event.
 
490
    $params = array(
 
491
        'context' => $context,
 
492
        'objectid' => $groupid
 
493
    );
 
494
    $event = \core\event\group_deleted::create($params);
 
495
    $event->add_record_snapshot('groups', $group);
 
496
    $event->trigger();
459
497
 
460
498
    return true;
461
499
}
499
537
    // Invalidate the grouping cache for the course
500
538
    cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($grouping->courseid));
501
539
 
502
 
    //trigger groups events
503
 
    events_trigger('groups_grouping_deleted', $grouping);
 
540
    // Trigger group event.
 
541
    $params = array(
 
542
        'context' => $context,
 
543
        'objectid' => $groupingid
 
544
    );
 
545
    $event = \core\event\grouping_deleted::create($params);
 
546
    $event->add_record_snapshot('groupings', $grouping);
 
547
    $event->trigger();
504
548
 
505
549
    return true;
506
550
}
521
565
        return false;
522
566
    }
523
567
 
524
 
    $params = array('courseid'=>$courseid);
 
568
    // Select * so that the function groups_remove_member() gets the whole record.
 
569
    $groups = $DB->get_recordset('groups', array('courseid' => $courseid));
 
570
    foreach ($groups as $group) {
 
571
        if ($userid) {
 
572
            $userids = array($userid);
 
573
        } else {
 
574
            $userids = $DB->get_fieldset_select('groups_members', 'userid', 'groupid = :groupid', array('groupid' => $group->id));
 
575
        }
525
576
 
526
 
    if ($userid) {
527
 
        $usersql = "AND userid = :userid";
528
 
        $params['userid'] = $userid;
529
 
    } else {
530
 
        $usersql = "";
 
577
        foreach ($userids as $id) {
 
578
            groups_remove_member($group, $id);
 
579
        }
531
580
    }
532
581
 
533
 
    $groupssql = "SELECT id FROM {groups} g WHERE g.courseid = :courseid";
534
 
    $DB->delete_records_select('groups_members', "groupid IN ($groupssql) $usersql", $params);
535
 
 
536
 
    //trigger groups events
 
582
    // TODO MDL-41312 Remove events_trigger_legacy('groups_members_removed').
 
583
    // This event is kept here for backwards compatibility, because it cannot be
 
584
    // translated to a new event as it is wrong.
537
585
    $eventdata = new stdClass();
538
586
    $eventdata->courseid = $courseid;
539
587
    $eventdata->userid   = $userid;
540
 
    events_trigger('groups_members_removed', $eventdata);
 
588
    events_trigger_legacy('groups_members_removed', $eventdata);
541
589
 
542
590
    if ($showfeedback) {
543
591
        echo $OUTPUT->notification(get_string('deleted').' - '.get_string('groupmembers', 'group'), 'notifysuccess');
557
605
    global $DB, $OUTPUT;
558
606
 
559
607
    $groupssql = "SELECT id FROM {groups} g WHERE g.courseid = ?";
560
 
    $DB->delete_records_select('groupings_groups', "groupid IN ($groupssql)", array($courseid));
 
608
    $results = $DB->get_recordset_select('groupings_groups', "groupid IN ($groupssql)",
 
609
        array($courseid), '', 'groupid, groupingid');
 
610
 
 
611
    foreach ($results as $result) {
 
612
        groups_unassign_grouping($result->groupingid, $result->groupid, false);
 
613
    }
561
614
 
562
615
    // Invalidate the grouping cache for the course
563
616
    cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($courseid));
564
617
 
565
 
    //trigger groups events
566
 
    events_trigger('groups_groupings_groups_removed', $courseid);
 
618
    // TODO MDL-41312 Remove events_trigger_legacy('groups_groupings_groups_removed').
 
619
    // This event is kept here for backwards compatibility, because it cannot be
 
620
    // translated to a new event as it is wrong.
 
621
    events_trigger_legacy('groups_groupings_groups_removed', $courseid);
567
622
 
568
623
    // no need to show any feedback here - we delete usually first groupings and then groups
569
624
 
580
635
function groups_delete_groups($courseid, $showfeedback=false) {
581
636
    global $CFG, $DB, $OUTPUT;
582
637
 
583
 
    // delete any uses of groups
584
 
    // Any associated files are deleted as part of groups_delete_groupings_groups
585
 
    groups_delete_groupings_groups($courseid, $showfeedback);
586
 
    groups_delete_group_members($courseid, 0, $showfeedback);
587
 
 
588
 
    // delete group pictures and descriptions
589
 
    $context = context_course::instance($courseid);
590
 
    $fs = get_file_storage();
591
 
    $fs->delete_area_files($context->id, 'group');
592
 
 
593
 
    // delete group calendar events
594
 
    $groupssql = "SELECT id FROM {groups} g WHERE g.courseid = ?";
595
 
    $DB->delete_records_select('event', "groupid IN ($groupssql)", array($courseid));
596
 
 
597
 
    $context = context_course::instance($courseid);
598
 
    $fs = get_file_storage();
599
 
    $fs->delete_area_files($context->id, 'group');
600
 
 
601
 
    $DB->delete_records('groups', array('courseid'=>$courseid));
 
638
    $groups = $DB->get_recordset('groups', array('courseid' => $courseid));
 
639
    foreach ($groups as $group) {
 
640
        groups_delete_group($group);
 
641
    }
602
642
 
603
643
    // Invalidate the grouping cache for the course
604
644
    cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($courseid));
605
645
 
606
 
    // trigger groups events
607
 
    events_trigger('groups_groups_deleted', $courseid);
 
646
    // TODO MDL-41312 Remove events_trigger_legacy('groups_groups_deleted').
 
647
    // This event is kept here for backwards compatibility, because it cannot be
 
648
    // translated to a new event as it is wrong.
 
649
    events_trigger_legacy('groups_groups_deleted', $courseid);
608
650
 
609
651
    if ($showfeedback) {
610
652
        echo $OUTPUT->notification(get_string('deleted').' - '.get_string('groups', 'group'), 'notifysuccess');
623
665
function groups_delete_groupings($courseid, $showfeedback=false) {
624
666
    global $DB, $OUTPUT;
625
667
 
626
 
    // delete any uses of groupings
627
 
    $sql = "DELETE FROM {groupings_groups}
628
 
             WHERE groupingid in (SELECT id FROM {groupings} g WHERE g.courseid = ?)";
629
 
    $DB->execute($sql, array($courseid));
630
 
 
631
 
    // remove the default groupingid from course
632
 
    $DB->set_field('course', 'defaultgroupingid', 0, array('id'=>$courseid));
633
 
    // remove the groupingid from all course modules
634
 
    $DB->set_field('course_modules', 'groupingid', 0, array('course'=>$courseid));
635
 
 
636
 
    // Delete all files associated with groupings for this course
637
 
    $context = context_course::instance($courseid);
638
 
    $fs = get_file_storage();
639
 
    $fs->delete_area_files($context->id, 'grouping');
640
 
 
641
 
    $DB->delete_records('groupings', array('courseid'=>$courseid));
642
 
 
643
 
    // Invalidate the grouping cache for the course
 
668
    $groupings = $DB->get_recordset_select('groupings', 'courseid = ?', array($courseid));
 
669
    foreach ($groupings as $grouping) {
 
670
        groups_delete_grouping($grouping);
 
671
    }
 
672
 
 
673
    // Invalidate the grouping cache for the course.
644
674
    cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($courseid));
645
675
 
646
 
    // trigger groups events
647
 
    events_trigger('groups_groupings_deleted', $courseid);
 
676
    // TODO MDL-41312 Remove events_trigger_legacy('groups_groupings_deleted').
 
677
    // This event is kept here for backwards compatibility, because it cannot be
 
678
    // translated to a new event as it is wrong.
 
679
    events_trigger_legacy('groups_groupings_deleted', $courseid);
648
680
 
649
681
    if ($showfeedback) {
650
682
        echo $OUTPUT->notification(get_string('deleted').' - '.get_string('groupings', 'group'), 'notifysuccess');
684
716
 
685
717
    $context = context_course::instance($courseid);
686
718
 
687
 
    // we are looking for all users with this role assigned in this context or higher
688
 
    $listofcontexts = get_related_contexts_string($context);
689
 
 
690
719
    list($esql, $params) = get_enrolled_sql($context);
691
720
 
692
721
    if ($roleid) {
693
 
        $params['roleid'] = $roleid;
 
722
        // We are looking for all users with this role assigned in this context or higher.
 
723
        list($relatedctxsql, $relatedctxparams) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'relatedctx');
 
724
 
 
725
        $params = array_merge($params, $relatedctxparams, array('roleid' => $roleid));
694
726
        $where = "WHERE u.id IN (SELECT userid
695
727
                                   FROM {role_assignments}
696
 
                                  WHERE roleid = :roleid AND contextid $listofcontexts)";
 
728
                                  WHERE roleid = :roleid AND contextid $relatedctxsql)";
697
729
    } else {
698
730
        $where = "";
699
731
    }
705
737
        $cohortjoin = "";
706
738
    }
707
739
 
708
 
    $sql = "SELECT u.id, u.username, u.firstname, u.lastname, u.idnumber
 
740
    $allusernamefields = get_all_user_name_fields(true, 'u');
 
741
    $sql = "SELECT u.id, u.username, $allusernamefields, u.idnumber
709
742
              FROM {user} u
710
743
              JOIN ($esql) e ON e.id = u.id
711
744
       $cohortjoin
812
845
 */
813
846
function groups_get_members_by_role($groupid, $courseid, $fields='u.*',
814
847
        $sort=null, $extrawheretest='', $whereorsortparams=array()) {
815
 
    global $CFG, $DB;
 
848
    global $DB;
816
849
 
817
850
    // Retrieve information about all users and their roles on the course or
818
851
    // parent ('related') contexts
819
852
    $context = context_course::instance($courseid);
820
853
 
 
854
    // We are looking for all users with this role assigned in this context or higher.
 
855
    list($relatedctxsql, $relatedctxparams) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'relatedctx');
 
856
 
821
857
    if ($extrawheretest) {
822
858
        $extrawheretest = ' AND ' . $extrawheretest;
823
859
    }
830
866
    $sql = "SELECT r.id AS roleid, u.id AS userid, $fields
831
867
              FROM {groups_members} gm
832
868
              JOIN {user} u ON u.id = gm.userid
833
 
         LEFT JOIN {role_assignments} ra ON (ra.userid = u.id AND ra.contextid ".get_related_contexts_string($context).")
 
869
         LEFT JOIN {role_assignments} ra ON (ra.userid = u.id AND ra.contextid $relatedctxsql)
834
870
         LEFT JOIN {role} r ON r.id = ra.roleid
835
871
             WHERE gm.groupid=:mgroupid
836
872
                   ".$extrawheretest."
837
873
          ORDER BY r.sortorder, $sort";
838
 
    $whereorsortparams['mgroupid'] = $groupid;
 
874
    $whereorsortparams = array_merge($whereorsortparams, $relatedctxparams, array('mgroupid' => $groupid));
839
875
    $rs = $DB->get_recordset_sql($sql, $whereorsortparams);
840
876
 
841
877
    return groups_calculate_role_people($rs, $context);