コード例 #1
0
ファイル: lib_test.php プロジェクト: evltuma/moodle
 public function test_member_added_event()
 {
     $this->resetAfterTest();
     $this->setAdminUser();
     $course = $this->getDataGenerator()->create_course();
     $user = $this->getDataGenerator()->create_user();
     $group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
     $this->getDataGenerator()->enrol_user($user->id, $course->id);
     $sink = $this->redirectEvents();
     groups_add_member($group->id, $user->id, 'mod_workshop', '123');
     $events = $sink->get_events();
     $this->assertCount(1, $events);
     $event = reset($events);
     $expected = new stdClass();
     $expected->groupid = $group->id;
     $expected->userid = $user->id;
     $expected->component = 'mod_workshop';
     $expected->itemid = '123';
     $this->assertEventLegacyData($expected, $event);
     $this->assertSame('groups_member_added', $event->get_legacy_eventname());
     $this->assertInstanceOf('\\core\\event\\group_member_added', $event);
     $this->assertEquals($user->id, $event->relateduserid);
     $this->assertEquals(context_course::instance($course->id), $event->get_context());
     $this->assertEquals($group->id, $event->objectid);
     $url = new moodle_url('/group/members.php', array('group' => $event->objectid));
     $this->assertEquals($url, $event->get_url());
 }
コード例 #2
0
ファイル: externallib_test.php プロジェクト: janeklb/moodle
 /**
  * Loads some data to be used by the different tests
  * @param  int $s1grade Student 1 grade
  * @param  int $s2grade Student 2 grade
  * @return array          Course and users instances
  */
 private function load_data($s1grade, $s2grade)
 {
     global $DB;
     $course = $this->getDataGenerator()->create_course(array('groupmode' => SEPARATEGROUPS, 'groupmodeforce' => 1));
     $studentrole = $DB->get_record('role', array('shortname' => 'student'));
     $student1 = $this->getDataGenerator()->create_user();
     $this->getDataGenerator()->enrol_user($student1->id, $course->id, $studentrole->id);
     $student2 = $this->getDataGenerator()->create_user();
     $this->getDataGenerator()->enrol_user($student2->id, $course->id, $studentrole->id);
     $teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
     $teacher = $this->getDataGenerator()->create_user();
     $this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
     $context = context_course::instance($course->id);
     assign_capability('moodle/site:accessallgroups', CAP_PROHIBIT, $teacherrole->id, $context);
     accesslib_clear_all_caches_for_unit_testing();
     $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
     $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
     groups_add_member($group1->id, $student1->id);
     groups_add_member($group1->id, $teacher->id);
     groups_add_member($group2->id, $student2->id);
     $assignment = $this->getDataGenerator()->create_module('assign', array('name' => "Test assign", 'course' => $course->id));
     $modcontext = get_coursemodule_from_instance('assign', $assignment->id, $course->id);
     $assignment->cmidnumber = $modcontext->id;
     $student1grade = array('userid' => $student1->id, 'rawgrade' => $s1grade);
     $student2grade = array('userid' => $student2->id, 'rawgrade' => $s2grade);
     $studentgrades = array($student1->id => $student1grade, $student2->id => $student2grade);
     assign_grade_item_update($assignment, $studentgrades);
     return array($course, $teacher, $student1, $student2, $assignment);
 }
コード例 #3
0
ファイル: GroupMagic.php プロジェクト: frapersan/group-magic
 private function _addUserToGroup($userId, $groupId)
 {
     global $CFG;
     require_once $CFG->dirroot . '/group/lib.php';
     groups_add_member($groupId, $userId);
     /* group/lib.php */
 }
コード例 #4
0
ファイル: member.php プロジェクト: bgao-ca/moodle-local_mr
 /**
  * Create the fixture
  *
  * This method must be safe to call multiple times.
  *
  * @return void
  * @throws moodle_exception
  */
 public function build()
 {
     global $DB;
     if (!$this->exists()) {
         // Dependents
         $this->get_group()->build();
         $this->get_enrollment()->build();
         groups_add_member($this->get_group()->get_results(), $this->get_user()->get_results());
         $conditions = array('groupid' => $this->get_group()->get('id'), 'userid' => $this->get_user()->get('id'));
         $this->set_results($DB->get_record('groups_members', $conditions, '*', MUST_EXIST));
     }
 }
コード例 #5
0
 function test_add_member()
 {
     // NOTE, interface change on add_member, remove_member.
     $this->assertTrue(groups_add_member($this->groupid, $this->userid));
     $this->assertTrue(groups_is_member($this->groupid, $this->userid));
     $this->assertTrue($userids = groups_get_members($this->groupid));
     //...
     $this->assertTrue($groupids = groups_get_groups_for_user($this->userid, $this->courseid));
     //...
     $this->assertTrue(1 == groups_count_group_members($this->groupid));
     //Utillib.
 }
コード例 #6
0
function local_syncgroups_do_sync($groups, $destinations, $trace)
{
    global $DB;
    foreach ($groups as $group) {
        $trace->output('Grupo: ' . $group->name);
        if (!($members = $DB->get_records_menu('groups_members', array('groupid' => $group->id), '', 'userid, id'))) {
            $trace->output('group with no members, skipping');
            continue;
        }
        foreach ($destinations as $dest) {
            $trace->output("Curso: {$dest->shortname}");
            if ($dgr = $DB->get_record('groups', array('courseid' => $dest->id, 'name' => $group->name), 'id, courseid, idnumber, name')) {
                $trace->output('grupo existente');
            } else {
                $trace->output("criado grupo");
                $dgr = new Stdclass();
                $dgr->courseid = $dest->id;
                $dgr->timecreated = time();
                $dgr->timemodified = $dgr->timecreated;
                $dgr->name = $group->name;
                $dgr->description = $group->description;
                $dgr->descriptionformat = $group->descriptionformat;
                if (!($dgr->id = groups_create_group($dgr))) {
                    print_error("?? erro ao criar grupo");
                }
            }
            $trace->output("inserindo membros: ");
            foreach ($members as $userid => $memberid) {
                if (!$DB->get_field('groups_members', 'id', array('groupid' => $dgr->id, 'userid' => $userid))) {
                    if ($DB->get_field('role_assignments', 'id', array('contextid' => $dest->context->id, 'userid' => $userid))) {
                        groups_add_member($dgr->id, $userid);
                        $trace->output('Usuário inserido no grupo: ' . $userid);
                    } else {
                        $trace->output("?? usuario id: {$userid} não inscrito no curso");
                    }
                }
            }
            $trace->output("removendo membros: ");
            $members_dest = $DB->get_records('groups_members', array('groupid' => $dgr->id), '', 'id, groupid, userid');
            foreach ($members_dest as $id => $usum) {
                if (!isset($members[$usum->userid])) {
                    groups_remove_member($dgr->id, $usum->userid);
                    $trace->output('Usuário removido do grupo: ' . $usum->userid);
                }
            }
        }
    }
    $trace->output('Concluído.');
    $trace->finished();
}
コード例 #7
0
 /**
  * This function creates a group with a particular name, adds it to the grouping,
  * and then adds the current user to that group.
  *
  * @param string $name The name to assign to the newly created group.
  * @return int The ID of the group that was group that was created.
  *
  */
 public function create_group($name)
 {
     global $DB, $USER;
     $sgs = new skills_group_setting($this->courseid);
     $group = new stdClass();
     if ($name === null || trim($name) == '') {
         $name = $this->name_empty_group();
     }
     $group->name = $name;
     $group->courseid = $this->courseid;
     $groupid = groups_create_group($group);
     groups_assign_grouping($sgs->get_grouping_id(), $groupid);
     groups_add_member($groupid, $USER->id);
     return $groupid;
 }
コード例 #8
0
 /**
  * setUp/tearDown: Better in a constructor/destructor, but PHP4 doesn't do destructors :(
  */
 function setUp()
 {
     parent::setUp();
     if ($course = groups_get_course_info(1)) {
         $this->courseid = $course->id;
     }
     if ($user = groups_get_user(2)) {
         //Primary admin.
         $this->userid = $user->id;
     }
     $this->groupid = groups_create_group($this->courseid);
     $groupinfo = groups_set_default_group_settings();
     $bok = groups_set_group_settings($this->groupid, $groupinfo);
     $bok = groups_add_member($this->groupid, $this->userid);
 }
コード例 #9
0
ファイル: locallib.php プロジェクト: stronk7/moodle
 /**
  * Event processor - cohort member added.
  * @param \core\event\cohort_member_added $event
  * @return bool
  */
 public static function member_added(\core\event\cohort_member_added $event)
 {
     global $DB, $CFG;
     require_once "{$CFG->dirroot}/group/lib.php";
     if (!enrol_is_enabled('cohort')) {
         return true;
     }
     // Does any enabled cohort instance want to sync with this cohort?
     $sql = "SELECT e.*, r.id as roleexists\n                  FROM {enrol} e\n             LEFT JOIN {role} r ON (r.id = e.roleid)\n                 WHERE e.customint1 = :cohortid AND e.enrol = 'cohort' AND e.status = :enrolstatus\n              ORDER BY e.id ASC";
     $params['cohortid'] = $event->objectid;
     $params['enrolstatus'] = ENROL_INSTANCE_ENABLED;
     if (!($instances = $DB->get_records_sql($sql, $params))) {
         return true;
     }
     $plugin = enrol_get_plugin('cohort');
     foreach ($instances as $instance) {
         if ($instance->status != ENROL_INSTANCE_ENABLED) {
             // No roles for disabled instances.
             $instance->roleid = 0;
         } else {
             if ($instance->roleid and !$instance->roleexists) {
                 // Invalid role - let's just enrol, they will have to create new sync and delete this one.
                 $instance->roleid = 0;
             }
         }
         unset($instance->roleexists);
         // No problem if already enrolled.
         $plugin->enrol_user($instance, $event->relateduserid, $instance->roleid, 0, 0, ENROL_USER_ACTIVE);
         // Sync groups.
         if ($instance->customint2) {
             if (!groups_is_member($instance->customint2, $event->relateduserid)) {
                 if ($group = $DB->get_record('groups', array('id' => $instance->customint2, 'courseid' => $instance->courseid))) {
                     groups_add_member($group->id, $event->relateduserid, 'enrol_cohort', $instance->id);
                 }
             }
         }
     }
     return true;
 }
コード例 #10
0
ファイル: uploaduser.php プロジェクト: richheath/moodle
             if (!array_key_exists($addgroup, $ccache[$shortname]->groups)) {
                 // if group doesn't exist,  create it
                 $newgroupdata = new stdClass();
                 $newgroupdata->name = $addgroup;
                 $newgroupdata->courseid = $ccache[$shortname]->id;
                 if ($ccache[$shortname]->groups[$addgroup]->id = groups_create_group($newgroupdata)) {
                     $ccache[$shortname]->groups[$addgroup]->name = $newgroupdata->name;
                 } else {
                     $upt->track('enrolments', get_string('unknowngroup', 'error', s($addgroup)), 'error');
                     continue;
                 }
             }
             $gid = $ccache[$shortname]->groups[$addgroup]->id;
             $gname = $ccache[$shortname]->groups[$addgroup]->name;
             try {
                 if (groups_add_member($gid, $user->id)) {
                     $upt->track('enrolments', get_string('addedtogroup', '', s($gname)));
                 } else {
                     $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
                 }
             } catch (moodle_exception $e) {
                 $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
                 continue;
             }
         }
     }
 }
 $upt->close();
 // close table
 $cir->close();
 $cir->cleanup(true);
コード例 #11
0
ファイル: Utils.php プロジェクト: sirromas/lms
 function add_to_group($groupid, $userid)
 {
     groups_add_member($groupid, $userid);
 }
コード例 #12
0
ファイル: lib.php プロジェクト: masaterutakeno/MoodleMobile
 /**
  * Restore user group membership.
  * @param stdClass $instance
  * @param int $groupid
  * @param int $userid
  */
 public function restore_group_member($instance, $groupid, $userid)
 {
     global $CFG;
     require_once "{$CFG->dirroot}/group/lib.php";
     // This might be called when forcing restore as manual enrolments.
     groups_add_member($groupid, $userid);
 }
コード例 #13
0
ファイル: lib.php プロジェクト: MoodleMetaData/MoodleMetaData
 private function process_course_cohort_membership_node($membershipnode, $xpath, $role = '01')
 {
     global $DB, $CFG;
     $idnumber = $xpath->evaluate("sourcedid/id", $membershipnode)->item(0);
     $course = $DB->get_record('course', array('idnumber' => $idnumber->nodeValue), '*', MUST_EXIST);
     $members = $xpath->evaluate("member", $membershipnode);
     foreach ($members as $mmember) {
         $midnumber = $xpath->evaluate("sourcedid/id", $mmember)->item(0);
         $idtype = $xpath->evaluate("idtype", $mmember)->item(0);
         if ($midnumber) {
             $member = new stdClass();
             $member->idnumber = $midnumber->nodeValue;
             $cohortid = $DB->get_field('cohort', 'id', array('idnumber' => $member->idnumber));
             $cohortname = $DB->get_field('cohort', 'name', array('idnumber' => $member->idnumber));
             if ($idtype->nodeValue == 'Add' && $cohortid) {
                 if (!($cohortinstanceid = $DB->get_field('enrol', 'id', array('enrol' => 'cohort', 'customint1' => $cohortid, 'courseid' => $course->id)))) {
                     $enrol = enrol_get_plugin('cohort');
                     $enrol->add_instance($course, array('name' => $cohortname, 'status' => 0, 'customint1' => $cohortid, 'roleid' => 5, 'customint2' => 0));
                     $trace = new null_progress_trace();
                     enrol_cohort_sync($trace, $course->id);
                     $trace->finished();
                 }
                 if (substr($idnumber->nodeValue, 0, 8) == 'UOFAB-XL') {
                     $data = new stdClass();
                     if (!($data->id = $DB->get_field('groups', 'id', array('courseid' => $course->id, 'name' => $cohortname)))) {
                         $data->timecreated = time();
                         $data->timemodified = time();
                         $data->name = trim($cohortname);
                         $data->description = '';
                         $data->descriptionformat = '1';
                         $data->courseid = $course->id;
                         $data->id = groups_create_group($data);
                     }
                     $cohortrec = $DB->get_fieldset_select('cohort_members', 'userid', 'cohortid=' . $cohortid);
                     foreach ($cohortrec as $curmember) {
                         $latestlist[$curmember] = $curmember;
                         groups_add_member($data->id, $curmember);
                     }
                     $grouprec = $DB->get_fieldset_select('groups_members', 'userid', 'groupid=' . $data->id);
                     foreach ($grouprec as $grpmember) {
                         if (!isset($latestlist[$grpmember])) {
                             groups_remove_member($data->id, $grpmember);
                         }
                     }
                 }
             } else {
                 if ($idtype->nodeValue == 'Delete') {
                     if ($cohortinstance = $DB->get_record('enrol', array('enrol' => 'cohort', 'customint1' => $cohortid, 'courseid' => $course->id))) {
                         $enrol = enrol_get_plugin('cohort');
                         $enrol->delete_instance($cohortinstance);
                     }
                 }
             }
         }
     }
 }
コード例 #14
0
 /**
  * Tests for mod_data_rating_can_see_item_ratings().
  *
  * @throws coding_exception
  * @throws rating_exception
  */
 public function test_mod_data_rating_can_see_item_ratings()
 {
     global $DB;
     $this->resetAfterTest();
     // Setup test data.
     $course = new stdClass();
     $course->groupmode = SEPARATEGROUPS;
     $course->groupmodeforce = true;
     $course = $this->getDataGenerator()->create_course($course);
     $data = $this->getDataGenerator()->create_module('data', array('course' => $course->id));
     $cm = get_coursemodule_from_instance('data', $data->id);
     $context = context_module::instance($cm->id);
     // Create users.
     $user1 = $this->getDataGenerator()->create_user();
     $user2 = $this->getDataGenerator()->create_user();
     $user3 = $this->getDataGenerator()->create_user();
     $user4 = $this->getDataGenerator()->create_user();
     // Groups and stuff.
     $role = $DB->get_record('role', array('shortname' => 'teacher'), '*', MUST_EXIST);
     $this->getDataGenerator()->enrol_user($user1->id, $course->id, $role->id);
     $this->getDataGenerator()->enrol_user($user2->id, $course->id, $role->id);
     $this->getDataGenerator()->enrol_user($user3->id, $course->id, $role->id);
     $this->getDataGenerator()->enrol_user($user4->id, $course->id, $role->id);
     $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
     $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
     groups_add_member($group1, $user1);
     groups_add_member($group1, $user2);
     groups_add_member($group2, $user3);
     groups_add_member($group2, $user4);
     // Add data.
     $field = data_get_field_new('text', $data);
     $fielddetail = new stdClass();
     $fielddetail->name = 'Name';
     $fielddetail->description = 'Some name';
     $field->define_field($fielddetail);
     $field->insert_field();
     // Add a record with a group id of zero (all participants).
     $recordid1 = data_add_record($data, 0);
     $datacontent = array();
     $datacontent['fieldid'] = $field->field->id;
     $datacontent['recordid'] = $recordid1;
     $datacontent['content'] = 'Obelix';
     $DB->insert_record('data_content', $datacontent);
     $recordid = data_add_record($data, $group1->id);
     $datacontent = array();
     $datacontent['fieldid'] = $field->field->id;
     $datacontent['recordid'] = $recordid;
     $datacontent['content'] = 'Asterix';
     $DB->insert_record('data_content', $datacontent);
     // Now try to access it as various users.
     unassign_capability('moodle/site:accessallgroups', $role->id);
     // Eveyone should have access to the record with the group id of zero.
     $params1 = array('contextid' => 2, 'component' => 'mod_data', 'ratingarea' => 'entry', 'itemid' => $recordid1, 'scaleid' => 2);
     $params = array('contextid' => 2, 'component' => 'mod_data', 'ratingarea' => 'entry', 'itemid' => $recordid, 'scaleid' => 2);
     $this->setUser($user1);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     $this->setUser($user2);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     $this->setUser($user3);
     $this->assertFalse(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     $this->setUser($user4);
     $this->assertFalse(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     // Now try with accessallgroups cap and make sure everything is visible.
     assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $role->id, $context->id);
     $this->setUser($user1);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     $this->setUser($user2);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     $this->setUser($user3);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     $this->setUser($user4);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     // Change group mode and verify visibility.
     $course->groupmode = VISIBLEGROUPS;
     $DB->update_record('course', $course);
     unassign_capability('moodle/site:accessallgroups', $role->id);
     $this->setUser($user1);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     $this->setUser($user2);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     $this->setUser($user3);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
     $this->setUser($user4);
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params));
     $this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
 }
コード例 #15
0
ファイル: lib_test.php プロジェクト: rushi963/moodle
 /**
  * Test forum_user_can_post_discussion
  */
 public function test_forum_user_can_post_discussion()
 {
     global $CFG, $DB;
     $this->resetAfterTest(true);
     // Create course to add the module.
     $course = self::getDataGenerator()->create_course(array('groupmode' => SEPARATEGROUPS, 'groupmodeforce' => 1));
     $user = self::getDataGenerator()->create_user();
     $this->getDataGenerator()->enrol_user($user->id, $course->id);
     // Forum forcing separate gropus.
     $record = new stdClass();
     $record->course = $course->id;
     $forum = self::getDataGenerator()->create_module('forum', $record, array('groupmode' => SEPARATEGROUPS));
     $cm = get_coursemodule_from_instance('forum', $forum->id);
     $context = context_module::instance($cm->id);
     self::setUser($user);
     // The user is not enroled in any group, try to post in a forum with separate groups.
     $can = forum_user_can_post_discussion($forum, null, -1, $cm, $context);
     $this->assertFalse($can);
     // Create a group.
     $group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
     // Try to post in a group the user is not enrolled.
     $can = forum_user_can_post_discussion($forum, $group->id, -1, $cm, $context);
     $this->assertFalse($can);
     // Add the user to a group.
     groups_add_member($group->id, $user->id);
     // Try to post in a group the user is not enrolled.
     $can = forum_user_can_post_discussion($forum, $group->id + 1, -1, $cm, $context);
     $this->assertFalse($can);
     // Now try to post in the user group. (null means it will guess the group).
     $can = forum_user_can_post_discussion($forum, null, -1, $cm, $context);
     $this->assertTrue($can);
     $can = forum_user_can_post_discussion($forum, $group->id, -1, $cm, $context);
     $this->assertTrue($can);
     // Test all groups.
     $can = forum_user_can_post_discussion($forum, -1, -1, $cm, $context);
     $this->assertFalse($can);
     $this->setAdminUser();
     $can = forum_user_can_post_discussion($forum, -1, -1, $cm, $context);
     $this->assertTrue($can);
     // Change forum type.
     $forum->type = 'news';
     $DB->update_record('forum', $forum);
     // Admin can post news.
     $can = forum_user_can_post_discussion($forum, null, -1, $cm, $context);
     $this->assertTrue($can);
     // Normal users don't.
     self::setUser($user);
     $can = forum_user_can_post_discussion($forum, null, -1, $cm, $context);
     $this->assertFalse($can);
     // Change forum type.
     $forum->type = 'eachuser';
     $DB->update_record('forum', $forum);
     // I didn't post yet, so I should be able to post.
     $can = forum_user_can_post_discussion($forum, null, -1, $cm, $context);
     $this->assertTrue($can);
     // Post now.
     $record = new stdClass();
     $record->course = $course->id;
     $record->userid = $user->id;
     $record->forum = $forum->id;
     $discussion = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_discussion($record);
     // I already posted, I shouldn't be able to post.
     $can = forum_user_can_post_discussion($forum, null, -1, $cm, $context);
     $this->assertFalse($can);
     // Last check with no groups, normal forum and course.
     $course->groupmode = NOGROUPS;
     $course->groupmodeforce = 0;
     $DB->update_record('course', $course);
     $forum->type = 'general';
     $forum->groupmode = NOGROUPS;
     $DB->update_record('forum', $forum);
     $can = forum_user_can_post_discussion($forum, null, -1, $cm, $context);
     $this->assertTrue($can);
 }
コード例 #16
0
ファイル: locallib.php プロジェクト: EmmanuelYupit/educursos
 /**
  * Adds a user to a group
  *
  * @param stdClass $user
  * @param int $groupid
  * @return bool
  */
 public function add_user_to_group($user, $groupid)
 {
     require_capability('moodle/course:managegroups', $this->context);
     $group = $this->get_group($groupid);
     if (!$group) {
         return false;
     }
     return groups_add_member($group->id, $user->id);
 }
コード例 #17
0
 /**
  * Add group members
  *
  * @param array $members of arrays with keys userid, groupid
  * @since Moodle 2.2
  */
 public static function add_group_members($members)
 {
     global $CFG, $DB;
     require_once "{$CFG->dirroot}/group/lib.php";
     $params = self::validate_parameters(self::add_group_members_parameters(), array('members' => $members));
     $transaction = $DB->start_delegated_transaction();
     foreach ($params['members'] as $member) {
         // validate params
         $groupid = $member['groupid'];
         $userid = $member['userid'];
         $group = groups_get_group($groupid, 'id, courseid', MUST_EXIST);
         $user = $DB->get_record('user', array('id' => $userid, 'deleted' => 0, 'mnethostid' => $CFG->mnet_localhost_id), '*', MUST_EXIST);
         // now security checks
         $context = context_course::instance($group->courseid, IGNORE_MISSING);
         try {
             self::validate_context($context);
         } catch (Exception $e) {
             $exceptionparam = new stdClass();
             $exceptionparam->message = $e->getMessage();
             $exceptionparam->courseid = $group->courseid;
             throw new moodle_exception('errorcoursecontextnotvalid', 'webservice', '', $exceptionparam);
         }
         require_capability('moodle/course:managegroups', $context);
         // now make sure user is enrolled in course - this is mandatory requirement,
         // unfortunately this is slow
         if (!is_enrolled($context, $userid)) {
             throw new invalid_parameter_exception('Only enrolled users may be members of groups');
         }
         groups_add_member($group, $user);
     }
     $transaction->allow_commit();
 }
コード例 #18
0
ファイル: members.php プロジェクト: ajv/Offline-Caching
require_login($course);
$context = get_context_instance(CONTEXT_COURSE, $courseid);
require_capability('moodle/course:managegroups', $context);
$returnurl = $CFG->wwwroot . '/group/index.php?id=' . $courseid . '&group=' . $group->id;
if (optional_param('cancel', false, PARAM_BOOL)) {
    redirect($returnurl);
}
$groupmembersselector = new group_members_selector('removeselect', array('groupid' => $groupid, 'courseid' => $course->id));
$groupmembersselector->set_extra_fields(array());
$potentialmembersselector = new group_non_members_selector('addselect', array('groupid' => $groupid, 'courseid' => $course->id));
$potentialmembersselector->set_extra_fields(array());
if (optional_param('add', false, PARAM_BOOL) && confirm_sesskey()) {
    $userstoadd = $potentialmembersselector->get_selected_users();
    if (!empty($userstoadd)) {
        foreach ($userstoadd as $user) {
            if (!groups_add_member($groupid, $user->id)) {
                print_error('erroraddremoveuser', 'group', $returnurl);
            }
            $groupmembersselector->invalidate_selected_users();
            $potentialmembersselector->invalidate_selected_users();
        }
    }
}
if (optional_param('remove', false, PARAM_BOOL) && confirm_sesskey()) {
    $userstoremove = $groupmembersselector->get_selected_users();
    if (!empty($userstoremove)) {
        foreach ($userstoremove as $user) {
            if (!groups_remove_member($groupid, $user->id)) {
                print_error('erroraddremoveuser', 'group', $returnurl);
            }
            $groupmembersselector->invalidate_selected_users();
コード例 #19
0
ファイル: data_generator.php プロジェクト: Burick/moodle
    /**
     * Create a test group member
     * @param array|stdClass $record
     * @throws coding_exception
     * @return boolean
     */
    public function create_group_member($record) {
        global $DB, $CFG;

        require_once($CFG->dirroot . '/group/lib.php');

        $record = (array)$record;

        if (empty($record['userid'])) {
            throw new coding_exception('user must be present in testing_util::create_group_member() $record');
        }

        if (!isset($record['groupid'])) {
            throw new coding_exception('group must be present in testing_util::create_group_member() $record');
        }

        if (!isset($record['component'])) {
            $record['component'] = null;
        }
        if (!isset($record['itemid'])) {
            $record['itemid'] = 0;
        }

        return groups_add_member($record['groupid'], $record['userid'], $record['component'], $record['itemid']);
    }
コード例 #20
0
ファイル: lib.php プロジェクト: narasimhaeabyas/tataaiapro
function enroll_users_tocourse($add_user,$assigned_course,$studentrole,$manual){
    global $DB,$CFG;
	
     $instance = $DB->get_record('enrol', array('courseid'=>$assigned_course->courseid, 'enrol'=>'manual'), '*', MUST_EXIST);
             if($instance){
                $timeend='';
                $manual->enrol_user($instance,$add_user, $studentrole->id,time(),$timeend);
				/* add members to a group*/
				if($assigned_course->testid !=0)
				groups_add_member($assigned_course->groupid, $add_user, $component=null, $itemid=0);

               
             }
}
コード例 #21
0
/**
 * @global object
 * @param int $formanswer
 * @param object $choicegroup
 * @param int $userid
 * @param object $course Course object
 * @param object $cm
 */
function choicegroup_user_submit_response($formanswer, $choicegroup, $userid, $course, $cm)
{
    global $DB, $CFG;
    require_once $CFG->libdir . '/completionlib.php';
    $context = context_module::instance($cm->id);
    $eventparams = array('context' => $context, 'objectid' => $choicegroup->id);
    $selected_option = $DB->get_record('choicegroup_options', array('id' => $formanswer));
    $current = choicegroup_get_user_answer($choicegroup, $userid);
    if ($current) {
        $currentgroup = $DB->get_record('groups', array('id' => $current->id), 'id,name', MUST_EXIST);
    }
    $selectedgroup = $DB->get_record('groups', array('id' => $selected_option->groupid), 'id,name', MUST_EXIST);
    $countanswers = 0;
    if ($choicegroup->limitanswers) {
        $groupmembers = $DB->get_records('groups_members', array('groupid' => $selected_option->groupid));
        $countanswers = count($groupmembers);
        $maxans = $choicegroup->maxanswers[$formanswer];
    }
    if (!($choicegroup->limitanswers && $countanswers >= $maxans)) {
        groups_add_member($selected_option->groupid, $userid);
        if ($current) {
            if (!($choicegroup->multipleenrollmentspossible == 1)) {
                if ($selected_option->groupid != $current->id) {
                    if (groups_is_member($current->id, $userid)) {
                        groups_remove_member($current->id, $userid);
                        //                        $eventparams['groupname'] = $currentgroup->name;
                        $event = \mod_choicegroup\event\choice_removed::create($eventparams);
                        $event->add_record_snapshot('course_modules', $cm);
                        $event->add_record_snapshot('course', $course);
                        $event->add_record_snapshot('choicegroup', $choicegroup);
                        $event->trigger();
                    }
                }
            }
        } else {
            // Update completion state
            $completion = new completion_info($course);
            if ($completion->is_enabled($cm) && $choicegroup->completionsubmit) {
                $completion->update_state($cm, COMPLETION_COMPLETE);
            }
            //            $eventparams['groupname'] = $selectedgroup->name;
            $event = \mod_choicegroup\event\choice_updated::create($eventparams);
            $event->add_record_snapshot('course_modules', $cm);
            $event->add_record_snapshot('course', $course);
            $event->add_record_snapshot('choicegroup', $choicegroup);
            $event->trigger();
        }
    } else {
        if (!$current || !($current->id == $selected_option->groupid)) {
            //check to see if current choicegroup already selected - if not display error
            print_error('choicegroupfull', 'choicegroup', $CFG->wwwroot . '/mod/choicegroup/view.php?id=' . $cm->id);
        }
    }
}
コード例 #22
0
ファイル: lib.php プロジェクト: nfreear/moodle
 /**
  * Creates course enrol form, checks if form submitted
  * and enrols user if necessary. It can also redirect.
  *
  * @param stdClass $instance
  * @return string html text, usually a form in a text box
  */
 public function enrol_page_hook(stdClass $instance)
 {
     global $CFG, $OUTPUT, $SESSION, $USER, $DB;
     if (isguestuser()) {
         // can not enrol guest!!
         return null;
     }
     if ($DB->record_exists('user_enrolments', array('userid' => $USER->id, 'enrolid' => $instance->id))) {
         //TODO: maybe we should tell them they are already enrolled, but can not access the course
         return null;
     }
     if ($instance->enrolstartdate != 0 and $instance->enrolstartdate > time()) {
         //TODO: inform that we can not enrol yet
         return null;
     }
     if ($instance->enrolenddate != 0 and $instance->enrolenddate < time()) {
         //TODO: inform that enrolment is not possible any more
         return null;
     }
     if ($instance->customint3 > 0) {
         // max enrol limit specified
         $count = $DB->count_records('user_enrolments', array('enrolid' => $instance->id));
         if ($count >= $instance->customint3) {
             // bad luck, no more self enrolments here
             return $OUTPUT->notification(get_string('maxenrolledreached', 'enrol_self'));
         }
     }
     require_once "{$CFG->dirroot}/enrol/self/locallib.php";
     require_once "{$CFG->dirroot}/group/lib.php";
     $form = new enrol_self_enrol_form(NULL, $instance);
     $instanceid = optional_param('instance', 0, PARAM_INT);
     if ($instance->id == $instanceid) {
         if ($data = $form->get_data()) {
             $enrol = enrol_get_plugin('self');
             $timestart = time();
             if ($instance->enrolperiod) {
                 $timeend = $timestart + $instance->enrolperiod;
             } else {
                 $timeend = 0;
             }
             $this->enrol_user($instance, $USER->id, $instance->roleid, $timestart, $timeend);
             add_to_log($instance->courseid, 'course', 'enrol', '../enrol/users.php?id=' . $instance->courseid, $instance->courseid);
             //there should be userid somewhere!
             if ($instance->password and $instance->customint1 and $data->enrolpassword !== $instance->password) {
                 // it must be a group enrolment, let's assign group too
                 $groups = $DB->get_records('groups', array('courseid' => $instance->courseid), 'id', 'id, enrolmentkey');
                 foreach ($groups as $group) {
                     if (empty($group->enrolmentkey)) {
                         continue;
                     }
                     if ($group->enrolmentkey === $data->enrolpassword) {
                         groups_add_member($group->id, $USER->id);
                         break;
                     }
                 }
             }
             // send welcome
             if ($instance->customint4) {
                 $this->email_welcome_message($instance, $USER);
             }
         }
     }
     ob_start();
     $form->display();
     $output = ob_get_clean();
     return $OUTPUT->box($output);
 }
コード例 #23
0
 /**
  * Assign people to groups based on their metacourse enrollments
  *
  * @access public
  * @static
  * @param stdClass $course            The course in which group assignments are made
  * @param array    $group_selections  Assoc. array ($enrol_id => $group_id)
  * @param boolean  $remove_current    Remove users' current group assignments
  * @return void
  *
  * @uses $DB
  */
 public static function metagroup_assign(stdClass $course, $group_selections, $remove_current = false)
 {
     global $DB;
     $result = '';
     $course_groups = groups_get_all_groups($course->id);
     foreach ($group_selections as $enrol_id => $assign_group_id) {
         // No assignment select for this enrol instance
         if (empty($assign_group_id)) {
             continue;
         }
         // Get users association with this enrol instance
         if (false === ($userids = $DB->get_records('user_enrolments', array('enrolid' => $enrol_id), 'userid', 'userid'))) {
             continue;
         }
         // Iterate the user id list for this enrol instance
         foreach ($userids as $userid => $record_object) {
             // Remove user from existing groups if needed
             if ($remove_current) {
                 foreach ($course_groups as $course_group) {
                     if ($course_group->id != $assign_group_id) {
                         groups_remove_member($course_group->id, $userid);
                     }
                 }
             }
             // Got an existing group's id
             groups_add_member($assign_group_id, $userid);
         }
         // foreach($userids...
     }
     // foreach($group_selections...
     self::set_group_prefs($course->id, $group_selections);
 }
コード例 #24
0
ファイル: externallib_test.php プロジェクト: dg711/moodle
 /**
  * Test get_course_completion_status
  */
 public function test_get_course_completion_status()
 {
     global $DB, $CFG, $COMPLETION_CRITERIA_TYPES;
     require_once $CFG->dirroot . '/completion/criteria/completion_criteria_self.php';
     require_once $CFG->dirroot . '/completion/criteria/completion_criteria_date.php';
     require_once $CFG->dirroot . '/completion/criteria/completion_criteria_unenrol.php';
     require_once $CFG->dirroot . '/completion/criteria/completion_criteria_activity.php';
     require_once $CFG->dirroot . '/completion/criteria/completion_criteria_duration.php';
     require_once $CFG->dirroot . '/completion/criteria/completion_criteria_grade.php';
     require_once $CFG->dirroot . '/completion/criteria/completion_criteria_role.php';
     require_once $CFG->dirroot . '/completion/criteria/completion_criteria_course.php';
     $this->resetAfterTest(true);
     $CFG->enablecompletion = true;
     $student = $this->getDataGenerator()->create_user();
     $teacher = $this->getDataGenerator()->create_user();
     $course = $this->getDataGenerator()->create_course(array('enablecompletion' => 1, 'groupmode' => SEPARATEGROUPS, 'groupmodeforce' => 1));
     $data = $this->getDataGenerator()->create_module('data', array('course' => $course->id), array('completion' => 1));
     $forum = $this->getDataGenerator()->create_module('forum', array('course' => $course->id), array('completion' => 1));
     $assign = $this->getDataGenerator()->create_module('assign', array('course' => $course->id));
     $cmdata = get_coursemodule_from_id('data', $data->cmid);
     $cmforum = get_coursemodule_from_id('forum', $forum->cmid);
     $studentrole = $DB->get_record('role', array('shortname' => 'student'));
     $teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));
     $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
     $this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
     $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
     $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
     // Teacher and student in different groups initially.
     groups_add_member($group1->id, $student->id);
     groups_add_member($group2->id, $teacher->id);
     // Set completion rules.
     $completion = new completion_info($course);
     // Loop through each criteria type and run its update_config() method.
     $criteriadata = new stdClass();
     $criteriadata->id = $course->id;
     $criteriadata->criteria_activity = array();
     // Some activities.
     $criteriadata->criteria_activity[$cmdata->id] = 1;
     $criteriadata->criteria_activity[$cmforum->id] = 1;
     // In a week criteria date value.
     $criteriadata->criteria_date_value = time() + WEEKSECS;
     // Self completion.
     $criteriadata->criteria_self = 1;
     foreach ($COMPLETION_CRITERIA_TYPES as $type) {
         $class = 'completion_criteria_' . $type;
         $criterion = new $class();
         $criterion->update_config($criteriadata);
     }
     // Handle overall aggregation.
     $aggdata = array('course' => $course->id, 'criteriatype' => null);
     $aggregation = new completion_aggregation($aggdata);
     $aggregation->setMethod(COMPLETION_AGGREGATION_ALL);
     $aggregation->save();
     $aggdata['criteriatype'] = COMPLETION_CRITERIA_TYPE_ACTIVITY;
     $aggregation = new completion_aggregation($aggdata);
     $aggregation->setMethod(COMPLETION_AGGREGATION_ALL);
     $aggregation->save();
     $this->setUser($student);
     $result = core_completion_external::get_course_completion_status($course->id, $student->id);
     // We need to execute the return values cleaning process to simulate the web service server.
     $studentresult = external_api::clean_returnvalue(core_completion_external::get_course_completion_status_returns(), $result);
     // 3 different criteria.
     $this->assertCount(3, $studentresult['completionstatus']['completions']);
     $this->assertEquals(COMPLETION_AGGREGATION_ALL, $studentresult['completionstatus']['aggregation']);
     $this->assertFalse($studentresult['completionstatus']['completed']);
     $this->assertEquals('No', $studentresult['completionstatus']['completions'][0]['status']);
     $this->assertEquals('No', $studentresult['completionstatus']['completions'][1]['status']);
     $this->assertEquals('No', $studentresult['completionstatus']['completions'][2]['status']);
     // Teacher should see students status, they are in different groups but the teacher can access all groups.
     $this->setUser($teacher);
     $result = core_completion_external::get_course_completion_status($course->id, $student->id);
     // We need to execute the return values cleaning process to simulate the web service server.
     $teacherresult = external_api::clean_returnvalue(core_completion_external::get_course_completion_status_returns(), $result);
     $this->assertEquals($studentresult, $teacherresult);
     // Change teacher role capabilities (disable access al goups).
     $context = context_course::instance($course->id);
     assign_capability('moodle/site:accessallgroups', CAP_PROHIBIT, $teacherrole->id, $context);
     accesslib_clear_all_caches_for_unit_testing();
     try {
         $result = core_completion_external::get_course_completion_status($course->id, $student->id);
         $this->fail('Exception expected due to groups permissions.');
     } catch (moodle_exception $e) {
         $this->assertEquals('accessdenied', $e->errorcode);
     }
     // Now add the teacher in the same group.
     groups_add_member($group1->id, $teacher->id);
     $result = core_completion_external::get_course_completion_status($course->id, $student->id);
     // We need to execute the return values cleaning process to simulate the web service server.
     $teacherresult = external_api::clean_returnvalue(core_completion_external::get_course_completion_status_returns(), $result);
     $this->assertEquals($studentresult, $teacherresult);
 }
コード例 #25
0
ファイル: restore_stepslib.php プロジェクト: Jinelle/moodle
 public function process_member($data)
 {
     global $DB, $CFG;
     require_once "{$CFG->dirroot}/group/lib.php";
     // NOTE: Always use groups_add_member() because it triggers events and verifies if user is enrolled.
     $data = (object) $data;
     // handy
     // get parent group->id
     $data->groupid = $this->get_new_parentid('group');
     // map user newitemid and insert if not member already
     if ($data->userid = $this->get_mappingid('user', $data->userid)) {
         if (!$DB->record_exists('groups_members', array('groupid' => $data->groupid, 'userid' => $data->userid))) {
             // Check the component, if any, exists.
             if (empty($data->component)) {
                 groups_add_member($data->groupid, $data->userid);
             } else {
                 if (strpos($data->component, 'enrol_') === 0) {
                     // Deal with enrolment groups - ignore the component and just find out the instance via new id,
                     // it is possible that enrolment was restored using different plugin type.
                     if (!isset($this->plugins)) {
                         $this->plugins = enrol_get_plugins(true);
                     }
                     if ($enrolid = $this->get_mappingid('enrol', $data->itemid)) {
                         if ($instance = $DB->get_record('enrol', array('id' => $enrolid))) {
                             if (isset($this->plugins[$instance->enrol])) {
                                 $this->plugins[$instance->enrol]->restore_group_member($instance, $data->groupid, $data->userid);
                             }
                         }
                     }
                 } else {
                     $dir = core_component::get_component_directory($data->component);
                     if ($dir and is_dir($dir)) {
                         if (component_callback($data->component, 'restore_group_member', array($this, $data), true)) {
                             return;
                         }
                     }
                     // Bad luck, plugin could not restore the data, let's add normal membership.
                     groups_add_member($data->groupid, $data->userid);
                     $message = "Restore of '{$data->component}/{$data->itemid}' group membership is not supported, using standard group membership instead.";
                     $this->log($message, backup::LOG_WARNING);
                 }
             }
         }
     }
 }
コード例 #26
0
ファイル: assign.php プロジェクト: veritech/pare-project
if ($success) {
    // Make sure that the user has permissions to manage groups.
    require_login($courseid);
    $context = get_context_instance(CONTEXT_COURSE, $courseid);
    if (!has_capability('moodle/course:managegroups', $context)) {
        redirect();
    }
    if ($frm = data_submitted() and confirm_sesskey()) {
        if (isset($frm->cancel)) {
            redirect('index.php?id=' . $courseid . '&grouping=' . $groupingid . '&group=' . $groupid);
        } elseif (isset($frm->add) and !empty($frm->addselect)) {
            foreach ($frm->addselect as $userid) {
                if (!($userid = clean_param($userid, PARAM_INT))) {
                    continue;
                }
                $success = groups_add_member($groupid, $userid);
                if (!$success) {
                    print_error('erroraddremoveuser', 'group', groups_home_url($courseid));
                }
            }
        } elseif (isset($frm->remove) and !empty($frm->removeselect)) {
            foreach ($frm->removeselect as $userid) {
                if (!($userid = clean_param($userid, PARAM_INT))) {
                    continue;
                }
                $success = groups_remove_member($groupid, $userid);
                if (!$success) {
                    print_error('erroraddremoveuser', 'group', groups_home_url($courseid));
                }
            }
        }
コード例 #27
0
ファイル: enrol.php プロジェクト: kai707/ITSA-backup
 /**
 * The other half to print_entry, this checks the form data
 *
 * This function checks that the user has completed the task on the
 * enrolment entry page and then enrolls them.
 *
 * @param    form    the form data submitted, as an object
 * @param    course  the current course, as an object
 */
 function check_entry($form, $course)
 {
     global $CFG, $USER, $SESSION, $THEME;
     if (empty($form->password)) {
         $form->password = '';
     }
     if (empty($course->password)) {
         // do not allow entry when no course password set
         // automatic login when manual primary, no login when secondary at all!!
         error('illegal enrolment attempted');
     }
     $groupid = $this->check_group_entry($course->id, $form->password);
     if (stripslashes($form->password) == $course->password or $groupid !== false) {
         if (isguestuser()) {
             // only real user guest, do not use this for users with guest role
             $USER->enrolkey[$course->id] = true;
             add_to_log($course->id, 'course', 'guest', 'view.php?id=' . $course->id, getremoteaddr());
         } else {
             /// Update or add new enrolment
             if (enrol_into_course($course, $USER, 'manual')) {
                 // force a refresh of mycourses
                 unset($USER->mycourses);
                 if ($groupid !== false) {
                     if (!groups_add_member($groupid, $USER->id)) {
                         print_error('couldnotassigngroup');
                     }
                 }
             } else {
                 print_error('couldnotassignrole');
             }
         }
         if ($SESSION->wantsurl) {
             $destination = $SESSION->wantsurl;
             unset($SESSION->wantsurl);
         } else {
             $destination = "{$CFG->wwwroot}/course/view.php?id={$course->id}";
         }
         redirect($destination);
     } else {
         if (!isset($CFG->enrol_manual_showhint) or $CFG->enrol_manual_showhint) {
             $this->errormsg = get_string('enrolmentkeyhint', '', substr($course->password, 0, 1));
         } else {
             $this->errormsg = get_string('enrolmentkeyerror', 'enrol_manual');
         }
     }
 }
コード例 #28
0
ファイル: login.php プロジェクト: nagyistoce/wp2moodle-moodle
                     $SESSION->wantsurl = new moodle_url('/course/view.php', array('id' => $enrolrow->courseid));
                 }
             }
         }
     }
 }
 // also optionally find a groupid we sent in, enrol this user in that group, and optionally open the course
 if (!empty($group)) {
     $ids = explode(',', $group);
     foreach ($ids as $group) {
         if ($DB->record_exists('groups', array('idnumber' => $group))) {
             $grouprow = $DB->get_record('groups', array('idnumber' => $group));
             enrol_into_course($grouprow->courseid, $user->id);
             if (!$DB->record_exists('groups_members', array('groupid' => $grouprow->id, 'userid' => $user->id))) {
                 // internally triggers groups_member_added event
                 groups_add_member($grouprow->id, $user->id);
                 //  not a component ,'enrol_wp2moodle');
             }
             // if the plugin auto-opens the course, then find the course this group is for and set it as the opener link
             if (get_config('auth/wp2moodle', 'autoopen') == 'yes') {
                 $SESSION->wantsurl = new moodle_url('/course/view.php', array('id' => $grouprow->courseid));
             }
         }
     }
 }
 // also optionally find a courseid we sent in, enrol this user in that course
 if (!empty($course)) {
     // find in table roles, record with shortname = student
     $studentrow = $DB->get_record('role', array('shortname' => 'student'));
     $ids = explode(',', $course);
     foreach ($ids as $course) {
コード例 #29
0
ファイル: lib.php プロジェクト: evltuma/moodle
 /**
  * Self enrol user to course
  *
  * @param stdClass $instance enrolment instance
  * @param stdClass $data data needed for enrolment.
  * @return bool|array true if enroled else eddor code and messege
  */
 public function enrol_self(stdClass $instance, $data = null)
 {
     global $DB, $USER, $CFG;
     // Don't enrol user if password is not passed when required.
     if ($instance->password && !isset($data->enrolpassword)) {
         return;
     }
     $timestart = time();
     if ($instance->enrolperiod) {
         $timeend = $timestart + $instance->enrolperiod;
     } else {
         $timeend = 0;
     }
     $this->enrol_user($instance, $USER->id, $instance->roleid, $timestart, $timeend);
     if ($instance->password and $instance->customint1 and $data->enrolpassword !== $instance->password) {
         // It must be a group enrolment, let's assign group too.
         $groups = $DB->get_records('groups', array('courseid' => $instance->courseid), 'id', 'id, enrolmentkey');
         foreach ($groups as $group) {
             if (empty($group->enrolmentkey)) {
                 continue;
             }
             if ($group->enrolmentkey === $data->enrolpassword) {
                 // Add user to group.
                 require_once $CFG->dirroot . '/group/lib.php';
                 groups_add_member($group->id, $USER->id);
                 break;
             }
         }
     }
     // Send welcome message.
     if ($instance->customint4) {
         $this->email_welcome_message($instance, $USER);
     }
 }
コード例 #30
0
ファイル: plugin_test.php プロジェクト: evltuma/moodle
 /**
  * Enrol users from another course into a course where one of the members is already enrolled
  * and is a member of the same group.
  */
 public function test_add_to_group_with_member()
 {
     global $CFG, $DB;
     require_once $CFG->dirroot . '/group/lib.php';
     $this->resetAfterTest(true);
     $metalplugin = enrol_get_plugin('meta');
     $user1 = $this->getDataGenerator()->create_user();
     $user2 = $this->getDataGenerator()->create_user();
     $course1 = $this->getDataGenerator()->create_course();
     $course2 = $this->getDataGenerator()->create_course();
     $manualenrol1 = $DB->get_record('enrol', array('courseid' => $course1->id, 'enrol' => 'manual'), '*', MUST_EXIST);
     $manualenrol2 = $DB->get_record('enrol', array('courseid' => $course2->id, 'enrol' => 'manual'), '*', MUST_EXIST);
     $student = $DB->get_record('role', array('shortname' => 'student'));
     $groupid = groups_create_group((object) array('name' => 'Grp', 'courseid' => $course2->id));
     $this->enable_plugin();
     set_config('unenrolaction', ENROL_EXT_REMOVED_UNENROL, 'enrol_meta');
     // Manually enrol user1 to course2 and add him to group.
     // Manually enrol user2 to course2 but do not add him to the group.
     enrol_get_plugin('manual')->enrol_user($manualenrol2, $user1->id, $student->id);
     groups_add_member($groupid, $user1->id);
     enrol_get_plugin('manual')->enrol_user($manualenrol2, $user2->id, $student->id);
     $this->assertTrue(groups_is_member($groupid, $user1->id));
     $this->assertFalse(groups_is_member($groupid, $user2->id));
     // Add instance of meta enrolment in course2 linking to course1 and enrol both users in course1.
     $metalplugin->add_instance($course2, array('customint1' => $course1->id, 'customint2' => $groupid));
     enrol_get_plugin('manual')->enrol_user($manualenrol1, $user1->id, $student->id);
     enrol_get_plugin('manual')->enrol_user($manualenrol1, $user2->id, $student->id);
     // Both users now should be members of the group.
     $this->assertTrue(groups_is_member($groupid, $user1->id));
     $this->assertTrue(groups_is_member($groupid, $user2->id));
     // Ununerol both users from course1.
     enrol_get_plugin('manual')->unenrol_user($manualenrol1, $user1->id);
     enrol_get_plugin('manual')->unenrol_user($manualenrol1, $user2->id);
     // User1 should still be member of the group because he was added there manually. User2 should no longer be there.
     $this->assertTrue(groups_is_member($groupid, $user1->id));
     $this->assertFalse(groups_is_member($groupid, $user2->id));
     // Assert that everything is the same after sync.
     enrol_meta_sync();
     $this->assertTrue(groups_is_member($groupid, $user1->id));
     $this->assertFalse(groups_is_member($groupid, $user2->id));
 }