PHP condition_info::add_grade_condition方法代码示例

//.........这里部分代码省略.........
        require_once $CFG->libdir . '/conditionlib.php';
        $table = new xmldb_table('certificate');
        // It is possible for these fields not to be added, ever, it is included in the upgrade
        // process but fresh certificate 1.9 install from CVS MOODLE_19_STABLE set the Moodle version
        // to 2009080900, which means it missed all the earlier code written for upgrading to 2.0.
        $reissuefield = new xmldb_field('reissuecert', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, null, '0', 'reportcert');
        $orientationfield = new xmldb_field('orientation', XMLDB_TYPE_CHAR, '10', null, XMLDB_NOTNULL, null, ' ', 'certificatetype');
        // Have to check, may be added during earlier upgrade, or may be missing due to not being included in install.xml
        if (!$dbman->field_exists($table, $reissuefield)) {
            $dbman->add_field($table, $reissuefield);
        }
        if (!$dbman->field_exists($table, $orientationfield)) {
            $dbman->add_field($table, $orientationfield);
        }
        // Fresh 2.0 installs won't have this table, but upgrades from 1.9 will
        if ($dbman->table_exists('certificate_linked_modules')) {
            // No longer need lock grade, or required grade, but first need to
            // convert so that the restrictions are still in place for Moodle 2.0
            if ($certs = $DB->get_records('certificate')) {
                foreach ($certs as $cert) {
                    if ($cert->lockgrade == 0) {
                        // Can skip this certificate, no course grade required
                        continue;
                    }
                    if (!($cm = get_coursemodule_from_instance('certificate', $cert->id))) {
                        // Not valid skip it
                        continue;
                    }
                    if (!($gradeitem = $DB->get_record('grade_items', array('courseid' => $cm->course, 'itemtype' => 'course')))) {
                        // Not valid skip it
                        continue;
                    }
                    $condition_info = new condition_info($cm, CONDITION_MISSING_EVERYTHING);
                    $condition_info->add_grade_condition($gradeitem->id, $cert->requiredgrade, '110');
                }
            }
            // Fresh installs won't have this table, but upgrades will
            // Lock grade and required grade field are not needed anymore
            if ($dbman->field_exists($table, 'lockgrade')) {
                $field = new xmldb_field('lockgrade');
                $dbman->drop_field($table, $field);
            }
            if ($dbman->field_exists($table, 'requiredgrade')) {
                $field = new xmldb_field('requiredgrade');
                $dbman->drop_field($table, $field);
            }
            // Now we need to loop through the restrictions in the certificate_linked_modules
            // table and convert it into the new Moodle 2.0 restrictions
            if ($certlinks = $DB->get_records('certificate_linked_modules')) {
                foreach ($certlinks as $link) {
                    // If the link id is '-1' then the setting applies to the time spent in the course and is not
                    // related to a module, meaning we can skip it for this section
                    if ($link->linkid == '-1') {
                        continue;
                    }
                    // Get the course module
                    if (!($cm = get_coursemodule_from_instance('certificate', $link->certificate_id))) {
                        // Not valid skip it
                        continue;
                    }
                    // Get grade item for module specified - is there an API function for this ??
                    $sql = "SELECT gi.id\n                            FROM {course_modules} cm\n                            INNER JOIN {modules} m\n                            ON cm.module = m.id\n                            INNER JOIN {grade_items} gi\n                            ON m.name = gi.itemmodule\n                            WHERE cm.id = :cmid\n                            AND cm.course = :courseid\n                            AND cm.instance = gi.iteminstance";
                    if (!($gradeitem = $DB->get_record_sql($sql, array('cmid' => $link->linkid, 'courseid' => $cm->course)))) {
                        // Not valid skip it
                        continue;
                    }

 public function test_cm_info_properties()
 {
     global $DB, $CFG;
     $this->resetAfterTest();
     $oldcfgenableavailability = $CFG->enableavailability;
     $oldcfgenablecompletion = $CFG->enablecompletion;
     set_config('enableavailability', 1);
     set_config('enablecompletion', 1);
     $this->setAdminUser();
     // Generate the course and pre-requisite module.
     $course = $this->getDataGenerator()->create_course(array('format' => 'topics', 'numsections' => 3, 'enablecompletion' => 1, 'groupmode' => SEPARATEGROUPS, 'forcegroupmode' => 0), array('createsections' => true));
     $coursecontext = context_course::instance($course->id);
     $prereqforum = $this->getDataGenerator()->create_module('forum', array('course' => $course->id), array('completion' => 1));
     // Generate the module and add availability conditions.
     $conditionscompletion = array($prereqforum->cmid => COMPLETION_COMPLETE);
     $conditionsgrade = array(666 => (object) array('min' => 0.4, 'max' => null, 'name' => '!missing'));
     $conditionsfield = array('email' => (object) array('fieldname' => 'email', 'operator' => 'contains', 'value' => 'test'));
     $assign = $this->getDataGenerator()->create_module('assign', array('course' => $course->id), array('idnumber' => 123, 'groupmode' => VISIBLEGROUPS, 'availablefrom' => time() + 3600, 'availableuntil' => time() + 5 * 3600));
     $ci = new condition_info((object) array('id' => $assign->cmid), CONDITION_MISSING_EVERYTHING);
     foreach ($conditionscompletion as $cmid => $requiredcompletion) {
         $ci->add_completion_condition($cmid, $requiredcompletion);
     }
     foreach ($conditionsgrade as $gradeid => $conditiongrade) {
         $ci->add_grade_condition($gradeid, $conditiongrade->min, $conditiongrade->max, true);
     }
     foreach ($conditionsfield as $conditionfield) {
         $ci->add_user_field_condition($conditionfield->fieldname, $conditionfield->operator, $conditionfield->value);
     }
     // Direct access to condition_info functions does not reset course cache, do it manually.
     rebuild_course_cache($course->id, true);
     // Retrieve all related records from DB.
     $assigndb = $DB->get_record('assign', array('id' => $assign->id));
     $moduletypedb = $DB->get_record('modules', array('name' => 'assign'));
     $moduledb = $DB->get_record('course_modules', array('module' => $moduletypedb->id, 'instance' => $assign->id));
     $sectiondb = $DB->get_record('course_sections', array('id' => $moduledb->section));
     $modnamessingular = get_module_types_names(false);
     $modnamesplural = get_module_types_names(true);
     // Create and enrol a student.
     $studentrole = $DB->get_record('role', array('shortname' => 'student'), '*', MUST_EXIST);
     $student = $this->getDataGenerator()->create_user();
     role_assign($studentrole->id, $student->id, $coursecontext);
     $enrolplugin = enrol_get_plugin('manual');
     $enrolinstance = $DB->get_record('enrol', array('courseid' => $course->id, 'enrol' => 'manual'));
     $enrolplugin->enrol_user($enrolinstance, $student->id);
     $this->setUser($student);
     // Emulate data used in building course cache to receive the same instance of cached_cm_info as was used in building modinfo.
     $rawmods = get_course_mods($course->id);
     $cachedcminfo = assign_get_coursemodule_info($rawmods[$moduledb->id]);
     // Get modinfo.
     $modinfo = get_fast_modinfo($course->id);
     $cm = $modinfo->instances['assign'][$assign->id];
     $this->assertEquals($moduledb->id, $cm->id);
     $this->assertEquals($assigndb->id, $cm->instance);
     $this->assertEquals($moduledb->course, $cm->course);
     $this->assertEquals($moduledb->idnumber, $cm->idnumber);
     $this->assertEquals($moduledb->added, $cm->added);
     $this->assertEquals($moduledb->visible, $cm->visible);
     $this->assertEquals($moduledb->visibleold, $cm->visibleold);
     $this->assertEquals($moduledb->groupmode, $cm->groupmode);
     $this->assertEquals(VISIBLEGROUPS, $cm->groupmode);
     $this->assertEquals($moduledb->groupingid, $cm->groupingid);
     $this->assertEquals($moduledb->groupmembersonly, $cm->groupmembersonly);
     $this->assertEquals($course->groupmodeforce, $cm->coursegroupmodeforce);
     $this->assertEquals($course->groupmode, $cm->coursegroupmode);
     $this->assertEquals(SEPARATEGROUPS, $cm->coursegroupmode);
     $this->assertEquals($course->groupmodeforce ? $course->groupmode : $moduledb->groupmode, $cm->effectivegroupmode);
     // (since mod_assign supports groups).
     $this->assertEquals(VISIBLEGROUPS, $cm->effectivegroupmode);
     $this->assertEquals($moduledb->indent, $cm->indent);
     $this->assertEquals($moduledb->completion, $cm->completion);
     $this->assertEquals($moduledb->completiongradeitemnumber, $cm->completiongradeitemnumber);
     $this->assertEquals($moduledb->completionview, $cm->completionview);
     $this->assertEquals($moduledb->completionexpected, $cm->completionexpected);
     $this->assertEquals($moduledb->availablefrom, $cm->availablefrom);
     $this->assertEquals($moduledb->availableuntil, $cm->availableuntil);
     $this->assertEquals($moduledb->showavailability, $cm->showavailability);
     $this->assertEquals($moduledb->showdescription, $cm->showdescription);
     $this->assertEquals(null, $cm->extra);
     // Deprecated field. Used in module types that don't return cached_cm_info.
     $this->assertEquals($cachedcminfo->icon, $cm->icon);
     $this->assertEquals($cachedcminfo->iconcomponent, $cm->iconcomponent);
     $this->assertEquals('assign', $cm->modname);
     $this->assertEquals($moduledb->module, $cm->module);
     $this->assertEquals($cachedcminfo->name, $cm->name);
     $this->assertEquals($sectiondb->section, $cm->sectionnum);
     $this->assertEquals($moduledb->section, $cm->section);
     $this->assertEquals($conditionscompletion, $cm->conditionscompletion);
     $this->assertEquals($conditionsgrade, $cm->conditionsgrade);
     $this->assertEquals($conditionsfield, $cm->conditionsfield);
     $this->assertEquals(context_module::instance($moduledb->id), $cm->context);
     $this->assertEquals($modnamessingular['assign'], $cm->modfullname);
     $this->assertEquals($modnamesplural['assign'], $cm->modplural);
     $this->assertEquals(new moodle_url('/mod/assign/view.php', array('id' => $moduledb->id)), $cm->url);
     $this->assertEquals($cachedcminfo->customdata, $cm->customdata);
     // Dynamic fields, just test that they can be retrieved (must be carefully tested in each activity type).
     $this->assertNotEmpty($cm->availableinfo);
     // Lists all unmet availability conditions.
     $this->assertEquals(0, $cm->uservisible);
     $this->assertEquals('', $cm->extraclasses);
     $this->assertEquals('', $cm->onclick);
//.........这里部分代码省略.........

 /**
  * Utility function called by modedit.php; updates the 
  * course_modules_availability table based on the module form data.
  *
  * @param object $cm Course-module with as much data as necessary, min id
  * @param object $fromform
  * @param bool $wipefirst Defaults to true
  */
 public static function update_cm_from_form($cm, $fromform, $wipefirst = true)
 {
     $ci = new condition_info($cm, CONDITION_MISSING_EVERYTHING, false);
     if ($wipefirst) {
         $ci->wipe_conditions();
     }
     foreach ($fromform->conditiongradegroup as $record) {
         if ($record['conditiongradeitemid']) {
             $ci->add_grade_condition($record['conditiongradeitemid'], $record['conditiongrademin'], $record['conditiongrademax']);
         }
     }
     if (isset($fromform->conditioncompletiongroup)) {
         foreach ($fromform->conditioncompletiongroup as $record) {
             if ($record['conditionsourcecmid']) {
                 $ci->add_completion_condition($record['conditionsourcecmid'], $record['conditionrequiredcompletion']);
             }
         }
     }
 }

 function test_is_available()
 {
     global $DB, $USER;
     $courseid = $this->make_course();
     // No conditions
     $cmid = $this->make_course_module($courseid);
     $ci = new condition_info((object) array('id' => $cmid), CONDITION_MISSING_EVERYTHING);
     $this->assertTrue($ci->is_available($text, false, 0));
     $this->assertEqual('', $text);
     // Time (from)
     $time = time() + 100;
     $cmid = $this->make_course_module($courseid, array('availablefrom' => $time));
     $ci = new condition_info((object) array('id' => $cmid), CONDITION_MISSING_EVERYTHING);
     $this->assertFalse($ci->is_available($text));
     $this->assert(new PatternExpectation('/' . preg_quote(userdate($time, get_string('strftimedate', 'langconfig'))) . '/'), $text);
     $time = time() - 100;
     $cmid = $this->make_course_module($courseid, array('availablefrom' => $time));
     $ci = new condition_info((object) array('id' => $cmid), CONDITION_MISSING_EVERYTHING);
     $this->assertTrue($ci->is_available($text));
     $this->assertEqual('', $text);
     $this->assert(new PatternExpectation('/' . preg_quote(userdate($time, get_string('strftimedate', 'langconfig'))) . '/'), $ci->get_full_information());
     // Time (until)
     $cmid = $this->make_course_module($courseid, array('availableuntil' => time() - 100));
     $ci = new condition_info((object) array('id' => $cmid), CONDITION_MISSING_EVERYTHING);
     $this->assertFalse($ci->is_available($text));
     $this->assertEqual('', $text);
     // Completion
     $oldid = $cmid;
     $cmid = $this->make_course_module($courseid);
     $this->make_section($courseid, array($oldid, $cmid));
     $oldcm = $DB->get_record('course_modules', array('id' => $oldid));
     $oldcm->completion = COMPLETION_TRACKING_MANUAL;
     $DB->update_record('course_modules', $oldcm);
     $ci = new condition_info((object) array('id' => $cmid), CONDITION_MISSING_EVERYTHING);
     $ci->add_completion_condition($oldid, COMPLETION_COMPLETE);
     $this->assertFalse($ci->is_available($text, false));
     $this->assertEqual(get_string('requires_completion_1', 'condition', 'xxx'), $text);
     $completion = new completion_info($DB->get_record('course', array('id' => $courseid)));
     $completion->update_state($oldcm, COMPLETION_COMPLETE);
     completion_info::wipe_session_cache();
     condition_info::wipe_session_cache();
     $this->assertTrue($ci->is_available($text));
     $this->assertFalse($ci->is_available($text, false, $USER->id + 1));
     completion_info::wipe_session_cache();
     condition_info::wipe_session_cache();
     $completion = new completion_info($DB->get_record('course', array('id' => $courseid)));
     $completion->update_state($oldcm, COMPLETION_INCOMPLETE);
     $this->assertFalse($ci->is_available($text));
     $ci->wipe_conditions();
     $ci->add_completion_condition($oldid, COMPLETION_INCOMPLETE);
     condition_info::wipe_session_cache();
     $this->assertTrue($ci->is_available($text));
     $this->assertTrue($ci->is_available($text, false, $USER->id + 1));
     condition_info::wipe_session_cache();
     $this->assertTrue($ci->is_available($text, true));
     // Grade
     $ci->wipe_conditions();
     // Add a fake grade item
     $gradeitemid = $DB->insert_record('grade_items', (object) array('courseid' => $courseid, 'itemname' => 'frog'));
     // Add a condition on a value existing...
     $ci->add_grade_condition($gradeitemid, null, null, true);
     $this->assertFalse($ci->is_available($text));
     $this->assertEqual(get_string('requires_grade_any', 'condition', 'frog'), $text);
     // Fake it existing
     $DB->insert_record('grade_grades', (object) array('itemid' => $gradeitemid, 'userid' => $USER->id, 'finalgrade' => 3.78));
     condition_info::wipe_session_cache();
     $this->assertTrue($ci->is_available($text));
     condition_info::wipe_session_cache();
     $this->assertTrue($ci->is_available($text, true));
     // Now require that user gets more than 3.78001
     $ci->wipe_conditions();
     $ci->add_grade_condition($gradeitemid, 3.78001, null, true);
     condition_info::wipe_session_cache();
     $this->assertFalse($ci->is_available($text));
     $this->assertEqual(get_string('requires_grade_min', 'condition', 'frog'), $text);
     // ...just on 3.78...
     $ci->wipe_conditions();
     $ci->add_grade_condition($gradeitemid, 3.78, null, true);
     condition_info::wipe_session_cache();
     $this->assertTrue($ci->is_available($text));
     // ...less than 3.78
     $ci->wipe_conditions();
     $ci->add_grade_condition($gradeitemid, null, 3.78, true);
     condition_info::wipe_session_cache();
     $this->assertFalse($ci->is_available($text));
     $this->assertEqual(get_string('requires_grade_max', 'condition', 'frog'), $text);
     // ...less than 3.78001
     $ci->wipe_conditions();
     $ci->add_grade_condition($gradeitemid, null, 3.78001, true);
     condition_info::wipe_session_cache();
     $this->assertTrue($ci->is_available($text));
     // ...in a range that includes it
     $ci->wipe_conditions();
     $ci->add_grade_condition($gradeitemid, 3, 4, true);
     condition_info::wipe_session_cache();
     $this->assertTrue($ci->is_available($text));
     // ...in a range that doesn't include it
     $ci->wipe_conditions();
     $ci->add_grade_condition($gradeitemid, 4, 5, true);
     condition_info::wipe_session_cache();
//.........这里部分代码省略.........