Exemplo n.º 1
0
    /**
     * Set up the database for tests
     *
     * This function is needed so that daily_log_provider has the before-test set up from setUp()
     */
    public function setUpDB() {
        global $DB;

        if ($DB->record_exists('user', array('username' => 'user1'))) {
            return;
        }

        $datagen = self::getDataGenerator();

        $user1   = $datagen->create_user(array('username'=>'user1'));
        $user2   = $datagen->create_user(array('username'=>'user2'));

        $course1 = $datagen->create_course(array('shortname'=>'course1'));

        $success = enrol_try_internal_enrol($course1->id, $user1->id, 5);

        if (! $success) {
            trigger_error('User enrollment failed', E_USER_ERROR);
        }

        $context = context_system::instance();
        role_assign(self::STID, $user2->id, $context->id);

        $this->generate_replacement_list();
    }
Exemplo n.º 2
0
     $ids = explode(',', $course);
     foreach ($ids as $course) {
         $courserow = new stdClass();
         // find course based upon idnumber
         if (intval(trim($course)) == $course) {
             $courserow = $DB->get_record('course', array('id' => intval($course)));
         } elseif (!$courserow && $DB->record_exists('course', array('shortname' => $course))) {
             // find course based upon shortname
             $courserow = $DB->get_record('course', array('shortname' => $course));
         }
         if (empty($courserow)) {
             continue;
         }
         // enrol student to course
         if (get_config('auth/wp2moodle', 'redirectnoenrol') == 'no') {
             if (!enrol_try_internal_enrol($courserow->id, $user->id, $studentrow->id)) {
                 continue;
             }
         }
         // 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' => $courserow->id));
         }
     }
 }
 // all that's left to do is to authenticate this user and set up their active session
 $authplugin = get_auth_plugin('wp2moodle');
 // me!
 if ($authplugin->user_login($user->username, $user->password)) {
     $user->loggedin = true;
     $user->site = $CFG->wwwroot;
/** 
 *  Create a new Module on the Moodle installation based
 * upon the ID of the record in the course request system.
 * 
 */
function block_cmanager_create_new_course_by_record_id($mid, $sendMail)
{
    global $CFG, $DB;
    require_once "{$CFG->libdir}/formslib.php";
    require_once '../../../course/lib.php';
    require_once $CFG->libdir . '/completionlib.php';
    //** Create an object to hold our new course information
    $new_course = new block_cmanager_new_course();
    $new_course->format = get_config('moodlecourse', 'format');
    //Get the default timestamp for new courses
    $timestamp_startdate = $DB->get_field('block_cmanager_config', 'value', array('varname' => 'startdate'), IGNORE_MULTIPLE);
    $new_course->startdate = $timestamp_startdate;
    $new_course->newsitems = get_config('moodlecourse', 'newsitems');
    $new_course->showgrades = get_config('moodlecourse', 'showgrades');
    $new_course->showreports = get_config('moodlecourse', 'showreports');
    $new_course->maxbytes = get_config('moodlecourse', 'maxbytes');
    //Formatting
    $new_course->numsections = get_config('moodlecourse', 'numsections');
    $new_course->hiddensections = get_config('moodlecourse', 'hiddensections');
    // Groups
    $new_course->groupmode = get_config('moodlecourse', 'groupmode');
    $new_course->groupmodeforce = get_config('moodlecourse', 'groupmodeforce');
    //completion
    $new_course->enablecompletion = get_config('moodlecourse', 'enablecompletion');
    // Visible
    $new_course->visible = get_config('moodlecourse', 'visible');
    $new_course->lang = get_config('moodlecourse', 'lang');
    //is course mode enabled (page 1 optional dropdown)
    $mode = $DB->get_field('block_cmanager_config', 'value', array('varname' => 'page1_field3status'));
    // what naming mode is operating
    $naming = $DB->get_field('block_cmanager_config', 'value', array('varname' => 'naming'), IGNORE_MULTIPLE);
    //what short naming format is operating
    $snaming = $DB->get_field('block_cmanager_config', 'value', array('varname' => 'snaming'), IGNORE_MULTIPLE);
    //get the record for the request
    $rec = $DB->get_record('block_cmanager_records', array('id' => $mid));
    // Build up a course record based on the request.
    if (empty($rec->cate)) {
        $new_course->category = $CFG->defaultrequestcategory;
    } else {
        $new_course->category = $rec->cate;
    }
    // Fields we are carrying across
    if ($mode == "enabled" && $snaming == 2) {
        $newShortName = $rec->modcode . ' - ' . $rec->modmode;
    } else {
        $newShortName = $rec->modcode;
    }
    $new_course->shortname = $newShortName;
    $p_key = $rec->modkey;
    //course naming
    if ($naming == 1) {
        $new_course->fullname = $rec->modname;
    } else {
        if ($naming == 2) {
            $new_course->fullname = $rec->modcode . ' - ' . $rec->modname;
        } else {
            if ($naming == 3) {
                $new_course->fullname = $rec->modname . ' (' . $rec->modcode . ')';
                // Fullname, shortname
            } else {
                if ($naming == 4) {
                    $new_course->fullname = $rec->modcode . ' - ' . $rec->modname . ' (' . date("Y") . ')';
                    // Shortname, fullname (year)
                } else {
                    if ($naming == 5) {
                        $new_course->fullname = $rec->modname . ' (' . date("Y") . ')';
                    }
                }
            }
        }
    }
    // Enrollment key
    // if the key thats been set, otherwise auto gen a key
    if (isset($rec->modkey)) {
        $modkey = $rec->modkey;
    } else {
        $modkey = rand(999, 5000);
    }
    $categoryid = $new_course->category;
    $category = $DB->get_record('course_categories', array('id' => $categoryid));
    $catcontext = context_coursecat::instance($category->id);
    $contextobject = $catcontext;
    $editoroptions = array('maxfiles' => EDITOR_UNLIMITED_FILES, 'maxbytes' => $CFG->maxbytes, 'trusttext' => false, 'noclean' => true, 'content' => $contextobject);
    // Create the course
    $course = create_course($new_course, $editoroptions);
    // Forward to the course editing page to allow the admin to make
    // any changes to the course
    $nid = $course->id;
    if ($nid == null) {
        return $nid;
    }
    // Update the record to say that it is now complete
    $updatedRecord = new stdClass();
    $updatedRecord->id = $rec->id;
    $updatedRecord->status = 'COMPLETE';
    $DB->update_record('block_cmanager_records', $updatedRecord);
    // Try enroll the creator
    if (!empty($CFG->creatornewroleid)) {
        // deal with course creators - enrol them internally with default role
        enrol_try_internal_enrol($nid, $rec->createdbyid, $CFG->creatornewroleid);
    }
    // Check to see if auto create enrollment keys
    // is enabled. If this option is set, add an
    // enrollment key.
    $autoKey = $DB->get_field_select('block_cmanager_config', 'value', "varname = 'autoKey'");
    if ($autoKey == 0 || $autoKey == 1) {
        // Add enrollnent key
        $enrollmentRecord = new stdClass();
        $enrollmentRecord->enrol = 'self';
        $enrollmentRecord->status = 0;
        $enrollmentRecord->courseid = $nid;
        $enrollmentRecord->sortorder = 3;
        $enrollmentRecord->name = '';
        $enrollmentRecord->enrolperiod = 0;
        $enrollmentRecord->enrolenddate = 0;
        $enrollmentRecord->expirynotify = 0;
        $enrollmentRecord->expirythreshold = 0;
        $enrollmentRecord->notifyall = 0;
        $enrollmentRecord->password = $modkey;
        $enrollmentRecord->cost = NULL;
        $enrollmentRecord->currency = NULL;
        $enrollmentRecord->roleid = 5;
        $enrollmentRecord->customint1 = 0;
        $enrollmentRecord->customint2 = 0;
        $enrollmentRecord->customint3 = 0;
        $enrollmentRecord->customint4 = 1;
        if ($CFG->version >= 2013051400) {
            $enrollmentRecord->customint5 = NULL;
            $enrollmentRecord->customint6 = 1;
        }
        $enrollmentRecord->customchar1 = NULL;
        $enrollmentRecord->customchar2 = NULL;
        $enrollmentRecord->customdec1 = NULL;
        $enrollmentRecord->customdec2 = NULL;
        $enrollmentRecord->customtext1 = '';
        $enrollmentRecord->customtext2 = NULL;
        $enrollmentRecord->timecreated = time();
        $enrollmentRecord->timemodified = time();
        $DB->insert_record('enrol', $enrollmentRecord);
    }
    if ($sendMail == true) {
        block_cmanager_send_emails($nid, $new_course->shortname, $new_course->fullname, $modkey, $mid);
    }
    return $nid;
}
Exemplo n.º 4
0
        }
        redirect($url);

} else if ($data = $editform->get_data()) {
    // process data if submitted

    if (empty($course->id)) {
        // In creating the course
        $course = create_course($data, $editoroptions);

        // Get the context of the newly created course
        $context = get_context_instance(CONTEXT_COURSE, $course->id, MUST_EXIST);

        if (!empty($CFG->creatornewroleid) and !is_viewing($context, NULL, 'moodle/role:assign') and !is_enrolled($context, NULL, 'moodle/role:assign')) {
            // deal with course creators - enrol them internally with default role
            enrol_try_internal_enrol($course->id, $USER->id, $CFG->creatornewroleid);

        }
        if (!is_enrolled($context)) {
            // Redirect to manual enrolment page if possible
            $instances = enrol_get_instances($course->id, true);
            foreach($instances as $instance) {
                if ($plugin = enrol_get_plugin($instance->enrol)) {
                    if ($plugin->get_manual_enrol_link($instance)) {
                        // we know that the ajax enrol UI will have an option to enrol
                        redirect(new moodle_url('/enrol/users.php', array('id'=>$course->id)));
                    }
                }
            }
        }
    } else {
if (count($users) > 0 and $form = data_submitted() and confirm_sesskey()) {
    if (count($users) > 0) {
        $assignableroles = get_assignable_roles(get_context_instance(CONTEXT_COURSE, $courseid));
        if (array_key_exists($role->id, $assignableroles)) {
            // For each "userd" in the form...
            foreach ($form->userid as $userid => $value) {
                $user_has_role = $DB->record_exists('role_assignments', array('userid' => $userid, 'contextid' => $context->id, 'roleid' => $roleid));
                // Assign or Unassign role
                /*if ( $assign_unassign == 1 && $user_has_role ) {
                      role_unassign( $role->id, $userid, $context->id );
                  } else*/
                if (!$user_has_role) {
                    role_assign($role->id, $userid, $context->id);
                }
                if (!is_enrolled($context, $userid)) {
                    enrol_try_internal_enrol($courseid, $userid);
                }
            }
        }
    }
    global $SESSION;
    $SESSION->user_filtering = array();
    // Redirect to calling page
    redirect('pick.php?courseid=' . $courseid, get_string('changessaved'));
}
$PAGE->set_url('/blocks/pick_students/assign.php');
$PAGE->set_pagelayout('base');
$title = print_context_name($context) . ' - ';
$strtitle = get_string('enrolledusers', 'enrol');
$PAGE->set_title($strtitle);
$PAGE->set_heading($title . $strtitle);
 /**
  * Validate that LO grades are locked when they are updated and grade
  * is sufficient when run for a specific user
  */
 public function test_methodlockslearningobjectivegradesduringupdateforspecificuserid()
 {
     global $DB;
     $this->load_csv_data();
     // Create enrolment.
     $this->make_course_enrollable();
     enrol_try_internal_enrol(2, 100, 1);
     enrol_try_internal_enrol(2, 101, 1);
     // Create LO and Moodle grade.
     $itemid = $this->create_grade_item();
     $this->create_grade_grade($itemid, 100, 75, 100, 1);
     $this->create_grade_grade($itemid, 101, 75, 100, 1);
     $this->create_course_completion('manualitem', 50);
     // Enrol in PM class.
     $studentgrade = new \student_grade(array('userid' => 103, 'classid' => 100, 'completionid' => 1, 'grade' => 75, 'locked' => 0, 'timegraded' => 1));
     $studentgrade->save();
     $studentgrade = new \student_grade(array('userid' => 104, 'classid' => 100, 'completionid' => 1, 'grade' => 75, 'locked' => 0, 'timegraded' => 1));
     $studentgrade->save();
     // Validate setup.
     $this->assert_num_student_grades(2);
     $count = $DB->count_records(\student_grade::TABLE, array('locked' => 1));
     $this->assertEquals(0, $count);
     $this->assert_student_grade_exists(100, 103, 1, null, 0);
     // Update Moodle info.
     $DB->execute("UPDATE {grade_grades} SET finalgrade = 80, timemodified = 2");
     // Run and validate.
     $sync = new \local_elisprogram\moodle\synchronize();
     $sync->synchronize_moodle_class_grades(100);
     $this->assert_num_student_grades(2);
     $count = $DB->count_records(\student_grade::TABLE, array('locked' => 1));
     $this->assertEquals(1, $count);
     $this->assert_student_grade_exists(100, 103, 1, null, 1);
 }
Exemplo n.º 7
0
 /**
  * Create an enrolment
  *
  * @param object $record One record of import data
  * @param string $filename The import file name, used for logging
  * @return boolean true on success, otherwise false
  */
 function enrolment_create($record, $filename)
 {
     global $CFG, $DB;
     require_once $CFG->dirroot . '/lib/enrollib.php';
     //set initial logging state with respect to enrolments (give non-specific message for now)
     $this->fslogger->set_enrolment_state(false, false);
     //field length checking
     $lengthcheck = $this->check_enrolment_field_lengths($record, $filename);
     if (!$lengthcheck) {
         return false;
     }
     //data checking
     if (!($roleid = $DB->get_field('role', 'id', array('shortname' => $record->role)))) {
         $identifier = $this->mappings['role'];
         $this->fslogger->log_failure("{$identifier} value of \"{$record->role}\" does not refer " . "to a valid role.", 0, $filename, $this->linenumber, $record, 'enrolment');
         return false;
     }
     // Check for valid enrolment time
     if (isset($record->enrolmenttime)) {
         $value = $this->parse_date($record->enrolmenttime);
         if ($value === false) {
             $identifier = $this->mappings['enrolmenttime'];
             $this->fslogger->log_failure("{$identifier} value of \"{$record->enrolmenttime}\" is not a valid date in " . "MM/DD/YYYY, DD-MM-YYYY, YYYY.MM.DD, or MMM/DD/YYYY format.", 0, $filename, $this->linenumber, $record, "enrolment");
             return false;
         }
     }
     // Check for valid complete time
     if (isset($record->completetime)) {
         $value = $this->parse_date($record->completetime);
         if ($value === false) {
             $identifier = $this->mappings['completetime'];
             $this->fslogger->log_failure("{$identifier} value of \"{$record->completetime}\" is not a valid date in " . "MM/DD/YYYY, DD-MM-YYYY, YYYY.MM.DD, or MMM/DD/YYYY format.", 0, $filename, $this->linenumber, $record, "enrolment");
             return false;
         }
     }
     //find existing user record
     if (!($userid = $this->get_userid_from_record($record, $filename))) {
         return false;
     }
     //track context info
     $contextinfo = $this->get_contextinfo_from_record($record, $filename);
     if ($contextinfo == false) {
         return false;
     }
     list($contextlevel, $context) = $contextinfo;
     //make sure the role is assignable at the course context level
     if (!$DB->record_exists('role_context_levels', array('roleid' => $roleid, 'contextlevel' => $contextlevel))) {
         $this->fslogger->log_failure("The role with shortname \"{$record->role}\" is not assignable " . "on the {$record->context} context level.", 0, $filename, $this->linenumber, $record, "enrolment");
         return false;
     }
     //note: this seems redundant but will be useful for error messages later
     $params = array('roleid' => $roleid, 'contextid' => $context->id, 'userid' => $userid, 'component' => '', 'itemid' => 0);
     $role_assignment_exists = $DB->record_exists('role_assignments', $params);
     //track whether an enrolment exists
     $enrolment_exists = false;
     if ($contextlevel == CONTEXT_COURSE) {
         $enrolment_exists = is_enrolled($context, $userid);
     }
     //after this point, general error messages should contain role assignment info
     //they should also contain enrolment info if the context is a course
     $track_enrolments = $record->context == 'course';
     $this->fslogger->set_enrolment_state(true, $track_enrolments);
     //track the group and grouping specified
     $groupid = 0;
     $groupingid = 0;
     //duplicate group / grouping name checks and name validity checking
     if ($record->context == 'course' && isset($record->group)) {
         $count = $DB->count_records('groups', array('name' => $record->group, 'courseid' => $context->instanceid));
         $creategroups = get_config('dhimport_version1', 'creategroupsandgroupings');
         if ($count > 1) {
             //ambiguous
             $identifier = $this->mappings['group'];
             $this->fslogger->log_failure("{$identifier} value of \"{$record->group}\" refers to multiple " . "groups in course with shortname \"{$record->instance}\".", 0, $filename, $this->linenumber, $record, 'enrolment');
             return false;
         } else {
             if ($count == 0 && empty($creategroups)) {
                 //does not exist and not creating
                 $identifier = $this->mappings['group'];
                 $this->fslogger->log_failure("{$identifier} value of \"{$record->group}\" does not refer to " . "a valid group in course with shortname \"{$record->instance}\".", 0, $filename, $this->linenumber, $record, "enrolment");
                 return false;
             } else {
                 //exact group exists
                 $groupid = groups_get_group_by_name($context->instanceid, $record->group);
             }
         }
         if (isset($record->grouping)) {
             $count = $DB->count_records('groupings', array('name' => $record->grouping, 'courseid' => $context->instanceid));
             if ($count > 1) {
                 //ambiguous
                 $identifier = $this->mappings['grouping'];
                 $this->fslogger->log_failure("{$identifier} value of \"{$record->grouping}\" refers to multiple " . "groupings in course with shortname \"{$record->instance}\".", 0, $filename, $this->linenumber, $record, "enrolment");
                 return false;
             } else {
                 if ($count == 0 && empty($creategroups)) {
                     //does not exist and not creating
                     $identifier = $this->mappings['grouping'];
                     $this->fslogger->log_failure("{$identifier} value of \"{$record->grouping}\" does not refer to " . "a valid grouping in course with shortname \"{$record->instance}\".", 0, $filename, $this->linenumber, $record, "enrolment");
                     return false;
                 } else {
                     //exact grouping exists
                     $groupingid = groups_get_grouping_by_name($context->instanceid, $record->grouping);
                 }
             }
         }
     }
     //string to describe the user
     $user_descriptor = $this->get_user_descriptor($record);
     //string to describe the context instance
     $context_descriptor = $this->get_context_descriptor($record);
     //going to collect all messages for this action
     $logmessages = array();
     if ($record->context == 'course') {
         // Set enrolment start and end time if specified, otherwise set enrolment time to 'now' to allow immediate access.
         $timestart = empty($record->enrolmenttime) ? time() : $this->parse_date($record->enrolmenttime);
         $timeend = empty($record->completetime) ? 0 : $this->parse_date($record->completetime);
         if ($role_assignment_exists && !$enrolment_exists) {
             // Role assignment already exists, so just enrol the user.
             enrol_try_internal_enrol($context->instanceid, $userid, null, $timestart, $timeend);
         } else {
             if (!$enrolment_exists) {
                 // Role assignment does not exist, so enrol and assign role.
                 enrol_try_internal_enrol($context->instanceid, $userid, $roleid, $timestart, $timeend);
                 //collect success message for logging at end of action
                 $logmessages[] = "User with {$user_descriptor} successfully assigned role with shortname " . "\"{$record->role}\" on {$context_descriptor}.";
             } else {
                 if (!$role_assignment_exists) {
                     //just assign the role
                     role_assign($roleid, $userid, $context->id);
                     //collect success message for logging at end of action
                     $logmessages[] = "User with {$user_descriptor} successfully assigned role with " . "shortname \"{$record->role}\" on {$context_descriptor}.";
                 } else {
                     //duplicate enrolment attempt
                     $this->fslogger->log_failure("User with {$user_descriptor} is already assigned role " . "with shortname \"{$record->role}\" on {$context_descriptor}. " . "User with {$user_descriptor} is already enrolled in course with " . "shortname \"{$record->instance}\".", 0, $filename, $this->linenumber, $record, 'enrolment');
                     return false;
                 }
             }
         }
         //collect success message for logging at end of action
         if (!$enrolment_exists) {
             $logmessages[] = "User with {$user_descriptor} enrolled in course with shortname \"{$record->instance}\".";
             if (!empty($context->instanceid) && !empty($userid)) {
                 $this->newenrolmentemail($userid, $context->instanceid);
             }
         }
     } else {
         if ($role_assignment_exists) {
             //role assignment already exists, so this action serves no purpose
             $this->fslogger->log_failure("User with {$user_descriptor} is already assigned role " . "with shortname \"{$record->role}\" on {$context_descriptor}.", 0, $filename, $this->linenumber, $record, 'enrolment');
             return false;
         }
         role_assign($roleid, $userid, $context->id);
         //collect success message for logging at end of action
         $logmessages[] = "User with {$user_descriptor} successfully assigned role with shortname \"{$record->role}\" on {$context_descriptor}.";
     }
     if ($record->context == 'course' && isset($record->group)) {
         //process specified group
         require_once $CFG->dirroot . '/lib/grouplib.php';
         require_once $CFG->dirroot . '/group/lib.php';
         if ($groupid == 0) {
             //need to create the group
             $data = new stdClass();
             $data->courseid = $context->instanceid;
             $data->name = $record->group;
             $groupid = groups_create_group($data);
             //collect success message for logging at end of action
             $logmessages[] = "Group created with name \"{$record->group}\".";
         }
         if (groups_is_member($groupid, $userid)) {
             //error handling
             $logmessages[] = "User with {$user_descriptor} is already assigned to group with name \"{$record->group}\".";
         } else {
             //try to assign the user to the group
             if (!groups_add_member($groupid, $userid)) {
                 //should never happen
             }
             //collect success message for logging at end of action
             $logmessages[] = "Assigned user with {$user_descriptor} to group with name \"{$record->group}\".";
         }
         if (isset($record->grouping)) {
             //process the specified grouping
             if ($groupingid == 0) {
                 //need to create the grouping
                 $data = new stdClass();
                 $data->courseid = $context->instanceid;
                 $data->name = $record->grouping;
                 $groupingid = groups_create_grouping($data);
                 //collect success message for logging at end of action
                 $logmessages[] = "Created grouping with name \"{$record->grouping}\".";
             }
             //assign the group to the grouping
             if ($DB->record_exists('groupings_groups', array('groupingid' => $groupingid, 'groupid' => $groupid))) {
                 //error handling
                 $logmessages[] = "Group with name \"{$record->group}\" is already assigned to grouping with name \"{$record->grouping}\".";
             } else {
                 if (!groups_assign_grouping($groupingid, $groupid)) {
                     //should never happen
                 }
                 //collect success message for logging at end of action
                 $logmessages[] = "Assigned group with name \"{$record->group}\" to grouping with name \"{$record->grouping}\".";
             }
         }
     }
     //log success
     $this->fslogger->log_success(implode(' ', $logmessages), 0, $filename, $this->linenumber);
     if (!$this->fslogger->get_logfile_status()) {
         return false;
     }
     return true;
 }
Exemplo n.º 8
0
/**
 * Import user and signup to session
 *
 * @access  public
 * @param   object  $course             Record from the course table
 * @param   object  $facetoface         Record from the facetoface table
 * @param   object  $session            Session to signup user to
 * @param   mixed   $userid             User to signup (normally int)
 * @param   array   $params             Optional suppressemail, ignoreconflicts, bulkaddsource, discountcode, notificationtype
 *          boolean $suppressemail      Suppress notifications flag
 *          boolean $ignoreconflicts    Ignore booking conflicts flag
 *          string  $bulkaddsource      Flag to indicate if $userid is actually another field
 *          string  $discountcode       Optional A user may specify a discount code
 *          integer $notificationtype   Optional A user may choose the type of notifications they will receive
 * @return  array
 */
function facetoface_user_import($course, $facetoface, $session, $userid, $params = array()) {
    global $DB, $CFG, $USER;

    $result = array();
    $result['id'] = $userid;

    $suppressemail    = (isset($params['suppressemail'])    ? $params['suppressemail']    : false);
    $ignoreconflicts  = (isset($params['ignoreconflicts'])  ? $params['ignoreconflicts']  : false);
    $bulkaddsource    = (isset($params['bulkaddsource'])    ? $params['bulkaddsource']    : 'bulkaddsourceuserid');
    $discountcode     = (isset($params['discountcode'])     ? $params['discountcode']     : '');
    $notificationtype = (isset($params['notificationtype']) ? $params['notificationtype'] : MDL_F2F_BOTH);

    if (isset($params['approvalreqd'])) {
        // Overwrite default behaviour as bulkadd_* is requested
        $facetoface->approvalreqd = $params['approvalreqd'];
        $facetoface->ccmanager = (isset($params['ccmanager']) ? $params['ccmanager'] : 0);
    }

    // Check parameters.
    if ($bulkaddsource == 'bulkaddsourceuserid') {
        if (!is_int($userid) && !ctype_digit($userid)) {
            $result['name'] = '';
            $result['result'] = get_string('error:userimportuseridnotanint', 'facetoface', $userid);
            return $result;
        }
    }

    // Get user.
    switch ($bulkaddsource) {
        case 'bulkaddsourceuserid':
            $user = $DB->get_record('user', array('id' => $userid));
            break;
        case 'bulkaddsourceidnumber':
            $user = $DB->get_record('user', array('idnumber' => $userid));
            break;
        case 'bulkaddsourceusername':
            $user = $DB->get_record('user', array('username' => $userid));
            break;
    }
    if (!$user) {
        $result['name'] = '';
        $a = array('fieldname' => get_string($bulkaddsource, 'facetoface'), 'value' => $userid);
        $result['result'] = get_string('userdoesnotexist', 'facetoface', $a);
        return $result;
    }

    $result['name'] = fullname($user);

    if (isguestuser($user)) {
        $a = array('fieldname' => get_string($bulkaddsource, 'facetoface'), 'value' => $userid);
        $result['result'] = get_string('cannotsignupguest', 'facetoface', $a);
        return $result;
    }

    // Make sure that the user is enroled in the course
    $context   = context_course::instance($course->id);
    if (!is_enrolled($context, $user)) {

        $defaultlearnerrole = $DB->get_record('role', array('id' => $CFG->learnerroleid));

        if (!enrol_try_internal_enrol($course->id, $user->id, $defaultlearnerrole->id, time())) {
            $result['result'] = get_string('error:enrolmentfailed', 'facetoface', fullname($user));
            return $result;
        }
    }

    // Check if they are already signed up
    $minimumstatus = ($session->datetimeknown) ? MDL_F2F_STATUS_BOOKED : MDL_F2F_STATUS_REQUESTED;
    // If multiple sessions are allowed then just check against this session
    // Otherwise check against all sessions
    $multisessionid = ($facetoface->multiplesessions ? $session->id : null);
    if (facetoface_get_user_submissions($facetoface->id, $user->id, $minimumstatus, MDL_F2F_STATUS_FULLY_ATTENDED, $multisessionid)) {
        if ($user->id == $USER->id) {
            $result['result'] = get_string('error:addalreadysignedupattendeeaddself', 'facetoface');
        } else {
            $result['result'] = get_string('error:addalreadysignedupattendee', 'facetoface');
        }
        return $result;
    }

    if (!facetoface_session_has_capacity($session, $context)) {
        if ($session->allowoverbook) {
            $status = MDL_F2F_STATUS_WAITLISTED;
        } else {
            $result['result'] = get_string('full', 'facetoface');
            return $result;
        }
    }

    // Check if we are waitlisting or booking
    if ($session->datetimeknown) {
        if (!isset($status)) {
            $status = MDL_F2F_STATUS_BOOKED;
        }

        // Check if there are any date conflicts
        if (!$ignoreconflicts) {
            $dates = facetoface_get_session_dates($session->id);
            if ($availability = facetoface_get_sessions_within($dates, $user->id)) {
                $result['result'] = facetoface_get_session_involvement($user, $availability);
                $result['conflict'] = true;
                return $result;
            }
        }
    } else {
        $status = MDL_F2F_STATUS_WAITLISTED;
    }

    // Finally attempt to enrol
    if (!facetoface_user_signup(
        $session,
        $facetoface,
        $course,
        $discountcode,
        $notificationtype,
        $status,
        $user->id,
        !$suppressemail)) {
            $result['result'] = get_string('error:addattendee', 'facetoface', fullname($user));
            return $result;
    }

    $result['result'] = true;
    return $result;
}
Exemplo n.º 9
0
    /**
     * Test the group event handlers
     */
    public function test_group_event_handlers() {
        global $DB,$CFG;

        $this->resetAfterTest();

        $this->setAdminUser();

        // Setup course, user and groups

        $course = $this->getDataGenerator()->create_course();
        $user1 = $this->getDataGenerator()->create_user();
        $studentrole = $DB->get_record('role', array('shortname'=>'student'));
        $this->assertNotEmpty($studentrole);
        $this->assertTrue(enrol_try_internal_enrol($course->id, $user1->id, $studentrole->id));
        $group1 = $this->getDataGenerator()->create_group(array('courseid'=>$course->id));
        $group2 = $this->getDataGenerator()->create_group(array('courseid'=>$course->id));
        $this->assertTrue(groups_add_member($group1, $user1));
        $this->assertTrue(groups_add_member($group2, $user1));

        $uniqueid = 0;

        $quiz_generator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');

        $quiz = $quiz_generator->create_instance(array('course'=>$course->id, 'timeclose'=>1200, 'timelimit'=>0));

        // add a group1 override
        $DB->insert_record('quiz_overrides', array('quiz'=>$quiz->id, 'groupid'=>$group1->id, 'timeclose'=>1300, 'timelimit'=>null));

        // add an attempt
        $attemptid = $DB->insert_record('quiz_attempts', array('quiz'=>$quiz->id, 'userid'=>$user1->id, 'state'=>'inprogress', 'timestart'=>100, 'timecheckstate'=>0, 'layout'=>'', 'uniqueid'=>$uniqueid++));

        // update timecheckstate
        quiz_update_open_attempts(array('quizid'=>$quiz->id));
        $this->assertEquals(1300, $DB->get_field('quiz_attempts', 'timecheckstate', array('id'=>$attemptid)));

        // remove from group
        $this->assertTrue(groups_remove_member($group1, $user1));
        $this->assertEquals(1200, $DB->get_field('quiz_attempts', 'timecheckstate', array('id'=>$attemptid)));

        // add back to group
        $this->assertTrue(groups_add_member($group1, $user1));
        $this->assertEquals(1300, $DB->get_field('quiz_attempts', 'timecheckstate', array('id'=>$attemptid)));

        // delete group
        groups_delete_group($group1);
        $this->assertEquals(1200, $DB->get_field('quiz_attempts', 'timecheckstate', array('id'=>$attemptid)));
        $this->assertEquals(0, $DB->count_records('quiz_overrides', array('quiz'=>$quiz->id)));

        // add a group2 override
        $DB->insert_record('quiz_overrides', array('quiz'=>$quiz->id, 'groupid'=>$group2->id, 'timeclose'=>1400, 'timelimit'=>null));
        quiz_update_open_attempts(array('quizid'=>$quiz->id));
        $this->assertEquals(1400, $DB->get_field('quiz_attempts', 'timecheckstate', array('id'=>$attemptid)));

        // delete user1 from all groups
        groups_delete_group_members($course->id, $user1->id);
        $this->assertEquals(1200, $DB->get_field('quiz_attempts', 'timecheckstate', array('id'=>$attemptid)));

        // add back to group2
        $this->assertTrue(groups_add_member($group2, $user1));
        $this->assertEquals(1400, $DB->get_field('quiz_attempts', 'timecheckstate', array('id'=>$attemptid)));

        // delete everyone from all groups
        groups_delete_group_members($course->id);
        $this->assertEquals(1200, $DB->get_field('quiz_attempts', 'timecheckstate', array('id'=>$attemptid)));
    }
 /**
  * Validates that, for deletion of a course role that is not assigned, an error is logged
  * instead of deleting the user's enrolment if they have some other role assignment on
  * the coruse
  */
 public function test_version1importlogsdeletionofenrolmentwhenrolesassignmentsexist()
 {
     global $CFG, $DB;
     require_once $CFG->dirroot . '/lib/enrollib.php';
     // Set up dependencies.
     $userid = $this->create_test_user();
     $unassignedroleid = $this->create_test_role('unassigned', 'unassigned', 'unassigned');
     $assignedroleid = $this->create_test_role('assigned', 'assigned', 'assigned');
     $courseid = $this->create_test_course();
     set_config('siteguest', '');
     $enrol = new stdClass();
     $enrol->enrol = 'manual';
     $enrol->courseid = $courseid;
     $enrol->status = ENROL_INSTANCE_ENABLED;
     $DB->insert_record('enrol', $enrol);
     // Set up a role assignment and an enrolment.
     enrol_try_internal_enrol($courseid, $userid, $assignedroleid);
     // Data.
     $data = array('action' => 'delete', 'username' => 'rlipusername', 'context' => 'course', 'instance' => 'rlipshortname', 'role' => 'unassigned');
     $message = "[enrolment.csv line 2] User with username \"rlipusername\" could not be unassigned role with shortname";
     $message .= " \"unassigned\" on course \"rlipshortname\". User with username \"rlipusername\" could not be unenrolled";
     $message .= " from course with shortname \"rlipshortname\". User with username \"rlipusername\" is not assigned role";
     $message .= " with shortname \"unassigned\" on course \"rlipshortname\". User with username \"rlipusername\" requires";
     $message .= " their enrolment to be maintained because they have another role assignment in this course.\n";
     $this->assert_data_produces_error($data, $message, 'enrolment');
 }
 /**
  * Validate that the import prevents assigning a user to the same group
  * twice
  */
 public function test_version1importpreventsduplicateusergroupassignments()
 {
     global $CFG, $DB;
     require_once $CFG->dirroot . '/group/lib.php';
     // Enrol the user in the course.
     enrol_try_internal_enrol(self::$courseid, self::$userid, self::$courseroleid, 0);
     // Set up the "pre-existing" group.
     $groupid = $this->create_test_group(self::$courseid);
     // Add the user to the group.
     groups_add_member($groupid, self::$userid);
     // Validate setup.
     $this->assertEquals($DB->count_records('groups_members'), 1);
     // Run the import.
     $data = $this->get_core_enrolment_data();
     $data['group'] = 'rlipgroup';
     $this->run_core_enrolment_import($data, false);
     // Compare data.
     $this->assertEquals($DB->count_records('groups_members'), 1);
 }
Exemplo n.º 12
0
 /**
  * Validate that the version 1 plugin deletes appropriate associations when
  * deleting a user
  */
 public function test_version1importdeleteuserdeletesassociations()
 {
     global $CFG, $DB;
     set_config('siteadmins', 0);
     // New config settings needed for course format refactoring in 2.4.
     set_config('numsections', 15, 'moodlecourse');
     set_config('hiddensections', 0, 'moodlecourse');
     set_config('coursedisplay', 1, 'moodlecourse');
     require_once $CFG->dirroot . '/cohort/lib.php';
     require_once $CFG->dirroot . '/course/lib.php';
     require_once $CFG->dirroot . '/group/lib.php';
     require_once $CFG->dirroot . '/lib/enrollib.php';
     require_once $CFG->dirroot . '/lib/gradelib.php';
     // Create our test user, and determine their userid.
     $this->run_core_user_import(array());
     $userid = (int) $DB->get_field('user', 'id', array('username' => 'rlipusername', 'mnethostid' => $CFG->mnet_localhost_id));
     // Create cohort.
     $cohort = new stdClass();
     $cohort->name = 'testcohort';
     $cohort->contextid = context_system::instance()->id;
     $cohortid = cohort_add_cohort($cohort);
     // Add the user to the cohort.
     cohort_add_member($cohortid, $userid);
     // Create a course category - there is no API for doing this.
     $category = new stdClass();
     $category->name = 'testcategory';
     $category->id = $DB->insert_record('course_categories', $category);
     // Create a course.
     set_config('defaultenrol', 1, 'enrol_manual');
     set_config('status', ENROL_INSTANCE_ENABLED, 'enrol_manual');
     $course = new stdClass();
     $course->category = $category->id;
     $course->fullname = 'testfullname';
     $course = create_course($course);
     // Create a grade.
     $gradeitem = new grade_item(array('courseid' => $course->id, 'itemtype' => 'manual', 'itemname' => 'testitem'), false);
     $gradeitem->insert();
     $gradegrade = new grade_grade(array('itemid' => $gradeitem->id, 'userid' => $userid), false);
     $gradegrade->insert();
     // Send the user an unprocessed message.
     set_config('noemailever', true);
     // Set up a user tag.
     tag_set('user', $userid, array('testtag'));
     // Create a new course-level role.
     $roleid = create_role('testrole', 'testrole', 'testrole');
     set_role_contextlevels($roleid, array(CONTEXT_COURSE));
     // Enrol the user in the course with the new role.
     enrol_try_internal_enrol($course->id, $userid, $roleid);
     // Create a group.
     $group = new stdClass();
     $group->name = 'testgroup';
     $group->courseid = $course->id;
     $groupid = groups_create_group($group);
     // Add the user to the group.
     groups_add_member($groupid, $userid);
     set_user_preference('testname', 'testvalue', $userid);
     // Create profile field data - don't both with the API here because it's a bit unwieldy.
     $userinfodata = new stdClass();
     $userinfodata->fieldid = 1;
     $userinfodata->data = 'bogus';
     $userinfodata->userid = $userid;
     $DB->insert_record('user_info_data', $userinfodata);
     // There is no easily accessible API for doing this.
     $lastaccess = new stdClass();
     $lastaccess->userid = $userid;
     $lastaccess->courseid = $course->id;
     $DB->insert_record('user_lastaccess', $lastaccess);
     $data = array('action' => 'delete', 'username' => 'rlipusername');
     $this->run_core_user_import($data, false);
     // Assert data condition after delete.
     $this->assertEquals($DB->count_records('message_read', array('useridto' => $userid)), 0);
     $this->assertEquals($DB->count_records('grade_grades'), 0);
     $this->assertEquals($DB->count_records('tag_instance'), 0);
     $this->assertEquals($DB->count_records('cohort_members'), 0);
     $this->assertEquals($DB->count_records('user_enrolments'), 0);
     $this->assertEquals($DB->count_records('role_assignments'), 0);
     $this->assertEquals($DB->count_records('groups_members'), 0);
     $this->assertEquals($DB->count_records('user_preferences'), 0);
     $this->assertEquals($DB->count_records('user_info_data'), 0);
     $this->assertEquals($DB->count_records('user_lastaccess'), 0);
 }
Exemplo n.º 13
0
     if (!$demostudentuser) {
         // Test this by setting $demostudentuser to false.
         print get_string('errorfailedtocreateuser', 'block_demostudent', $demostudentusername);
         print get_string('returntocourse', 'block_demostudent', $url);
         exit;
     }
 }
 // Else DemoStudent user already exists for this instructor.
 $demostudentid = $demostudentuser->id;
 // Enrol DemoStudent in this course (as a demostudent).
 $demostudentroleid = get_roleid_by_roleshortname('demostudent');
 if (!$demostudentroleid) {
     print get_string('warningmissingrole', 'block_demostudent');
 }
 if (!is_enrolled($coursecontext, $demostudentuser)) {
     if (!enrol_try_internal_enrol($courseid, $demostudentid, $demostudentroleid)) {
         // Enrolment failed.  Haven't seen this happen yet.
         trigger_error('DemoStudent user enrolment failed!<br>Parameters:<br>' . '<br> url=' . var_export($url, true) . '<br> viewrole=' . var_export($viewrole, true) . '<br> courseid=' . var_export($courseid, true) . '<br>Globals:' . '<br> userid=' . var_export($userid, true) . '<br> username='******'<br>Locals:' . '<br> demostudentid=' . var_export($demostudentid, true) . '<br> demostudentroleid=' . var_export($demostudentroleid, true) . '<br> coursecontext=' . var_export($coursecontext, true) . '<br> demostudentuser='******'s possible that the function failed, but that the user is nevertheless enrolled.
         // If the user is not enrolled, a later check will take care of things.
     }
 }
 // Aditionally, if we are switching from 'instructor' view (i.e., not in 'firstuse' mode), switch user.
 if ($viewrole == 'instructor') {
     if (is_siteadmin($demostudentid)) {
         // This should never happen.  Haven't seen it happen yet.
         print_error('nologinas');
     }
     if (!is_enrolled($coursecontext, $demostudentid)) {
         // This should never happen.  Haven't seen it happen yet.
         print_error('usernotincourse');
Exemplo n.º 14
0
 /**
  * Validate that the version 1 plugin deletes appropriate associations when
  * deleting a course
  */
 public function test_version1importdeletecoursedeletesassociations()
 {
     global $DB, $CFG, $USER;
     require_once $CFG->dirroot . '/user/lib.php';
     require_once $CFG->dirroot . '/lib/gradelib.php';
     require_once $CFG->dirroot . '/group/lib.php';
     require_once $CFG->dirroot . '/lib/conditionlib.php';
     require_once $CFG->dirroot . '/lib/enrollib.php';
     require_once $CFG->dirroot . '/tag/lib.php';
     require_once $CFG->dirroot . '/lib/questionlib.php';
     // Setup.
     $initialnumcontexts = $DB->count_records('context', array('contextlevel' => CONTEXT_COURSE));
     $DB->delete_records('block_instances');
     // Set up the course with one section, including default blocks.
     set_config('defaultblocks_topics', 'search_forums');
     set_config('maxsections', 10, 'moodlecourse');
     $this->run_core_course_import(array('shortname' => 'deleteassociationsshortname', 'numsections' => 1));
     // Create a user record.
     $record = new stdClass();
     $record->username = '******';
     $record->password = '******';
     $userid = user_create_user($record);
     // Create a course-level role.
     $courseid = $DB->get_field('course', 'id', array('shortname' => 'deleteassociationsshortname'));
     $coursecontext = context_course::instance($courseid);
     $roleid = create_role('deleterole', 'deleterole', 'deleterole');
     set_role_contextlevels($roleid, array(CONTEXT_COURSE));
     $enrol = new stdClass();
     $enrol->enrol = 'manual';
     $enrol->courseid = $courseid;
     $enrol->status = ENROL_INSTANCE_ENABLED;
     if (!$DB->record_exists('enrol', (array) $enrol)) {
         $DB->insert_record('enrol', $enrol);
     }
     // Assign the user to the course-level role.
     enrol_try_internal_enrol($courseid, $userid, $roleid);
     // Create a grade item.
     $gradeitem = new grade_item(array('courseid' => $courseid, 'itemtype' => 'manual', 'itemname' => 'testitem'), false);
     $gradeitem->insert();
     $gradegrade = new grade_grade(array('itemid' => $gradeitem->id, 'userid' => $userid), false);
     // Assign the user a grade.
     $gradegrade->insert();
     // Create a grade outcome.
     $gradeoutcome = new grade_outcome(array('courseid' => $courseid, 'shortname' => 'bogusshortname', 'fullname' => 'bogusfullname'));
     $gradeoutcome->insert();
     // Create a grade scale.
     $gradescale = new grade_scale(array('courseid' => $courseid, 'name' => 'bogusname', 'userid' => $userid, 'scale' => 'bogusscale', 'description' => 'bogusdescription'));
     $gradescale->insert();
     // Set a grade setting value.
     grade_set_setting($courseid, 'bogus', 'bogus');
     // Set up a grade letter.
     $gradeletter = new stdClass();
     $gradeletter->contextid = $coursecontext->id;
     $gradeletter->lowerboundary = 80;
     $gradeletter->letter = 'A';
     $DB->insert_record('grade_letters', $gradeletter);
     // Set up a forum instance.
     $forum = new stdClass();
     $forum->course = $courseid;
     $forum->intro = 'intro';
     $forum->id = $DB->insert_record('forum', $forum);
     // Add it as a course module.
     $forum->module = $DB->get_field('modules', 'id', array('name' => 'forum'));
     $forum->instance = $forum->id;
     $cmid = add_course_module($forum);
     // Set up a completion record.
     $completion = new stdClass();
     $completion->coursemoduleid = $cmid;
     $completion->completionstate = 0;
     $completion->userid = 9999;
     $completion->timemodified = time();
     $DB->insert_record('course_modules_completion', $completion);
     // Set up a completion condition.
     $forum->id = $cmid;
     $ci = new condition_info($forum, CONDITION_MISSING_EVERYTHING, false);
     $ci->add_completion_condition($cmid, COMPLETION_ENABLED);
     // Set the blocks position.
     $instances = $DB->get_records('block_instances', array('parentcontextid' => $coursecontext->id));
     $page = new stdClass();
     $page->context = $coursecontext;
     $page->pagetype = 'course-view-*';
     $page->subpage = false;
     foreach ($instances as $instance) {
         blocks_set_visibility($instance, $page, 1);
     }
     // Create a group.
     $group = new stdClass();
     $group->name = 'testgroup';
     $group->courseid = $courseid;
     $groupid = groups_create_group($group);
     // Add the user to the group.
     groups_add_member($groupid, $userid);
     // Create a grouping containing our group.
     $grouping = new stdClass();
     $grouping->name = 'testgrouping';
     $grouping->courseid = $courseid;
     $groupingid = groups_create_grouping($grouping);
     groups_assign_grouping($groupingid, $groupid);
     // Set up a user tag.
     tag_set('course', $courseid, array('testtag'));
     // Add a course-level log.
     add_to_log($courseid, 'bogus', 'bogus');
     // Set up the default course question category.
     $newcategory = question_make_default_categories(array($coursecontext));
     // Create a test question.
     $question = new stdClass();
     $question->qtype = 'truefalse';
     $form = new stdClass();
     $form->category = $newcategory->id;
     $form->name = 'testquestion';
     $form->correctanswer = 1;
     $form->feedbacktrue = array('text' => 'bogustext', 'format' => FORMAT_HTML);
     $form->feedbackfalse = array('text' => 'bogustext', 'format' => FORMAT_HTML);
     $question = question_bank::get_qtype('truefalse')->save_question($question, $form);
     if (function_exists('course_set_display')) {
         // Set a "course display" setting.
         course_set_display($courseid, 1);
     }
     // Make a bogus backup record.
     $backupcourse = new stdClass();
     $backupcourse->courseid = $courseid;
     $DB->insert_record('backup_courses', $backupcourse);
     // Add a user lastaccess record.
     $lastaccess = new stdClass();
     $lastaccess->userid = $userid;
     $lastaccess->courseid = $courseid;
     $DB->insert_record('user_lastaccess', $lastaccess);
     // Make a bogus backup log record.
     $log = new stdClass();
     $log->backupid = $courseid;
     $log->timecreated = time();
     $log->loglevel = 1;
     $log->message = 'bogus';
     $DB->insert_record('backup_logs', $log);
     // Get initial counts.
     $initialnumcourse = $DB->count_records('course');
     $initialnumroleassignments = $DB->count_records('role_assignments');
     $initialnumuserenrolments = $DB->count_records('user_enrolments');
     $initialnumgradeitems = $DB->count_records('grade_items');
     $initialnumgradegrades = $DB->count_records('grade_grades');
     $initialnumgradeoutcomes = $DB->count_records('grade_outcomes');
     $initialnumgradeoutcomescourses = $DB->count_records('grade_outcomes_courses');
     $initialnumscale = $DB->count_records('scale');
     $initialnumgradesettings = $DB->count_records('grade_settings');
     $initialnumgradeletters = $DB->count_records('grade_letters');
     $initialnumforum = $DB->count_records('forum');
     $initialnumcoursemodules = $DB->count_records('course_modules');
     $initialnumcoursemodulescompletion = $DB->count_records('course_modules_completion');
     $initialnumcoursemodulesavailability = $DB->count_records('course_modules_availability');
     $initialnumblockinstances = $DB->count_records('block_instances');
     $initialnumblockpositions = $DB->count_records('block_positions');
     $initialnumgroups = $DB->count_records('groups');
     $initialnumgroupsmembers = $DB->count_records('groups_members');
     $initialnumgroupings = $DB->count_records('groupings');
     $initialnumgroupingsgroups = $DB->count_records('groupings_groups');
     $initialnumtaginstance = $DB->count_records('tag_instance');
     $initialnumcoursesections = $DB->count_records('course_sections');
     $initialnumquestioncategories = $DB->count_records('question_categories');
     $initialnumquestion = $DB->count_records('question');
     if (self::$coursedisplay) {
         $initialnumcoursedisplay = $DB->count_records('course_display');
     }
     $initialnumbackupcourses = $DB->count_records('backup_courses');
     $initialnumuserlastaccess = $DB->count_records('user_lastaccess');
     $initialnumbackuplogs = $DB->count_records('backup_logs');
     // Delete the course.
     $data = array('action' => 'delete', 'shortname' => 'deleteassociationsshortname');
     $this->run_core_course_import($data, false);
     // Validate the result.
     $this->assertEquals($DB->count_records('course'), $initialnumcourse - 1);
     $this->assertEquals($DB->count_records('role_assignments'), $initialnumroleassignments - 1);
     $this->assertEquals($DB->count_records('user_enrolments'), $initialnumuserenrolments - 1);
     $this->assertEquals($DB->count_records('grade_items'), $initialnumgradeitems - 2);
     $this->assertEquals($DB->count_records('grade_grades'), $initialnumgradegrades - 1);
     $this->assertEquals($DB->count_records('grade_outcomes'), $initialnumgradeoutcomes - 1);
     $this->assertEquals($DB->count_records('grade_outcomes_courses'), $initialnumgradeoutcomescourses - 1);
     $this->assertEquals($DB->count_records('scale'), $initialnumscale - 1);
     $this->assertEquals($DB->count_records('grade_settings'), $initialnumgradesettings - 1);
     $this->assertEquals($DB->count_records('grade_letters'), $initialnumgradeletters - 1);
     $this->assertEquals($DB->count_records('forum'), $initialnumforum - 1);
     $this->assertEquals($DB->count_records('course_modules'), $initialnumcoursemodules - 1);
     /*
      Uncomment the two lines below when this fix is available: http://tracker.moodle.org/browse/MDL-32988
      $this->assertEquals($DB->count_records('course_modules_completion'), $initialnumcourse_modules_completion - 1);
      $this->assertEquals($DB->count_records('course_modules_availability'), $initialnumcourse_modules_availability - 1);
     */
     $this->assertEquals($initialnumblockinstances - 4, $DB->count_records('block_instances'));
     $this->assertEquals($DB->count_records('block_positions'), 0);
     $this->assertEquals($DB->count_records('groups'), $initialnumgroups - 1);
     $this->assertEquals($DB->count_records('groups_members'), $initialnumgroupsmembers - 1);
     $this->assertEquals($DB->count_records('groupings'), $initialnumgroupings - 1);
     $this->assertEquals($DB->count_records('groupings_groups'), $initialnumgroupingsgroups - 1);
     $this->assertEquals($DB->count_records('log', array('course' => $courseid)), 0);
     $this->assertEquals($DB->count_records('tag_instance'), $initialnumtaginstance - 1);
     $this->assertEquals($DB->count_records('course_sections'), $initialnumcoursesections - 1);
     $this->assertEquals($DB->count_records('question_categories'), $initialnumquestioncategories - 1);
     $this->assertEquals($DB->count_records('question'), $initialnumquestion - 1);
     if (self::$coursedisplay) {
         $this->assertEquals($DB->count_records('course_display'), $initialnumcoursedisplay - 1);
     }
     $this->assertEquals($DB->count_records('backup_courses'), $initialnumbackupcourses - 1);
     $this->assertEquals($DB->count_records('user_lastaccess'), $initialnumuserlastaccess - 1);
 }
Exemplo n.º 15
0
$potentialuserselector = new facetoface_candidate_selector('addselect', array('sessionid' => $session->id));
$existinguserselector = new facetoface_existing_selector('removeselect', array('sessionid' => $session->id));
// Process incoming user assignments.
if (optional_param('add', false, PARAM_BOOL) && confirm_sesskey()) {
    require_capability('mod/facetoface:addattendees', $context);
    $userstoassign = $potentialuserselector->get_selected_users();
    if (!empty($userstoassign)) {
        foreach ($userstoassign as $adduser) {
            if (!($adduser = clean_param($adduser->id, PARAM_INT))) {
                continue;
                // Invalid userid.
            }
            // Make sure that the user is enroled in the course.
            if (!has_capability('moodle/course:view', $context, $adduser)) {
                $user = $DB->get_record('user', array('id' => $adduser));
                if (!enrol_try_internal_enrol($course->id, $user->id, 5)) {
                    $errors[] = get_string('error:enrolmentfailed', 'facetoface', fullname($user));
                    $errors[] = get_string('error:addattendee', 'facetoface', fullname($user));
                    continue;
                    // Don't sign the user up.
                }
            }
            $usernamefields = get_all_user_name_fields(true);
            if (facetoface_get_user_submissions($facetoface->id, $adduser)) {
                $erruser = $DB->get_record('user', array('id' => $adduser), "id, {$usernamefields}");
                $errors[] = get_string('error:addalreadysignedupattendee', 'facetoface', fullname($erruser));
            } else {
                if (!facetoface_session_has_capacity($session, $context)) {
                    $errors[] = get_string('full', 'facetoface');
                    break;
                    // No point in trying to add other people.
Exemplo n.º 16
0
        if (!($group = $DB->get_record("groups", array("name" => $v[1], "courseid" => $id)))) {
            $newgroupdata = new stdClass();
            $newgroupdata->name = $v[1];
            $newgroupdata->courseid = $id;
            $newgroupdata->description = '';
            $gid = groups_create_group($newgroupdata);
            if ($gid) {
                $group = $DB->get_record("groups", array("id" => $gid));
            }
            $report['groupcreated'][$gid] = array($newgroupdata->name);
        }
        if (!$user) {
            $report['studentnotfound'][] = array($v[0], $group->name);
        }
        if ($user && $group) {
            enrol_try_internal_enrol($id, $user->id, 5, time());
            groups_add_member($group->id, $user->id);
            $report['studentregistered'][] = array($user->username, $user->lastname, $user->firstname, $user->email, $group->name);
        }
    }
}
///Excel report
$course = $DB->get_record("course", array("id" => $id));
$name = "GroupReg_" . $course->shortname . "_" . date(get_string('timeformat', 'block_groupreg'), time());
if (!($data = $DB->get_record_sql("SELECT itemid FROM {files} WHERE component='block_groupreg' AND filearea='excel' AND contextid=? ORDER BY itemid DESC LIMIT 1", array($context->id)))) {
    $itemid = 1;
} else {
    $itemid = $data->itemid + 1;
}
$fs = get_file_storage();
$fileinfo = array('contextid' => $context->id, 'component' => 'block_groupreg', 'filearea' => 'excel', 'itemid' => $itemid, 'filepath' => '/', 'filename' => $name . '.json');
Exemplo n.º 17
0
 /**
  * This function approves the request turning it into a course
  *
  * This function converts the course request into a course, at the same time
  * transferring any files used in the summary to the new course and then removing
  * the course request and the files associated with it.
  *
  * @return int The id of the course that was created from this request
  */
 public function approve()
 {
     global $CFG, $DB, $USER;
     $user = $DB->get_record('user', array('id' => $this->properties->requester, 'deleted' => 0), '*', MUST_EXIST);
     $category = get_course_category($CFG->defaultrequestcategory);
     $courseconfig = get_config('moodlecourse');
     // Transfer appropriate settings
     $data = clone $this->properties;
     unset($data->id);
     unset($data->reason);
     unset($data->requester);
     // Set category
     $data->category = $category->id;
     $data->sortorder = $category->sortorder;
     // place as the first in category
     // Set misc settings
     $data->requested = 1;
     // Apply course default settings
     $data->format = $courseconfig->format;
     $data->numsections = $courseconfig->numsections;
     $data->hiddensections = $courseconfig->hiddensections;
     $data->newsitems = $courseconfig->newsitems;
     $data->showgrades = $courseconfig->showgrades;
     $data->showreports = $courseconfig->showreports;
     $data->maxbytes = $courseconfig->maxbytes;
     $data->groupmode = $courseconfig->groupmode;
     $data->groupmodeforce = $courseconfig->groupmodeforce;
     $data->visible = $courseconfig->visible;
     $data->visibleold = $data->visible;
     $data->lang = $courseconfig->lang;
     $course = create_course($data);
     $context = get_context_instance(CONTEXT_COURSE, $course->id, MUST_EXIST);
     // add enrol instances
     if (!$DB->record_exists('enrol', array('courseid' => $course->id, 'enrol' => 'manual'))) {
         if ($manual = enrol_get_plugin('manual')) {
             $manual->add_default_instance($course);
         }
     }
     // enrol the requester as teacher if necessary
     if (!empty($CFG->creatornewroleid) and !is_viewing($context, $user, 'moodle/role:assign') and !is_enrolled($context, $user, 'moodle/role:assign')) {
         enrol_try_internal_enrol($course->id, $user->id, $CFG->creatornewroleid);
     }
     $this->delete();
     $a = new stdClass();
     $a->name = format_string($course->fullname, true, array('context' => get_context_instance(CONTEXT_COURSE, $course->id)));
     $a->url = $CFG->wwwroot . '/course/view.php?id=' . $course->id;
     $this->notify($user, $USER, 'courserequestapproved', get_string('courseapprovedsubject'), get_string('courseapprovedemail2', 'moodle', $a));
     return $course->id;
 }
Exemplo n.º 18
0
/**
 * Claim a coupon
 *
 * @param string $code coupon submission code
 */
function claim_coupon_confirm($code)
{
    global $CFG, $DB, $USER;
    // Because we're outside course context we've got to include groups library manually.
    require_once $CFG->dirroot . '/group/lib.php';
    require_once $CFG->dirroot . '/cohort/lib.php';
    $role = $DB->get_record('role', array('shortname' => 'student'));
    $coupon = $DB->get_record('block_coupon', array('submission_code' => $code));
    $couponcourses = $DB->get_records('block_coupon_courses', array('couponid' => $coupon->id));
    // We'll handle coupon_cohorts.
    if (empty($couponcourses)) {
        $couponcohorts = $DB->get_records('block_coupon_cohorts', array('couponid' => $coupon->id));
        if (count($couponcohorts) == 0) {
            throw new exception('error:missing_cohort');
        }
        // Add user to cohort.
        foreach ($couponcohorts as $couponcohort) {
            if (!$DB->get_record('cohort', array('id' => $couponcohort->cohortid))) {
                throw new exception('error:missing_cohort');
            }
            cohort_add_member($couponcohort->cohortid, $USER->id);
        }
        // Now execute the cohort sync.
        $result = self::enrol_cohort_sync();
        // If result = 0 it went ok. (lol!).
        if ($result === 1) {
            throw new exception('error:cohort_sync');
        } else {
            if ($result === 2) {
                throw new exception('error:plugin_disabled');
            }
        }
        // Otherwise we'll handle based on courses.
    } else {
        // Set enrolment period.
        $endenrolment = 0;
        if (!is_null($coupon->enrolperiod) && $coupon->enrolperiod > 0) {
            $endenrolment = strtotime("+ {$coupon->enrolperiod} days");
        }
        foreach ($couponcourses as $couponcourse) {
            // Make sure we only enrol if its not enrolled yet.
            $context = \context_course::instance($couponcourse->courseid);
            if (is_null($context) || $context === false) {
                throw new exception('error:course-not-found');
            }
            if (is_enrolled($context, $USER->id)) {
                continue;
            }
            // Now we can enrol.
            if (!enrol_try_internal_enrol($couponcourse->courseid, $USER->id, $role->id, time(), $endenrolment)) {
                throw new exception('error:unable_to_enrol');
            }
            // Mark the context for cache refresh.
            $context->mark_dirty();
            remove_temp_course_roles($context);
        }
        // And add user to groups.
        $coupongroups = $DB->get_records('block_coupon_groups', array('couponid' => $coupon->id));
        if (!empty($coupongroups)) {
            foreach ($coupongroups as $coupongroup) {
                // Check if the group exists.
                if (!$DB->get_record('groups', array('id' => $coupongroup->groupid))) {
                    throw new exception('error:missing_group');
                }
                // Add user if its not a member yet.
                if (!groups_is_member($coupongroup->groupid, $USER->id)) {
                    groups_add_member($coupongroup->groupid, $USER->id);
                }
            }
        }
    }
    // And finally update the coupon record.
    $coupon->userid = $USER->id;
    $coupon->timemodified = time();
    $DB->update_record('block_coupon', $coupon);
    // Trigger event.
    $event = \block_coupon\event\coupon_used::create(array('objectid' => $coupon->id, 'relateduserid' => $USER->id, 'context' => \context_user::instance($USER->id)));
    $event->add_record_snapshot('block_coupon', $coupon);
    $event->trigger();
    //return (empty($coupon->redirect_url)) ? $CFG->wwwroot . "/my" : $coupon->redirect_url;
}
Exemplo n.º 19
0
 protected function define_execution()
 {
     global $CFG, $DB;
     if (!($userid = $this->task->get_userid())) {
         return;
     }
     if (empty($CFG->restorernewroleid)) {
         // Bad luck, no fallback role for restorers specified
         return;
     }
     $courseid = $this->get_courseid();
     $context = context_course::instance($courseid);
     if (is_enrolled($context, $userid, 'moodle/course:update', true) or is_viewing($context, $userid, 'moodle/course:update')) {
         // Current user may access the course (admin, category manager or restored teacher enrolment usually)
         return;
     }
     // Try to add role only - we do not need enrolment if user has moodle/course:view or is already enrolled
     role_assign($CFG->restorernewroleid, $userid, $context);
     if (is_enrolled($context, $userid, 'moodle/course:update', true) or is_viewing($context, $userid, 'moodle/course:update')) {
         // Extra role is enough, yay!
         return;
     }
     // The last chance is to create manual enrol if it does not exist and and try to enrol the current user,
     // hopefully admin selected suitable $CFG->restorernewroleid ...
     if (!enrol_is_enabled('manual')) {
         return;
     }
     if (!($enrol = enrol_get_plugin('manual'))) {
         return;
     }
     if (!$DB->record_exists('enrol', array('enrol' => 'manual', 'courseid' => $courseid))) {
         $course = $DB->get_record('course', array('id' => $courseid), '*', MUST_EXIST);
         $fields = array('status' => ENROL_INSTANCE_ENABLED, 'enrolperiod' => $enrol->get_config('enrolperiod', 0), 'roleid' => $enrol->get_config('roleid', 0));
         $enrol->add_instance($course, $fields);
     }
     enrol_try_internal_enrol($courseid, $userid);
 }
 /**
  * Set up data that is needed for testing
  */
 private function set_up_required_data($assignusertouserset = true, $assigncoursetoclass = true, $assigntracktoclass = true, $initclusterprofile = false, $initusersetfielddata = true)
 {
     global $CFG, $DB;
     require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
     require_once $CFG->dirroot . '/course/lib.php';
     require_once $CFG->dirroot . '/lib/enrollib.php';
     require_once elis::lib('data/customfield.class.php');
     require_once elispm::file('accesslib.php');
     require_once elispm::lib('data/classmoodlecourse.class.php');
     require_once elispm::lib('data/clusterassignment.class.php');
     require_once elispm::lib('data/clustertrack.class.php');
     require_once elispm::lib('data/course.class.php');
     require_once elispm::lib('data/curriculum.class.php');
     require_once elispm::lib('data/pmclass.class.php');
     require_once elispm::lib('data/track.class.php');
     require_once elispm::lib('data/user.class.php');
     require_once elispm::lib('data/userset.class.php');
     require_once elispm::lib('data/usertrack.class.php');
     $fieldcategoryid = $DB->get_field(field_category::TABLE, 'id', array('name' => 'Associated Group'));
     $this->assertNotEquals(false, $fieldcategoryid);
     $fieldcategory = new field_category($fieldcategoryid);
     $fieldcategory->load();
     // Set up the test user.
     $user = new user(array('idnumber' => 'testuseridnumber', 'username' => 'testuserusername', 'firstname' => 'testuserfirstname', 'lastname' => 'testuserlastname', 'email' => '*****@*****.**', 'country' => 'CA'));
     $user->save();
     // Set up the test course description and class instance.
     $course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
     $course->save();
     $pmclass = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
     $pmclass->save();
     $category = new stdClass();
     $category->name = 'testcategoryname';
     $category->id = $DB->insert_record('course_categories', $category);
     // Set up the test Moodle course.
     set_config('enrol_plugins_enabled', 'manual');
     set_config('defaultenrol', 1, 'enrol_manual');
     set_config('status', ENROL_INSTANCE_ENABLED, 'enrol_manual');
     $course = new stdClass();
     $course->category = $category->id;
     $course->shortname = 'testcourseshortname';
     $course->fullname = 'testcoursefullname';
     $course = create_course($course);
     if ($assigncoursetoclass) {
         // Assign the Moodle course to a class instance.
         $classmoodlecourse = new classmoodlecourse(array('classid' => $pmclass->id, 'moodlecourseid' => $course->id));
         $classmoodlecourse->save();
     }
     // Set up the test program and track.
     $curriculum = new curriculum(array('idnumber' => 'testcurriculumidnumber'));
     $curriculum->save();
     $track = new track(array('curid' => $curriculum->id, 'idnumber' => 'testtrackidnumber'));
     $track->save();
     if ($assigntracktoclass) {
         // Assign the test track to the test class instance.
         $trackassignment = new trackassignment(array('trackid' => $track->id, 'classid' => $pmclass->id, 'autoenrol' => 1));
         $trackassignment->save();
     }
     // Set up the test userset.
     $userset = new userset();
     $usersetdata = array('name' => 'testusersetname');
     if ($initusersetfielddata) {
         $usersetdata['field_userset_group'] = 1;
         $usersetdata['field_userset_groupings'] = 1;
     }
     $userset->set_from_data((object) $usersetdata);
     $userset->save();
     // Assign the test user to the test track.
     $usertrack = new usertrack(array('userid' => $user->id, 'trackid' => $track->id));
     $usertrack->save();
     $clustertrack = new clustertrack(array('clusterid' => $userset->id, 'trackid' => $track->id));
     $clustertrack->save();
     if ($assignusertouserset) {
         // Assign the test user to the test userset.
         $clusterassignment = new clusterassignment(array('userid' => $user->id, 'clusterid' => $userset->id, 'plugin' => 'manual'));
         $clusterassignment->save();
     }
     if ($initclusterprofile) {
         // Set up a file we can use to auto-associate users to a userset.
         $field = new field(array('categoryid' => $fieldcategory->id, 'shortname' => 'autoassociate', 'name' => 'autoassociate', 'datatype' => 'bool'));
         $field->save();
         // Ensure manual field owner exists for syncing.
         field_owner::ensure_field_owner_exists($field, 'manual');
         $ownerid = $DB->get_field(field_owner::TABLE, 'id', array('fieldid' => $field->id, 'plugin' => 'manual'));
         $owner = new field_owner($ownerid);
         $owner->param_control = 'checkbox';
         $owner->save();
         field_owner::ensure_field_owner_exists($field, 'moodle_profile');
         $DB->execute("UPDATE {" . field_owner::TABLE . "} SET exclude = ?", array(pm_moodle_profile::sync_to_moodle));
         $fieldcontextlevel = new field_contextlevel(array('fieldid' => $field->id, 'contextlevel' => CONTEXT_ELIS_USER));
         $fieldcontextlevel->save();
         // The associated Moodle user profile field.
         require_once $CFG->dirroot . '/user/profile/definelib.php';
         require_once $CFG->dirroot . '/user/profile/field/checkbox/define.class.php';
         $profiledefinecheckbox = new profile_define_checkbox();
         $data = new stdClass();
         $data->datatype = 'checkbox';
         $data->categoryid = 99999;
         $data->shortname = 'autoassociate';
         $data->name = 'autoassociate';
         $profiledefinecheckbox->define_save($data);
         $mfield = $DB->get_record('user_info_field', array('shortname' => 'autoassociate'));
         // The "cluster-profile" association.
         $usersetprofile = new userset_profile(array('clusterid' => $userset->id, 'fieldid' => $mfield->id, 'value' => true));
         $usersetprofile->save();
     }
     // Enrol the user in the Moodle course.
     $mdluserid = $DB->get_field('user', 'id', array('username' => 'testuserusername'));
     $roleid = create_role('testrole', 'testrole', 'testrole');
     enrol_try_internal_enrol($course->id, $mdluserid, $roleid);
     // Set up the necessary config data.
     set_config('userset_groups', 1, 'elisprogram_usetgroups');
     set_config('siteguest', '');
     // Validate setup.
     $this->assertEquals(0, $DB->count_records('groups'));
 }