badges/classes/external.php

   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  * Badges external API
  19  *
  20  * @package    core_badges
  21  * @category   external
  22  * @copyright  2016 Juan Leyva <juan@moodle.com>
  23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24  * @since      Moodle 3.1
  25  */
  26
  27 defined('MOODLE_INTERNAL') || die;
  28
  29 require_once($CFG->libdir . '/externallib.php');
  30 require_once($CFG->libdir . '/badgeslib.php');
  31
  32 use core_badges\external\user_badge_exporter;
  33
  34 /**
  35  * Badges external functions
  36  *
  37  * @package    core_badges
  38  * @category   external
  39  * @copyright  2016 Juan Leyva <juan@moodle.com>
  40  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  41  * @since      Moodle 3.1
  42  */
  43 class core_badges_external extends external_api {
  44
  45     /**
  46      * Describes the parameters for get_user_badges.
  47      *
  48      * @return external_function_parameters
  49      * @since Moodle 3.1
  50      */
  51     public static function get_user_badges_parameters() {
  52         return new external_function_parameters (
  53             array(
  54                 'userid' => new external_value(PARAM_INT, 'Badges only for this user id, empty for current user', VALUE_DEFAULT, 0),
  55                 'courseid' => new external_value(PARAM_INT, 'Filter badges by course id, empty all the courses', VALUE_DEFAULT, 0),
  56                 'page' => new external_value(PARAM_INT, 'The page of records to return.', VALUE_DEFAULT, 0),
  57                 'perpage' => new external_value(PARAM_INT, 'The number of records to return per page', VALUE_DEFAULT, 0),
  58                 'search' => new external_value(PARAM_RAW, 'A simple string to search for', VALUE_DEFAULT, ''),
  59                 'onlypublic' => new external_value(PARAM_BOOL, 'Whether to return only public badges', VALUE_DEFAULT, false),
  60             )
  61         );
  62     }
  63
  64     /**
  65      * Returns the list of badges awarded to a user.
  66      *
  67      * @param int $userid       user id
  68      * @param int $courseid     course id
  69      * @param int $page         page of records to return
  70      * @param int $perpage      number of records to return per page
  71      * @param string  $search   a simple string to search for
  72      * @param bool $onlypublic  whether to return only public badges
  73      * @return array array containing warnings and the awarded badges
  74      * @since  Moodle 3.1
  75      * @throws moodle_exception
  76      */
  77     public static function get_user_badges($userid = 0, $courseid = 0, $page = 0, $perpage = 0, $search = '', $onlypublic = false) {
  78         global $CFG, $USER, $PAGE;
  79
  80         $warnings = array();
  81
  82         $params = array(
  83             'userid' => $userid,
  84             'courseid' => $courseid,
  85             'page' => $page,
  86             'perpage' => $perpage,
  87             'search' => $search,
  88             'onlypublic' => $onlypublic,
  89         );
  90         $params = self::validate_parameters(self::get_user_badges_parameters(), $params);
  91
  92         if (empty($CFG->enablebadges)) {
  93             throw new moodle_exception('badgesdisabled', 'badges');
  94         }
  95
  96         if (empty($CFG->badges_allowcoursebadges) && $params['courseid'] != 0) {
  97             throw new moodle_exception('coursebadgesdisabled', 'badges');
  98         }
  99
 100         // Default value for userid.
 101         if (empty($params['userid'])) {
 102             $params['userid'] = $USER->id;
 103         }
 104
 105         // Validate the user.
 106         $user = core_user::get_user($params['userid'], '*', MUST_EXIST);
 107         core_user::require_active_user($user);
 108
 109         $usercontext = context_user::instance($user->id);
 110         self::validate_context($usercontext);
 111
 112         if ($USER->id != $user->id) {
 113             require_capability('moodle/badges:viewotherbadges', $usercontext);
 114             // We are looking other user's badges, we must retrieve only public badges.
 115             $params['onlypublic'] = true;
 116         }
 117
 118         $userbadges = badges_get_user_badges($user->id, $params['courseid'], $params['page'], $params['perpage'], $params['search'],
 119                                                 $params['onlypublic']);
 120
 121         $result = array();
 122         $result['badges'] = array();
 123         $result['warnings'] = $warnings;
 124
 125         foreach ($userbadges as $badge) {
 126             $context = ($badge->type == BADGE_TYPE_SITE) ? context_system::instance() : context_course::instance($badge->courseid);
 127             $canconfiguredetails = has_capability('moodle/badges:configuredetails', $context);
 128
 129             // If the user is viewing another user's badge and doesn't have the right capability return only part of the data.
 130             if ($USER->id != $user->id and !$canconfiguredetails) {
 131                 $badge = (object) array(
 132                     'id' => $badge->id,
 133                     'name' => $badge->name,
 134                     'description' => $badge->description,
 135                     'issuername' => $badge->issuername,
 136                     'issuerurl' => $badge->issuerurl,
 137                     'issuercontact' => $badge->issuercontact,
 138                     'uniquehash' => $badge->uniquehash,
 139                     'dateissued' => $badge->dateissued,
 140                     'dateexpire' => $badge->dateexpire,
 141                     'version' => $badge->version,
 142                     'language' => $badge->language,
 143                     'imageauthorname' => $badge->imageauthorname,
 144                     'imageauthoremail' => $badge->imageauthoremail,
 145                     'imageauthorurl' => $badge->imageauthorurl,
 146                     'imagecaption' => $badge->imagecaption,
 147                 );
 148             }
 149
 150             // Create a badge instance to be able to get the endorsement and other info.
 151             $badgeinstance = new badge($badge->id);
 152             $endorsement = $badgeinstance->get_endorsement();
 153             $alignments = $badgeinstance->get_alignments();
 154             $relatedbadges = $badgeinstance->get_related_badges();
 155
 156             if (!$canconfiguredetails) {
 157                 // Return only the properties visible by the user.
 158
 159                 if (!empty($alignments)) {
 160                     foreach ($alignments as $alignment) {
 161                         unset($alignment->targetdescription);
 162                         unset($alignment->targetframework);
 163                         unset($alignment->targetcode);
 164                     }
 165                 }
 166
 167                 if (!empty($relatedbadges)) {
 168                     foreach ($relatedbadges as $relatedbadge) {
 169                         unset($relatedbadge->version);
 170                         unset($relatedbadge->language);
 171                         unset($relatedbadge->type);
 172                     }
 173                 }
 174             }
 175
 176             $related = array(
 177                 'context' => $context,
 178                 'endorsement' => $endorsement ? $endorsement : null,
 179                 'alignment' => $alignments,
 180                 'relatedbadges' => $relatedbadges,
 181             );
 182
 183             $exporter = new user_badge_exporter($badge, $related);
 184             $result['badges'][] = $exporter->export($PAGE->get_renderer('core'));
 185         }
 186
 187         return $result;
 188     }
 189
 190     /**
 191      * Describes the get_user_badges return value.
 192      *
 193      * @return external_single_structure
 194      * @since Moodle 3.1
 195      */
 196     public static function get_user_badges_returns() {
 197         return new external_single_structure(
 198             array(
 199                 'badges' => new external_multiple_structure(
 200                     user_badge_exporter::get_read_structure()
 201                 ),
 202                 'warnings' => new external_warnings(),
 203             )
 204         );
 205     }
 206 }