/**
  * Return the custom definition of the properties of this model.
  *
  * @param int $courseid The course we want to generate statistics for.
  */
 public function __construct($courseid)
 {
     global $USER;
     $this->competencycount = api::count_competencies_in_course($courseid);
     $this->proficientcompetencycount = api::count_proficient_competencies_in_course_for_user($courseid, $USER->id);
     $this->leastproficientcompetencies = api::get_least_proficient_competencies_for_course($courseid, 0, 3);
 }

 /**
  * Export the data.
  *
  * @param renderer_base $output
  * @return stdClass
  */
 public function export_for_template(\renderer_base $output)
 {
     $frameworks = array();
     $scales = array();
     $planexporter = new plan_exporter($this->plan, array('template' => $this->plan->get_template()));
     $data = new stdClass();
     $data->plan = $planexporter->export($output);
     $data->competencies = array();
     $data->pluginbaseurl = (new moodle_url('/admin/tool/lp'))->out(false);
     $data->contextid = $this->plan->get_context()->id;
     if ($data->plan->iscompleted) {
         $ucproperty = 'usercompetencyplan';
         $ucexporter = 'core_competency\\external\\user_competency_plan_exporter';
     } else {
         $ucproperty = 'usercompetency';
         $ucexporter = 'core_competency\\external\\user_competency_exporter';
     }
     $pclist = api::list_plan_competencies($this->plan);
     $proficientcount = 0;
     foreach ($pclist as $pc) {
         $comp = $pc->competency;
         $usercomp = $pc->{$ucproperty};
         // Get the framework.
         if (!isset($frameworks[$comp->get_competencyframeworkid()])) {
             $frameworks[$comp->get_competencyframeworkid()] = $comp->get_framework();
         }
         $framework = $frameworks[$comp->get_competencyframeworkid()];
         // Get the scale.
         $scaleid = $comp->get_scaleid();
         if ($scaleid === null) {
             $scaleid = $framework->get_scaleid();
         }
         if (!isset($scales[$framework->get_scaleid()])) {
             $scales[$framework->get_scaleid()] = $framework->get_scale();
         }
         $scale = $scales[$framework->get_scaleid()];
         // Prepare the data.
         $record = new stdClass();
         $exporter = new competency_exporter($comp, array('context' => $framework->get_context()));
         $record->competency = $exporter->export($output);
         // Competency path.
         $exporter = new competency_path_exporter(['ancestors' => $comp->get_ancestors(), 'framework' => $framework, 'context' => $framework->get_context()]);
         $record->comppath = $exporter->export($output);
         $exporter = new $ucexporter($usercomp, array('scale' => $scale));
         $record->{$ucproperty} = $exporter->export($output);
         $data->competencies[] = $record;
         if ($usercomp->get_proficiency()) {
             $proficientcount++;
         }
     }
     $data->competencycount = count($data->competencies);
     $data->proficientcompetencycount = $proficientcount;
     if ($data->competencycount) {
         $data->proficientcompetencypercentage = (double) $proficientcount / (double) $data->competencycount * 100.0;
     } else {
         $data->proficientcompetencypercentage = 0.0;
     }
     $data->proficientcompetencypercentageformatted = format_float($data->proficientcompetencypercentage);
     return $data;
 }

 protected function get_other_values(renderer_base $output)
 {
     // Arrays are copy on assign.
     $related = $this->related;
     $result = new stdClass();
     // Remove course from related as it is not wanted by the user_competency_summary_exporter.
     unset($related['course']);
     $related['usercompetencyplan'] = null;
     $related['usercompetency'] = null;
     $exporter = new user_competency_summary_exporter(null, $related);
     $result->usercompetencysummary = $exporter->export($output);
     $result->usercompetencysummary->cangrade = user_competency::can_grade_user_in_course($this->related['user']->id, $this->related['course']->id);
     $context = context_course::instance($this->related['course']->id);
     $exporter = new course_summary_exporter($this->related['course'], array('context' => $context));
     $result->course = $exporter->export($output);
     $coursemodules = api::list_course_modules_using_competency($this->related['competency']->get_id(), $this->related['course']->id);
     $fastmodinfo = get_fast_modinfo($this->related['course']->id);
     $exportedmodules = array();
     foreach ($coursemodules as $cm) {
         $cminfo = $fastmodinfo->cms[$cm];
         $cmexporter = new course_module_summary_exporter(null, array('cm' => $cminfo));
         $exportedmodules[] = $cmexporter->export($output);
     }
     $result->coursemodules = $exportedmodules;
     return (array) $result;
 }

 /**
  * Export the data.
  *
  * @param renderer_base $output
  * @return stdClass
  */
 public function export_for_template(renderer_base $output)
 {
     $data = new stdClass();
     $data->userid = $this->userid;
     $data->competencyid = $this->competencyid;
     $data->planid = $this->planid;
     $data->baseurl = $this->baseurl;
     $plancompetencies = \core_competency\api::list_plan_competencies($data->planid);
     $data->competencies = array();
     $contextcache = array();
     foreach ($plancompetencies as $plancompetency) {
         $frameworkid = $plancompetency->competency->get_competencyframeworkid();
         if (!isset($contextcache[$frameworkid])) {
             $contextcache[$frameworkid] = $plancompetency->competency->get_context();
         }
         $context = $contextcache[$frameworkid];
         $exporter = new competency_exporter($plancompetency->competency, array('context' => $context));
         $competency = $exporter->export($output);
         if ($competency->id == $this->competencyid) {
             $competency->selected = true;
         }
         $data->competencies[] = $competency;
     }
     $data->hascompetencies = count($data->competencies);
     return $data;
 }

 /**
  * Constructor
  *
  * @param string $elementName Element name
  * @param mixed $elementLabel Label(s) for an element
  * @param array $options Options to control the element's display
  * @param mixed $attributes Either a typical HTML attribute string or an associative array.
  */
 public function __construct($elementName = null, $elementLabel = null, $options = array(), $attributes = null)
 {
     global $OUTPUT;
     if ($elementName == null) {
         // This is broken quickforms messing with the constructors.
         return;
     }
     if (!isset($options['courseid'])) {
         throw new coding_exception('Course id is required for the course_competencies form element');
     }
     $courseid = $options['courseid'];
     if (!empty($options['cmid'])) {
         $current = \core_competency\api::list_course_module_competencies_in_course_module($options['cmid']);
         $ids = array();
         foreach ($current as $coursemodulecompetency) {
             array_push($ids, $coursemodulecompetency->get_competencyid());
         }
         $this->setValue($ids);
     }
     $competencies = api::list_course_competencies($courseid);
     $validoptions = array();
     $context = context_course::instance($courseid);
     foreach ($competencies as $competency) {
         // We don't need to show the description as part of the options, so just set this to null.
         $competency['competency']->set_description(null);
         $exporter = new competency_exporter($competency['competency'], array('context' => $context));
         $templatecontext = array('competency' => $exporter->export($OUTPUT));
         $id = $competency['competency']->get_id();
         $validoptions[$id] = $OUTPUT->render_from_template('tool_lp/competency_summary', $templatecontext);
     }
     $attributes['tags'] = false;
     $attributes['multiple'] = 'multiple';
     parent::__construct($elementName, $elementLabel, $validoptions, $attributes);
 }

 /**
  * Construct this renderable.
  *
  * @param context $pagecontext The page context
  */
 public function __construct(context $pagecontext)
 {
     $this->pagecontext = $pagecontext;
     if (competency_framework::can_manage_context($this->pagecontext)) {
         $addpage = new single_button(new moodle_url('/admin/tool/lp/editcompetencyframework.php', array('pagecontextid' => $this->pagecontext->id)), get_string('addnewcompetencyframework', 'tool_lp'), 'get');
         $this->navigation[] = $addpage;
     }
     $this->competencyframeworks = api::list_frameworks('shortname', 'ASC', 0, 0, $this->pagecontext);
 }

 /**
  * Construct this renderable.
  * @param context $pagecontext
  */
 public function __construct(context $pagecontext)
 {
     $this->pagecontext = $pagecontext;
     if (template::can_manage_context($this->pagecontext)) {
         $addpage = new single_button(new moodle_url('/admin/tool/lp/edittemplate.php', array('pagecontextid' => $this->pagecontext->id)), get_string('addnewtemplate', 'tool_lp'), 'get');
         $this->navigation[] = $addpage;
     }
     $this->templates = api::list_templates('shortname', 'ASC', 0, 0, $this->pagecontext);
 }

 /**
  * Construct this renderable.
  *
  * @param int $userid
  */
 public function __construct($userid)
 {
     $this->userid = $userid;
     $this->plans = api::list_user_plans($userid);
     $this->context = context_user::instance($userid);
     if (plan::can_manage_user($userid) || plan::can_manage_user_draft($userid)) {
         $addplan = new single_button(new moodle_url('/admin/tool/lp/editplan.php', array('userid' => $userid)), get_string('addnewplan', 'tool_lp'), 'get');
         $this->navigation[] = $addplan;
     }
 }

 /**
  * Construct this renderable.
  *
  * @param int $userid
  */
 public function __construct($userid)
 {
     $this->userid = $userid;
     $this->context = context_user::instance($userid);
     $this->evidence = api::list_user_evidence($userid);
     $this->canmanage = user_evidence::can_manage_user($this->userid);
     if ($this->canmanage) {
         $addevidence = new single_button(new moodle_url('/admin/tool/lp/user_evidence_edit.php', array('userid' => $userid)), get_string('addnewuserevidence', 'tool_lp'), 'get');
         $this->navigation[] = $addevidence;
     }
 }

 /**
  * Construct this renderable.
  *
  * @param \core_competency\competency $competency Competency persistent.
  * @param \core_competency\competency_framework $framework framework persistent.
  * @param boolean $includerelated Include or not related competencies.
  * @param boolean $includecourses Include or not competency courses.
  */
 public function __construct($competency, $framework, $includerelated, $includecourses)
 {
     $this->competency = $competency;
     $this->framework = $framework;
     if ($includerelated) {
         $this->relatedcompetencies = api::list_related_competencies($competency->get_id());
     }
     if ($includecourses) {
         $this->courses = api::list_courses_using_competency($competency->get_id());
     }
 }

 /**
  * Return the custom definition of the properties of this model.
  *
  * @param int $templateid The template we want to generate statistics for.
  */
 public function __construct($templateid)
 {
     $template = new template($templateid);
     $this->competencycount = api::count_competencies_in_template($template);
     $this->unlinkedcompetencycount = api::count_competencies_in_template_with_no_courses($template);
     $this->plancount = api::count_plans_for_template($template, 0);
     $this->completedplancount = api::count_plans_for_template($template, plan::STATUS_COMPLETE);
     $this->usercompetencyplancount = api::count_user_competency_plans_for_template($template);
     $this->proficientusercompetencyplancount = api::count_user_competency_plans_for_template($template, true);
     $this->leastproficientcompetencies = api::get_least_proficient_competencies_for_template($template, 0, 3);
 }

 /**
  * Do the job.
  */
 public function execute()
 {
     if (!api::is_enabled()) {
         return;
     }
     $records = plan::get_recordset_for_due_and_incomplete();
     foreach ($records as $record) {
         $plan = new plan(0, $record);
         api::complete_plan($plan);
     }
     $records->close();
 }

 /**
  * Export the data.
  *
  * @param renderer_base $output
  * @return stdClass
  */
 public function export_for_template(renderer_base $output)
 {
     if (!isset($related['user'])) {
         $related['user'] = core_user::get_user($this->usercompetency->get_userid());
     }
     if (!isset($related['competency'])) {
         $related['competency'] = $this->usercompetency->get_competency();
     }
     $related += array('usercompetency' => $this->usercompetency, 'usercompetencyplan' => null, 'usercompetencycourse' => null, 'evidence' => api::list_evidence($this->usercompetency->get_userid(), $this->usercompetency->get_competencyid()), 'relatedcompetencies' => api::list_related_competencies($this->usercompetency->get_competencyid()));
     $exporter = new user_competency_summary_exporter(null, $related);
     $data = $exporter->export($output);
     return $data;
 }

 /**
  * Constructor.
  * @param stdClass $user The user.
  */
 public function __construct($user = null)
 {
     global $USER;
     if (!$user) {
         $user = $USER;
     }
     $this->user = $user;
     // Get the plans.
     $this->plans = api::list_user_plans($this->user->id);
     // Get the competencies to review.
     $this->compstoreview = api::list_user_competencies_to_review(0, 3);
     // Get the plans to review.
     $this->planstoreview = api::list_plans_to_review(0, 3);
 }

 public function test_import_framework()
 {
     $this->resetAfterTest(true);
     $this->setAdminUser();
     $importer = new framework_importer(file_get_contents(__DIR__ . '/fixtures/example.csv'));
     $this->assertEquals('', $importer->get_error());
     $framework = $importer->import();
     $this->assertEmpty('', $importer->get_error());
     $this->assertGreaterThan(0, $framework->get_id());
     $filters = ['competencyframeworkid' => $framework->get_id()];
     $count = api::count_competencies($filters);
     $this->assertEquals(64, $count);
     // We can't test the exporter because it sends force-download headers.
 }

 /**
  * Do the job.
  */
 public function execute()
 {
     if (!api::is_enabled()) {
         return;
     }
     $missingplans = template_cohort::get_all_missing_plans(self::get_last_run_time());
     foreach ($missingplans as $missingplan) {
         foreach ($missingplan['userids'] as $userid) {
             try {
                 api::create_plan_from_template($missingplan['template'], $userid);
             } catch (\Exception $e) {
                 debugging(sprintf('Exception caught while creating plan for user %d from template %d. Message: %s', $userid, $missingplan['template']->get_id(), $e->getMessage()), DEBUG_DEVELOPER);
             }
         }
     }
 }

 /**
  * Export all the competencies from this framework to a csv file.
  */
 public function export()
 {
     global $CFG;
     require_once $CFG->libdir . '/csvlib.class.php';
     $writer = new csv_export_writer();
     $filename = clean_param($this->framework->get_shortname() . '-' . $this->framework->get_idnumber(), PARAM_FILE);
     $writer->set_filename($filename);
     $headers = framework_importer::list_required_headers();
     $writer->add_data($headers);
     // Order and number of columns must match framework_importer::list_required_headers().
     $row = array('', $this->framework->get_idnumber(), $this->framework->get_shortname(), $this->framework->get_description(), $this->framework->get_descriptionformat(), $this->framework->get_scale()->compact_items(), $this->framework->get_scaleconfiguration(), '', '', '', '', '', true, implode(',', $this->framework->get_taxonomies()));
     $writer->add_data($row);
     $filters = array('competencyframeworkid' => $this->framework->get_id());
     $competencies = api::list_competencies($filters);
     // Index by id so we can lookup parents.
     $indexed = array();
     foreach ($competencies as $competency) {
         $indexed[$competency->get_id()] = $competency;
     }
     foreach ($competencies as $competency) {
         $parentidnumber = '';
         if ($competency->get_parentid() > 0) {
             $parent = $indexed[$competency->get_parentid()];
             $parentidnumber = $parent->get_idnumber();
         }
         $scalevalues = '';
         $scaleconfig = '';
         if ($competency->get_scaleid() !== null) {
             $scalevalues = $competency->get_scale()->compact_items();
             $scaleconfig = $competency->get_scaleconfiguration();
         }
         $ruleconfig = $competency->get_ruleconfig();
         if ($ruleconfig === null) {
             $ruleconfig = "null";
         }
         $allrelated = $competency->get_related_competencies();
         $relatedidnumbers = array();
         foreach ($allrelated as $onerelated) {
             $relatedidnumbers[] = str_replace(',', '%2C', $onerelated->get_idnumber());
         }
         $relatedidnumbers = implode(',', $relatedidnumbers);
         // Order and number of columns must match framework_importer::list_required_headers().
         $row = array($parentidnumber, $competency->get_idnumber(), $competency->get_shortname(), $competency->get_description(), $competency->get_descriptionformat(), $scalevalues, $scaleconfig, $competency->get_ruletype(), $competency->get_ruleoutcome(), $ruleconfig, $relatedidnumbers, $competency->get_id(), false, '');
         $writer->add_data($row);
     }
     $writer->download_file();
 }

 /**
  * Export the data.
  *
  * @param renderer_base $output
  * @return stdClass
  */
 public function export_for_template(renderer_base $output)
 {
     global $DB;
     $usercompetencycourse = api::get_user_competency_in_course($this->courseid, $this->userid, $this->competencyid);
     $competency = $usercompetencycourse->get_competency();
     if (empty($usercompetencycourse) || empty($competency)) {
         throw new \invalid_parameter_exception('Invalid params. The competency does not belong to the course.');
     }
     $relatedcompetencies = api::list_related_competencies($competency->get_id());
     $user = $DB->get_record('user', array('id' => $this->userid));
     $evidence = api::list_evidence_in_course($this->userid, $this->courseid, $this->competencyid);
     $course = $DB->get_record('course', array('id' => $this->courseid));
     $params = array('competency' => $competency, 'usercompetencycourse' => $usercompetencycourse, 'evidence' => $evidence, 'user' => $user, 'course' => $course, 'scale' => $competency->get_scale(), 'relatedcompetencies' => $relatedcompetencies);
     $exporter = new user_competency_summary_in_course_exporter(null, $params);
     $data = $exporter->export($output);
     return $data;
 }

 /**
  * Define the form - called by parent constructor
  */
 public function definition()
 {
     $mform = $this->_form;
     $context = context_system::instance();
     $frameworks = api::list_frameworks('shortname', 'ASC', null, null, $context);
     $options = array();
     foreach ($frameworks as $framework) {
         $options[$framework->get_id()] = $framework->get_shortname();
     }
     if (empty($options)) {
         $mform->addElement('static', 'frameworkid', '', get_string('noframeworks', 'tool_lpimportcsv'));
     } else {
         $mform->addElement('select', 'frameworkid', get_string('competencyframework', 'tool_lp'), $options);
         $mform->setType('frameworkid', PARAM_INT);
         $mform->addRule('frameworkid', null, 'required', null, 'client');
         $this->add_action_buttons(true, get_string('export', 'tool_lpimportcsv'));
     }
     $mform->setDisableShortforms();
 }

 /**
  * Constructor
  *
  * @param string $elementName Element name
  * @param mixed $elementLabel Label(s) for an element
  * @param array $options Options to control the element's display
  * @param mixed $attributes Either a typical HTML attribute string or an associative array.
  */
 public function __construct($elementName = null, $elementLabel = null, $options = array(), $attributes = null)
 {
     if ($elementName == null) {
         // This is broken quickforms messing with the constructors.
         return;
     }
     if (!empty($options['cmid'])) {
         $cmid = $options['cmid'];
         $current = \core_competency\api::list_course_module_competencies_in_course_module($cmid);
         // Note: We just pick the outcome set on the first course_module_competency - because in our UI are are
         // forcing them to be all the same for each activity.
         if (!empty($current)) {
             $one = array_pop($current);
             $this->setValue($one->get_ruleoutcome());
         }
     }
     $validoptions = course_module_competency::get_ruleoutcome_list();
     parent::__construct($elementName, $elementLabel, $validoptions, $attributes);
 }