PHP api::add_competency_to_course方法代码示例

 /**
  * Process each course individually.
  * @return void
  */
 protected function process_courses()
 {
     global $DB;
     $this->progress->start_progress(get_string('migratingcourses', 'tool_lpmigrate'), count($this->coursescompetencies));
     // Process each course.
     foreach ($this->coursescompetencies as $courseid => $competencyids) {
         $this->progress->increment_progress();
         $competenciestoremovefromcourse = array();
         $skipcompetencies = array();
         // First, add all the new competencies to the course.
         foreach ($competencyids as $key => $competencyid) {
             $this->coursecompetencyexpectedmigrations++;
             $mapto = isset($this->mappings[$competencyid]) ? $this->mappings[$competencyid] : false;
             // Skip the competencies that are not mapped.
             if ($mapto === false) {
                 $this->missingmappings[$competencyid] = true;
                 if ($this->removewhenmappingismissing) {
                     $competenciestoremovefromcourse[$competencyid] = true;
                 }
                 continue;
             }
             $transaction = $DB->start_delegated_transaction();
             try {
                 // Add the new competency to the course.
                 if (api::add_competency_to_course($courseid, $mapto)) {
                     // Find the added course competency.
                     $cc = course_competency::get_record(array('courseid' => $courseid, 'competencyid' => $mapto));
                     // Set the rule.
                     api::set_course_competency_ruleoutcome($cc, $this->coursescompetenciesoutcomes[$courseid][$competencyid]);
                     // Adapt the sortorder.
                     api::reorder_course_competency($courseid, $mapto, $competencyid);
                     $competenciestoremovefromcourse[$competencyid] = true;
                     $this->coursecompetencymigrations++;
                 } else {
                     // The competency was already in the course...
                     if ($this->removeoriginalwhenalreadypresent) {
                         $competenciestoremovefromcourse[$competencyid] = true;
                     } else {
                         $this->log_warning($courseid, $competencyid, null, get_string('warningdestinationcoursecompetencyalreadyexists', 'tool_lpmigrate'));
                     }
                 }
             } catch (moodle_exception $e) {
                 // There was a major problem with this competency, we will ignore it entirely for the course.
                 $skipcompetencies[$competencyid] = true;
                 $this->log_error($courseid, $competencyid, null, get_string('errorwhilemigratingcoursecompetencywithexception', 'tool_lpmigrate', $e->getMessage()));
                 try {
                     $transaction->rollback($e);
                 } catch (moodle_exception $e) {
                     // Catch the re-thrown exception.
                 }
                 continue;
             }
             $transaction->allow_commit();
         }
         // Then, convert the module competencies.
         if (!empty($this->modulecompetencies[$courseid])) {
             foreach ($this->modulecompetencies[$courseid] as $cmid => $competencyids) {
                 foreach ($competencyids as $competencyid) {
                     $this->modulecompetencyexpectedmigrations++;
                     // This mapped competency was not added to the course.
                     if (!empty($skipcompetencies[$competencyid])) {
                         continue;
                     }
                     $remove = true;
                     $mapto = isset($this->mappings[$competencyid]) ? $this->mappings[$competencyid] : false;
                     // We don't have mapping.
                     if ($mapto === false) {
                         if (!$this->removewhenmappingismissing) {
                             $remove = false;
                         }
                     } else {
                         // We have a mapping.
                         $transaction = $DB->start_delegated_transaction();
                         try {
                             // The competency was added successfully.
                             if (api::add_competency_to_course_module($cmid, $mapto)) {
                                 // Find the added module competency.
                                 $mc = course_module_competency::get_record(array('cmid' => $cmid, 'competencyid' => $mapto));
                                 // Set the competency rule.
                                 api::set_course_module_competency_ruleoutcome($mc, $this->modulecompetenciesoutcomes[$courseid][$cmid][$competencyid]);
                                 // Adapt the sortorder.
                                 api::reorder_course_module_competency($cmid, $mapto, $competencyid);
                                 $this->modulecompetencymigrations++;
                             } else {
                                 // The competency was already in the module.
                                 if (!$this->removeoriginalwhenalreadypresent) {
                                     $remove = false;
                                     $competencieswithissues[$competencyid] = true;
                                     $this->log_warning($courseid, $competencyid, $cmid, get_string('warningdestinationmodulecompetencyalreadyexists', 'tool_lpmigrate'));
                                 }
                             }
                         } catch (moodle_exception $e) {
                             // There was a major problem with this competency in this module.
                             $competencieswithissues[$competencyid] = true;
                             $message = get_string('errorwhilemigratingmodulecompetencywithexception', 'tool_lpmigrate', $e->getMessage());
                             $this->log_error($courseid, $competencyid, $cmid, $message);
//.........这里部分代码省略.........

 /**
  * Test when adding competency that belong to hidden framework to plan/template/course.
  */
 public function test_hidden_framework()
 {
     $this->resetAfterTest(true);
     $this->setAdminUser();
     $dg = $this->getDataGenerator();
     $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
     $user = $dg->create_user();
     // Create a course.
     $cat1 = $dg->create_category();
     $course = $dg->create_course(array('category' => $cat1->id));
     // Create a template.
     $template = $lpg->create_template();
     // Create a plan.
     $plan = $lpg->create_plan(array('userid' => $user->id));
     // Create a hidden framework.
     $frm = array('visible' => false);
     $framework = $lpg->create_framework($frm);
     $competency = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
     // Linking competency that belong to hidden framework to course.
     try {
         api::add_competency_to_course($course->id, $competency->get_id());
         $this->fail('A competency belonging to hidden framework can not be linked to course');
     } catch (coding_exception $e) {
         $this->assertTrue(true);
     }
     // Adding competency that belong to hidden framework to template.
     try {
         api::add_competency_to_template($template->get_id(), $competency->get_id());
         $this->fail('A competency belonging to hidden framework can not be added to template');
     } catch (coding_exception $e) {
         $this->assertTrue(true);
     }
     // Adding competency that belong to hidden framework to plan.
     try {
         api::add_competency_to_plan($plan->get_id(), $competency->get_id());
         $this->fail('A competency belonging to hidden framework can not be added to plan');
     } catch (coding_exception $e) {
         $this->assertTrue(true);
     }
 }

 /**
  * Count the competencies (visible to this user) in this course.
  *
  * @param int $courseid The course id to check.
  * @param int $competencyid Competency id.
  * @return int
  */
 public static function add_competency_to_course($courseid, $competencyid)
 {
     $params = self::validate_parameters(self::add_competency_to_course_parameters(), array('courseid' => $courseid, 'competencyid' => $competencyid));
     self::validate_context(context_course::instance($params['courseid']));
     return api::add_competency_to_course($params['courseid'], $params['competencyid']);
 }