PHP core_user::is_real_user方法代码示例

 public function test_get_user()
 {
     global $CFG;
     $this->resetAfterTest(true);
     // Create user and try fetach it with api.
     $user = $this->getDataGenerator()->create_user();
     $this->assertEquals($user, core_user::get_user($user->id, '*', MUST_EXIST));
     // Test noreply user.
     $CFG->noreplyuserid = null;
     $noreplyuser = core_user::get_noreply_user();
     $this->assertEquals(1, $noreplyuser->emailstop);
     $this->assertFalse(core_user::is_real_user($noreplyuser->id));
     $this->assertEquals($CFG->noreplyaddress, $noreplyuser->email);
     $this->assertEquals(get_string('noreplyname'), $noreplyuser->firstname);
     // Set user as noreply user and make sure noreply propery is set.
     core_user::reset_internal_users();
     $CFG->noreplyuserid = $user->id;
     $noreplyuser = core_user::get_noreply_user();
     $this->assertEquals(1, $noreplyuser->emailstop);
     $this->assertTrue(core_user::is_real_user($noreplyuser->id));
     // Test support user.
     core_user::reset_internal_users();
     $CFG->supportemail = null;
     $CFG->noreplyuserid = null;
     $supportuser = core_user::get_support_user();
     $adminuser = get_admin();
     $this->assertEquals($adminuser, $supportuser);
     $this->assertTrue(core_user::is_real_user($supportuser->id));
     // When supportemail is set.
     core_user::reset_internal_users();
     $CFG->supportemail = 'test@support.moodle.test';
     $supportuser = core_user::get_support_user();
     $this->assertEquals(core_user::SUPPORT_USER, $supportuser->id);
     $this->assertFalse(core_user::is_real_user($supportuser->id));
     // Set user as support user and make sure noreply propery is set.
     core_user::reset_internal_users();
     $CFG->supportuserid = $user->id;
     $supportuser = core_user::get_support_user();
     $this->assertEquals($user, $supportuser);
     $this->assertTrue(core_user::is_real_user($supportuser->id));
 }

    $currentuser = false;
    //if we're looking at someone else's messages we need to lock/remove some UI elements
    $showactionlinks = false;
} else {
    $user1 = $USER;
}
unset($user1id);
$user2 = null;
if (!empty($user2id)) {
    $user2 = core_user::get_user($user2id);
    if (!$user2) {
        print_error('invaliduserid');
    }
}
unset($user2id);
$user2realuser = !empty($user2) && core_user::is_real_user($user2->id);
$showactionlinks = $showactionlinks && $user2realuser;
$systemcontext = context_system::instance();
if ($currentuser === false && !has_capability('moodle/site:readallmessages', $systemcontext)) {
    print_error('accessdenied', 'admin');
}
if (substr($viewing, 0, 7) == MESSAGE_VIEW_COURSE) {
    $courseid = intval(substr($viewing, 7));
    require_login($courseid);
    require_capability('moodle/course:viewparticipants', context_course::instance($courseid));
    $PAGE->set_pagelayout('incourse');
} else {
    $PAGE->set_pagelayout('standard');
    $PAGE->set_context(context_user::instance($user1->id));
}
if (!empty($user1->id) && $user1->id != $USER->id) {

 /**
  * Get messages function implementation.
  *
  * @since  2.8
  * @throws invalid_parameter_exception
  * @throws moodle_exception
  * @param  int      $useridto       the user id who received the message
  * @param  int      $useridfrom     the user id who send the message. -10 or -20 for no-reply or support user
  * @param  string   $type           type of message to return, expected values: notifications, conversations and both
  * @param  bool     $read           true for retreiving read messages, false for unread
  * @param  bool     $newestfirst    true for ordering by newest first, false for oldest first
  * @param  int      $limitfrom      limit from
  * @param  int      $limitnum       limit num
  * @return external_description
  */
 public static function get_messages($useridto, $useridfrom = 0, $type = 'both', $read = true, $newestfirst = true, $limitfrom = 0, $limitnum = 0)
 {
     global $CFG, $USER;
     $warnings = array();
     $params = array('useridto' => $useridto, 'useridfrom' => $useridfrom, 'type' => $type, 'read' => $read, 'newestfirst' => $newestfirst, 'limitfrom' => $limitfrom, 'limitnum' => $limitnum);
     $params = self::validate_parameters(self::get_messages_parameters(), $params);
     $context = context_system::instance();
     self::validate_context($context);
     $useridto = $params['useridto'];
     $useridfrom = $params['useridfrom'];
     $type = $params['type'];
     $read = $params['read'];
     $newestfirst = $params['newestfirst'];
     $limitfrom = $params['limitfrom'];
     $limitnum = $params['limitnum'];
     $allowedvalues = array('notifications', 'conversations', 'both');
     if (!in_array($type, $allowedvalues)) {
         throw new invalid_parameter_exception('Invalid value for type parameter (value: ' . $type . '),' . 'allowed values are: ' . implode(',', $allowedvalues));
     }
     // Check if private messaging between users is allowed.
     if (empty($CFG->messaging)) {
         // If we are retreiving only conversations, and messaging is disabled, throw an exception.
         if ($type == "conversations") {
             throw new moodle_exception('disabled', 'message');
         }
         if ($type == "both") {
             $warning = array();
             $warning['item'] = 'message';
             $warning['itemid'] = $USER->id;
             $warning['warningcode'] = '1';
             $warning['message'] = 'Private messages (conversations) are not enabled in this site.
                 Only notifications will be returned';
             $warnings[] = $warning;
         }
     }
     if (!empty($useridto)) {
         if (core_user::is_real_user($useridto)) {
             $userto = core_user::get_user($useridto, '*', MUST_EXIST);
         } else {
             throw new moodle_exception('invaliduser');
         }
     }
     if (!empty($useridfrom)) {
         // We use get_user here because the from user can be the noreply or support user.
         $userfrom = core_user::get_user($useridfrom, '*', MUST_EXIST);
     }
     // Check if the current user is the sender/receiver or just a privileged user.
     if ($useridto != $USER->id and $useridfrom != $USER->id and !has_capability('moodle/site:readallmessages', $context)) {
         throw new moodle_exception('accessdenied', 'admin');
     }
     // Which type of messages to retrieve.
     $notifications = -1;
     if ($type != 'both') {
         $notifications = $type == 'notifications' ? 1 : 0;
     }
     $orderdirection = $newestfirst ? 'DESC' : 'ASC';
     $sort = "mr.timecreated {$orderdirection}";
     if ($messages = message_get_messages($useridto, $useridfrom, $notifications, $read, $sort, $limitfrom, $limitnum)) {
         $canviewfullname = has_capability('moodle/site:viewfullnames', $context);
         // In some cases, we don't need to get the to/from user objects from the sql query.
         $userfromfullname = '';
         $usertofullname = '';
         // In this case, the useridto field is not empty, so we can get the user destinatary fullname from there.
         if (!empty($useridto)) {
             $usertofullname = fullname($userto, $canviewfullname);
             // The user from may or may not be filled.
             if (!empty($useridfrom)) {
                 $userfromfullname = fullname($userfrom, $canviewfullname);
             }
         } else {
             // If the useridto field is empty, the useridfrom must be filled.
             $userfromfullname = fullname($userfrom, $canviewfullname);
         }
         foreach ($messages as $mid => $message) {
             // Do not return deleted messages.
             if ($useridto == $USER->id and $message->timeusertodeleted or $useridfrom == $USER->id and $message->timeuserfromdeleted) {
                 unset($messages[$mid]);
                 continue;
             }
             // We need to get the user from the query.
             if (empty($userfromfullname)) {
                 // Check for non-reply and support users.
                 if (core_user::is_real_user($message->useridfrom)) {
                     $user = new stdClass();
                     $user = username_load_fields_from_object($user, $message, 'userfrom');
//.........这里部分代码省略.........

/**
 * Called when a message provider wants to send a message.
 * This functions checks the message recipient's message processor configuration then
 * sends the message to the configured processors
 *
 * Required parameters of the $eventdata object:
 *  component string component name. must exist in message_providers
 *  name string message type name. must exist in message_providers
 *  userfrom object|int the user sending the message
 *  userto object|int the message recipient
 *  subject string the message subject
 *  fullmessage string the full message in a given format
 *  fullmessageformat int the format if the full message (FORMAT_MOODLE, FORMAT_HTML, ..)
 *  fullmessagehtml string the full version (the message processor will choose with one to use)
 *  smallmessage string the small version of the message
 *
 * Optional parameters of the $eventdata object:
 *  notification bool should the message be considered as a notification rather than a personal message
 *  contexturl string if this is a notification then you can specify a url to view the event. For example the forum post the user is being notified of.
 *  contexturlname string the display text for contexturl
 *
 * Note: processor failure is is not reported as false return value,
 *       earlier versions did not do it consistently either.
 *
 * @todo MDL-55449 Drop support for stdClass in Moodle 3.6
 * @category message
 * @param \core\message\message $eventdata information about the message (component, userfrom, userto, ...)
 * @return mixed the integer ID of the new message or false if there was a problem with submitted data
 */
function message_send($eventdata) {
    global $CFG, $DB;

    // TODO MDL-55449 Drop support for stdClass in Moodle 3.6.
    if ($eventdata instanceof \stdClass) {
        if (!isset($eventdata->courseid)) {
            $eventdata->courseid = null;
        }

        debugging('eventdata as \stdClass is deprecated. Please use core\message\message instead.', DEBUG_DEVELOPER);
    }

    //new message ID to return
    $messageid = false;

    // Fetch default (site) preferences
    $defaultpreferences = get_message_output_default_preferences();
    $preferencebase = $eventdata->component.'_'.$eventdata->name;
    // If message provider is disabled then don't do any processing.
    if (!empty($defaultpreferences->{$preferencebase.'_disable'})) {
        return $messageid;
    }

    // By default a message is a notification. Only personal/private messages aren't notifications.
    if (!isset($eventdata->notification)) {
        $eventdata->notification = 1;
    }

    if (!is_object($eventdata->userto)) {
        $eventdata->userto = core_user::get_user($eventdata->userto);
    }
    if (!is_object($eventdata->userfrom)) {
        $eventdata->userfrom = core_user::get_user($eventdata->userfrom);
    }
    if (!$eventdata->userto) {
        debugging('Attempt to send msg to unknown user', DEBUG_NORMAL);
        return false;
    }
    if (!$eventdata->userfrom) {
        debugging('Attempt to send msg from unknown user', DEBUG_NORMAL);
        return false;
    }

    // Verify all necessary data fields are present.
    if (!isset($eventdata->userto->auth) or !isset($eventdata->userto->suspended)
            or !isset($eventdata->userto->deleted) or !isset($eventdata->userto->emailstop)) {

        debugging('Necessary properties missing in userto object, fetching full record', DEBUG_DEVELOPER);
        $eventdata->userto = core_user::get_user($eventdata->userto->id);
    }

    $usertoisrealuser = (core_user::is_real_user($eventdata->userto->id) != false);
    // If recipient is internal user (noreply user), and emailstop is set then don't send any msg.
    if (!$usertoisrealuser && !empty($eventdata->userto->emailstop)) {
        debugging('Attempt to send msg to internal (noreply) user', DEBUG_NORMAL);
        return false;
    }

    //after how long inactive should the user be considered logged off?
    if (isset($CFG->block_online_users_timetosee)) {
        $timetoshowusers = $CFG->block_online_users_timetosee * 60;
    } else {
        $timetoshowusers = 300;//5 minutes
    }

    // Work out if the user is logged in or not
    if (!empty($eventdata->userto->lastaccess) && (time()-$timetoshowusers) < $eventdata->userto->lastaccess) {
        $userstate = 'loggedin';
    } else {
        $userstate = 'loggedoff';
    }
//.........这里部分代码省略.........

 *
 * @package    core_user
 * @copyright  2015 Frédéric Massart - FMCorz.net
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
require_once __DIR__ . '/../config.php';
require_once $CFG->libdir . '/navigationlib.php';
require_login(null, false);
if (isguestuser()) {
    throw new require_login_exception('Guests are not allowed here.');
}
$userid = optional_param('userid', $USER->id, PARAM_INT);
$currentuser = $userid == $USER->id;
// Check that the user is a valid user.
$user = core_user::get_user($userid);
if (!$user || !core_user::is_real_user($userid)) {
    throw new moodle_exception('invaliduser', 'error');
}
$PAGE->set_context(context_user::instance($userid));
$PAGE->set_url('/user/preferences.php', array('userid' => $userid));
$PAGE->set_pagelayout('admin');
$PAGE->set_pagetype('user-preferences');
$PAGE->set_title(get_string('preferences'));
$PAGE->set_heading(fullname($user));
if (!$currentuser) {
    $PAGE->navigation->extend_for_user($user);
    // Need to check that settings exist.
    if ($settings = $PAGE->settingsnav->find('userviewingsettings' . $user->id, null)) {
        $settings->make_active();
    }
    $url = new moodle_url('/user/preferences.php', array('userid' => $userid));

/**
 * Print a row of contactlist displaying user picture, messages waiting and
 * block links etc
 *
 * @param object $contact contact object containing all fields required for $OUTPUT->user_picture()
 * @param bool $incontactlist is the user a contact of ours?
 * @param bool $isblocked is the user blocked?
 * @param string $selectcontacturl the url to send the user to when a contact's name is clicked
 * @param bool $showactionlinks display action links next to the other users (add contact, block user etc)
 * @param object $selecteduser the user the current user is viewing (if any). They will be highlighted.
 * @return void
 */
function message_print_contactlist_user($contact, $incontactlist = true, $isblocked = false, $selectcontacturl = null, $showactionlinks = true, $selecteduser=null) {
    global $OUTPUT, $USER, $COURSE;
    $fullname  = fullname($contact);
    $fullnamelink  = $fullname;
    $output = '';

    $linkclass = '';
    if (!empty($selecteduser) && $contact->id == $selecteduser->id) {
        $linkclass = 'messageselecteduser';
    }

    // Are there any unread messages for this contact?
    if ($contact->messagecount > 0 ){
        $fullnamelink = '<strong>'.$fullnamelink.' ('.$contact->messagecount.')</strong>';
    }

    $strcontact = $strblock = $strhistory = null;

    if ($showactionlinks) {
        // Show block and delete links if user is real user.
        if (core_user::is_real_user($contact->id)) {
            $strcontact = message_get_contact_add_remove_link($incontactlist, $isblocked, $contact);
            $strblock   = message_get_contact_block_link($incontactlist, $isblocked, $contact);
        }
        $strhistory = message_history_link($USER->id, $contact->id, true, '', '', 'icon');
    }

    $output .= html_writer::start_tag('div', array('class' => 'pix'));
    $output .= $OUTPUT->user_picture($contact, array('size' => 20, 'courseid' => $COURSE->id));
    $output .= html_writer::end_tag('div');

    $popupoptions = array(
            'height' => MESSAGE_DISCUSSION_HEIGHT,
            'width' => MESSAGE_DISCUSSION_WIDTH,
            'menubar' => false,
            'location' => false,
            'status' => true,
            'scrollbars' => true,
            'resizable' => true);

    $link = $action = null;
    if (!empty($selectcontacturl)) {
        $link = new moodle_url($selectcontacturl.'&user2='.$contact->id);
    } else {
        //can $selectcontacturl be removed and maybe the be removed and hardcoded?
        $link = new moodle_url("/message/index.php?id=$contact->id");
        $action = new popup_action('click', $link, "message_$contact->id", $popupoptions);
    }


    if (strlen($strcontact . $strblock . $strhistory) > 0) {
        $output .= html_writer::tag('div', $strcontact . $strblock . $strhistory, array('class' => 'link'));

        $output .= html_writer::start_tag('div', array('class' => 'contact'));
        $linkattr = array('class' => $linkclass, 'title' => get_string('sendmessageto', 'message', $fullname));
        $output .= $OUTPUT->action_link($link, $fullnamelink, $action, $linkattr);
        $output .= html_writer::end_tag('div');
    } else {
        $output .= html_writer::start_tag('div', array('class' => 'contact nolinks'));
        $linkattr = array('class' => $linkclass, 'title' => get_string('sendmessageto', 'message', $fullname));
        $output .= $OUTPUT->action_link($link, $fullnamelink, $action, $linkattr);
        $output .= html_writer::end_tag('div');
    }

    return $output;
}

/**
 * Called when a message provider wants to send a message.
 * This functions checks the message recipient's message processor configuration then
 * sends the message to the configured processors
 *
 * Required parameters of the $eventdata object:
 *  component string component name. must exist in message_providers
 *  name string message type name. must exist in message_providers
 *  userfrom object|int the user sending the message
 *  userto object|int the message recipient
 *  subject string the message subject
 *  fullmessage string the full message in a given format
 *  fullmessageformat int the format if the full message (FORMAT_MOODLE, FORMAT_HTML, ..)
 *  fullmessagehtml string the full version (the message processor will choose with one to use)
 *  smallmessage string the small version of the message
 *
 * Optional parameters of the $eventdata object:
 *  notification bool should the message be considered as a notification rather than a personal message
 *  contexturl string if this is a notification then you can specify a url to view the event. For example the forum post the user is being notified of.
 *  contexturlname string the display text for contexturl
 *
 * @category message
 * @param object $eventdata information about the message (component, userfrom, userto, ...)
 * @return mixed the integer ID of the new message or false if there was a problem with a processor
 */
function message_send($eventdata)
{
    global $CFG, $DB;
    //new message ID to return
    $messageid = false;
    // Fetch default (site) preferences
    $defaultpreferences = get_message_output_default_preferences();
    $preferencebase = $eventdata->component . '_' . $eventdata->name;
    // If message provider is disabled then don't do any processing.
    if (!empty($defaultpreferences->{$preferencebase . '_disable'})) {
        return $messageid;
    }
    //TODO: we need to solve problems with database transactions here somehow, for now we just prevent transactions - sorry
    $DB->transactions_forbidden();
    // By default a message is a notification. Only personal/private messages aren't notifications.
    if (!isset($eventdata->notification)) {
        $eventdata->notification = 1;
    }
    if (is_number($eventdata->userto)) {
        $eventdata->userto = core_user::get_user($eventdata->userto);
    }
    if (is_int($eventdata->userfrom)) {
        $eventdata->userfrom = core_user::get_user($eventdata->userfrom);
    }
    $usertoisrealuser = core_user::is_real_user($eventdata->userto->id) != false;
    // If recipient is internal user (noreply user), and emailstop is set then don't send any msg.
    if (!$usertoisrealuser && !empty($eventdata->userto->emailstop)) {
        debugging('Attempt to send msg to internal (noreply) user', DEBUG_NORMAL);
        return false;
    }
    if (!isset($eventdata->userto->auth) or !isset($eventdata->userto->suspended) or !isset($eventdata->userto->deleted)) {
        $eventdata->userto = core_user::get_user($eventdata->userto->id);
    }
    //after how long inactive should the user be considered logged off?
    if (isset($CFG->block_online_users_timetosee)) {
        $timetoshowusers = $CFG->block_online_users_timetosee * 60;
    } else {
        $timetoshowusers = 300;
        //5 minutes
    }
    // Work out if the user is logged in or not
    if (!empty($eventdata->userto->lastaccess) && time() - $timetoshowusers < $eventdata->userto->lastaccess) {
        $userstate = 'loggedin';
    } else {
        $userstate = 'loggedoff';
    }
    // Create the message object
    $savemessage = new stdClass();
    $savemessage->useridfrom = $eventdata->userfrom->id;
    $savemessage->useridto = $eventdata->userto->id;
    $savemessage->subject = $eventdata->subject;
    $savemessage->fullmessage = $eventdata->fullmessage;
    $savemessage->fullmessageformat = $eventdata->fullmessageformat;
    $savemessage->fullmessagehtml = $eventdata->fullmessagehtml;
    $savemessage->smallmessage = $eventdata->smallmessage;
    $savemessage->notification = $eventdata->notification;
    if (!empty($eventdata->contexturl)) {
        $savemessage->contexturl = $eventdata->contexturl;
    } else {
        $savemessage->contexturl = null;
    }
    if (!empty($eventdata->contexturlname)) {
        $savemessage->contexturlname = $eventdata->contexturlname;
    } else {
        $savemessage->contexturlname = null;
    }
    $savemessage->timecreated = time();
    if (PHPUNIT_TEST and class_exists('phpunit_util')) {
        // Add some more tests to make sure the normal code can actually work.
        $componentdir = core_component::get_component_directory($eventdata->component);
        if (!$componentdir or !is_dir($componentdir)) {
            throw new coding_exception('Invalid component specified in message-send(): ' . $eventdata->component);
        }
        if (!file_exists("{$componentdir}/db/messages.php")) {
            throw new coding_exception("{$eventdata->component} does not contain db/messages.php necessary for message_send()");
//.........这里部分代码省略.........

 /**
  * Message someone about something.
  *
  * @param stdClass $userfrom
  * @param stdClass $userto
  * @param string $messagetype
  * @param string $eventtype
  * @param int $updatetime
  * @return void
  */
 public function send_notification($userfrom, $userto, $messagetype, $eventtype, $updatetime) {
     global $USER;
     $userid = core_user::is_real_user($userfrom->id) ? $userfrom->id : $USER->id;
     $uniqueid = $this->get_uniqueid_for_user($userid);
     self::send_assignment_notification($userfrom,
                                        $userto,
                                        $messagetype,
                                        $eventtype,
                                        $updatetime,
                                        $this->get_course_module(),
                                        $this->get_context(),
                                        $this->get_course(),
                                        $this->get_module_name(),
                                        $this->get_instance()->name,
                                        $this->is_blind_marking(),
                                        $uniqueid);
 }

 /**
  * Return legacy data for add_to_log().
  *
  * @return array
  */
 protected function get_legacy_logdata()
 {
     // The add_to_log function was only ever called when we sent a message from one user to another. We do not want
     // to return the legacy log data if we are sending a system message, so check that the userid is valid.
     if (\core_user::is_real_user($this->userid)) {
         return array(SITEID, 'message', 'write', 'index.php?user=' . $this->userid . '&id=' . $this->relateduserid . '&history=1#m' . $this->other['messageid'], $this->userid);
     }
     return null;
 }

 /**
  * Validate the action user ID.
  *
  * @param  int $value A user ID.
  * @return true|lang_string
  */
 protected function validate_actionuserid($value)
 {
     if ($value !== null && !\core_user::is_real_user($value)) {
         return new lang_string('invaliddata', 'error');
     }
     return true;
 }

 /**
  * Mark all notifications as read function.
  *
  * @since  3.2
  * @throws invalid_parameter_exception
  * @throws moodle_exception
  * @param  int      $useridto       the user id who received the message
  * @param  int      $useridfrom     the user id who send the message. -10 or -20 for no-reply or support user
  * @return external_description
  */
 public static function mark_all_messages_as_read($useridto, $useridfrom)
 {
     global $USER, $CFG;
     // Check if messaging is enabled.
     if (empty($CFG->messaging)) {
         throw new moodle_exception('disabled', 'message');
     }
     $params = self::validate_parameters(self::mark_all_messages_as_read_parameters(), array('useridto' => $useridto, 'useridfrom' => $useridfrom));
     $context = context_system::instance();
     self::validate_context($context);
     $useridto = $params['useridto'];
     $useridfrom = $params['useridfrom'];
     if (!empty($useridto)) {
         if (core_user::is_real_user($useridto)) {
             $userto = core_user::get_user($useridto, '*', MUST_EXIST);
         } else {
             throw new moodle_exception('invaliduser');
         }
     }
     if (!empty($useridfrom)) {
         // We use get_user here because the from user can be the noreply or support user.
         $userfrom = core_user::get_user($useridfrom, '*', MUST_EXIST);
     }
     // Check if the current user is the sender/receiver or just a privileged user.
     if ($useridto != $USER->id and $useridfrom != $USER->id and !has_capability('moodle/site:deleteanymessage', $context)) {
         throw new moodle_exception('accessdenied', 'admin');
     }
     \core_message\api::mark_all_read_for_user($useridto, $useridfrom, MESSAGE_TYPE_MESSAGE);
     return true;
 }

/**
 * Print information on a user. Used when printing search results.
 *
 * @param object/bool $user the user to display or false if you just want $USER
 * @param bool $iscontact is the user being displayed a contact?
 * @param bool $isblocked is the user being displayed blocked?
 * @param bool $includeicontext include text next to the action icons?
 * @return void
 */
function message_print_user($user = false, $iscontact = false, $isblocked = false, $includeicontext = false)
{
    global $USER, $OUTPUT;
    $userpictureparams = array('size' => 20, 'courseid' => SITEID);
    if ($user === false) {
        echo $OUTPUT->user_picture($USER, $userpictureparams);
    } else {
        if (core_user::is_real_user($user->id)) {
            // If not real user, then don't show any links.
            $userpictureparams['link'] = false;
            echo $OUTPUT->user_picture($USER, $userpictureparams);
            echo fullname($user);
        } else {
            echo $OUTPUT->user_picture($user, $userpictureparams);
            $link = new moodle_url("/message/index.php?id={$user->id}");
            echo $OUTPUT->action_link($link, fullname($user), null, array('title' => get_string('sendmessageto', 'message', fullname($user))));
            $return = false;
            $script = null;
            if ($iscontact) {
                message_contact_link($user->id, 'remove', $return, $script, $includeicontext);
            } else {
                message_contact_link($user->id, 'add', $return, $script, $includeicontext);
            }
            if ($isblocked) {
                message_contact_link($user->id, 'unblock', $return, $script, $includeicontext);
            } else {
                message_contact_link($user->id, 'block', $return, $script, $includeicontext);
            }
        }
    }
}

 /**
  * Get unread notification count function.
  *
  * @since  3.2
  * @throws invalid_parameter_exception
  * @throws moodle_exception
  * @param  int      $useridto       the user id who received the message
  * @return external_description
  */
 public static function get_unread_popup_notification_count($useridto)
 {
     global $USER;
     $params = self::validate_parameters(self::get_unread_popup_notification_count_parameters(), array('useridto' => $useridto));
     $context = context_system::instance();
     self::validate_context($context);
     $useridto = $params['useridto'];
     if (!empty($useridto)) {
         if (core_user::is_real_user($useridto)) {
             $userto = core_user::get_user($useridto, '*', MUST_EXIST);
         } else {
             throw new moodle_exception('invaliduser');
         }
     }
     // Check if the current user is the sender/receiver or just a privileged user.
     if ($useridto != $USER->id and !has_capability('moodle/site:readallmessages', $context)) {
         throw new moodle_exception('accessdenied', 'admin');
     }
     return \message_popup\api::count_unread_popup_notifications($useridto);
 }