Gazelle/classes/forums.class.php

<?php
class Forums
{
    /**
     * Get information on a thread.
     *
     * @param int $ThreadID the thread ID.
     * @param boolean $Return indicates whether thread info should be returned.
     * @param Boolean $SelectiveCache cache thread info.
     * @return array holding thread information.
     */
    public static function get_thread_info($ThreadID, $Return = true, $SelectiveCache = false)
    {
        if ((!$ThreadInfo = G::$Cache->get_value('thread_' . $ThreadID . '_info')) || !isset($ThreadInfo['Ranking'])) {
            $QueryID = G::$DB->get_query_id();
            G::$DB->query("
        SELECT
          t.Title,
          t.ForumID,
          t.IsLocked,
          t.IsSticky,
          COUNT(fp.id) AS Posts,
          t.LastPostAuthorID,
          ISNULL(p.TopicID) AS NoPoll,
          t.StickyPostID,
          t.AuthorID as OP,
          t.Ranking
        FROM forums_topics AS t
          JOIN forums_posts AS fp ON fp.TopicID = t.ID
          LEFT JOIN forums_polls AS p ON p.TopicID = t.ID
        WHERE t.ID = ?
        GROUP BY fp.TopicID", $ThreadID);
            if (!G::$DB->has_results()) {
                G::$DB->set_query_id($QueryID);
                return null;
            }
            $ThreadInfo = G::$DB->next_record(MYSQLI_ASSOC, false);
            if ($ThreadInfo['StickyPostID']) {
                $ThreadInfo['Posts']--;
                G::$DB->query(
                    "SELECT
            p.ID,
            p.AuthorID,
            p.AddedTime,
            p.Body,
            p.EditedUserID,
            p.EditedTime,
            ed.Username
            FROM forums_posts AS p
              LEFT JOIN users_main AS ed ON ed.ID = p.EditedUserID
            WHERE p.TopicID = ?
              AND p.ID = ?",
                    $ThreadID,
                    $ThreadInfo['StickyPostID']
                );
                list($ThreadInfo['StickyPost']) = G::$DB->to_array(false, MYSQLI_ASSOC);
            }
            G::$DB->set_query_id($QueryID);
            if (!$SelectiveCache || !$ThreadInfo['IsLocked'] || $ThreadInfo['IsSticky']) {
                G::$Cache->cache_value('thread_' . $ThreadID . '_info', $ThreadInfo, 0);
            }
        }
        if ($Return) {
            return $ThreadInfo;
        }
    }

    /**
     * Checks whether user has permissions on a forum.
     *
     * @param int $ForumID the forum ID.
     * @param string $Perm the permissision to check, defaults to 'Read'
     * @return boolean true if user has permission
     */
    public static function check_forumperm($ForumID, $Perm = 'Read')
    {
        $Forums = self::get_forums();
        if (isset(G::$LoggedUser['CustomForums'][$ForumID]) && G::$LoggedUser['CustomForums'][$ForumID] == 1) {
            return true;
        }
        if ($ForumID == DONOR_FORUM && Donations::has_donor_forum(G::$LoggedUser['ID'])) {
            return true;
        }
        if ($Forums[$ForumID]['MinClass' . $Perm] > G::$LoggedUser['Class'] && (!isset(G::$LoggedUser['CustomForums'][$ForumID]) || G::$LoggedUser['CustomForums'][$ForumID] == 0)) {
            return false;
        }
        if (isset(G::$LoggedUser['CustomForums'][$ForumID]) && G::$LoggedUser['CustomForums'][$ForumID] == 0) {
            return false;
        }
        return true;
    }

    /**
     * Gets basic info on a forum.
     *
     * @param int $ForumID the forum ID.
     */
    public static function get_forum_info($ForumID)
    {
        $Forum = G::$Cache->get_value("ForumInfo_$ForumID");
        if (!$Forum) {
            $QueryID = G::$DB->get_query_id();
            G::$DB->query("
        SELECT
          Name,
          MinClassRead,
          MinClassWrite,
          MinClassCreate,
          COUNT(forums_topics.ID) AS Topics
        FROM forums
          LEFT JOIN forums_topics ON forums_topics.ForumID = forums.ID
        WHERE forums.ID = ?
        GROUP BY ForumID", $ForumID);
            if (!G::$DB->has_results()) {
                return false;
            }
            // Makes an array, with $Forum['Name'], etc.
            $Forum = G::$DB->next_record(MYSQLI_ASSOC);

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

            G::$Cache->cache_value("ForumInfo_$ForumID", $Forum, 86400);
        }
        return $Forum;
    }

    /**
     * Get the forum categories
     * @return array ForumCategoryID => Name
     */
    public static function get_forum_categories()
    {
        $ForumCats = G::$Cache->get_value('forums_categories');
        if ($ForumCats === false) {
            $QueryID = G::$DB->get_query_id();
            G::$DB->query("
        SELECT ID, Name
        FROM forums_categories");
            $ForumCats = [];
            while (list($ID, $Name) = G::$DB->next_record()) {
                $ForumCats[$ID] = $Name;
            }
            G::$DB->set_query_id($QueryID);
            G::$Cache->cache_value('forums_categories', $ForumCats, 0);
        }
        return $ForumCats;
    }

    /**
     * Get the forums
     * @return array ForumID => (various information about the forum)
     */
    public static function get_forums()
    {
        if (!$Forums = G::$Cache->get_value('forums_list')) {
            $QueryID = G::$DB->get_query_id();
            G::$DB->query("
        SELECT
          f.ID,
          f.CategoryID,
          f.Name,
          f.Description,
          f.MinClassRead AS MinClassRead,
          f.MinClassWrite AS MinClassWrite,
          f.MinClassCreate AS MinClassCreate,
          f.NumTopics,
          f.NumPosts,
          f.LastPostID,
          f.LastPostAuthorID,
          f.LastPostTopicID,
          f.LastPostTime,
          0 AS SpecificRules,
          t.Title,
          t.IsLocked AS Locked,
          t.IsSticky AS Sticky
        FROM forums AS f
          JOIN forums_categories AS fc ON fc.ID = f.CategoryID
          LEFT JOIN forums_topics AS t ON t.ID = f.LastPostTopicID
        GROUP BY f.ID
        ORDER BY fc.Sort, fc.Name, f.CategoryID, f.Sort");
            $Forums = G::$DB->to_array('ID', MYSQLI_ASSOC, false);

            G::$DB->query("
        SELECT ForumID, ThreadID
        FROM forums_specific_rules");
            $SpecificRules = [];
            while (list($ForumID, $ThreadID) = G::$DB->next_record(MYSQLI_NUM, false)) {
                $SpecificRules[$ForumID][] = $ThreadID;
            }
            G::$DB->set_query_id($QueryID);
            foreach ($Forums as $ForumID => &$Forum) {
                if (isset($SpecificRules[$ForumID])) {
                    $Forum['SpecificRules'] = $SpecificRules[$ForumID];
                } else {
                    $Forum['SpecificRules'] = [];
                }
            }
            G::$Cache->cache_value('forums_list', $Forums, 0);
        }
        return $Forums;
    }

    /**
     * Get all forums that the current user has special access to ("Extra forums" in the profile)
     * @return array Array of ForumIDs
     */
    public static function get_permitted_forums()
    {
        if (isset(G::$LoggedUser['CustomForums'])) {
            return (array)array_keys(G::$LoggedUser['CustomForums'], 1);
        } else {
            return [];
        }
    }

    /**
     * Get all forums that the current user does not have access to ("Restricted forums" in the profile)
     * @return array Array of ForumIDs
     */
    public static function get_restricted_forums()
    {
        if (isset(G::$LoggedUser['CustomForums'])) {
            return (array)array_keys(G::$LoggedUser['CustomForums'], 0);
        } else {
            return [];
        }
    }

    /**
     * Get the last read posts for the current user
     * @param array $Forums Array of forums as returned by self::get_forums()
     * @return array TopicID => array(TopicID, PostID, Page) where PostID is the ID of the last read post and Page is the page on which that post is
     */
    public static function get_last_read($Forums)
    {
        if (isset(G::$LoggedUser['PostsPerPage'])) {
            $PerPage = G::$LoggedUser['PostsPerPage'];
        } else {
            $PerPage = POSTS_PER_PAGE;
        }
        $TopicIDs = [];
        foreach ($Forums as $Forum) {
            if (!empty($Forum['LastPostTopicID'])) {
                $TopicIDs[] = $Forum['LastPostTopicID'];
            }
        }
        if (!empty($TopicIDs)) {
            $QueryID = G::$DB->get_query_id();
            G::$DB->query("
        SELECT
          l.TopicID,
          l.PostID,
          CEIL(
            (
              SELECT
                COUNT(p.ID)
              FROM forums_posts AS p
              WHERE p.TopicID = l.TopicID
                AND p.ID <= l.PostID
            ) / ?
          ) AS Page
        FROM forums_last_read_topics AS l
        WHERE l.TopicID IN(" . implode(',', $TopicIDs) . ") AND
          l.UserID = ?", $PerPage, G::$LoggedUser['ID']);
            $LastRead = G::$DB->to_array('TopicID', MYSQLI_ASSOC);
            G::$DB->set_query_id($QueryID);
        } else {
            $LastRead = [];
        }
        return $LastRead;
    }

    /**
     * Add a note to a topic.
     * @param int $TopicID
     * @param string $Note
     * @param int|null $UserID
     * @return boolean
     */
    public static function add_topic_note($TopicID, $Note, $UserID = null)
    {
        if ($UserID === null) {
            $UserID = G::$LoggedUser['ID'];
        }
        $QueryID = G::$DB->get_query_id();
        G::$DB->query("
      INSERT INTO forums_topic_notes
        (TopicID, AuthorID, AddedTime, Body)
      VALUES
        (?, ?, NOW(), ?)", $TopicID, $UserID, $Note);
        G::$DB->set_query_id($QueryID);
        return (bool)G::$DB->affected_rows();
    }

    /**
     * Determine if a thread is unread
     * @param bool $Locked
     * @param bool $Sticky
     * @param int $LastPostID
     * @param array $LastRead An array as returned by self::get_last_read
     * @param int $LastTopicID TopicID of the thread where the most recent post was made
     * @param string $LastTime Datetime of the last post
     * @return bool
     */
    public static function is_unread($Locked, $Sticky, $LastPostID, $LastRead, $LastTopicID, $LastTime)
    {
        return (!$Locked || $Sticky) && $LastPostID != 0 && ((empty($LastRead[$LastTopicID]) || $LastRead[$LastTopicID]['PostID'] < $LastPostID) && strtotime($LastTime) > G::$LoggedUser['CatchupTime']);
    }

    /**
     * Create the part of WHERE in the sql queries used to filter forums for a
     * specific user (MinClassRead, restricted and permitted forums).
     * @return string
     */
    public static function user_forums_sql()
    {
        // I couldn't come up with a good name, please rename this if you can. -- Y
        $RestrictedForums = self::get_restricted_forums();
        $PermittedForums = self::get_permitted_forums();
        if (Donations::has_donor_forum(G::$LoggedUser['ID']) && !in_array(DONOR_FORUM, $PermittedForums)) {
            $PermittedForums[] = DONOR_FORUM;
        }
        $SQL = "((f.MinClassRead <= '" . G::$LoggedUser['Class'] . "'";
        if (count($RestrictedForums)) {
            $SQL .= " AND f.ID NOT IN ('" . implode("', '", $RestrictedForums) . "')";
        }
        $SQL .= ')';
        if (count($PermittedForums)) {
            $SQL .= " OR f.ID IN ('" . implode("', '", $PermittedForums) . "')";
        }
        $SQL .= ')';
        return $SQL;
    }
}