Gazelle/classes/users.class.php

<?php
class Users
{
    /**
     * Get $Classes (list of classes keyed by ID) and $ClassLevels
     *    (list of classes keyed by level)
     * @return array ($Classes, $ClassLevels)
     */
    public static function get_classes()
    {
        global $Debug;
        // Get permissions
        list($Classes, $ClassLevels) = G::$Cache->get_value('classes');
        if (!$Classes || !$ClassLevels) {
            $QueryID = G::$DB->get_query_id();
            G::$DB->query('
        SELECT ID, Name, Abbreviation, Level, Secondary
        FROM permissions
        ORDER BY Level');
            $Classes = G::$DB->to_array('ID');
            $ClassLevels = G::$DB->to_array('Level');
            G::$DB->set_query_id($QueryID);
            G::$Cache->cache_value('classes', [$Classes, $ClassLevels], 0);
        }
        $Debug->set_flag('Loaded permissions');

        return [$Classes, $ClassLevels];
    }


    /**
     * Get user info, is used for the current user and usernames all over the site.
     *
     * @param $UserID int   The UserID to get info for
     * @return array with the following keys:
     *  int     ID
     *  string  Username
     *  int     PermissionID
     *  array   Paranoia - $Paranoia array sent to paranoia.class
     *  boolean Artist
     *  boolean Donor
     *  string  Warned - When their warning expires in international time format
     *  string  Avatar - URL
     *  boolean Enabled
     *  string  Title
     *  string  CatchupTime - When they last caught up on forums
     *  boolean Visible - If false, they don't show up on peer lists
     *  array   ExtraClasses - Secondary classes.
     *  int     EffectiveClass - the highest level of their main and secondary classes
     *  array   Badges - list of all the user's badges of the form BadgeID => Displayed
     */
    public static function user_info($UserID)
    {
        global $Classes;
        $UserInfo = G::$Cache->get_value("user_info_$UserID");
        // the !isset($UserInfo['Paranoia']) can be removed after a transition period
        if (empty($UserInfo) || empty($UserInfo['ID']) || !isset($UserInfo['Paranoia']) || empty($UserInfo['Class'])) {
            $OldQueryID = G::$DB->get_query_id();

            G::$DB->query("
        SELECT
          m.ID,
          m.Username,
          m.PermissionID,
          m.Paranoia,
          i.Artist,
          i.Donor,
          i.Warned,
          i.Avatar,
          m.Enabled,
          m.Title,
          i.CatchupTime,
          m.Visible,
          la.Type AS LockedAccount,
          GROUP_CONCAT(ul.PermissionID SEPARATOR ',') AS Levels
        FROM users_main AS m
          INNER JOIN users_info AS i ON i.UserID = m.ID
          LEFT JOIN locked_accounts AS la ON la.UserID = m.ID
          LEFT JOIN users_levels AS ul ON ul.UserID = m.ID
        WHERE m.ID = '$UserID'
        GROUP BY m.ID");

            if (!G::$DB->has_results()) { // Deleted user, maybe?
                $UserInfo = [
                    'ID'           => $UserID,
                    'Username'     => '',
                    'PermissionID' => 0,
                    'Paranoia'     => [],
                    'Artist'       => false,
                    'Donor'        => false,
                    'Warned'       => null,
                    'Avatar'       => '',
                    'Enabled'      => 0,
                    'Title'        => '',
                    'CatchupTime'  => 0,
                    'Visible'      => '1',
                    'Levels'       => '',
                    'Class'        => 0
                  ];
            } else {
                $UserInfo = G::$DB->next_record(MYSQLI_ASSOC, ['Paranoia', 'Title']);
                $UserInfo['CatchupTime'] = strtotime($UserInfo['CatchupTime']);
                if (!is_array($UserInfo['Paranoia'])) {
                    $UserInfo['Paranoia'] = json_decode($UserInfo['Paranoia'], true);
                }
                if (!$UserInfo['Paranoia']) {
                    $UserInfo['Paranoia'] = [];
                }
                $UserInfo['Class'] = $Classes[$UserInfo['PermissionID']]['Level'];

                G::$DB->query("
          SELECT BadgeID, Displayed
          FROM users_badges
          WHERE UserID = ".$UserID);

                $Badges = [];
                if (G::$DB->has_results()) {
                    while (list($BadgeID, $Displayed) = G::$DB->next_record()) {
                        $Badges[$BadgeID] = $Displayed;
                    }
                }
                $UserInfo['Badges'] = $Badges;
            }

            if (isset($UserInfo['LockedAccount']) && $UserInfo['LockedAccount'] == "") {
                unset($UserInfo['LockedAccount']);
            }

            if (!empty($UserInfo['Levels'])) {
                $UserInfo['ExtraClasses'] = array_fill_keys(explode(',', $UserInfo['Levels']), 1);
            } else {
                $UserInfo['ExtraClasses'] = [];
            }
            unset($UserInfo['Levels']);
            $EffectiveClass = $UserInfo['Class'];
            foreach ($UserInfo['ExtraClasses'] as $Class => $Val) {
                $EffectiveClass = max($EffectiveClass, $Classes[$Class]['Level']);
            }
            $UserInfo['EffectiveClass'] = $EffectiveClass;

            G::$Cache->cache_value("user_info_$UserID", $UserInfo, 2592000);
            G::$DB->set_query_id($OldQueryID);
        }
        if (strtotime($UserInfo['Warned']) < time()) {
            $UserInfo['Warned'] = null;
            G::$Cache->cache_value("user_info_$UserID", $UserInfo, 2592000);
        }

        return $UserInfo;
    }

    /**
     * Gets the heavy user info
     * Only used for current user
     *
     * @param $UserID The userid to get the information for
     * @return fetched heavy info.
     *    Just read the goddamn code, I don't have time to comment this shit.
     */
    public static function user_heavy_info($UserID)
    {
        $HeavyInfo = G::$Cache->get_value("user_info_heavy_$UserID");
        if (empty($HeavyInfo)) {
            $QueryID = G::$DB->get_query_id();
            G::$DB->query("
        SELECT
          m.Invites,
          m.torrent_pass,
          m.IP,
          m.CustomPermissions,
          m.can_leech AS CanLeech,
          i.AuthKey,
          i.RatioWatchEnds,
          i.RatioWatchDownload,
          i.StyleID,
          i.StyleURL,
          i.DisableInvites,
          i.DisablePosting,
          i.DisableUpload,
          i.DisableWiki,
          i.DisableAvatar,
          i.DisablePM,
          i.DisablePoints,
          i.DisablePromotion,
          i.DisableRequests,
          i.DisableForums,
          i.DisableTagging,
          i.SiteOptions,
          i.LastReadNews,
          i.LastReadBlog,
          i.RestrictedForums,
          i.PermittedForums,
          m.FLTokens,
          m.BonusPoints,
          m.HnR,
          m.PermissionID
        FROM users_main AS m
          INNER JOIN users_info AS i ON i.UserID = m.ID
        WHERE m.ID = '$UserID'");
            $HeavyInfo = G::$DB->next_record(MYSQLI_ASSOC, ['CustomPermissions', 'SiteOptions']);

            $HeavyInfo['CustomPermissions'] = [];
            if (!empty($HeavyInfo['CustomPermissions'])) {
                $HeavyInfo['CustomPermissions'] = json_decode($HeavyInfo['CustomPermissions'], true);
            }

            $RestrictedForums = [];
            if (!empty($HeavyInfo['RestrictedForums'])) {
                $RestrictedForums = array_map('trim', explode(',', $HeavyInfo['RestrictedForums']));
            }
            unset($HeavyInfo['RestrictedForums']);

            $PermittedForums = [];
            if (!empty($HeavyInfo['PermittedForums'])) {
                $PermittedForums = array_map('trim', explode(',', $HeavyInfo['PermittedForums']));
            }
            unset($HeavyInfo['PermittedForums']);

            G::$DB->query("
        SELECT PermissionID
        FROM users_levels
        WHERE UserID = $UserID");
            $PermIDs = G::$DB->collect('PermissionID');
            foreach ($PermIDs as $PermID) {
                $Perms = Permissions::get_permissions($PermID);
                if (!empty($Perms['PermittedForums'])) {
                    $PermittedForums = array_merge($PermittedForums, array_map('trim', explode(',', $Perms['PermittedForums'])));
                }
            }
            $Perms = Permissions::get_permissions($HeavyInfo['PermissionID']);
            unset($HeavyInfo['PermissionID']);
            if (!empty($Perms['PermittedForums'])) {
                $PermittedForums = array_merge($PermittedForums, array_map('trim', explode(',', $Perms['PermittedForums'])));
            }

            $HeavyInfo['CustomForums'] = null;
            if (!empty($PermittedForums) || !empty($RestrictedForums)) {
                $HeavyInfo['CustomForums'] = [];
                foreach ($RestrictedForums as $ForumID) {
                    $HeavyInfo['CustomForums'][$ForumID] = 0;
                }
                foreach ($PermittedForums as $ForumID) {
                    $HeavyInfo['CustomForums'][$ForumID] = 1;
                }
            }
            if (isset($HeavyInfo['CustomForums'][''])) {
                unset($HeavyInfo['CustomForums']['']);
            }

            $HeavyInfo['SiteOptions'] = json_decode($HeavyInfo['SiteOptions'], true);
            if (!empty($HeavyInfo['SiteOptions'])) {
                $HeavyInfo = array_merge($HeavyInfo, $HeavyInfo['SiteOptions']);
            }
            unset($HeavyInfo['SiteOptions']);

            G::$DB->set_query_id($QueryID);

            G::$Cache->cache_value("user_info_heavy_$UserID", $HeavyInfo, 0);
        }
        return $HeavyInfo;
    }

    /**
     * Updates the site options in the database
     *
     * @param int $UserID the UserID to set the options for
     * @param array $NewOptions the new options to set
     * @return false if $NewOptions is empty, true otherwise
     */
    public static function update_site_options($UserID, $NewOptions)
    {
        if (!is_number($UserID)) {
            error(0);
        }
        if (empty($NewOptions)) {
            return false;
        }

        $QueryID = G::$DB->get_query_id();

        // Get SiteOptions
        G::$DB->query("
      SELECT SiteOptions
      FROM users_info
      WHERE UserID = $UserID");
        list($SiteOptions) = G::$DB->next_record(MYSQLI_NUM, false);
        $SiteOptions = json_decode($SiteOptions, true);

        // Get HeavyInfo
        $HeavyInfo = Users::user_heavy_info($UserID);

        // Insert new/replace old options
        $SiteOptions = array_merge($SiteOptions, $NewOptions);
        $HeavyInfo = array_merge($HeavyInfo, $NewOptions);

        // Update DB
        G::$DB->query("
      UPDATE users_info
      SET SiteOptions = '".db_string(json_encode($SiteOptions, true))."'
      WHERE UserID = $UserID");
        G::$DB->set_query_id($QueryID);

        // Update cache
        G::$Cache->cache_value("user_info_heavy_$UserID", $HeavyInfo, 0);

        // Update G::$LoggedUser if the options are changed for the current
        if (G::$LoggedUser['ID'] == $UserID) {
            G::$LoggedUser = array_merge(G::$LoggedUser, $NewOptions);
            G::$LoggedUser['ID'] = $UserID; // We don't want to allow userid switching
        }
        return true;
    }

    /**
     * Generate a random string
     *
     * @param Length
     * @return random alphanumeric string
     */
    public static function make_secret($Length = 32)
    {
        $Secret = '';
        $Chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
        for ($i = 0; $i < $Length; $i++) {
            $Secret .= $Chars[random_int(0, strlen($Chars)-1)];
        }
        return str_shuffle($Secret);
    }

    /**
     * Verify a password against a password hash
     *
     * @param $Password password
     * @param $Hash password hash
     * @return true on correct password
     */
    public static function check_password($Password, $Hash)
    {
        if (!$Password || !$Hash) {
            return false;
        }
        return password_verify(str_replace("\0", "", hash("sha512", $Password, true)), $Hash);
    }

    /**
     * Create salted hash for a given string
     *
     * @param $Str string to hash
     * @return salted hash
     */
    public static function make_sec_hash($Str)
    {
        return password_hash(str_replace("\0", "", hash("sha512", $Str, true)), PASSWORD_DEFAULT);
    }

    /**
     * Returns a username string for display
     *
     * @param int $UserID
     * @param boolean $Badges whether or not badges (donor, warned, enabled) should be shown
     * @param boolean $IsWarned
     * @param boolean $IsEnabled
     * @param boolean $Class whether or not to show the class
     * @param boolean $Title whether or not to show the title
     * @param boolean $IsDonorForum for displaying donor forum honorific prefixes and suffixes
     * @return HTML formatted username
     */
    public static function format_username($UserID, $Badges = false, $IsWarned = true, $IsEnabled = true, $Class = false, $Title = false, $IsDonorForum = false)
    {
        global $Classes;

        if ($UserID == 0) {
            return 'System';
        }

        $UserInfo = self::user_info($UserID);
        if ($UserInfo['Username'] == '') {
            return "Unknown [$UserID]";
        }

        $Str = '';

        $Username = $UserInfo['Username'];
        $Paranoia = $UserInfo['Paranoia'];

        if ($UserInfo['Class'] < $Classes[MOD]['Level']) {
            $OverrideParanoia = check_perms('users_override_paranoia', $UserInfo['Class']);
        } else {
            // Don't override paranoia for mods who don't want to show their donor heart
            $OverrideParanoia = false;
        }
        $ShowDonorIcon = (!in_array('hide_donor_heart', $Paranoia) || $OverrideParanoia);

        if ($IsDonorForum) {
            list($Prefix, $Suffix, $HasComma) = Donations::get_titles($UserID);
            $Username = "$Prefix $Username" . ($HasComma ? ', ' : ' ') . "$Suffix ";
        }

        if ($Title) {
            $Str .= "<strong><a href=\"user.php?id=$UserID\">$Username</a></strong>";
        } else {
            $Str .= "<a href=\"user.php?id=$UserID\">$Username</a>";
        }
        if ($Badges) {
            $DonorRank = Donations::get_rank($UserID);
            if ($DonorRank == 0 && $UserInfo['Donor'] == 1) {
                $DonorRank = 1;
            }
            if ($ShowDonorIcon && $DonorRank > 0) {
                $IconLink = 'donate.php';
                $IconImage = 'donor.png';
                $IconText = 'Donor';
                $DonorHeart = $DonorRank;
                $SpecialRank = Donations::get_special_rank($UserID);
                $EnabledRewards = Donations::get_enabled_rewards($UserID);
                $DonorRewards = Donations::get_rewards($UserID);
                if ($EnabledRewards['HasDonorIconMouseOverText'] && !empty($DonorRewards['IconMouseOverText'])) {
                    $IconText = display_str($DonorRewards['IconMouseOverText']);
                }
                if ($EnabledRewards['HasDonorIconLink'] && !empty($DonorRewards['CustomIconLink'])) {
                    $IconLink = display_str($DonorRewards['CustomIconLink']);
                }
                if ($EnabledRewards['HasCustomDonorIcon'] && !empty($DonorRewards['CustomIcon'])) {
                    $IconImage = ImageTools::process($DonorRewards['CustomIcon']);
                } else {
                    if ($SpecialRank === MAX_SPECIAL_RANK) {
                        $DonorHeart = 6;
                    } elseif ($DonorRank === 5) {
                        $DonorHeart = 4; // Two points between rank 4 and 5
                    } elseif ($DonorRank >= MAX_RANK) {
                        $DonorHeart = 5;
                    }
                    if ($DonorHeart === 1) {
                        $IconImage = STATIC_SERVER . 'common/symbols/donor.png';
                    } else {
                        $IconImage = STATIC_SERVER . "common/symbols/donor_{$DonorHeart}.png";
                    }
                }
                $Str .= "<a target=\"_blank\" href=\"$IconLink\"><img class=\"donor_icon tooltip\" src=\"$IconImage\" alt=\"$IconText\" title=\"$IconText\" /></a>";
            }
            $Str .= Badges::display_badges(Badges::get_displayed_badges($UserID), true);
        }

        $Str .= ($IsWarned && $UserInfo['Warned']) ? '<a href="wiki.php?action=article&amp;name=warnings"'
          . '><img src="'.STATIC_SERVER.'common/symbols/warned.png" alt="Warned" title="Warned'
          . (G::$LoggedUser['ID'] === $UserID ? ' - Expires ' . date('Y-m-d H:i', strtotime($UserInfo['Warned'])) : '')
          . '" class="tooltip" /></a>' : '';
        $Str .= ($IsEnabled && $UserInfo['Enabled'] == 2) ? '<a href="rules.php"><img src="'.STATIC_SERVER.'common/symbols/disabled.png" alt="Banned" title="Disabled" class="tooltip" /></a>' : '';

        if ($Class) {
            foreach (array_keys($UserInfo['ExtraClasses']) as $ExtraClass) {
                $Str .= ' ['.Users::make_class_abbrev_string($ExtraClass).']';
            }
            if ($Title) {
                $Str .= ' <strong>('.Users::make_class_string($UserInfo['PermissionID']).')</strong>';
            } else {
                $Str .= ' ('.Users::make_class_string($UserInfo['PermissionID']).')';
            }
        }

        if ($Title) {
            // Image proxy CTs
            if (check_perms('site_proxy_images') && !empty($UserInfo['Title'])) {
                $UserInfo['Title'] = preg_replace_callback(
                    '~src=("?)(http.+?)(["\s>])~',
                    function ($Matches) {
                        return 'src=' . $Matches[1] . ImageTools::process($Matches[2]) . $Matches[3];
                    },
                    $UserInfo['Title']
                );
            }

            if ($UserInfo['Title']) {
                $Str .= ' <span class="user_title">('.$UserInfo['Title'].')</span>';
            }
        }
        return $Str;
    }

    /**
     * Given a class ID, return its name.
     *
     * @param int $ClassID
     * @return string name
     */
    public static function make_class_string($ClassID)
    {
        global $Classes;
        return $Classes[$ClassID]['Name'];
    }

    public static function make_class_abbrev_string($ClassID)
    {
        global $Classes;
        return '<abbr title="'.$Classes[$ClassID]['Name'].'">'.$Classes[$ClassID]['Abbreviation'].'</abbr>';
    }

    /**
     * Returns an array with User Bookmark data: group IDs, collage data, torrent data
     * @param string|int $UserID
     * @return array Group IDs, Bookmark Data, Torrent List
     */
    public static function get_bookmarks($UserID)
    {
        $UserID = (int)$UserID;

        if (($Data = G::$Cache->get_value("bookmarks_group_ids_$UserID"))) {
            list($GroupIDs, $BookmarkData) = $Data;
        } else {
            $QueryID = G::$DB->get_query_id();
            G::$DB->query("
        SELECT GroupID, Sort, `Time`
        FROM bookmarks_torrents
        WHERE UserID = $UserID
        ORDER BY Sort, `Time` ASC");
            $GroupIDs = G::$DB->collect('GroupID');
            $BookmarkData = G::$DB->to_array('GroupID', MYSQLI_ASSOC);
            G::$DB->set_query_id($QueryID);
            G::$Cache->cache_value("bookmarks_group_ids_$UserID", [$GroupIDs, $BookmarkData], 3600);
        }

        $TorrentList = Torrents::get_groups($GroupIDs);

        return [$GroupIDs, $BookmarkData, $TorrentList];
    }

    /**
     * Generate HTML for a user's avatar or just return the avatar URL
     * @param unknown $Avatar
     * @param unknown $UserID
     * @param unknown $Username
     * @param unknown $Setting
     * @param number $Size
     * @param string $ReturnHTML
     * @return string
     */
    public static function show_avatar($Avatar, $UserID, $Username, $Setting, $Size = 150, $ReturnHTML = true)
    {
        $Avatar = ImageTools::process($Avatar, 'avatar');
        $Style = 'style="max-height: 400px;"';
        $AvatarMouseOverText = '';
        $SecondAvatar = '';
        $Class = 'class="double_avatar"';
        $EnabledRewards = Donations::get_enabled_rewards($UserID);

        if ($EnabledRewards['HasAvatarMouseOverText']) {
            $Rewards = Donations::get_rewards($UserID);
            $AvatarMouseOverText = $Rewards['AvatarMouseOverText'];
        }
        if (!empty($AvatarMouseOverText)) {
            $AvatarMouseOverText =  "title=\"$AvatarMouseOverText\" alt=\"$AvatarMouseOverText\"";
        } else {
            $AvatarMouseOverText = "alt=\"$Username's avatar\"";
        }
        if ($EnabledRewards['HasSecondAvatar'] && !empty($Rewards['SecondAvatar'])) {
            $SecondAvatar = ' data-gazelle-second-avatar="' . ImageTools::process($Rewards['SecondAvatar'], 'avatar') . '"';
        }
        // case 1 is avatars disabled
        switch ($Setting) {
            case 0:
                if (!empty($Avatar)) {
                    $ToReturn = ($ReturnHTML ? "<a href=\"user.php?id=$UserID\"><img src=\"$Avatar\" ".($Size?"width=\"$Size\" ":"")."$Style $AvatarMouseOverText$SecondAvatar $Class /></a>" : $Avatar);
                } else {
                    $URL = STATIC_SERVER.'common/avatars/default.png';
                    $ToReturn = ($ReturnHTML ? "<img src=\"$URL\" width=\"$Size\" $Style $AvatarMouseOverText$SecondAvatar />" : $URL);
                }
                break;
            case 2:
                $ShowAvatar = true;
                // no break
            case 3:
                switch (G::$LoggedUser['Identicons']) {
                    case 0:
                        $Type = 'identicon';
                        break;
                    case 1:
                        $Type = 'monsterid';
                        break;
                    case 2:
                        $Type = 'wavatar';
                        break;
                    case 3:
                        $Type = 'retro';
                        break;
                    case 4:
                        $Type = '1';
                        $Robot = true;
                        break;
                    case 5:
                        $Type = '2';
                        $Robot = true;
                        break;
                    case 6:
                        $Type = '3';
                        $Robot = true;
                        break;
                    default:
                        $Type = 'identicon';
                }
                $Rating = 'pg';
                if (!isset($Robot) || !$Robot) {
                    $URL = 'https://secure.gravatar.com/avatar/'.md5(strtolower(trim($Username)))."?s=$Size&amp;d=$Type&amp;r=$Rating";
                } else {
                    $URL = 'https://robohash.org/'.md5($Username)."?set=set$Type&amp;size={$Size}x$Size";
                }
                if ($ShowAvatar == true && !empty($Avatar)) {
                    $ToReturn = ($ReturnHTML ? "<img src=\"$Avatar\" width=\"$Size\" $Style $AvatarMouseOverText$SecondAvatar $Class />" : $Avatar);
                } else {
                    $ToReturn = ($ReturnHTML ? "<img src=\"$URL\" width=\"$Size\" $Style $AvatarMouseOverText $Class />" : $URL);
                }
                break;
            default:
                $URL = STATIC_SERVER.'common/avatars/default.png';
                $ToReturn = ($ReturnHTML ? "<img src=\"$URL\" width=\"$Size\" $Style $AvatarMouseOverText$SecondAvatar $Class/>" : $URL);
        }
        return $ToReturn;
    }

    public static function has_avatars_enabled()
    {
        global $HeavyInfo;
        return isset($HeavyInfo['DisableAvatars']) && ($HeavyInfo['DisableAvatars'] != 1);
    }

    /**
     * Checks whether user has autocomplete enabled
     *
     * 0 - Enabled everywhere (default), 1 - Disabled, 2 - Searches only
     *
     * @param string $Type the type of the input.
     * @param boolean $Output echo out HTML
     * @return boolean
     */
    public static function has_autocomplete_enabled($Type, $Output = true)
    {
        $Enabled = false;
        if (empty(G::$LoggedUser['AutoComplete'])) {
            $Enabled = true;
        } elseif (G::$LoggedUser['AutoComplete'] !== 1) {
            switch ($Type) {
                case 'search':
                    if (G::$LoggedUser['AutoComplete'] == 2) {
                        $Enabled = true;
                    }
                    break;
                case 'other':
                    if (G::$LoggedUser['AutoComplete'] != 2) {
                        $Enabled = true;
                    }
                    break;
            }
        }
        if ($Enabled && $Output) {
            echo ' data-gazelle-autocomplete="true"';
        }
        if (!$Output) {
            // don't return a boolean if you're echoing HTML
            return $Enabled;
        }
    }

    /*
     * Initiate a password reset
     *
     * @param int $UserID The user ID
     * @param string $Username The username
     * @param string $Email The email address
     */
    public static function reset_password($UserID, $Username, $Email)
    {
        $ResetKey = Users::make_secret();
        G::$DB->query("
      UPDATE users_info
      SET
        ResetKey = '" . db_string($ResetKey) . "',
        ResetExpires = '" . time_plus(60 * 60) . "'
      WHERE UserID = '$UserID'");
        require_once(SERVER_ROOT . '/classes/templates.class.php');
        $TPL = new TEMPLATE;
        $TPL->open(SERVER_ROOT . '/templates/password_reset.tpl'); // Password reset template
        $TPL->set('Username', $Username);
        $TPL->set('ResetKey', $ResetKey);
        $TPL->set('IP', $_SERVER['REMOTE_ADDR']);
        $TPL->set('SITE_NAME', SITE_NAME);
        $TPL->set('SITE_DOMAIN', SITE_DOMAIN);

        Misc::send_email($Email, 'Password reset information for ' . SITE_NAME, $TPL->get(), 'noreply');
    }


    /*
     * Authorize a new location
     *
     * @param int $UserID The user ID
     * @param string $Username The username
     * @param int $ASN The ASN
     * @param string $Email The email address
     */
    public static function auth_location($UserID, $Username, $ASN, $Email)
    {
        $AuthKey = Users::make_secret();
        G::$Cache->cache_value('new_location_'.$AuthKey, ['UserID'=>$UserID, 'ASN'=>$ASN], 3600*2);
        require_once(SERVER_ROOT . '/classes/templates.class.php');
        $TPL = new TEMPLATE;
        $TPL->open(SERVER_ROOT . '/templates/new_location.tpl');
        $TPL->set('Username', $Username);
        $TPL->set('AuthKey', $AuthKey);
        $TPL->set('IP', $_SERVER['REMOTE_ADDR']);
        $TPL->set('SITE_NAME', SITE_NAME);
        $TPL->set('SITE_DOMAIN', SITE_DOMAIN);

        Misc::send_email($Email, 'Login from new location for '.SITE_NAME, $TPL->get(), 'noreply');
    }
    /*
     * @return array of strings that can be added to next source flag ( [current, old] )
     */
    public static function get_upload_sources()
    {
        if (!($SourceKey = G::$Cache->get_value('source_key_new'))) {
            G::$Cache->cache_value('source_key_new', $SourceKey = [Users::make_secret(), time()]);
        }
        $SourceKeyOld = G::$Cache->get_value('source_key_old');
        if ($SourceKey[1]-time() > 3600) {
            G::$Cache->cache_value('source_key_old', $SourceKeyOld = $SourceKey);
            G::$Cache->cache_value('source_key_new', $SourceKey = [Users::make_secret(), time()]);
        }
        G::$DB->query("
      SELECT
        COUNT(ID)
      FROM torrents
      WHERE UserID = ".G::$LoggedUser['ID']);
        list($Uploads) = G::$DB->next_record();
        $Source[0] = SITE_NAME.'-'.substr(hash('sha256', $SourceKey[0].G::$LoggedUser['ID'].$Uploads), 0, 10);
        $Source[1] = $SourceKeyOld ? SITE_NAME.'-'.substr(hash('sha256', $SourceKeyOld[0].G::$LoggedUser['ID'].$Uploads), 0, 10) : $Source[0];
        return $Source;
    }
}