Search moodle.org's
Developer Documentation
Developer Documentation
- Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
- Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
- PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.
/competency/classes/privacy/ -> provider.php (source)
Differences Between: [Versions 311 and 400] [Versions 311 and 401] [Versions 311 and 402] [Versions 311 and 403]
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 * Data provider. 19 * 20 * @package core_competency 21 * @copyright 2018 Frédéric Massart 22 * @author Frédéric Massart <fred@branchup.tech> 23 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 24 */ 25 26 namespace core_competency\privacy; 27 defined('MOODLE_INTERNAL') || die(); 28 29 use context; 30 use context_course; 31 use context_helper; 32 use context_module; 33 use context_system; 34 use context_user; 35 use moodle_recordset; 36 use core_competency\api; 37 use core_competency\competency; 38 use core_competency\competency_framework; 39 use core_competency\course_competency; 40 use core_competency\course_competency_settings; 41 use core_competency\course_module_competency; 42 use core_competency\evidence; 43 use core_competency\plan; 44 use core_competency\plan_competency; 45 use core_competency\related_competency; 46 use core_competency\template; 47 use core_competency\template_cohort; 48 use core_competency\template_competency; 49 use core_competency\user_competency; 50 use core_competency\user_competency_course; 51 use core_competency\user_competency_plan; 52 use core_competency\user_evidence; 53 use core_competency\user_evidence_competency; 54 use core_competency\external\performance_helper; 55 use core_privacy\local\metadata\collection; 56 use core_privacy\local\request\approved_userlist; 57 use core_privacy\local\request\contextlist; 58 use core_privacy\local\request\approved_contextlist; 59 use core_privacy\local\request\transform; 60 use core_privacy\local\request\userlist; 61 use core_privacy\local\request\writer; 62 63 /** 64 * Data provider class. 65 * 66 * @package core_competency 67 * @copyright 2018 Frédéric Massart 68 * @author Frédéric Massart <fred@branchup.tech> 69 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 70 */ 71 class provider implements 72 \core_privacy\local\metadata\provider, 73 \core_privacy\local\request\core_userlist_provider, 74 \core_privacy\local\request\subsystem\provider { 75 76 /** 77 * Returns metadata. 78 * 79 * @param collection $collection The initialised collection to add items to. 80 * @return collection A listing of user data stored through this system. 81 */ 82 public static function get_metadata(collection $collection) : collection { 83 84 // Tables not related to users aside from the editing information. 85 $collection->add_database_table('competency', [ 86 'timecreated' => 'privacy:metadata:timecreated', 87 'timemodified' => 'privacy:metadata:timemodified', 88 'usermodified' => 'privacy:metadata:usermodified', 89 ], 'privacy:metadata:competency'); 90 91 $collection->add_database_table('competency_coursecompsetting', [ 92 'timecreated' => 'privacy:metadata:timecreated', 93 'timemodified' => 'privacy:metadata:timemodified', 94 'usermodified' => 'privacy:metadata:usermodified', 95 ], 'privacy:metadata:competency_coursecompsetting'); 96 97 $collection->add_database_table('competency_framework', [ 98 'timecreated' => 'privacy:metadata:timecreated', 99 'timemodified' => 'privacy:metadata:timemodified', 100 'usermodified' => 'privacy:metadata:usermodified', 101 ], 'privacy:metadata:competency_framework'); 102 103 $collection->add_database_table('competency_coursecomp', [ 104 'timecreated' => 'privacy:metadata:timecreated', 105 'timemodified' => 'privacy:metadata:timemodified', 106 'usermodified' => 'privacy:metadata:usermodified', 107 ], 'privacy:metadata:competency_coursecomp'); 108 109 $collection->add_database_table('competency_template', [ 110 'timecreated' => 'privacy:metadata:timecreated', 111 'timemodified' => 'privacy:metadata:timemodified', 112 'usermodified' => 'privacy:metadata:usermodified', 113 ], 'privacy:metadata:competency_template'); 114 115 $collection->add_database_table('competency_templatecomp', [ 116 'timecreated' => 'privacy:metadata:timecreated', 117 'timemodified' => 'privacy:metadata:timemodified', 118 'usermodified' => 'privacy:metadata:usermodified', 119 ], 'privacy:metadata:competency_templatecomp'); 120 121 $collection->add_database_table('competency_templatecohort', [ 122 'timecreated' => 'privacy:metadata:timecreated', 123 'timemodified' => 'privacy:metadata:timemodified', 124 'usermodified' => 'privacy:metadata:usermodified', 125 ], 'privacy:metadata:competency_templatecohort'); 126 127 $collection->add_database_table('competency_relatedcomp', [ 128 'timecreated' => 'privacy:metadata:timecreated', 129 'timemodified' => 'privacy:metadata:timemodified', 130 'usermodified' => 'privacy:metadata:usermodified', 131 ], 'privacy:metadata:competency_relatedcomp'); 132 133 $collection->add_database_table('competency_modulecomp', [ 134 'timecreated' => 'privacy:metadata:timecreated', 135 'timemodified' => 'privacy:metadata:timemodified', 136 'usermodified' => 'privacy:metadata:usermodified', 137 ], 'privacy:metadata:competency_modulecomp'); 138 139 // Tables containing user data. 140 $collection->add_database_table('competency_plan', [ 141 'name' => 'privacy:metadata:plan:name', 142 'description' => 'privacy:metadata:plan:description', 143 'userid' => 'privacy:metadata:plan:userid', 144 'status' => 'privacy:metadata:plan:status', 145 'duedate' => 'privacy:metadata:plan:duedate', 146 'reviewerid' => 'privacy:metadata:plan:reviewerid', 147 'timecreated' => 'privacy:metadata:timecreated', 148 'timemodified' => 'privacy:metadata:timemodified', 149 'usermodified' => 'privacy:metadata:usermodified', 150 ], 'privacy:metadata:competency_plan'); 151 152 $collection->add_database_table('competency_usercomp', [ 153 'userid' => 'privacy:metadata:usercomp:userid', 154 'status' => 'privacy:metadata:usercomp:status', 155 'reviewerid' => 'privacy:metadata:usercomp:reviewerid', 156 'proficiency' => 'privacy:metadata:usercomp:proficiency', 157 'grade' => 'privacy:metadata:usercomp:grade', 158 'timecreated' => 'privacy:metadata:timecreated', 159 'timemodified' => 'privacy:metadata:timemodified', 160 'usermodified' => 'privacy:metadata:usermodified', 161 ], 'privacy:metadata:competency_usercomp'); 162 163 $collection->add_database_table('competency_usercompcourse', [ 164 'userid' => 'privacy:metadata:usercomp:userid', 165 'proficiency' => 'privacy:metadata:usercomp:proficiency', 166 'grade' => 'privacy:metadata:usercomp:grade', 167 'timecreated' => 'privacy:metadata:timecreated', 168 'timemodified' => 'privacy:metadata:timemodified', 169 'usermodified' => 'privacy:metadata:usermodified', 170 ], 'privacy:metadata:competency_usercompcourse'); 171 172 $collection->add_database_table('competency_usercompplan', [ 173 'userid' => 'privacy:metadata:usercomp:userid', 174 'proficiency' => 'privacy:metadata:usercomp:proficiency', 175 'grade' => 'privacy:metadata:usercomp:grade', 176 'timecreated' => 'privacy:metadata:timecreated', 177 'timemodified' => 'privacy:metadata:timemodified', 178 'usermodified' => 'privacy:metadata:usermodified', 179 ], 'privacy:metadata:competency_usercompplan'); 180 181 $collection->add_database_table('competency_plancomp', [ 182 'timecreated' => 'privacy:metadata:timecreated', 183 'timemodified' => 'privacy:metadata:timemodified', 184 'usermodified' => 'privacy:metadata:usermodified', 185 ], 'privacy:metadata:competency_plancomp'); 186 187 $collection->add_database_table('competency_evidence', [ 188 'action' => 'privacy:metadata:evidence:action', 189 'actionuserid' => 'privacy:metadata:evidence:actionuserid', 190 'descidentifier' => 'privacy:metadata:evidence:descidentifier', 191 'desccomponent' => 'privacy:metadata:evidence:desccomponent', 192 'desca' => 'privacy:metadata:evidence:desca', 193 'url' => 'privacy:metadata:evidence:url', 194 'grade' => 'privacy:metadata:evidence:grade', 195 'note' => 'privacy:metadata:evidence:note', 196 'timecreated' => 'privacy:metadata:timecreated', 197 'timemodified' => 'privacy:metadata:timemodified', 198 'usermodified' => 'privacy:metadata:usermodified', 199 ], 'privacy:metadata:competency_evidence'); 200 201 $collection->add_database_table('competency_userevidence', [ 202 'name' => 'privacy:metadata:userevidence:name', 203 'description' => 'privacy:metadata:userevidence:description', 204 'url' => 'privacy:metadata:userevidence:url', 205 'timecreated' => 'privacy:metadata:timecreated', 206 'timemodified' => 'privacy:metadata:timemodified', 207 'usermodified' => 'privacy:metadata:usermodified', 208 ], 'privacy:metadata:competency_userevidence'); 209 210 $collection->add_database_table('competency_userevidencecomp', [ 211 'timecreated' => 'privacy:metadata:timecreated', 212 'timemodified' => 'privacy:metadata:timemodified', 213 'usermodified' => 'privacy:metadata:usermodified', 214 ], 'privacy:metadata:competency_userevidencecomp'); 215 216 // Comments can be left on learning plans and competencies. 217 $collection->link_subsystem('core_comment', 'privacy:metadata:core_comments'); 218 219 return $collection; 220 } 221 222 /** 223 * Get the list of contexts that contain user information for the specified user. 224 * 225 * @param int $userid The user to search. 226 * @return contextlist $contextlist The contextlist containing the list of contexts used in this plugin. 227 */ 228 public static function get_contexts_for_userid(int $userid) : contextlist { 229 global $DB; 230 $contextlist = new \core_privacy\local\request\contextlist(); 231 232 // Find the contexts of the frameworks, and related data, modified by the user. 233 $sql = " 234 SELECT DISTINCT ctx.id 235 FROM {context} ctx 236 JOIN {" . competency_framework::TABLE . "} cf 237 ON cf.contextid = ctx.id 238 LEFT JOIN {" . competency::TABLE . "} c 239 ON c.competencyframeworkid = cf.id 240 LEFT JOIN {" . related_competency::TABLE . "} cr 241 ON cr.competencyid = c.id 242 WHERE cf.usermodified = :userid1 243 OR c.usermodified = :userid2 244 OR cr.usermodified = :userid3"; 245 $params = ['userid1' => $userid, 'userid2' => $userid, 'userid3' => $userid]; 246 $contextlist->add_from_sql($sql, $params); 247 248 // Find the contexts of the templates, and related data, modified by the user. 249 $sql = " 250 SELECT DISTINCT ctx.id 251 FROM {context} ctx 252 JOIN {" . template::TABLE . "} tpl 253 ON tpl.contextid = ctx.id 254 LEFT JOIN {" . template_cohort::TABLE . "} tch 255 ON tch.templateid = tpl.id 256 AND tch.usermodified = :userid2 257 LEFT JOIN {" . template_competency::TABLE . "} tc 258 ON tc.templateid = tpl.id 259 AND tc.usermodified = :userid3 260 WHERE tpl.usermodified = :userid1 261 OR tch.id IS NOT NULL 262 OR tc.id IS NOT NULL"; 263 $params = ['userid1' => $userid, 'userid2' => $userid, 'userid3' => $userid]; 264 $contextlist->add_from_sql($sql, $params); 265 266 // Find the possible course contexts. 267 $sql = " 268 SELECT DISTINCT ctx.id 269 FROM {" . course_competency::TABLE . "} cc 270 JOIN {context} ctx 271 ON ctx.instanceid = cc.courseid 272 AND ctx.contextlevel = :courselevel 273 WHERE cc.usermodified = :userid"; 274 $params = ['courselevel' => CONTEXT_COURSE, 'userid' => $userid]; 275 $contextlist->add_from_sql($sql, $params); 276 277 $sql = " 278 SELECT DISTINCT ctx.id 279 FROM {" . course_competency_settings::TABLE . "} ccs 280 JOIN {context} ctx 281 ON ctx.instanceid = ccs.courseid 282 AND ctx.contextlevel = :courselevel 283 WHERE ccs.usermodified = :userid"; 284 $params = ['courselevel' => CONTEXT_COURSE, 'userid' => $userid]; 285 $contextlist->add_from_sql($sql, $params); 286 287 $sql = " 288 SELECT DISTINCT ctx.id 289 FROM {" . user_competency_course::TABLE . "} ucc 290 JOIN {context} ctx 291 ON ctx.instanceid = ucc.courseid 292 AND ctx.contextlevel = :courselevel 293 WHERE ucc.usermodified = :userid"; 294 $params = ['courselevel' => CONTEXT_COURSE, 'userid' => $userid]; 295 $contextlist->add_from_sql($sql, $params); 296 297 // Find the possible module contexts. 298 $sql = " 299 SELECT DISTINCT ctx.id 300 FROM {" . course_module_competency::TABLE . "} cmc 301 JOIN {context} ctx 302 ON ctx.instanceid = cmc.cmid 303 AND ctx.contextlevel = :modulelevel 304 WHERE cmc.usermodified = :userid"; 305 $params = ['modulelevel' => CONTEXT_MODULE, 'userid' => $userid]; 306 $contextlist->add_from_sql($sql, $params); 307 308 // Add user contexts through usermodified/reviewing of plan related data. 309 $sql = " 310 SELECT DISTINCT ctx.id 311 FROM {" . plan::TABLE . "} p 312 JOIN {context} ctx 313 ON ctx.instanceid = p.userid 314 AND ctx.contextlevel = :userlevel 315 LEFT JOIN {" . plan_competency::TABLE . "} pc 316 ON pc.planid = p.id 317 AND pc.usermodified = :userid3 318 LEFT JOIN {" . user_competency_plan::TABLE . "} upc 319 ON upc.planid = p.id 320 AND upc.usermodified = :userid4 321 WHERE p.usermodified = :userid1 322 OR p.reviewerid = :userid2 323 OR pc.id IS NOT NULL 324 OR upc.id IS NOT NULL"; 325 $params = [ 326 'userlevel' => CONTEXT_USER, 327 'userid1' => $userid, 328 'userid2' => $userid, 329 'userid3' => $userid, 330 'userid4' => $userid, 331 ]; 332 $contextlist->add_from_sql($sql, $params); 333 334 // Add user contexts through usermodified/reviewing of competency data. 335 $sql = " 336 SELECT DISTINCT ctx.id 337 FROM {context} ctx 338 LEFT JOIN {" . user_competency::TABLE . "} uc 339 ON uc.userid = ctx.instanceid 340 AND ctx.contextlevel = :userlevel1 341 LEFT JOIN {" . evidence::TABLE . "} e 342 ON e.usercompetencyid = uc.id 343 AND (e.usermodified = :userid3 OR e.actionuserid = :userid4) 344 LEFT JOIN {" . user_evidence::TABLE . "} ue 345 ON ue.userid = ctx.instanceid 346 AND ctx.contextlevel = :userlevel2 347 AND ue.usermodified = :userid5 348 LEFT JOIN {" . user_evidence_competency::TABLE . "} uec 349 ON uec.userevidenceid = ue.id 350 AND uec.usermodified = :userid6 351 WHERE uc.usermodified = :userid1 352 OR uc.reviewerid = :userid2 353 OR e.id IS NOT NULL 354 OR ue.id IS NOT NULL 355 OR uec.id IS NOT NULL"; 356 $params = [ 357 'userlevel1' => CONTEXT_USER, 358 'userlevel2' => CONTEXT_USER, 359 'userid1' => $userid, 360 'userid2' => $userid, 361 'userid3' => $userid, 362 'userid4' => $userid, 363 'userid5' => $userid, 364 'userid6' => $userid, 365 ]; 366 $contextlist->add_from_sql($sql, $params); 367 368 // Now, the easy part, we fetch the user context for user plans and competencies. 369 // We also fetch the course context for the state of competencies for the user in courses. 370 $sql = " 371 SELECT DISTINCT ctx.id 372 FROM {context} ctx 373 LEFT JOIN {" . plan::TABLE . "} p 374 ON p.userid = ctx.instanceid 375 AND ctx.contextlevel = :userlevel1 376 LEFT JOIN {" . user_competency::TABLE . "} uc 377 ON uc.userid = ctx.instanceid 378 AND ctx.contextlevel = :userlevel2 379 AND uc.userid = :userid2 380 LEFT JOIN {" . user_evidence::TABLE . "} ue 381 ON ue.userid = ctx.instanceid 382 AND ctx.contextlevel = :userlevel3 383 AND ue.userid = :userid3 384 LEFT JOIN {" . user_competency_course::TABLE . "} ucc 385 ON ucc.courseid = ctx.instanceid 386 AND ctx.contextlevel = :courselevel 387 AND ucc.userid = :userid4 388 WHERE p.userid = :userid1 389 OR uc.id IS NOT NULL 390 OR ue.id IS NOT NULL 391 OR ucc.id IS NOT NULL"; 392 $params = [ 393 'userlevel1' => CONTEXT_USER, 394 'userlevel2' => CONTEXT_USER, 395 'userlevel3' => CONTEXT_USER, 396 'courselevel' => CONTEXT_COURSE, 397 'userid1' => $userid, 398 'userid2' => $userid, 399 'userid3' => $userid, 400 'userid4' => $userid, 401 ]; 402 $contextlist->add_from_sql($sql, $params); 403 404 // Include the user contexts in which the user commented. 405 $sql = " 406 SELECT ctx.id 407 FROM {context} ctx 408 JOIN {comments} c 409 ON c.contextid = ctx.id 410 WHERE c.component = :component 411 AND c.commentarea IN (:planarea, :usercomparea) 412 AND c.userid = :userid"; 413 $params = [ 414 'component' => 'competency', // Must not be core_competency. 415 'planarea' => 'plan', 416 'usercomparea' => 'user_competency', 417 'userid' => $userid 418 ]; 419 $contextlist->add_from_sql($sql, $params); 420 421 return $contextlist; 422 } 423 424 /** 425 * Get the list of users who have data within a context. 426 * 427 * @param userlist $userlist The userlist containing the list of users who have data in this context/plugin combination. 428 */ 429 public static function get_users_in_context(userlist $userlist) { 430 $context = $userlist->get_context(); 431 $params = ['contextid' => $context->id]; 432 433 // Add users who have modified the frameworks and related data in the context. 434 $sql = " 435 SELECT cf.usermodified 436 FROM {" . competency_framework::TABLE . "} cf 437 WHERE cf.contextid = :contextid"; 438 $userlist->add_from_sql('usermodified', $sql, $params); 439 440 $sql = " 441 SELECT c.usermodified 442 FROM {" . competency_framework::TABLE . "} cf 443 JOIN {" . competency::TABLE . "} c 444 ON c.competencyframeworkid = cf.id 445 WHERE cf.contextid = :contextid"; 446 $userlist->add_from_sql('usermodified', $sql, $params); 447 448 $sql = " 449 SELECT cr.usermodified 450 FROM {" . competency_framework::TABLE . "} cf 451 JOIN {" . competency::TABLE . "} c 452 ON c.competencyframeworkid = cf.id 453 JOIN {" . related_competency::TABLE . "} cr 454 ON cr.competencyid = c.id 455 WHERE cf.contextid = :contextid"; 456 $userlist->add_from_sql('usermodified', $sql, $params); 457 458 // Add users who have modified the templates and related data in the context. 459 $sql = " 460 SELECT tpl.usermodified 461 FROM {" . template::TABLE . "} tpl 462 WHERE tpl.contextid = :contextid"; 463 $userlist->add_from_sql('usermodified', $sql, $params); 464 465 $sql = " 466 SELECT tch.usermodified 467 FROM {" . template::TABLE . "} tpl 468 JOIN {" . template_cohort::TABLE . "} tch 469 ON tch.templateid = tpl.id 470 WHERE tpl.contextid = :contextid"; 471 $userlist->add_from_sql('usermodified', $sql, $params); 472 473 $sql = " 474 SELECT tc.usermodified 475 FROM {" . template::TABLE . "} tpl 476 JOIN {" . template_competency::TABLE . "} tc 477 ON tc.templateid = tpl.id 478 WHERE tpl.contextid = :contextid"; 479 $userlist->add_from_sql('usermodified', $sql, $params); 480 481 // Add users if userlist is in course context. 482 if (is_a($context, \context_course::class)) { 483 $params = ['courseid' => $context->instanceid]; 484 485 $sql = " 486 SELECT cc.usermodified 487 FROM {" . course_competency::TABLE . "} cc 488 WHERE cc.courseid = :courseid"; 489 $userlist->add_from_sql('usermodified', $sql, $params); 490 491 $sql = " 492 SELECT ccs.usermodified 493 FROM {" . course_competency_settings::TABLE . "} ccs 494 WHERE ccs.courseid = :courseid"; 495 $userlist->add_from_sql('usermodified', $sql, $params); 496 497 $sql = " 498 SELECT ucc.userid, ucc.usermodified 499 FROM {" . user_competency_course::TABLE . "} ucc 500 WHERE ucc.courseid = :courseid"; 501 $userlist->add_from_sql('userid', $sql, $params); 502 $userlist->add_from_sql('usermodified', $sql, $params); 503 504 } else if (is_a($context, \context_module::class)) { 505 // Add users if userlist is in module context. 506 $params = ['moduleid' => $context->instanceid]; 507 508 $sql = " 509 SELECT cmc.usermodified 510 FROM {" . course_module_competency::TABLE . "} cmc 511 WHERE cmc.cmid = :moduleid"; 512 $userlist->add_from_sql('usermodified', $sql, $params); 513 514 } else if (is_a($context, \context_user::class)) { 515 $params = ['userid' => $context->instanceid]; 516 517 // Add users through plan related data. 518 $sql = " 519 SELECT p.userid, p.usermodified, p.reviewerid 520 FROM {" . plan::TABLE . "} p 521 WHERE p.userid = :userid"; 522 $userlist->add_from_sql('userid', $sql, $params); 523 $userlist->add_from_sql('usermodified', $sql, $params); 524 $userlist->add_from_sql('reviewerid', $sql, $params); 525 526 $sql = " 527 SELECT pc.usermodified 528 FROM {" . plan::TABLE . "} p 529 JOIN {" . plan_competency::TABLE . "} pc 530 ON pc.planid = p.id 531 WHERE p.userid = :userid"; 532 $userlist->add_from_sql('usermodified', $sql, $params); 533 534 $sql = " 535 SELECT upc.usermodified 536 FROM {" . user_competency_plan::TABLE . "} upc 537 WHERE upc.userid = :userid"; 538 $userlist->add_from_sql('usermodified', $sql, $params); 539 540 // Add users through competency data. 541 $sql = " 542 SELECT uc.userid, uc.usermodified, uc.reviewerid 543 FROM {" . user_competency::TABLE . "} uc 544 WHERE uc.userid = :userid"; 545 $userlist->add_from_sql('userid', $sql, $params); 546 $userlist->add_from_sql('usermodified', $sql, $params); 547 $userlist->add_from_sql('reviewerid', $sql, $params); 548 549 $sql = " 550 SELECT e.usermodified, e.actionuserid 551 FROM {" . user_competency::TABLE . "} uc 552 JOIN {" . evidence::TABLE . "} e 553 ON e.usercompetencyid = uc.id 554 WHERE uc.userid = :userid"; 555 $userlist->add_from_sql('usermodified', $sql, $params); 556 $userlist->add_from_sql('actionuserid', $sql, $params); 557 558 // Add users through evidence data. 559 $sql = " 560 SELECT ue.userid, ue.usermodified 561 FROM {" . user_evidence::TABLE . "} ue 562 WHERE ue.userid = :userid"; 563 $userlist->add_from_sql('userid', $sql, $params); 564 $userlist->add_from_sql('usermodified', $sql, $params); 565 566 $sql = " 567 SELECT ue.usermodified 568 FROM {" . user_evidence::TABLE . "} ue 569 JOIN {" . user_evidence_competency::TABLE . "} uec 570 ON uec.userevidenceid = ue.id 571 WHERE ue.userid = :userid"; 572 $userlist->add_from_sql('usermodified', $sql, $params); 573 } 574 575 // Add users who commented in the context. 576 // Note: Comment component must be competency and not core_competency. 577 \core_comment\privacy\provider::get_users_in_context_from_sql( 578 $userlist, 'com', 'competency', 'plan', $context->id); 579 580 \core_comment\privacy\provider::get_users_in_context_from_sql( 581 $userlist, 'com', 'competency', 'user_competency', $context->id); 582 } 583 584 /** 585 * Export all user data for the specified user, in the specified contexts. 586 * 587 * @param approved_contextlist $contextlist The approved contexts to export information for. 588 */ 589 public static function export_user_data(approved_contextlist $contextlist) { 590 $user = $contextlist->get_user(); 591 $userid = $user->id; 592 593 // Re-arrange the contexts by context level. 594 $groupedcontexts = array_reduce($contextlist->get_contexts(), function($carry, $context) { 595 $contextlevel = $context->contextlevel; 596 if (!in_array($contextlevel, [CONTEXT_USER, CONTEXT_COURSE, CONTEXT_MODULE, CONTEXT_SYSTEM, CONTEXT_COURSECAT])) { 597 return $carry; 598 } 599 $carry[$contextlevel][] = $context; 600 return $carry; 601 }, [ 602 CONTEXT_COURSE => [], 603 CONTEXT_COURSECAT => [], 604 CONTEXT_MODULE => [], 605 CONTEXT_SYSTEM => [], 606 CONTEXT_USER => [], 607 ]); 608 609 // Process module contexts. 610 static::export_user_data_in_module_contexts($userid, $groupedcontexts[CONTEXT_MODULE]); 611 612 // Process course contexts. 613 static::export_user_data_in_course_contexts($userid, $groupedcontexts[CONTEXT_COURSE]); 614 615 // Process course categories context. 616 static::export_user_data_in_category_contexts($userid, $groupedcontexts[CONTEXT_COURSECAT]); 617 618 // Process system context. 619 if (!empty($groupedcontexts[CONTEXT_SYSTEM])) { 620 static::export_user_data_in_system_context($userid); 621 } 622 623 // Process user contexts. 624 static::export_user_data_in_user_contexts($userid, $groupedcontexts[CONTEXT_USER]); 625 } 626 627 /** 628 * Delete all data for all users in the specified context. 629 * 630 * @param context $context The specific context to delete data for. 631 */ 632 public static function delete_data_for_all_users_in_context(context $context) { 633 global $DB; 634 635 switch ($context->contextlevel) { 636 case CONTEXT_USER: 637 $userid = $context->instanceid; 638 static::delete_user_evidence_of_prior_learning($userid); 639 static::delete_user_plans($userid); 640 static::delete_user_competencies($userid); 641 break; 642 643 case CONTEXT_COURSE: 644 static::delete_user_competencies_in_course($context->instanceid); 645 break; 646 } 647 } 648 649 /** 650 * Delete all user data for the specified user, in the specified contexts. 651 * 652 * Here we only delete the private data of user, not whether they modified, are reviewing, 653 * or are associated with the record on at a second level. Only data directly linked to the 654 * user will be affected. 655 * 656 * @param approved_contextlist $contextlist The approved contexts and user information to delete information for. 657 */ 658 public static function delete_data_for_user(approved_contextlist $contextlist) { 659 $user = $contextlist->get_user(); 660 $userid = $user->id; 661 662 foreach ($contextlist as $context) { 663 switch ($context->contextlevel) { 664 case CONTEXT_USER: 665 if ($context->instanceid == $userid) { 666 // Only delete the user's information when they requested their context to be deleted. We 667 // do not take any action on other user's contexts because we don't own the data there. 668 static::delete_user_evidence_of_prior_learning($userid); 669 static::delete_user_plans($userid); 670 static::delete_user_competencies($userid); 671 } 672 break; 673 674 case CONTEXT_COURSE: 675 static::delete_user_competencies_in_course($context->instanceid, [$userid]); 676 break; 677 } 678 } 679 } 680 681 /** 682 * Delete multiple users within a single context. 683 * 684 * Here we only delete the private data of users, not whether they modified, are reviewing, 685 * or are associated with the record on at a second level. Only data directly linked to the 686 * user will be affected. 687 * 688 * @param approved_userlist $userlist The approved context and user information to delete information for. 689 */ 690 public static function delete_data_for_users(approved_userlist $userlist) { 691 $context = $userlist->get_context(); 692 $userids = $userlist->get_userids(); 693 694 switch ($context->contextlevel) { 695 case CONTEXT_USER: 696 // Only delete the user's information when their context is being deleted. 697 // We do not take any action on other user's contexts because we don't own the data there. 698 if (in_array($context->instanceid, $userids)) { 699 static::delete_user_evidence_of_prior_learning($context->instanceid); 700 static::delete_user_plans($context->instanceid); 701 static::delete_user_competencies($context->instanceid); 702 } 703 704 break; 705 706 case CONTEXT_COURSE: 707 static::delete_user_competencies_in_course($context->instanceid, $userids); 708 break; 709 } 710 } 711 712 /** 713 * Delete evidence of prior learning. 714 * 715 * @param int $userid The user ID. 716 * @return void 717 */ 718 protected static function delete_user_evidence_of_prior_learning($userid) { 719 global $DB; 720 721 $usercontext = context_user::instance($userid); 722 $ueids = $DB->get_fieldset_select(user_evidence::TABLE, 'id', 'userid = :userid', ['userid' => $userid]); 723 if (empty($ueids)) { 724 return; 725 } 726 list($insql, $inparams) = $DB->get_in_or_equal($ueids, SQL_PARAMS_NAMED); 727 728 // Delete competencies associated with user evidence. 729 $DB->delete_records_select(user_evidence_competency::TABLE, "userevidenceid $insql", $inparams); 730 731 // Delete the user evidence. 732 $DB->delete_records_select(user_evidence::TABLE, "id $insql", $inparams); 733 734 // Delete the user evidence files. 735 $fs = get_file_storage(); 736 $fs->delete_area_files($usercontext->id, 'core_competency', 'userevidence'); 737 } 738 739 /** 740 * User plans. 741 * 742 * @param int $userid The user ID. 743 * @return void 744 */ 745 protected static function delete_user_plans($userid) { 746 global $DB; 747 $usercontext = context_user::instance($userid); 748 749 // Remove all the comments made on plans. 750 \core_comment\privacy\provider::delete_comments_for_all_users($usercontext, 'competency', 'plan'); 751 752 // Find the user plan IDs. 753 $planids = $DB->get_fieldset_select(plan::TABLE, 'id', 'userid = :userid', ['userid' => $userid]); 754 if (empty($planids)) { 755 return; 756 } 757 list($insql, $inparams) = $DB->get_in_or_equal($planids, SQL_PARAMS_NAMED); 758 759 // Delete all the competencies proficiency in the plans. 760 $DB->delete_records_select(user_competency_plan::TABLE, "planid $insql", $inparams); 761 762 // Delete all the competencies in the plans. 763 $DB->delete_records_select(plan_competency::TABLE, "planid $insql", $inparams); 764 765 // Delete all the plans. 766 $DB->delete_records_select(plan::TABLE, "id $insql", $inparams); 767 } 768 769 /** 770 * Delete user competency data. 771 * 772 * @param int $userid The user ID. 773 * @return void 774 */ 775 protected static function delete_user_competencies($userid) { 776 global $DB; 777 $usercontext = context_user::instance($userid); 778 779 // Remove all the comments made on user competencies. 780 \core_comment\privacy\provider::delete_comments_for_all_users($usercontext, 'competency', 'user_competency'); 781 782 // Find the user competency IDs. 783 $ucids = $DB->get_fieldset_select(user_competency::TABLE, 'id', 'userid = :userid', ['userid' => $userid]); 784 if (empty($ucids)) { 785 return; 786 } 787 list($insql, $inparams) = $DB->get_in_or_equal($ucids, SQL_PARAMS_NAMED); 788 789 // Delete all the evidence associated with competencies. 790 $DB->delete_records_select(evidence::TABLE, "usercompetencyid $insql", $inparams); 791 792 // Delete all the record of competency. 793 $DB->delete_records_select(user_competency::TABLE, "id $insql", $inparams); 794 } 795 796 /** 797 * Delete the record of competencies for user(s) in a course. 798 * 799 * @param int $courseid The course ID. 800 * @param int[] $userids The user IDs, if deleting for specific user(s). 801 * @return void 802 */ 803 protected static function delete_user_competencies_in_course($courseid, $userids = []) { 804 global $DB; 805 806 $params = ['courseid' => $courseid]; 807 $where = "courseid = :courseid"; 808 809 if (!empty($userids)) { 810 list($insql, $inparams) = $DB->get_in_or_equal($userids, SQL_PARAMS_NAMED); 811 $params = $params + $inparams; 812 813 $where .= " AND userid {$insql}"; 814 } 815 816 $DB->delete_records_select(user_competency_course::TABLE, $where, $params); 817 } 818 819 /** 820 * Export the user data in user context. 821 * 822 * @param int $userid The user ID. 823 * @param array $contexts The contexts. 824 * @return void 825 */ 826 protected static function export_user_data_in_user_contexts($userid, array $contexts) { 827 global $DB; 828 829 $mycontext = context_user::instance($userid); 830 $contextids = array_map(function($context) { 831 return $context->id; 832 }, $contexts); 833 $exportowncontext = in_array($mycontext->id, $contextids); 834 $othercontexts = array_filter($contextids, function($contextid) use ($mycontext) { 835 return $contextid != $mycontext->id; 836 }); 837 838 if ($exportowncontext) { 839 static::export_user_data_learning_plans($mycontext); 840 static::export_user_data_competencies($mycontext); 841 static::export_user_data_user_evidence($mycontext); 842 } 843 844 foreach ($othercontexts as $contextid) { 845 static::export_user_data_learning_plans_related_to_me($userid, context::instance_by_id($contextid)); 846 static::export_user_data_competencies_related_to_me($userid, context::instance_by_id($contextid)); 847 static::export_user_data_user_evidence_related_to_me($userid, context::instance_by_id($contextid)); 848 } 849 } 850 851 /** 852 * Export the user data in systen context. 853 * 854 * @param int $userid The user ID. 855 * @return void 856 */ 857 protected static function export_user_data_in_system_context($userid) { 858 static::export_user_data_frameworks_in_context($userid, context_system::instance()); 859 static::export_user_data_templates_in_context($userid, context_system::instance()); 860 } 861 862 /** 863 * Export the user data in category contexts. 864 * 865 * @param int $userid The user ID. 866 * @param array $contexts The contexts. 867 * @return void 868 */ 869 protected static function export_user_data_in_category_contexts($userid, array $contexts) { 870 $contexts = array_filter($contexts, function($context) { 871 return $context->contextlevel == CONTEXT_COURSECAT; 872 }); 873 if (empty($contexts)) { 874 return; 875 } 876 877 foreach ($contexts as $context) { 878 static::export_user_data_frameworks_in_context($userid, $context); 879 static::export_user_data_templates_in_context($userid, $context); 880 } 881 } 882 883 /** 884 * Export the user data in course contexts. 885 * 886 * @param int $userid The user whose data we're exporting. 887 * @param array $contexts A list of contexts. 888 * @return void 889 */ 890 protected static function export_user_data_in_course_contexts($userid, array $contexts) { 891 global $DB; 892 893 $contexts = array_filter($contexts, function($context) { 894 return $context->contextlevel == CONTEXT_COURSE; 895 }); 896 if (empty($contexts)) { 897 return; 898 } 899 900 $helper = new performance_helper(); 901 $path = [get_string('competencies', 'core_competency')]; 902 $courseids = array_map(function($context) { 903 return $context->instanceid; 904 }, $contexts); 905 906 // Fetch all the records of competency proficiency in the course. 907 $ffields = competency_framework::get_sql_fields('f', 'f_'); 908 $compfields = competency::get_sql_fields('c', 'c_'); 909 $uccfields = user_competency_course::get_sql_fields('ucc', 'ucc_'); 910 $ctxfields = context_helper::get_preload_record_columns_sql('ctx'); 911 list($insql, $inparams) = $DB->get_in_or_equal($courseids, SQL_PARAMS_NAMED); 912 $sql = " 913 SELECT $ffields, $compfields, $uccfields, $ctxfields 914 FROM {" . user_competency_course::TABLE . "} ucc 915 JOIN {" . competency::TABLE . "} c 916 ON c.id = ucc.competencyid 917 JOIN {" . competency_framework::TABLE . "} f 918 ON f.id = c.competencyframeworkid 919 JOIN {context} ctx 920 ON ctx.id = f.contextid 921 WHERE ucc.userid = :userid 922 AND ucc.courseid $insql 923 ORDER BY ucc.courseid, c.id"; 924 $params = array_merge($inparams, ['userid' => $userid]); 925 926 // Export data. 927 $recordset = $DB->get_recordset_sql($sql, $params); 928 static::recordset_loop_and_export($recordset, 'ucc_courseid', [], function($carry, $record) use ($helper) { 929 context_helper::preload_from_record($record); 930 $framework = new competency_framework(null, competency_framework::extract_record($record, 'f_')); 931 $competency = new competency(null, competency::extract_record($record, 'c_')); 932 $ucc = new user_competency_course(null, user_competency_course::extract_record($record, 'ucc_')); 933 $helper->ingest_framework($framework); 934 935 $carry[] = array_merge(static::transform_competency_brief($competency), [ 936 'rating' => [ 937 'rating' => static::transform_competency_grade($competency, $ucc->get('grade'), $helper), 938 'proficient' => static::transform_proficiency($ucc->get('proficiency')), 939 'timecreated' => transform::datetime($ucc->get('timecreated')), 940 'timemodified' => transform::datetime($ucc->get('timemodified')), 941 ] 942 ]); 943 return $carry; 944 945 }, function($courseid, $data) use ($path) { 946 $context = context_course::instance($courseid); 947 writer::with_context($context)->export_data($path, (object) ['ratings' => $data]); 948 }); 949 950 // Export usermodified data. 951 static::export_user_data_in_course_contexts_associations($userid, $courseids, $path); 952 static::export_user_data_in_course_contexts_settings($userid, $courseids, $path); 953 static::export_user_data_in_course_contexts_rated_by_me($userid, $courseids, $path, $helper); 954 } 955 956 /** 957 * Export the ratings given in a course. 958 * 959 * @param int $userid The user ID. 960 * @param array $courseids The course IDs. 961 * @param array $path The root path. 962 * @param performance_helper $helper The performance helper. 963 * @return void 964 */ 965 protected static function export_user_data_in_course_contexts_rated_by_me($userid, $courseids, $path, 966 performance_helper $helper) { 967 global $DB; 968 969 // Fetch all the records of competency proficiency in the course. 970 $ffields = competency_framework::get_sql_fields('f', 'f_'); 971 $compfields = competency::get_sql_fields('c', 'c_'); 972 $uccfields = user_competency_course::get_sql_fields('ucc', 'ucc_'); 973 $ctxfields = context_helper::get_preload_record_columns_sql('ctx'); 974 list($insql, $inparams) = $DB->get_in_or_equal($courseids, SQL_PARAMS_NAMED); 975 $sql = " 976 SELECT $ffields, $compfields, $uccfields, $ctxfields 977 FROM {" . user_competency_course::TABLE . "} ucc 978 JOIN {" . competency::TABLE . "} c 979 ON c.id = ucc.competencyid 980 JOIN {" . competency_framework::TABLE . "} f 981 ON f.id = c.competencyframeworkid 982 JOIN {context} ctx 983 ON ctx.id = f.contextid 984 WHERE ucc.usermodified = :userid 985 AND ucc.courseid $insql 986 ORDER BY ucc.courseid, ucc.id"; 987 $params = array_merge($inparams, ['userid' => $userid]); 988 989 // Export the data. 990 static::recordset_loop_and_export($DB->get_recordset_sql($sql, $params), 'ucc_courseid', [], 991 function($carry, $record) use ($helper) { 992 context_helper::preload_from_record($record); 993 994 $framework = new competency_framework(null, competency_framework::extract_record($record, 'f_')); 995 $competency = new competency(null, competency::extract_record($record, 'c_')); 996 $ucc = new user_competency_course(null, user_competency_course::extract_record($record, 'ucc_')); 997 $helper->ingest_framework($framework); 998 999 $carry[] = array_merge(static::transform_competency_brief($competency), [ 1000 'rating' => [ 1001 'userid' => transform::user($ucc->get('userid')), 1002 'rating' => static::transform_competency_grade($competency, $ucc->get('grade'), $helper), 1003 'proficient' => static::transform_proficiency($ucc->get('proficiency')), 1004 'timemodified' => transform::datetime($ucc->get('timemodified')), 1005 ] 1006 ]); 1007 return $carry; 1008 1009 }, function($courseid, $data) use ($path) { 1010 $context = context_course::instance($courseid); 1011 writer::with_context($context)->export_related_data($path, 'rated_by_me', (object) [ 1012 'ratings' => $data 1013 ]); 1014 } 1015 ); 1016 } 1017 1018 /** 1019 * Export user data in course contexts related to linked competencies. 1020 * 1021 * @param int $userid The user ID. 1022 * @param array $courseids The course IDs. 1023 * @param array $path The root path to export at. 1024 * @return void 1025 */ 1026 protected static function export_user_data_in_course_contexts_associations($userid, $courseids, $path) { 1027 global $DB; 1028 1029 // Fetch all the courses with associations we created or modified. 1030 $compfields = competency::get_sql_fields('c', 'c_'); 1031 $ccfields = course_competency::get_sql_fields('cc', 'cc_'); 1032 $ctxfields = context_helper::get_preload_record_columns_sql('ctx'); 1033 list($insql, $inparams) = $DB->get_in_or_equal($courseids, SQL_PARAMS_NAMED); 1034 $sql = " 1035 SELECT $compfields, $ccfields, $ctxfields 1036 FROM {" . course_competency::TABLE . "} cc 1037 JOIN {" . competency::TABLE . "} c 1038 ON c.id = cc.competencyid 1039 JOIN {" . competency_framework::TABLE . "} f 1040 ON f.id = c.competencyframeworkid 1041 JOIN {context} ctx 1042 ON ctx.id = f.contextid 1043 WHERE cc.usermodified = :userid 1044 AND cc.courseid $insql 1045 ORDER BY cc.courseid, c.id"; 1046 $params = array_merge($inparams, ['userid' => $userid]); 1047 $recordset = $DB->get_recordset_sql($sql, $params); 1048 1049 // Export the data. 1050 static::recordset_loop_and_export($recordset, 'cc_courseid', [], function($carry, $record) { 1051 context_helper::preload_from_record($record); 1052 $competency = new competency(null, competency::extract_record($record, 'c_')); 1053 $cc = new course_competency(null, course_competency::extract_record($record, 'cc_')); 1054 $carry[] = array_merge(static::transform_competency_brief($competency), [ 1055 'timemodified' => transform::datetime($cc->get('timemodified')), 1056 'created_or_modified_by_you' => transform::yesno(true) 1057 ]); 1058 return $carry; 1059 1060 }, function($courseid, $data) use ($path, $userid, $DB) { 1061 $context = context_course::instance($courseid); 1062 writer::with_context($context)->export_related_data($path, 'associations', (object) ['competencies' => $data]); 1063 }); 1064 } 1065 1066 /** 1067 * Export user data in course contexts related to course settings. 1068 * 1069 * @param int $userid The user ID. 1070 * @param array $courseids The course IDs. 1071 * @param array $path The root path to export at. 1072 * @return void 1073 */ 1074 protected static function export_user_data_in_course_contexts_settings($userid, $courseids, $path) { 1075 global $DB; 1076 1077 // Fetch all the courses with associations we created or modified. 1078 $ccsfields = course_competency_settings::get_sql_fields('ccs', 'ccs_'); 1079 list($insql, $inparams) = $DB->get_in_or_equal($courseids, SQL_PARAMS_NAMED); 1080 $sql = " 1081 SELECT $ccsfields 1082 FROM {" . course_competency_settings::TABLE . "} ccs 1083 WHERE ccs.usermodified = :userid 1084 AND ccs.courseid $insql 1085 ORDER BY ccs.courseid"; 1086 $params = array_merge($inparams, ['userid' => $userid]); 1087 $recordset = $DB->get_recordset_sql($sql, $params); 1088 1089 // Export the data. 1090 static::recordset_loop_and_export($recordset, 'ccs_courseid', [], function($carry, $record) { 1091 $ccs = new course_competency_settings(null, course_competency_settings::extract_record($record, 'ccs_')); 1092 return [ 1093 'timemodified' => transform::datetime($ccs->get('timemodified')), 1094 'created_or_modified_by_you' => transform::yesno(true) 1095 ]; 1096 }, function($courseid, $data) use ($path, $userid, $DB) { 1097 $context = context_course::instance($courseid); 1098 writer::with_context($context)->export_related_data($path, 'settings', (object) $data); 1099 }); 1100 } 1101 1102 /** 1103 * Export the user data in module contexts. 1104 * 1105 * @param int $userid The user whose data we're exporting. 1106 * @param array $contexts A list of contexts. 1107 * @return void 1108 */ 1109 protected static function export_user_data_in_module_contexts($userid, array $contexts) { 1110 global $DB; 1111 1112 $contexts = array_filter($contexts, function($context) { 1113 return $context->contextlevel == CONTEXT_MODULE; 1114 }); 1115 if (empty($contexts)) { 1116 return; 1117 } 1118 1119 $path = [get_string('competencies', 'core_competency')]; 1120 $cmids = array_map(function($context) { 1121 return $context->instanceid; 1122 }, $contexts); 1123 1124 // Fetch all the modules with associations we created or modified. 1125 $compfields = competency::get_sql_fields('c', 'c_'); 1126 $cmcfields = course_module_competency::get_sql_fields('cmc', 'cmc_'); 1127 $ctxfields = context_helper::get_preload_record_columns_sql('ctx'); 1128 list($insql, $inparams) = $DB->get_in_or_equal($cmids, SQL_PARAMS_NAMED); 1129 $sql = " 1130 SELECT $compfields, $cmcfields, $ctxfields 1131 FROM {" . course_module_competency::TABLE . "} cmc 1132 JOIN {" . competency::TABLE . "} c 1133 ON c.id = cmc.competencyid 1134 JOIN {" . competency_framework::TABLE . "} f 1135 ON f.id = c.competencyframeworkid 1136 JOIN {context} ctx 1137 ON ctx.id = f.contextid 1138 WHERE cmc.usermodified = :userid 1139 AND cmc.cmid $insql 1140 ORDER BY cmc.cmid"; 1141 $params = array_merge($inparams, ['userid' => $userid]); 1142 1143 // Export the data. 1144 $recordset = $DB->get_recordset_sql($sql, $params); 1145 static::recordset_loop_and_export($recordset, 'cmc_cmid', [], function($carry, $record) { 1146 context_helper::preload_from_record($record); 1147 $competency = new competency(null, competency::extract_record($record, 'c_')); 1148 $cmc = new course_module_competency(null, course_module_competency::extract_record($record, 'cmc_')); 1149 $carry[] = array_merge(static::transform_competency_brief($competency), [ 1150 'timecreated' => transform::datetime($cmc->get('timecreated')), 1151 'timemodified' => transform::datetime($cmc->get('timemodified')), 1152 'created_or_modified_by_you' => transform::yesno(true) 1153 ]); 1154 return $carry; 1155 1156 }, function($cmid, $data) use ($path) { 1157 $context = context_module::instance($cmid); 1158 writer::with_context($context)->export_data($path, (object) ['associations' => $data]); 1159 }); 1160 } 1161 1162 /** 1163 * Export a user's competencies. 1164 * 1165 * @param context_user $context The context of the user requesting the export. 1166 * @return void 1167 */ 1168 protected static function export_user_data_competencies(context_user $context) { 1169 global $DB; 1170 1171 $userid = $context->instanceid; 1172 $path = [get_string('competencies', 'core_competency'), get_string('competencies', 'core_competency')]; 1173 $helper = new performance_helper(); 1174 $cfields = competency::get_sql_fields('c', 'c_'); 1175 $ucfields = user_competency::get_sql_fields('uc', 'uc_'); 1176 $efields = evidence::get_sql_fields('e', 'e_'); 1177 1178 $makecomppath = function($competencyid, $data) use ($path) { 1179 return array_merge($path, [$data['name'] . ' (' . $competencyid . ')']); 1180 }; 1181 1182 $sql = " 1183 SELECT $cfields, $ucfields, $efields 1184 FROM {" . user_competency::TABLE . "} uc 1185 JOIN {" . competency::TABLE . "} c 1186 ON c.id = uc.competencyid 1187 LEFT JOIN {" . evidence::TABLE . "} e 1188 ON uc.id = e.usercompetencyid 1189 WHERE uc.userid = :userid 1190 ORDER BY c.id, e.timecreated DESC, e.id DESC"; 1191 $params = ['userid' => $userid]; 1192 1193 $recordset = $DB->get_recordset_sql($sql, $params); 1194 static::recordset_loop_and_export($recordset, 'c_id', null, function($carry, $record) 1195 use ($context, $userid, $helper, $makecomppath) { 1196 1197 $competency = new competency(null, competency::extract_record($record, 'c_')); 1198 1199 if ($carry === null) { 1200 $uc = new user_competency(null, user_competency::extract_record($record, 'uc_')); 1201 $carry = array_merge(static::transform_competency_brief($competency), [ 1202 'rating' => static::transform_user_competency($userid, $uc, $competency, $helper), 1203 'evidence' => [] 1204 ]); 1205 \core_comment\privacy\provider::export_comments($context, 'competency', 'user_competency', 1206 $uc->get('id'), $makecomppath($competency->get('id'), $carry), false); 1207 } 1208 1209 // There is an evidence in this record. 1210 if (!empty($record->e_id)) { 1211 $evidence = new evidence(null, evidence::extract_record($record, 'e_')); 1212 $carry['evidence'][] = static::transform_evidence($userid, $evidence, $competency, $helper); 1213 } 1214 1215 return $carry; 1216 1217 }, function($competencyid, $data) use ($makecomppath, $context) { 1218 writer::with_context($context)->export_data($makecomppath($competencyid, $data), (object) $data); 1219 }); 1220 } 1221 1222 /** 1223 * Export a user's learning plans. 1224 * 1225 * @param context_user $context The context of the user requesting the export. 1226 * @return void 1227 */ 1228 protected static function export_user_data_learning_plans(context_user $context) { 1229 global $DB; 1230 1231 $userid = $context->instanceid; 1232 $path = [get_string('competencies', 'core_competency'), get_string('privacy:path:plans', 'core_competency')]; 1233 $helper = new performance_helper(); 1234 $pfields = plan::get_sql_fields('p', 'p_'); 1235 $pcfields = plan_competency::get_sql_fields('pc', 'pc_'); 1236 $cfields = competency::get_sql_fields('c', 'c_'); 1237 $ucfields = user_competency::get_sql_fields('uc', 'uc_'); 1238 $ucpfields = user_competency_plan::get_sql_fields('ucp', 'ucp_'); 1239 1240 // The user's learning plans. 1241 $sql = " 1242 SELECT $pfields, $pcfields, $cfields, $ucfields, $ucpfields 1243 FROM {" . plan::TABLE . "} p 1244 LEFT JOIN {" . plan_competency::TABLE . "} pc 1245 ON p.id = pc.planid 1246 AND p.templateid IS NULL 1247 AND p.status != :complete1 1248 LEFT JOIN {" . template_competency::TABLE . "} tc 1249 ON tc.templateid = p.templateid 1250 AND p.templateid IS NOT NULL 1251 AND p.status != :complete2 1252 LEFT JOIN {" . user_competency_plan::TABLE . "} ucp 1253 ON ucp.planid = p.id 1254 AND p.status = :complete3 1255 LEFT JOIN {" . competency::TABLE . "} c 1256 ON c.id = pc.competencyid 1257 OR c.id = tc.competencyid 1258 OR c.id = ucp.competencyid 1259 LEFT JOIN {" . user_competency::TABLE . "} uc 1260 ON uc.userid = p.userid 1261 AND (uc.competencyid = pc.competencyid OR uc.competencyid = tc.competencyid) 1262 WHERE p.userid = :userid 1263 ORDER BY p.id, c.id"; 1264 $params = [ 1265 'userid' => $userid, 1266 'complete1' => plan::STATUS_COMPLETE, 1267 'complete2' => plan::STATUS_COMPLETE, 1268 'complete3' => plan::STATUS_COMPLETE, 1269 ]; 1270 1271 $recordset = $DB->get_recordset_sql($sql, $params); 1272 static::recordset_loop_and_export($recordset, 'p_id', null, function($carry, $record) use ($userid, $helper, $context) { 1273 $iscomplete = $record->p_status == plan::STATUS_COMPLETE; 1274 1275 if ($carry === null) { 1276 $plan = new plan(null, plan::extract_record($record, 'p_')); 1277 $options = ['context' => $context]; 1278 $carry = [ 1279 'name' => format_string($plan->get('name'), true, $options), 1280 'description' => format_text($plan->get('description'), $plan->get('descriptionformat'), $options), 1281 'status' => $plan->get_statusname(), 1282 'duedate' => $plan->get('duedate') ? transform::datetime($plan->get('duedate')) : '-', 1283 'reviewerid' => $plan->get('reviewerid') ? transform::user($plan->get('reviewerid')) : '-', 1284 'timecreated' => transform::datetime($plan->get('timecreated')), 1285 'timemodified' => transform::datetime($plan->get('timemodified')), 1286 'competencies' => [], 1287 ]; 1288 } 1289 1290 // The plan is empty. 1291 if (empty($record->c_id)) { 1292 return $carry; 1293 } 1294 1295 $competency = new competency(null, competency::extract_record($record, 'c_')); 1296 $rating = null; 1297 1298 if ($iscomplete) { 1299 // When the plan is complete, we should always found the user_competency_plan. 1300 $ucp = new user_competency_plan(null, user_competency_plan::extract_record($record, 'ucp_')); 1301 $rating = static::transform_user_competency($userid, $ucp, $competency, $helper); 1302 1303 } else if (!empty($record->uc_id)) { 1304 // When the plan is complete, there are still records of user_competency but we do not 1305 // export them here, we export them as part of the competencies structure. The reason why 1306 // we try to get the user_competency when the plan is not complete is to give the most accurate 1307 // representation of the plan as possible. 1308 $uc = new user_competency(null, user_competency::extract_record($record, 'uc_')); 1309 $rating = static::transform_user_competency($userid, $uc, $competency, $helper); 1310 } 1311 1312 $carry['competencies'][] = array_merge(static::transform_competency_brief($competency), ['rating' => $rating]); 1313 return $carry; 1314 1315 }, function($planid, $data) use ($context, $path) { 1316 $planpath = array_merge($path, [$data['name'] . ' (' . $planid . ')']); 1317 \core_comment\privacy\provider::export_comments($context, 'competency', 'plan', $planid, $planpath, false); 1318 writer::with_context($context)->export_data($planpath, (object) $data); 1319 }); 1320 } 1321 1322 /** 1323 * Export a user's data related to learning plans. 1324 * 1325 * @param int $userid The user ID we're exporting for. 1326 * @param context_user $context The context of the user in which we're gathering data. 1327 * @return void 1328 */ 1329 protected static function export_user_data_learning_plans_related_to_me($userid, context_user $context) { 1330 global $DB; 1331 1332 $path = [ 1333 get_string('competencies', 'core_competency'), 1334 get_string('privacy:path:relatedtome', 'core_competency'), 1335 get_string('privacy:path:plans', 'core_competency'), 1336 ]; 1337 $plans = []; 1338 $helper = new performance_helper(); 1339 $pfields = plan::get_sql_fields('p', 'p_'); 1340 $pcfields = plan_competency::get_sql_fields('pc', 'pc_'); 1341 $cfields = competency::get_sql_fields('c', 'c_'); 1342 $ucpfields = user_competency_plan::get_sql_fields('ucp', 'ucp_'); 1343 1344 // Function to initialise a plan record. 1345 $initplan = function($record) use ($context, $userid, &$plans) { 1346 $plan = new plan(null, plan::extract_record($record, 'p_')); 1347 $options = ['context' => $context]; 1348 $plans[$plan->get('id')] = [ 1349 'name' => format_string($plan->get('name'), true, $options), 1350 'reviewer_is_you' => transform::yesno($plan->get('reviewerid') == $userid), 1351 'timecreated' => transform::datetime($plan->get('timecreated')), 1352 'timemodified' => transform::datetime($plan->get('timemodified')), 1353 'created_or_modified_by_you' => transform::yesno($plan->get('usermodified') == $userid), 1354 'competencies' => [], 1355 ]; 1356 }; 1357 1358 $initcompetency = function($record, $planid) use (&$plans) { 1359 $competency = new competency(null, competency::extract_record($record, 'c_')); 1360 $plans[$planid]['competencies'][$competency->get('id')] = static::transform_competency_brief($competency); 1361 }; 1362 1363 // Look for associations that were created. 1364 $sql = " 1365 SELECT $pfields, $pcfields, $cfields 1366 FROM {" . plan_competency::TABLE . "} pc 1367 JOIN {" . plan::TABLE . "} p 1368 ON p.id = pc.planid 1369 JOIN {" . competency::TABLE . "} c 1370 ON c.id = pc.competencyid 1371 WHERE p.userid = :targetuserid 1372 AND pc.usermodified = :userid 1373 ORDER BY p.id, c.id"; 1374 $params = [ 1375 'targetuserid' => $context->instanceid, 1376 'userid' => $userid, 1377 ]; 1378 1379 $recordset = $DB->get_recordset_sql($sql, $params); 1380 foreach ($recordset as $record) { 1381 $planid = $record->p_id; 1382 if (!isset($plans[$planid])) { 1383 $initplan($record); 1384 } 1385 1386 $initcompetency($record, $planid); 1387 $pc = new plan_competency(null, plan_competency::extract_record($record, 'pc_')); 1388 $plans[$planid]['competencies'][$pc->get('competencyid')] = array_merge( 1389 $plans[$planid]['competencies'][$pc->get('competencyid')], [ 1390 'timemodified' => $pc->get('timemodified') ? transform::datetime($pc->get('timemodified')) : '-', 1391 'timecreated' => $pc->get('timecreated') ? transform::datetime($pc->get('timecreated')) : '-', 1392 'created_or_modified_by_you' => transform::yesno($pc->get('usermodified') == $userid), 1393 ] 1394 ); 1395 } 1396 $recordset->close(); 1397 1398 // Look for final grades that were given. 1399 $sql = " 1400 SELECT $pfields, $ucpfields, $cfields 1401 FROM {" . user_competency_plan::TABLE . "} ucp 1402 JOIN {" . plan::TABLE . "} p 1403 ON p.id = ucp.planid 1404 JOIN {" . competency::TABLE . "} c 1405 ON c.id = ucp.competencyid 1406 WHERE p.userid = :targetuserid 1407 AND ucp.usermodified = :userid 1408 ORDER BY p.id, c.id"; 1409 $params = [ 1410 'targetuserid' => $context->instanceid, 1411 'userid' => $userid, 1412 ]; 1413 1414 $recordset = $DB->get_recordset_sql($sql, $params); 1415 foreach ($recordset as $record) { 1416 $planid = $record->p_id; 1417 $competencyid = $record->c_id; 1418 1419 if (!isset($plans[$planid])) { 1420 $initplan($record); 1421 } 1422 1423 if (!isset($plans[$planid]['competencies'][$competencyid])) { 1424 $initcompetency($record, $planid); 1425 } 1426 1427 $competency = new competency(null, competency::extract_record($record, 'c_')); 1428 $ucp = new user_competency_plan(null, user_competency_plan::extract_record($record, 'ucp_')); 1429 $plans[$planid]['competencies'][$competencyid]['rating'] = static::transform_user_competency($userid, $ucp, 1430 $competency, $helper); 1431 } 1432 $recordset->close(); 1433 1434 // Find the plans that were modified or reviewed. 1435 $insql = " > 0"; 1436 $inparams = []; 1437 if (!empty($plans)) { 1438 list($insql, $inparams) = $DB->get_in_or_equal(array_keys($plans), SQL_PARAMS_NAMED, 'param', false); 1439 } 1440 $sql = " 1441 SELECT $pfields 1442 FROM {" . plan::TABLE . "} p 1443 LEFT JOIN {comments} c 1444 ON c.contextid = :contextid 1445 AND c.commentarea = :planarea 1446 AND c.component = :competency 1447 AND c.itemid = p.id 1448 WHERE p.userid = :targetuserid 1449 AND (p.usermodified = :userid1 1450 OR p.reviewerid = :userid2 1451 OR c.userid = :userid3) 1452 AND p.id $insql 1453 ORDER BY p.id"; 1454 $params = array_merge($inparams, [ 1455 'targetuserid' => $context->instanceid, 1456 'userid1' => $userid, 1457 'userid2' => $userid, 1458 'userid3' => $userid, 1459 'contextid' => $context->id, 1460 'planarea' => 'plan', 1461 'competency' => 'competency' 1462 ]); 1463 1464 $recordset = $DB->get_recordset_sql($sql, $params); 1465 foreach ($recordset as $record) { 1466 $planid = $record->p_id; 1467 if (!isset($plans[$planid])) { 1468 $initplan($record); 1469 } 1470 } 1471 $recordset->close(); 1472 1473 // Export each plan on its own. 1474 foreach ($plans as $planid => $plan) { 1475 $planpath = array_merge($path, ["{$plan['name']} ({$planid})"]); 1476 $plan['competencies'] = array_values($plan['competencies']); // Drop the keys. 1477 1478 writer::with_context($context)->export_data($planpath, (object) $plan); 1479 \core_comment\privacy\provider::export_comments($context, 'competency', 'plan', $planid, $planpath, true); 1480 } 1481 } 1482 1483 /** 1484 * Export a user's data related to competencies. 1485 * 1486 * @param int $userid The user ID we're exporting for. 1487 * @param context_user $context The context of the user in which we're gathering data. 1488 * @return void 1489 */ 1490 protected static function export_user_data_competencies_related_to_me($userid, context_user $context) { 1491 global $DB; 1492 1493 $path = [ 1494 get_string('competencies', 'core_competency'), 1495 get_string('privacy:path:relatedtome', 'core_competency'), 1496 get_string('competencies', 'core_competency'), 1497 ]; 1498 $competencies = []; 1499 $helper = new performance_helper(); 1500 $cfields = competency::get_sql_fields('c', 'c_'); 1501 $ucfields = user_competency::get_sql_fields('uc', 'uc_'); 1502 $efields = evidence::get_sql_fields('e', 'e_'); 1503 1504 $initcompetency = function($record) use (&$competencies) { 1505 $competency = new competency(null, competency::extract_record($record, 'c_')); 1506 $competencies[$competency->get('id')] = array_merge(static::transform_competency_brief($competency), [ 1507 'evidence' => [] 1508 ]); 1509 }; 1510 1511 $initusercomp = function($competency, $record) use (&$competencies, $userid, $helper) { 1512 $competencyid = $competency->get('id'); 1513 $uc = new user_competency(null, user_competency::extract_record($record, 'uc_')); 1514 $competencies[$competencyid]['uc_id'] = $uc->get('id'); 1515 $competencies[$competencyid]['rating'] = static::transform_user_competency($userid, $uc, $competency, $helper); 1516 }; 1517 1518 // Look for evidence. 1519 $sql = " 1520 SELECT $efields, $ucfields, $cfields 1521 FROM {" . evidence::TABLE . "} e 1522 JOIN {" . user_competency::TABLE . "} uc 1523 ON uc.id = e.usercompetencyid 1524 JOIN {" . competency::TABLE . "} c 1525 ON c.id = uc.competencyid 1526 WHERE uc.userid = :targetuserid 1527 AND (e.usermodified = :userid1 1528 OR e.actionuserid = :userid2) 1529 ORDER BY c.id, e.id"; 1530 $params = [ 1531 'targetuserid' => $context->instanceid, 1532 'userid1' => $userid, 1533 'userid2' => $userid, 1534 ]; 1535 $recordset = $DB->get_recordset_sql($sql, $params); 1536 foreach ($recordset as $record) { 1537 $competencyid = $record->c_id; 1538 $competency = new competency(null, competency::extract_record($record, 'c_')); 1539 1540 if (!isset($competencies[$competencyid])) { 1541 $initcompetency($record); 1542 } 1543 1544 if (!array_key_exists('rating', $competencies[$competencyid])) { 1545 $competencies[$competencyid]['rating'] = null; 1546 if ($record->uc_reviewerid == $userid || $record->uc_usermodified == $userid) { 1547 $initusercomp($competency, $record); 1548 } 1549 } 1550 1551 $evidence = new evidence(null, evidence::extract_record($record, 'e_')); 1552 $competencies[$competencyid]['evidence'][] = static::transform_evidence($userid, $evidence, $competency, $helper); 1553 } 1554 $recordset->close(); 1555 1556 // Look for user competency we modified and didn't catch. 1557 $insql = ' > 0'; 1558 $inparams = []; 1559 if (!empty($competencies)) { 1560 list($insql, $inparams) = $DB->get_in_or_equal(array_keys($competencies), SQL_PARAMS_NAMED, 'param', false); 1561 } 1562 $sql = " 1563 SELECT $ucfields, $cfields 1564 FROM {" . user_competency::TABLE . "} uc 1565 JOIN {" . competency::TABLE . "} c 1566 ON c.id = uc.competencyid 1567 LEFT JOIN {comments} cmt 1568 ON cmt.contextid = :contextid 1569 AND cmt.commentarea = :ucarea 1570 AND cmt.component = :competency 1571 AND cmt.itemid = uc.id 1572 WHERE uc.userid = :targetuserid 1573 AND (uc.usermodified = :userid1 1574 OR uc.reviewerid = :userid2 1575 OR cmt.userid = :userid3) 1576 AND uc.competencyid $insql 1577 ORDER BY c.id, uc.id"; 1578 $params = array_merge($inparams, [ 1579 'targetuserid' => $context->instanceid, 1580 'userid1' => $userid, 1581 'userid2' => $userid, 1582 'userid3' => $userid, 1583 'contextid' => $context->id, 1584 'ucarea' => 'user_competency', 1585 'competency' => 'competency', 1586 ]); 1587 1588 $recordset = $DB->get_recordset_sql($sql, $params); 1589 foreach ($recordset as $record) { 1590 $competency = new competency(null, competency::extract_record($record, 'c_')); 1591 if (!isset($competencies[$competency->get('id')])) { 1592 $initcompetency($record); 1593 $initusercomp($competency, $record); 1594 } 1595 } 1596 $recordset->close(); 1597 1598 // Export each competency on its own. 1599 foreach ($competencies as $competencyid => $competency) { 1600 $comppath = array_merge($path, ["{$competency['name']} ({$competencyid})"]); 1601 $ucid = isset($competency['uc_id']) ? $competency['uc_id'] : null; 1602 unset($competency['uc_id']); 1603 1604 // Send to writer. 1605 writer::with_context($context)->export_data($comppath, (object) $competency); 1606 if ($ucid) { 1607 \core_comment\privacy\provider::export_comments($context, 'competency', 'user_competency', $ucid, $comppath, true); 1608 } 1609 } 1610 } 1611 1612 /** 1613 * Export a user's data related to evidence of prior learning. 1614 * 1615 * @param int $userid The user ID we're exporting for. 1616 * @param context_user $context The context of the user in which we're gathering data. 1617 * @return void 1618 */ 1619 protected static function export_user_data_user_evidence_related_to_me($userid, context_user $context) { 1620 global $DB; 1621 1622 $path = [ 1623 get_string('competencies', 'core_competency'), 1624 get_string('privacy:path:relatedtome', 'core_competency'), 1625 get_string('privacy:path:userevidence', 'core_competency'), 1626 ]; 1627 $evidence = []; 1628 $helper = new performance_helper(); 1629 $cfields = competency::get_sql_fields('c', 'c_'); 1630 $uecfields = user_evidence_competency::get_sql_fields('uec', 'uec_'); 1631 $uefields = user_evidence::get_sql_fields('ue', 'ue_'); 1632 1633 $initevidence = function($record) use (&$evidence, $userid) { 1634 $ue = new user_evidence(null, user_evidence::extract_record($record, 'ue_')); 1635 $evidence[$ue->get('id')] = static::transform_user_evidence($userid, $ue); 1636 }; 1637 1638 // Look for evidence. 1639 $sql = " 1640 SELECT $uefields, $uecfields, $cfields 1641 FROM {" . user_evidence_competency::TABLE . "} uec 1642 JOIN {" . user_evidence::TABLE . "} ue 1643 ON ue.id = uec.userevidenceid 1644 JOIN {" . competency::TABLE . "} c 1645 ON c.id = uec.competencyid 1646 WHERE ue.userid = :targetuserid 1647 AND uec.usermodified = :userid 1648 ORDER BY ue.id, c.id"; 1649 $params = [ 1650 'targetuserid' => $context->instanceid, 1651 'userid' => $userid, 1652 ]; 1653 $recordset = $DB->get_recordset_sql($sql, $params); 1654 foreach ($recordset as $record) { 1655 $ueid = $record->ue_id; 1656 if (!isset($evidence[$ueid])) { 1657 $initevidence($record); 1658 } 1659 1660 $competency = new competency(null, competency::extract_record($record, 'c_')); 1661 $uec = new user_evidence_competency(null, user_evidence_competency::extract_record($record, 'uec_')); 1662 $evidence[$ueid]['competencies'][] = array_merge(static::transform_competency_brief($competency), [ 1663 'timemodified' => $uec->get('timemodified') ? transform::datetime($uec->get('timemodified')) : '-', 1664 'timecreated' => $uec->get('timecreated') ? transform::datetime($uec->get('timecreated')) : '-', 1665 'created_or_modified_by_you' => transform::yesno($uec->get('usermodified')) 1666 ]); 1667 } 1668 $recordset->close(); 1669 1670 // Look for user evidence we modified or reviewed and didn't catch. 1671 $insql = ' > 0'; 1672 $inparams = []; 1673 if (!empty($evidence)) { 1674 list($insql, $inparams) = $DB->get_in_or_equal(array_keys($evidence), SQL_PARAMS_NAMED, 'param', false); 1675 } 1676 $sql = " 1677 SELECT $uefields 1678 FROM {" . user_evidence::TABLE . "} ue 1679 WHERE ue.userid = :targetuserid 1680 AND ue.usermodified = :userid 1681 AND ue.id $insql 1682 ORDER BY ue.id"; 1683 $params = array_merge($inparams, [ 1684 'targetuserid' => $context->instanceid, 1685 'userid' => $userid, 1686 ]); 1687 1688 $recordset = $DB->get_recordset_sql($sql, $params); 1689 foreach ($recordset as $record) { 1690 $initevidence($record); 1691 } 1692 $recordset->close(); 1693 1694 // Export files, then content. 1695 foreach ($evidence as $ueid => $data) { 1696 $uepath = array_merge($path, ["{$data['name']} ({$ueid})"]); 1697 writer::with_context($context)->export_area_files($uepath, 'core_competency', 'userevidence', $ueid); 1698 writer::with_context($context)->export_data($uepath, (object) $data); 1699 } 1700 } 1701 1702 /** 1703 * Export the evidence of prior learning of a user. 1704 * 1705 * @param context_user $context The context of the user we're exporting for. 1706 * @return void 1707 */ 1708 protected static function export_user_data_user_evidence(context_user $context) { 1709 global $DB; 1710 1711 $userid = $context->instanceid; 1712 $path = [get_string('competencies', 'core_competency'), get_string('privacy:path:userevidence', 'core_competency')]; 1713 $uefields = user_evidence::get_sql_fields('ue', 'ue_'); 1714 $cfields = competency::get_sql_fields('c', 'c_'); 1715 1716 $sql = " 1717 SELECT $uefields, $cfields 1718 FROM {" . user_evidence::TABLE . "} ue 1719 LEFT JOIN {" . user_evidence_competency::TABLE . "} uec 1720 ON uec.userevidenceid = ue.id 1721 LEFT JOIN {" . competency::TABLE . "} c 1722 ON c.id = uec.competencyid 1723 WHERE ue.userid = :userid 1724 ORDER BY ue.id"; 1725 $params = ['userid' => $userid]; 1726 1727 $recordset = $DB->get_recordset_sql($sql, $params); 1728 static::recordset_loop_and_export($recordset, 'ue_id', null, function($carry, $record) use ($userid, $context){ 1729 if ($carry === null) { 1730 $ue = new user_evidence(null, user_evidence::extract_record($record, 'ue_')); 1731 $carry = static::transform_user_evidence($userid, $ue); 1732 } 1733 1734 if (!empty($record->c_id)) { 1735 $competency = new competency(null, competency::extract_record($record, 'c_')); 1736 $carry['competencies'][] = static::transform_competency_brief($competency); 1737 } 1738 1739 return $carry; 1740 }, function($ueid, $data) use ($context, $path) { 1741 $finalpath = array_merge($path, [$data['name'] . ' (' . $ueid . ')']); 1742 writer::with_context($context)->export_area_files($finalpath, 'core_competency', 'userevidence', $ueid); 1743 writer::with_context($context)->export_data($finalpath, (object) $data); 1744 }); 1745 } 1746 1747 /** 1748 * Export the user data related to frameworks in context. 1749 * 1750 * @param int $userid The user ID. 1751 * @param context $context The context. 1752 * @return void 1753 */ 1754 protected static function export_user_data_frameworks_in_context($userid, context $context) { 1755 global $DB; 1756 1757 $ffields = competency_framework::get_sql_fields('f', 'f_'); 1758 $cfields = competency::get_sql_fields('c', 'c_'); 1759 $c2fields = competency::get_sql_fields('c2', 'c2_'); 1760 $rcfields = related_competency::get_sql_fields('rc', 'rc_'); 1761 1762 $frameworks = []; 1763 $initframework = function($record) use (&$frameworks, $userid) { 1764 $framework = new competency_framework(null, competency_framework::extract_record($record, 'f_')); 1765 $frameworks[$framework->get('id')] = array_merge(static::transform_framework_brief($framework), [ 1766 'timemodified' => transform::datetime($framework->get('timemodified')), 1767 'created_or_modified_by_you' => transform::yesno($framework->get('usermodified') == $userid), 1768 'competencies' => [] 1769 ]); 1770 }; 1771 $initcompetency = function($record, $prefix) use (&$frameworks, $userid) { 1772 $competency = new competency(null, competency::extract_record($record, $prefix)); 1773 $frameworks[$competency->get('competencyframeworkid')]['competencies'][$competency->get('id')] = array_merge( 1774 static::transform_competency_brief($competency), 1775 [ 1776 'timemodified' => transform::datetime($competency->get('timemodified')), 1777 'created_or_modified_by_you' => transform::yesno($competency->get('usermodified') == $userid), 1778 'related_competencies' => [] 1779 ] 1780 ); 1781 }; 1782 1783 // Start by looking for related competencies. 1784 $sql = " 1785 SELECT $ffields, $cfields, $c2fields, $rcfields 1786 FROM {" . related_competency::TABLE . "} rc 1787 JOIN {" . competency::TABLE . "} c 1788 ON c.id = rc.competencyid 1789 JOIN {" . competency::TABLE . "} c2 1790 ON c2.id = rc.relatedcompetencyid 1791 JOIN {" . competency_framework::TABLE . "} f 1792 ON f.id = c.competencyframeworkid 1793 WHERE rc.usermodified = :userid 1794 AND f.contextid = :contextid 1795 ORDER BY rc.id, c.id"; 1796 $params = ['userid' => $userid, 'contextid' => $context->id]; 1797 1798 $recordset = $DB->get_recordset_sql($sql, $params); 1799 foreach ($recordset as $record) { 1800 $frameworkid = $record->f_id; 1801 $comp1id = $record->c_id; 1802 $comp2id = $record->c2_id; 1803 1804 if (!isset($frameworks[$frameworkid])) { 1805 $initframework($record); 1806 } 1807 1808 foreach (['c_', 'c2_'] as $key) { 1809 $competencyid = $record->{$key . 'id'}; 1810 if (!isset($frameworks[$frameworkid]['competencies'][$competencyid])) { 1811 $initcompetency($record, $key); 1812 } 1813 } 1814 1815 $relcomp = new related_competency(null, related_competency::extract_record($record, 'rc_')); 1816 foreach (['c_' => 'c2_', 'c2_' => 'c_'] as $key => $relatedkey) { 1817 $competencyid = $record->{$key . 'id'}; 1818 $competency = new competency(null, competency::extract_record($record, $relatedkey)); 1819 $frameworks[$frameworkid]['competencies'][$competencyid]['related_competencies'][] = [ 1820 'name' => $competency->get('shortname'), 1821 'idnumber' => $competency->get('idnumber'), 1822 'timemodified' => transform::datetime($relcomp->get('timemodified')), 1823 'created_or_modified_by_you' => transform::yesno($relcomp->get('usermodified') == $userid), 1824 ]; 1825 } 1826 } 1827 $recordset->close(); 1828 1829 // Now look for competencies, but skip the ones we've already seen. 1830 $competencyids = array_reduce($frameworks, function($carry, $framework) { 1831 return array_merge($carry, array_keys($framework['competencies'])); 1832 }, []); 1833 $insql = ' IS NOT NULL'; 1834 $inparams = []; 1835 if (!empty($competencyids)) { 1836 list($insql, $inparams) = $DB->get_in_or_equal($competencyids, SQL_PARAMS_NAMED, 'param', false); 1837 } 1838 $sql = " 1839 SELECT $ffields, $cfields 1840 FROM {" . competency::TABLE . "} c 1841 JOIN {" . competency_framework::TABLE . "} f 1842 ON f.id = c.competencyframeworkid 1843 WHERE c.usermodified = :userid 1844 AND f.contextid = :contextid 1845 AND c.id $insql 1846 ORDER BY c.id"; 1847 $params = array_merge($inparams, ['userid' => $userid, 'contextid' => $context->id]); 1848 $recordset = $DB->get_recordset_sql($sql, $params); 1849 foreach ($recordset as $record) { 1850 $frameworkid = $record->f_id; 1851 if (!isset($frameworks[$frameworkid])) { 1852 $initframework($record); 1853 } 1854 $initcompetency($record, 'c_'); 1855 } 1856 $recordset->close(); 1857 1858 // Now look for frameworks, but skip the ones we've already seen. 1859 $frameworkids = array_keys($frameworks); 1860 $insql = ' IS NOT NULL'; 1861 $inparams = []; 1862 if (!empty($frameworkids)) { 1863 list($insql, $inparams) = $DB->get_in_or_equal($frameworkids, SQL_PARAMS_NAMED, 'param', false); 1864 } 1865 $sql = " 1866 SELECT $ffields 1867 FROM {" . competency_framework::TABLE . "} f 1868 WHERE f.usermodified = :userid 1869 AND f.contextid = :contextid 1870 AND f.id $insql 1871 ORDER BY f.id"; 1872 $params = array_merge($inparams, ['userid' => $userid, 'contextid' => $context->id]); 1873 $recordset = $DB->get_recordset_sql($sql, $params); 1874 foreach ($recordset as $record) { 1875 context_helper::preload_from_record($record); 1876 $initframework($record); 1877 } 1878 $recordset->close(); 1879 1880 // Export all the things! 1881 writer::with_context($context)->export_related_data( 1882 [get_string('competencies', 'core_competency')], 1883 'frameworks', 1884 (object) [ 1885 // Drop the temporary IDs. 1886 'frameworks' => array_reduce($frameworks, function($carry, $item) { 1887 $item['competencies'] = array_values($item['competencies']); 1888 $carry[] = $item; 1889 return $carry; 1890 }, []) 1891 ] 1892 ); 1893 } 1894 1895 /** 1896 * Export the user data related to templates in contexts. 1897 * 1898 * @param int $userid The user ID. 1899 * @param context $context The context. 1900 * @return void 1901 */ 1902 protected static function export_user_data_templates_in_context($userid, context $context) { 1903 global $DB; 1904 1905 $tfields = template::get_sql_fields('t', 't_'); 1906 $cfields = competency::get_sql_fields('c', 'c_'); 1907 $tcfields = template_competency::get_sql_fields('tc', 'tc_'); 1908 $tchfields = template_cohort::get_sql_fields('tch', 'tch_'); 1909 1910 $templates = []; 1911 $inittemplate = function($record) use (&$templates, $userid) { 1912 $template = new template(null, template::extract_record($record, 't_')); 1913 $templates[$template->get('id')] = array_merge(static::transform_template_brief($template), [ 1914 'timemodified' => transform::datetime($template->get('timemodified')), 1915 'created_or_modified_by_you' => transform::yesno($template->get('usermodified') == $userid), 1916 'competencies' => [], 1917 'cohorts' => [] 1918 ]); 1919 }; 1920 1921 // Find the template competencies. 1922 $sql = " 1923 SELECT $tfields, $cfields, $tcfields 1924 FROM {" . template_competency::TABLE . "} tc 1925 JOIN {" . template::TABLE . "} t 1926 ON t.id = tc.templateid 1927 JOIN {" . competency::TABLE . "} c 1928 ON c.id = tc.competencyid 1929 WHERE t.contextid = :contextid 1930 AND tc.usermodified = :userid 1931 ORDER BY t.id, tc.id"; 1932 $params = ['userid' => $userid, 'contextid' => $context->id]; 1933 $recordset = $DB->get_recordset_sql($sql, $params); 1934 foreach ($recordset as $record) { 1935 $templateid = $record->t_id; 1936 if (!isset($templates[$templateid])) { 1937 $inittemplate($record); 1938 } 1939 $tplcomp = new template_competency(null, template_competency::extract_record($record, 'tc_')); 1940 $competency = new competency(null, competency::extract_record($record, 'c_')); 1941 $templates[$templateid]['competencies'][] = array_merge( 1942 static::transform_competency_brief($competency), 1943 [ 1944 'timemodified' => transform::datetime($tplcomp->get('timemodified')), 1945 'created_or_modified_by_you' => transform::yesno($tplcomp->get('usermodified') == $userid) 1946 ] 1947 ); 1948 } 1949 $recordset->close(); 1950 1951 // Find the template cohorts. 1952 $sql = " 1953 SELECT $tfields, $tchfields, c.name AS cohortname 1954 FROM {" . template_cohort::TABLE . "} tch 1955 JOIN {" . template::TABLE . "} t 1956 ON t.id = tch.templateid 1957 JOIN {cohort} c 1958 ON c.id = tch.cohortid 1959 WHERE t.contextid = :contextid 1960 AND tch.usermodified = :userid 1961 ORDER BY t.id, tch.id"; 1962 $params = ['userid' => $userid, 'contextid' => $context->id]; 1963 $recordset = $DB->get_recordset_sql($sql, $params); 1964 foreach ($recordset as $record) { 1965 $templateid = $record->t_id; 1966 if (!isset($templates[$templateid])) { 1967 $inittemplate($record); 1968 } 1969 $tplcohort = new template_cohort(null, template_cohort::extract_record($record, 'tch_')); 1970 $templates[$templateid]['cohorts'][] = [ 1971 'name' => $record->cohortname, 1972 'timemodified' => transform::datetime($tplcohort->get('timemodified')), 1973 'created_or_modified_by_you' => transform::yesno($tplcohort->get('usermodified') == $userid) 1974 ]; 1975 } 1976 $recordset->close(); 1977 1978 // Find the modified templates which we haven't been found yet. 1979 $templateids = array_keys($templates); 1980 $insql = "IS NOT NULL"; 1981 $inparams = []; 1982 if (!empty($templateids)) { 1983 list($insql, $inparams) = $DB->get_in_or_equal($templateids, SQL_PARAMS_NAMED, 'param', false); 1984 } 1985 $sql = " 1986 SELECT $tfields 1987 FROM {" . template::TABLE . "} t 1988 WHERE t.contextid = :contextid 1989 AND t.usermodified = :userid 1990 AND t.id $insql 1991 ORDER BY t.id"; 1992 $params = array_merge($inparams, ['userid' => $userid, 'contextid' => $context->id]); 1993 $recordset = $DB->get_recordset_sql($sql, $params); 1994 foreach ($recordset as $record) { 1995 $inittemplate($record); 1996 } 1997 $recordset->close(); 1998 1999 // Export all the things! 2000 writer::with_context($context)->export_related_data([get_string('competencies', 'core_competency')], 2001 'templates', (object) ['templates' => array_values($templates)]); 2002 } 2003 2004 /** 2005 * Transform a competency into a brief description. 2006 * 2007 * @param competency $competency The competency. 2008 * @return array 2009 */ 2010 protected static function transform_competency_brief(competency $competency) { 2011 global $OUTPUT; 2012 $exporter = new \core_competency\external\competency_exporter($competency, ['context' => $competency->get_context()]); 2013 $data = $exporter->export($OUTPUT); 2014 return [ 2015 'idnumber' => $data->idnumber, 2016 'name' => $data->shortname, 2017 'description' => $data->description 2018 ]; 2019 } 2020 2021 /** 2022 * Transform a competency rating. 2023 * 2024 * @param competency $competency The competency. 2025 * @param int $grade The grade. 2026 * @param performance_helper $helper The performance helper. 2027 * @return string 2028 */ 2029 protected static function transform_competency_grade(competency $competency, $grade, performance_helper $helper) { 2030 if ($grade === null) { 2031 return '-'; 2032 } 2033 $scale = $helper->get_scale_from_competency($competency); 2034 return $scale->scale_items[$grade - 1]; 2035 } 2036 2037 /** 2038 * Transform an evidence. 2039 * 2040 * @param int $userid The user ID we are exporting for. 2041 * @param evidence $evidence The evidence. 2042 * @param competency $competency The associated competency. 2043 * @param performance_helper $helper The performance helper. 2044 * @return array 2045 */ 2046 protected static function transform_evidence($userid, evidence $evidence, competency $competency, performance_helper $helper) { 2047 $action = $evidence->get('action'); 2048 $actiontxt = '?'; 2049 if ($action == evidence::ACTION_LOG) { 2050 $actiontxt = get_string('privacy:evidence:action:log', 'core_competency'); 2051 } else if ($action == evidence::ACTION_COMPLETE) { 2052 $actiontxt = get_string('privacy:evidence:action:complete', 'core_competency'); 2053 } else if ($action == evidence::ACTION_OVERRIDE) { 2054 $actiontxt = get_string('privacy:evidence:action:override', 'core_competency'); 2055 } 2056 2057 $actionuserid = $evidence->get('actionuserid'); 2058 2059 return [ 2060 'action' => $actiontxt, 2061 'actionuserid' => $actionuserid ? transform::user($actionuserid) : '-', 2062 'acting_user_is_you' => transform::yesno($userid == $actionuserid), 2063 'description' => (string) $evidence->get_description(), 2064 'url' => $evidence->get('url'), 2065 'grade' => static::transform_competency_grade($competency, $evidence->get('grade'), $helper), 2066 'note' => $evidence->get('note'), 2067 'timecreated' => transform::datetime($evidence->get('timecreated')), 2068 'timemodified' => transform::datetime($evidence->get('timemodified')), 2069 'created_or_modified_by_you' => transform::yesno($userid == $evidence->get('usermodified')) 2070 ]; 2071 } 2072 2073 /** 2074 * Transform a framework into a brief description. 2075 * 2076 * @param competency_framework $framework The framework. 2077 * @return array 2078 */ 2079 protected static function transform_framework_brief(competency_framework $framework) { 2080 global $OUTPUT; 2081 $exporter = new \core_competency\external\competency_framework_exporter($framework); 2082 $data = $exporter->export($OUTPUT); 2083 return [ 2084 'name' => $data->shortname, 2085 'idnumber' => $data->idnumber, 2086 'description' => $data->description 2087 ]; 2088 } 2089 2090 /** 2091 * Transform a template into a brief description. 2092 * 2093 * @param template $template The Template. 2094 * @return array 2095 */ 2096 protected static function transform_template_brief(template $template) { 2097 global $OUTPUT; 2098 $exporter = new \core_competency\external\template_exporter($template); 2099 $data = $exporter->export($OUTPUT); 2100 return [ 2101 'name' => $data->shortname, 2102 'description' => $data->description 2103 ]; 2104 } 2105 2106 /** 2107 * Transform proficiency. 2108 * 2109 * @param null|bool $proficiency The proficiency. 2110 * @return string 2111 */ 2112 protected static function transform_proficiency($proficiency) { 2113 return $proficiency !== null ? transform::yesno($proficiency) : '-'; 2114 } 2115 2116 /** 2117 * Transform user competency. 2118 * 2119 * @param int $userid The user ID we are exporting for. 2120 * @param user_competency|user_competency_plan|user_competency_course $uc The user competency. 2121 * @param competency $competency The associated competency. 2122 * @param performance_helper $helper The performance helper. 2123 * @return array 2124 */ 2125 protected static function transform_user_competency($userid, $uc, competency $competency, performance_helper $helper) { 2126 $data = [ 2127 'proficient' => static::transform_proficiency($uc->get('proficiency')), 2128 'rating' => static::transform_competency_grade($competency, $uc->get('grade'), $helper), 2129 'timemodified' => $uc->get('timemodified') ? transform::datetime($uc->get('timemodified')) : '-', 2130 'timecreated' => $uc->get('timecreated') ? transform::datetime($uc->get('timecreated')) : '-', 2131 'created_or_modified_by_you' => transform::yesno($uc->get('usermodified') == $userid), 2132 ]; 2133 2134 if ($uc instanceof user_competency) { 2135 $reviewer = $uc->get('reviewerid'); 2136 $data['status'] = (string) user_competency::get_status_name($uc->get('status')); 2137 $data['reviewerid'] = $reviewer ? transform::user($reviewer) : '-'; 2138 $data['reviewer_is_you'] = transform::yesno($reviewer == $userid); 2139 } 2140 2141 return $data; 2142 } 2143 2144 /** 2145 * Transform a user evidence. 2146 * 2147 * @param int $userid The user we are exporting for. 2148 * @param user_evidence $ue The evidence of prior learning. 2149 * @return array 2150 */ 2151 protected static function transform_user_evidence($userid, user_evidence $ue) { 2152 $options = ['context' => $ue->get_context()]; 2153 return [ 2154 'name' => format_string($ue->get('name'), true, $options), 2155 'description' => format_text($ue->get('description'), $ue->get('descriptionformat'), $options), 2156 'url' => $ue->get('url'), 2157 'timecreated' => $ue->get('timecreated') ? transform::datetime($ue->get('timecreated')) : '-', 2158 'timemodified' => $ue->get('timemodified') ? transform::datetime($ue->get('timemodified')) : '-', 2159 'created_or_modified_by_you' => transform::yesno($ue->get('usermodified') == $userid), 2160 'competencies' => [] 2161 ]; 2162 } 2163 2164 /** 2165 * Loop and export from a recordset. 2166 * 2167 * @param moodle_recordset $recordset The recordset. 2168 * @param string $splitkey The record key to determine when to export. 2169 * @param mixed $initial The initial data to reduce from. 2170 * @param callable $reducer The function to return the dataset, receives current dataset, and the current record. 2171 * @param callable $export The function to export the dataset, receives the last value from $splitkey and the dataset. 2172 * @return void 2173 */ 2174 protected static function recordset_loop_and_export(moodle_recordset $recordset, $splitkey, $initial, 2175 callable $reducer, callable $export) { 2176 2177 $data = $initial; 2178 $lastid = null; 2179 2180 foreach ($recordset as $record) { 2181 if ($lastid && $record->{$splitkey} != $lastid) { 2182 $export($lastid, $data); 2183 $data = $initial; 2184 } 2185 $data = $reducer($data, $record); 2186 $lastid = $record->{$splitkey}; 2187 } 2188 $recordset->close(); 2189 2190 if (!empty($lastid)) { 2191 $export($lastid, $data); 2192 } 2193 } 2194 }
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
