[Summary view] [Print] [Text view]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  /**
  18   * Competency data generator.
  19   *
  20   * @package    core_competency
  21   * @category   test
  22   * @copyright  2015 Frédéric Massart - FMCorz.net
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  use core_competency\competency;
  27  use core_competency\competency_framework;
  28  use core_competency\course_competency;
  29  use core_competency\course_module_competency;
  30  use core_competency\evidence;
  31  use core_competency\external;
  32  use core_competency\plan;
  33  use core_competency\plan_competency;
  34  use core_competency\related_competency;
  35  use core_competency\template;
  36  use core_competency\template_cohort;
  37  use core_competency\template_competency;
  38  use core_competency\user_competency;
  39  use core_competency\user_competency_course;
  40  use core_competency\user_competency_plan;
  41  use core_competency\user_evidence;
  42  use core_competency\user_evidence_competency;
  43  
  44  
  45  defined('MOODLE_INTERNAL') || die();
  46  
  47  global $CFG;
  48  require_once($CFG->libdir . '/grade/grade_scale.php');
  49  
  50  /**
  51   * Competency data generator class.
  52   *
  53   * @package    core_competency
  54   * @category   test
  55   * @copyright  2015 Frédéric Massart - FMCorz.net
  56   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  57   */
  58  class core_competency_generator extends component_generator_base {
  59  
  60      /** @var int Number of created competencies. */
  61      protected $competencycount = 0;
  62  
  63      /** @var int Number of created frameworks. */
  64      protected $frameworkcount = 0;
  65  
  66      /** @var int Number of created plans. */
  67      protected $plancount = 0;
  68  
  69      /** @var int Number of created templates. */
  70      protected $templatecount = 0;
  71  
  72      /** @var int Number of created user_evidence. */
  73      protected $userevidencecount = 0;
  74  
  75      /** @var stdClass Scale that we might need. */
  76      protected $scale;
  77  
  78      /**
  79       * Reset process.
  80       *
  81       * Do not call directly.
  82       *
  83       * @return void
  84       */
  85      public function reset() {
  86          $this->competencycount = 0;
  87          $this->frameworkcount = 0;
  88          $this->scale = null;
  89      }
  90  
  91      /**
  92       * Create a new competency.
  93       *
  94       * @param array|stdClass $record
  95       * @return competency
  96       */
  97      public function create_competency($record = null) {
  98          $this->frameworkcount++;
  99          $i = $this->frameworkcount;
 100          $record = (object) $record;
 101  
 102          if (!isset($record->competencyframeworkid)) {
 103              throw new coding_exception('The competencyframeworkid value is required.');
 104          }
 105          if (!isset($record->shortname)) {
 106              $record->shortname = "Competency shortname $i";
 107          }
 108          if (!isset($record->idnumber)) {
 109              $record->idnumber = "cmp{$i}";
 110          }
 111          if (!isset($record->description)) {
 112              $record->description = "Competency $i description ";
 113          }
 114          if (!isset($record->descriptionformat)) {
 115              $record->descriptionformat = FORMAT_HTML;
 116          }
 117          if (isset($record->scaleconfiguration)
 118                  && (is_array($record->scaleconfiguration) || is_object($record->scaleconfiguration))) {
 119              // Conveniently encode the config.
 120              $record->scaleconfiguration = json_encode($record->scaleconfiguration);
 121          }
 122  
 123          $competency = new competency(0, $record);
 124          $competency->create();
 125  
 126          return $competency;
 127      }
 128  
 129      /**
 130       * Create a new framework.
 131       *
 132       * @param array|stdClass $record
 133       * @return competency_framework
 134       */
 135      public function create_framework($record = null) {
 136          $generator = phpunit_util::get_data_generator();
 137          $this->frameworkcount++;
 138          $i = $this->frameworkcount;
 139          $record = (object) $record;
 140  
 141          if (!isset($record->shortname)) {
 142              $record->shortname = "Framework shortname $i";
 143          }
 144          if (!isset($record->idnumber)) {
 145              $record->idnumber = "frm{$i}";
 146          }
 147          if (!isset($record->description)) {
 148              $record->description = "Framework $i description ";
 149          }
 150          if (!isset($record->descriptionformat)) {
 151              $record->descriptionformat = FORMAT_HTML;
 152          }
 153          if (!isset($record->visible)) {
 154              $record->visible = 1;
 155          }
 156          if (!isset($record->scaleid)) {
 157              if (isset($record->scaleconfiguration)) {
 158                  throw new coding_exception('Scale configuration must be provided with a scale.');
 159              }
 160              if (!$this->scale) {
 161                  $this->scale = $generator->create_scale(array('scale' => 'A,B,C,D'));
 162              }
 163              $record->scaleid = $this->scale->id;
 164          }
 165          if (!isset($record->scaleconfiguration)) {
 166              $scale = grade_scale::fetch(array('id' => $record->scaleid));
 167              $values = $scale->load_items();
 168              foreach ($values as $key => $value) {
 169                  // Add a key (make the first value 1).
 170                  $values[$key] = array('id' => $key + 1, 'name' => $value);
 171              }
 172              if (count($values) < 2) {
 173                  throw new coding_exception('Please provide the scale configuration for one-item scales.');
 174              }
 175              $scaleconfig = array();
 176              // Last item is proficient.
 177              $item = array_pop($values);
 178              array_unshift($scaleconfig, array(
 179                  'id' => $item['id'],
 180                  'proficient' => 1
 181              ));
 182              // Second-last item is default and proficient.
 183              $item = array_pop($values);
 184              array_unshift($scaleconfig, array(
 185                  'id' => $item['id'],
 186                  'scaledefault' => 1,
 187                  'proficient' => 1
 188              ));
 189              array_unshift($scaleconfig, array('scaleid' => $record->scaleid));
 190              $record->scaleconfiguration = json_encode($scaleconfig);
 191          }
 192          if (is_array($record->scaleconfiguration) || is_object($record->scaleconfiguration)) {
 193              // Conveniently encode the config.
 194              $record->scaleconfiguration = json_encode($record->scaleconfiguration);
 195          }
 196          if (!isset($record->contextid)) {
 197              $record->contextid = context_system::instance()->id;
 198          }
 199  
 200          $framework = new competency_framework(0, $record);
 201          $framework->create();
 202  
 203          return $framework;
 204      }
 205  
 206      /**
 207       * Create a related competency.
 208       *
 209       * @param array|stdClass $record
 210       * @return related_competency
 211       */
 212      public function create_related_competency($record = null) {
 213          $record = (object) $record;
 214  
 215          if (!isset($record->competencyid)) {
 216              throw new coding_exception('Property competencyid is required.');
 217          }
 218          if (!isset($record->relatedcompetencyid)) {
 219              throw new coding_exception('Property relatedcompetencyid is required.');
 220          }
 221  
 222          $relation = related_competency::get_relation($record->competencyid, $record->relatedcompetencyid);
 223          if ($relation->get_id()) {
 224              throw new coding_exception('Relation already exists');
 225          }
 226          $relation->create();
 227  
 228          return $relation;
 229      }
 230  
 231      /**
 232       * Create a template.
 233       *
 234       * @param array|stdClass $record
 235       * @return template
 236       */
 237      public function create_template($record = null) {
 238          $this->templatecount++;
 239          $i = $this->templatecount;
 240          $record = (object) $record;
 241  
 242          if (!isset($record->shortname)) {
 243              $record->shortname = "Template shortname $i";
 244          }
 245          if (!isset($record->description)) {
 246              $record->description = "Template $i description ";
 247          }
 248          if (!isset($record->contextid)) {
 249              $record->contextid = context_system::instance()->id;
 250          }
 251  
 252          $template = new template(0, $record);
 253          $template->create();
 254  
 255          return $template;
 256      }
 257  
 258      /**
 259       * Create a template competency.
 260       *
 261       * @param array|stdClass $record
 262       * @return template_competency
 263       */
 264      public function create_template_competency($record = null) {
 265          $record = (object) $record;
 266  
 267          if (!isset($record->competencyid)) {
 268              throw new coding_exception('Property competencyid is required.');
 269          }
 270          if (!isset($record->templateid)) {
 271              throw new coding_exception('Property templateid is required.');
 272          }
 273  
 274          $relation = new template_competency(0, $record);
 275          $relation->create();
 276  
 277          return $relation;
 278      }
 279  
 280      /**
 281       * Create a new user competency.
 282       *
 283       * @param array|stdClass $record
 284       * @return user_competency
 285       */
 286      public function create_user_competency($record = null) {
 287          $record = (object) $record;
 288  
 289          if (!isset($record->userid)) {
 290              throw new coding_exception('The userid value is required.');
 291          }
 292          if (!isset($record->competencyid)) {
 293              throw new coding_exception('The competencyid value is required.');
 294          }
 295  
 296          $usercompetency = new user_competency(0, $record);
 297          $usercompetency->create();
 298  
 299          return $usercompetency;
 300      }
 301  
 302      /**
 303       * Create a new plan.
 304       *
 305       * @param array|stdClass $record
 306       * @return plan
 307       */
 308      public function create_plan($record = null) {
 309          $this->plancount++;
 310          $i = $this->plancount;
 311          $record = (object) $record;
 312  
 313          if (!isset($record->name)) {
 314              $record->name = "Plan shortname $i";
 315          }
 316          if (!isset($record->description)) {
 317              $record->description = "Plan $i description";
 318          }
 319          if (!isset($record->descriptionformat)) {
 320              $record->descriptionformat = FORMAT_HTML;
 321          }
 322          if (!isset($record->userid)) {
 323              throw new coding_exception('The userid value is required.');
 324          }
 325  
 326          $plan = new plan(0, $record);
 327          $plan->create();
 328  
 329          return $plan;
 330      }
 331  
 332      /**
 333       * Create a new user competency course.
 334       *
 335       * @param array|stdClass $record
 336       * @return user_competency_course
 337       */
 338      public function create_user_competency_course($record = null) {
 339          $record = (object) $record;
 340  
 341          if (!isset($record->userid)) {
 342              throw new coding_exception('The userid value is required.');
 343          }
 344          if (!isset($record->competencyid)) {
 345              throw new coding_exception('The competencyid value is required.');
 346          }
 347  
 348          if (!isset($record->courseid)) {
 349              throw new coding_exception('The courseid value is required.');
 350          }
 351  
 352          $usercompetencycourse = new user_competency_course(0, $record);
 353          $usercompetencycourse->create();
 354  
 355          return $usercompetencycourse;
 356      }
 357  
 358      /**
 359       * Create a new user competency plan.
 360       *
 361       * @param array|stdClass $record
 362       * @return user_competency_plan
 363       */
 364      public function create_user_competency_plan($record = null) {
 365          $record = (object) $record;
 366  
 367          if (!isset($record->userid)) {
 368              throw new coding_exception('The userid value is required.');
 369          }
 370          if (!isset($record->competencyid)) {
 371              throw new coding_exception('The competencyid value is required.');
 372          }
 373  
 374          if (!isset($record->planid)) {
 375              throw new coding_exception('The planid value is required.');
 376          }
 377  
 378          if (!isset($record->sortorder)) {
 379              $record->sortorder = 0;
 380          }
 381  
 382          $usercompetencyplan = new user_competency_plan(0, $record);
 383          $usercompetencyplan->create();
 384  
 385          return $usercompetencyplan;
 386      }
 387  
 388      /**
 389       * Create a new plan competency.
 390       *
 391       * @param array|stdClass $record
 392       * @return plan_competency
 393       */
 394      public function create_plan_competency($record = null) {
 395          $record = (object) $record;
 396  
 397          if (!isset($record->planid)) {
 398              throw new coding_exception('The planid value is required.');
 399          }
 400          if (!isset($record->competencyid)) {
 401              throw new coding_exception('The competencyid value is required.');
 402          }
 403  
 404          $plancompetency = new plan_competency(0, $record);
 405          $plancompetency->create();
 406  
 407          return $plancompetency;
 408      }
 409  
 410      /**
 411       * Create a new template cohort.
 412       *
 413       * @param array|stdClass $record
 414       * @return template_cohort
 415       */
 416      public function create_template_cohort($record = null) {
 417          $record = (object) $record;
 418  
 419          if (!isset($record->templateid)) {
 420              throw new coding_exception('The templateid value is required.');
 421          }
 422          if (!isset($record->cohortid)) {
 423              throw new coding_exception('The cohortid value is required.');
 424          }
 425  
 426          $tplcohort = new template_cohort(0, $record);
 427          $tplcohort->create();
 428  
 429          return $tplcohort;
 430      }
 431  
 432      /**
 433       * Create a new evidence.
 434       *
 435       * @param array|stdClass $record
 436       * @return evidence
 437       */
 438      public function create_evidence($record = null) {
 439          $record = (object) $record;
 440  
 441          if (!isset($record->usercompetencyid)) {
 442              throw new coding_exception('The usercompetencyid value is required.');
 443          }
 444          if (!isset($record->action) && !isset($record->grade)) {
 445              $record->action = evidence::ACTION_LOG;
 446          }
 447          if (!isset($record->action)) {
 448              throw new coding_exception('The action value is required with a grade.');
 449          }
 450  
 451          if (!isset($record->contextid)) {
 452              $record->contextid = context_system::instance()->id;
 453          }
 454          if (!isset($record->descidentifier)) {
 455              $record->descidentifier = 'invalidevidencedesc';
 456          }
 457          if (!isset($record->desccomponent)) {
 458              $record->desccomponent = 'core_competency';
 459          }
 460          $evidence = new evidence(0, $record);
 461          $evidence->create();
 462  
 463          return $evidence;
 464      }
 465  
 466      /**
 467       * Create a new course competency.
 468       *
 469       * @param array|stdClass $record
 470       * @return user_competency
 471       */
 472      public function create_course_competency($record = null) {
 473          $record = (object) $record;
 474  
 475          if (!isset($record->courseid)) {
 476              throw new coding_exception('The courseid value is required.');
 477          }
 478          if (!isset($record->competencyid)) {
 479              throw new coding_exception('The competencyid value is required.');
 480          }
 481  
 482          $cc = new course_competency(0, $record);
 483          $cc->create();
 484  
 485          return $cc;
 486      }
 487  
 488      /**
 489       * Create a new course module competency.
 490       *
 491       * @param array|stdClass $record
 492       * @return course_module_competency
 493       */
 494      public function create_course_module_competency($record = null) {
 495          $record = (object) $record;
 496  
 497          if (!isset($record->cmid)) {
 498              throw new coding_exception('The cmid value is required.');
 499          }
 500          if (!isset($record->competencyid)) {
 501              throw new coding_exception('The competencyid value is required.');
 502          }
 503  
 504          $cc = new course_module_competency(0, $record);
 505          $cc->create();
 506  
 507          return $cc;
 508      }
 509  
 510      /**
 511       * Create a new user_evidence.
 512       *
 513       * @param array|stdClass $record
 514       * @return evidence
 515       */
 516      public function create_user_evidence($record = null) {
 517          $this->userevidencecount++;
 518          $i = $this->userevidencecount;
 519          $record = (object) $record;
 520  
 521          if (!isset($record->userid)) {
 522              throw new coding_exception('The userid value is required.');
 523          }
 524          if (!isset($record->name)) {
 525              $record->name = "Evidence $i name";
 526          }
 527          if (!isset($record->description)) {
 528              $record->description = "Evidence $i description";
 529          }
 530          if (!isset($record->descriptionformat)) {
 531              $record->descriptionformat = FORMAT_HTML;
 532          }
 533  
 534          $ue = new user_evidence(0, $record);
 535          $ue->create();
 536  
 537          return $ue;
 538      }
 539  
 540      /**
 541       * Create a new user_evidence_comp.
 542       *
 543       * @param array|stdClass $record
 544       * @return evidence
 545       */
 546      public function create_user_evidence_competency($record = null) {
 547          $record = (object) $record;
 548  
 549          if (!isset($record->userevidenceid)) {
 550              throw new coding_exception('The userevidenceid value is required.');
 551          }
 552          if (!isset($record->competencyid)) {
 553              throw new coding_exception('The competencyid value is required.');
 554          }
 555  
 556          $uec = new user_evidence_competency(0, $record);
 557          $uec->create();
 558  
 559          return $uec;
 560      }
 561  
 562  }
 563