PHP grade_object::set_properties方法代码示例

 /**
  * Using this object's id field, fetches the matching record in the DB, and looks at
  * each variable in turn. If the DB has different data, the db's data is used to update
  * the object. This is different from the update() function, which acts on the DB record
  * based on the object.
  */
 public function update_from_db()
 {
     if (empty($this->id)) {
         debugging("The object could not be used in its state to retrieve a matching record from the DB, because its id field is not set.");
         return false;
     }
     global $DB;
     if (!($params = $DB->get_record($this->table, array('id' => $this->id)))) {
         debugging("Object with this id:{$this->id} does not exist in table:{$this->table}, can not update from db!");
         return false;
     }
     grade_object::set_properties($this, $params);
     return true;
 }

 /**
  * Static method - returns all outcomes available in course
  * @static
  * @param int $courseid
  * @return array
  */
 function fetch_all_available($courseid)
 {
     global $CFG;
     $result = array();
     $sql = "SELECT go.*\n                  FROM {$CFG->prefix}grade_outcomes go, {$CFG->prefix}grade_outcomes_courses goc\n                 WHERE go.id = goc.outcomeid AND goc.courseid = {$courseid}\n              ORDER BY go.id ASC";
     if ($datas = get_records_sql($sql)) {
         foreach ($datas as $data) {
             $instance = new grade_outcome();
             grade_object::set_properties($instance, $data);
             $result[$instance->id] = $instance;
         }
     }
     return $result;
 }

 /**
  * Overrides grade_object::set_properties() to add special handling for changes to category aggregation types
  *
  * @param stdClass $instance the object to set the properties on
  * @param array|stdClass $params Either an associative array or an object containing property name, property value pairs
  */
 public static function set_properties(&$instance, $params)
 {
     global $DB;
     parent::set_properties($instance, $params);
     //if they've changed aggregation type we made need to do some fiddling to provide appropriate defaults
     if (!empty($params->aggregation)) {
         //weight and extra credit share a column :( Would like a default of 1 for weight and 0 for extra credit
         //Flip from the default of 0 to 1 (or vice versa) if ALL items in the category are still set to the old default.
         if ($params->aggregation == GRADE_AGGREGATE_WEIGHTED_MEAN || $params->aggregation == GRADE_AGGREGATE_EXTRACREDIT_MEAN) {
             $sql = $defaultaggregationcoef = null;
             if ($params->aggregation == GRADE_AGGREGATE_WEIGHTED_MEAN) {
                 //if all items in this category have aggregation coefficient of 0 we can change it to 1 ie evenly weighted
                 $sql = "select count(id) from {grade_items} where categoryid=:categoryid and aggregationcoef!=0";
                 $defaultaggregationcoef = 1;
             } else {
                 if ($params->aggregation == GRADE_AGGREGATE_EXTRACREDIT_MEAN) {
                     //if all items in this category have aggregation coefficient of 1 we can change it to 0 ie no extra credit
                     $sql = "select count(id) from {grade_items} where categoryid=:categoryid and aggregationcoef!=1";
                     $defaultaggregationcoef = 0;
                 }
             }
             $params = array('categoryid' => $instance->id);
             $count = $DB->count_records_sql($sql, $params);
             if ($count === 0) {
                 //category is either empty or all items are set to a default value so we can switch defaults
                 $params['aggregationcoef'] = $defaultaggregationcoef;
                 $DB->execute("update {grade_items} set aggregationcoef=:aggregationcoef where categoryid=:categoryid", $params);
             }
         }
     }
 }

 /**
  * Static method that returns all outcomes available in course
  *
  * @static
  * @param int $courseid
  * @return array
  */
 public static function fetch_all_available($courseid)
 {
     global $CFG, $DB;
     $result = array();
     $params = array($courseid);
     $sql = "SELECT go.*\n                  FROM {grade_outcomes} go, {grade_outcomes_courses} goc\n                 WHERE go.id = goc.outcomeid AND goc.courseid = ?\n              ORDER BY go.id ASC";
     if ($datas = $DB->get_records_sql($sql, $params)) {
         foreach ($datas as $data) {
             $instance = new grade_outcome();
             grade_object::set_properties($instance, $data);
             $result[$instance->id] = $instance;
         }
     }
     return $result;
 }

 /**
  * Obtains the name of a grade item.
  *
  * @global object
  * @param object $gradeitemobj Object from get_record on grade_items table,
  *     (can be empty if you want to just get !missing)
  * @return string Name of item of !missing if it didn't exist
  */
 private static function get_grade_name($gradeitemobj)
 {
     global $CFG;
     if (isset($gradeitemobj->id)) {
         require_once $CFG->libdir . '/gradelib.php';
         $item = new grade_item();
         grade_object::set_properties($item, $gradeitemobj);
         return $item->get_name();
     } else {
         return '!missing';
         // Ooops, missing grade
     }
 }

 /**
  * Obtains the name of a grade item, also checking that it exists. Uses a
  * cache. The name returned is suitable for display.
  *
  * @param int $courseid Course id
  * @param int $gradeitemid Grade item id
  * @return string Grade name or empty string if no grade with that id
  */
 private static function get_cached_grade_name($courseid, $gradeitemid)
 {
     global $DB, $CFG;
     require_once $CFG->libdir . '/gradelib.php';
     // Get all grade item names from cache, or using db query.
     $cache = \cache::make('availability_grade', 'items');
     if (($cacheditems = $cache->get($courseid)) === false) {
         // We cache the whole items table not the name; the format_string
         // call for the name might depend on current user (e.g. multilang)
         // and this is a shared cache.
         $cacheditems = $DB->get_records('grade_items', array('courseid' => $courseid));
         $cache->set($courseid, $cacheditems);
     }
     // Return name from cached item or a lang string.
     if (!array_key_exists($gradeitemid, $cacheditems)) {
         return get_string('missing', 'availability_grade');
     }
     $gradeitemobj = $cacheditems[$gradeitemid];
     $item = new \grade_item();
     \grade_object::set_properties($item, $gradeitemobj);
     return $item->get_name();
 }

 /**
  * Overrides grade_object::set_properties() to add special handling for changes to category aggregation types
  *
  * @param stdClass $instance the object to set the properties on
  * @param array|stdClass $params Either an associative array or an object containing property name, property value pairs
  */
 public static function set_properties(&$instance, $params)
 {
     global $DB;
     $fromaggregation = $instance->aggregation;
     parent::set_properties($instance, $params);
     // The aggregation method is changing and this category has already been saved.
     if (isset($params->aggregation) && !empty($instance->id)) {
         $achildwasdupdated = false;
         // Get all its children.
         $children = $instance->get_children();
         foreach ($children as $child) {
             $item = $child['object'];
             if ($child['type'] == 'category') {
                 $item = $item->load_grade_item();
             }
             // Set the new aggregation fields.
             if ($item->set_aggregation_fields_for_aggregation($fromaggregation, $params->aggregation)) {
                 $item->update();
                 $achildwasdupdated = true;
             }
         }
         // If this is the course category, it is possible that its grade item was set as needsupdate
         // by one of its children. If we keep a reference to that stale object we might cause the
         // needsupdate flag to be lost. It's safer to just reload the grade_item from the database.
         if ($achildwasdupdated && !empty($instance->grade_item) && $instance->is_course_category()) {
             $instance->grade_item = null;
             $instance->load_grade_item();
         }
     }
 }

 /**
  * Tests the is_available and get_description functions.
  */
 public function test_usage()
 {
     global $CFG, $DB;
     require_once $CFG->dirroot . '/mod/assign/locallib.php';
     $this->resetAfterTest();
     // Create course with completion turned on.
     $CFG->enablecompletion = true;
     $CFG->enableavailability = true;
     $generator = $this->getDataGenerator();
     $course = $generator->create_course(array('enablecompletion' => 1));
     $user = $generator->create_user();
     $generator->enrol_user($user->id, $course->id);
     $this->setUser($user);
     // Create a Page with manual completion for basic checks.
     $page = $generator->get_plugin_generator('mod_page')->create_instance(array('course' => $course->id, 'name' => 'Page!', 'completion' => COMPLETION_TRACKING_MANUAL));
     // Create an assignment - we need to have something that can be graded
     // so as to test the PASS/FAIL states. Set it up to be completed based
     // on its grade item.
     $assignrow = $this->getDataGenerator()->create_module('assign', array('course' => $course->id, 'name' => 'Assign!', 'completion' => COMPLETION_TRACKING_AUTOMATIC));
     $DB->set_field('course_modules', 'completiongradeitemnumber', 0, array('id' => $assignrow->cmid));
     $assign = new assign(context_module::instance($assignrow->cmid), false, false);
     // Get basic details.
     $modinfo = get_fast_modinfo($course);
     $pagecm = $modinfo->get_cm($page->cmid);
     $assigncm = $assign->get_course_module();
     $info = new \core_availability\mock_info($course, $user->id);
     // COMPLETE state (false), positive and NOT.
     $cond = new condition((object) array('cm' => (int) $pagecm->id, 'e' => COMPLETION_COMPLETE));
     $this->assertFalse($cond->is_available(false, $info, true, $user->id));
     $information = $cond->get_description(false, false, $info);
     $information = \core_availability\info::format_info($information, $course);
     $this->assertRegExp('~Page!.*is marked complete~', $information);
     $this->assertTrue($cond->is_available(true, $info, true, $user->id));
     // INCOMPLETE state (true).
     $cond = new condition((object) array('cm' => (int) $pagecm->id, 'e' => COMPLETION_INCOMPLETE));
     $this->assertTrue($cond->is_available(false, $info, true, $user->id));
     $this->assertFalse($cond->is_available(true, $info, true, $user->id));
     $information = $cond->get_description(false, true, $info);
     $information = \core_availability\info::format_info($information, $course);
     $this->assertRegExp('~Page!.*is marked complete~', $information);
     // Mark page complete.
     $completion = new completion_info($course);
     $completion->update_state($pagecm, COMPLETION_COMPLETE);
     // COMPLETE state (true).
     $cond = new condition((object) array('cm' => (int) $pagecm->id, 'e' => COMPLETION_COMPLETE));
     $this->assertTrue($cond->is_available(false, $info, true, $user->id));
     $this->assertFalse($cond->is_available(true, $info, true, $user->id));
     $information = $cond->get_description(false, true, $info);
     $information = \core_availability\info::format_info($information, $course);
     $this->assertRegExp('~Page!.*is incomplete~', $information);
     // INCOMPLETE state (false).
     $cond = new condition((object) array('cm' => (int) $pagecm->id, 'e' => COMPLETION_INCOMPLETE));
     $this->assertFalse($cond->is_available(false, $info, true, $user->id));
     $information = $cond->get_description(false, false, $info);
     $information = \core_availability\info::format_info($information, $course);
     $this->assertRegExp('~Page!.*is incomplete~', $information);
     $this->assertTrue($cond->is_available(true, $info, true, $user->id));
     // We are going to need the grade item so that we can get pass/fails.
     $gradeitem = $assign->get_grade_item();
     grade_object::set_properties($gradeitem, array('gradepass' => 50.0));
     $gradeitem->update();
     // With no grade, it should return true for INCOMPLETE and false for
     // the other three.
     $cond = new condition((object) array('cm' => (int) $assigncm->id, 'e' => COMPLETION_INCOMPLETE));
     $this->assertTrue($cond->is_available(false, $info, true, $user->id));
     $this->assertFalse($cond->is_available(true, $info, true, $user->id));
     $cond = new condition((object) array('cm' => (int) $assigncm->id, 'e' => COMPLETION_COMPLETE));
     $this->assertFalse($cond->is_available(false, $info, true, $user->id));
     $this->assertTrue($cond->is_available(true, $info, true, $user->id));
     // Check $information for COMPLETE_PASS and _FAIL as we haven't yet.
     $cond = new condition((object) array('cm' => (int) $assigncm->id, 'e' => COMPLETION_COMPLETE_PASS));
     $this->assertFalse($cond->is_available(false, $info, true, $user->id));
     $information = $cond->get_description(false, false, $info);
     $information = \core_availability\info::format_info($information, $course);
     $this->assertRegExp('~Assign!.*is complete and passed~', $information);
     $this->assertTrue($cond->is_available(true, $info, true, $user->id));
     $cond = new condition((object) array('cm' => (int) $assigncm->id, 'e' => COMPLETION_COMPLETE_FAIL));
     $this->assertFalse($cond->is_available(false, $info, true, $user->id));
     $information = $cond->get_description(false, false, $info);
     $information = \core_availability\info::format_info($information, $course);
     $this->assertRegExp('~Assign!.*is complete and failed~', $information);
     $this->assertTrue($cond->is_available(true, $info, true, $user->id));
     // Change the grade to be complete and failed.
     self::set_grade($assignrow, $user->id, 40);
     $cond = new condition((object) array('cm' => (int) $assigncm->id, 'e' => COMPLETION_INCOMPLETE));
     $this->assertFalse($cond->is_available(false, $info, true, $user->id));
     $this->assertTrue($cond->is_available(true, $info, true, $user->id));
     $cond = new condition((object) array('cm' => (int) $assigncm->id, 'e' => COMPLETION_COMPLETE));
     $this->assertTrue($cond->is_available(false, $info, true, $user->id));
     $this->assertFalse($cond->is_available(true, $info, true, $user->id));
     $cond = new condition((object) array('cm' => (int) $assigncm->id, 'e' => COMPLETION_COMPLETE_PASS));
     $this->assertFalse($cond->is_available(false, $info, true, $user->id));
     $information = $cond->get_description(false, false, $info);
     $information = \core_availability\info::format_info($information, $course);
     $this->assertRegExp('~Assign!.*is complete and passed~', $information);
     $this->assertTrue($cond->is_available(true, $info, true, $user->id));
     $cond = new condition((object) array('cm' => (int) $assigncm->id, 'e' => COMPLETION_COMPLETE_FAIL));
//.........这里部分代码省略.........

 public function test_course_completion_progress()
 {
     global $CFG, $DB;
     $CFG->enablecompletion = true;
     $DB->update_record('course', (object) ['id' => $this->course->id, 'enablecompletion' => 1]);
     $this->course = $DB->get_record('course', ['id' => $this->course->id]);
     $actual = local::course_completion_progress($this->course);
     $this->assertNull($actual);
     $this->create_extra_users();
     $this->setUser($this->extrasuspendedstudents[0]);
     $actual = local::course_completion_progress($this->course);
     $this->assertNull($actual);
     $this->setUser($this->students[0]);
     $actual = local::course_completion_progress($this->course);
     $this->assertNull($actual);
     // Create an assignment that is enabled for completion.
     $this->setUSer($this->teachers[0]);
     $assign = $this->create_instance(['course' => $this->course->id, 'name' => 'Assign!', 'completion' => COMPLETION_TRACKING_AUTOMATIC]);
     // Should now have something that can be tracked for progress.
     $this->setUser($this->students[0]);
     $actual = local::course_completion_progress($this->course);
     $this->assertInstanceOf('stdClass', $actual);
     $this->assertEquals(0, $actual->complete);
     $this->assertEquals(1, $actual->total);
     $this->assertEquals(0, $actual->progress);
     // Make sure completion updates on grading.
     $DB->set_field('course_modules', 'completiongradeitemnumber', 0, ['id' => $assign->get_course_module()->id]);
     $gradeitem = $assign->get_grade_item();
     grade_object::set_properties($gradeitem, array('gradepass' => 50.0));
     $gradeitem->update();
     $assignrow = $assign->get_instance();
     $grades = array();
     $grades[$this->students[0]->id] = (object) ['rawgrade' => 60, 'userid' => $this->students[0]->id];
     $assignrow->cmidnumber = null;
     assign_grade_item_update($assignrow, $grades);
     $actual = local::course_completion_progress($this->course);
     $this->assertInstanceOf('stdClass', $actual);
     $this->assertEquals(1, $actual->complete);
     $this->assertEquals(1, $actual->total);
     $this->assertEquals(100, $actual->progress);
     // Make sure course completion returns null when disabled at site level.
     $CFG->enablecompletion = false;
     $actual = local::course_completion_progress($this->course);
     $this->assertNull($actual);
     // Make sure course completion returns null when disabled at course level.
     $CFG->enablecompletion = true;
     $DB->update_record('course', (object) ['id' => $this->course->id, 'enablecompletion' => 0]);
     $this->course = $DB->get_record('course', ['id' => $this->course->id]);
     $actual = local::course_completion_progress($this->course);
     $this->assertNull($actual);
 }

 /**
  * Returns the grade items associated with the courses.
  *
  * @param array $courseids Array of course ids.
  * @return array Array of grade_items for each course level grade item.
  */
 public static function fetch_course_items(array $courseids)
 {
     global $DB;
     $courseitems = array();
     if (!empty($courseids)) {
         list($courseidssql, $courseidsparams) = $DB->get_in_or_equal($courseids);
         $select = 'courseid ' . $courseidssql . ' AND itemtype = ?';
         $params = array_merge($courseidsparams, array('course'));
         $rs = $DB->get_recordset_select('grade_items', $select, $params);
         $courseitems = array();
         foreach ($rs as $data) {
             $instance = new \grade_item();
             \grade_object::set_properties($instance, $data);
             $courseitems[$instance->id] = $instance;
         }
         $rs->close();
     }
     // Determine if any courses were missing.
     $receivedids = array();
     foreach ($courseitems as $item) {
         $receivedids[] = $item->courseid;
     }
     $missingids = array_diff($courseids, $receivedids);
     // Create grade items for any courses that didn't have one.
     if (!empty($missingids)) {
         foreach ($missingids as $courseid) {
             // First get category - it creates the associated grade item.
             $coursecategory = \grade_category::fetch_course_category($courseid);
             $gradeitem = $coursecategory->get_grade_item();
             $courseitems[$gradeitem->id] = $gradeitem;
         }
     }
     return $courseitems;
 }