mirror of
https://github.com/discourse/discourse.git
synced 2024-11-28 07:43:41 +08:00
343 lines
9.4 KiB
Ruby
343 lines
9.4 KiB
Ruby
require_dependency 'guardian'
|
|
require_dependency 'topic_query'
|
|
require_dependency 'summarize'
|
|
|
|
class TopicView
|
|
|
|
attr_reader :topic, :posts, :index_offset, :index_reverse, :guardian
|
|
attr_accessor :draft, :draft_key, :draft_sequence
|
|
|
|
def initialize(topic_id, user=nil, options={})
|
|
@topic = find_topic(topic_id)
|
|
raise Discourse::NotFound if @topic.blank?
|
|
|
|
@guardian = Guardian.new(user)
|
|
|
|
# Special case: If the topic is private and the user isn't logged in, ask them
|
|
# to log in!
|
|
if @topic.present? && @topic.private_message? && user.blank?
|
|
raise Discourse::NotLoggedIn.new
|
|
end
|
|
|
|
guardian.ensure_can_see!(@topic)
|
|
@post_number, @page = options[:post_number], options[:page]
|
|
|
|
@limit = options[:limit] || SiteSetting.posts_per_page;
|
|
|
|
@filtered_posts = @topic.posts
|
|
@filtered_posts = @filtered_posts.with_deleted if user.try(:staff?)
|
|
@filtered_posts = @filtered_posts.best_of if options[:best_of].present?
|
|
@filtered_posts = @filtered_posts.where('posts.post_type <> ?', Post.types[:moderator_action]) if options[:best].present?
|
|
|
|
if options[:username_filters].present?
|
|
usernames = options[:username_filters].map{|u| u.downcase}
|
|
@filtered_posts = @filtered_posts.where('post_number = 1 or user_id in (select u.id from users u where username_lower in (?))', usernames)
|
|
end
|
|
|
|
@user = user
|
|
@initial_load = true
|
|
@index_reverse = false
|
|
|
|
filter_posts(options)
|
|
|
|
@draft_key = @topic.draft_key
|
|
@draft_sequence = DraftSequence.current(user, @draft_key)
|
|
end
|
|
|
|
def canonical_path
|
|
path = @topic.relative_url
|
|
path << if @post_number
|
|
page = ((@post_number.to_i - 1) / SiteSetting.posts_per_page) + 1
|
|
(page > 1) ? "?page=#{page}" : ""
|
|
else
|
|
(@page && @page.to_i > 1) ? "?page=#{@page}" : ""
|
|
end
|
|
path
|
|
end
|
|
|
|
def next_page
|
|
last_post = @filtered_posts.last
|
|
if last_post.present? && (@topic.highest_post_number > last_post.post_number)
|
|
(@filtered_posts[0].post_number / SiteSetting.posts_per_page) + 1
|
|
end
|
|
end
|
|
|
|
def next_page_path
|
|
"#{@topic.relative_url}?page=#{next_page}"
|
|
end
|
|
|
|
def absolute_url
|
|
"#{Discourse.base_url}#{@topic.relative_url}"
|
|
end
|
|
|
|
def relative_url
|
|
@topic.relative_url
|
|
end
|
|
|
|
def title
|
|
@topic.title
|
|
end
|
|
|
|
def filtered_posts_count
|
|
@filtered_posts_count ||= @filtered_posts.count
|
|
end
|
|
|
|
def summary
|
|
return nil if posts.blank?
|
|
Summarize.new(posts.first.cooked).summary
|
|
end
|
|
|
|
def image_url
|
|
return nil if posts.blank?
|
|
posts.first.user.small_avatar_url
|
|
end
|
|
|
|
def filter_posts(opts = {})
|
|
return filter_posts_near(opts[:post_number].to_i) if opts[:post_number].present?
|
|
return filter_posts_before(opts[:posts_before].to_i) if opts[:posts_before].present?
|
|
return filter_posts_after(opts[:posts_after].to_i) if opts[:posts_after].present?
|
|
if opts[:best].present?
|
|
return filter_best(opts[:best], opts)
|
|
end
|
|
|
|
filter_posts_paged(opts[:page].to_i)
|
|
end
|
|
|
|
|
|
# Find the sort order for a post in the topic
|
|
def sort_order_for_post_number(post_number)
|
|
Post.where(topic_id: @topic.id, post_number: post_number)
|
|
.with_deleted
|
|
.select(:sort_order)
|
|
.first
|
|
.try(:sort_order)
|
|
end
|
|
|
|
# Filter to all posts near a particular post number
|
|
def filter_posts_near(post_number)
|
|
|
|
# Find the closest number we have
|
|
closest_post_id = @filtered_posts.order("@(post_number - #{post_number})").first.try(:id)
|
|
return nil if closest_post_id.blank?
|
|
|
|
closest_index = filtered_post_ids.index(closest_post_id)
|
|
return nil if closest_index.blank?
|
|
|
|
# Make sure to get at least one post before, even with rounding
|
|
posts_before = (SiteSetting.posts_per_page.to_f / 4).floor
|
|
posts_before = 1 if posts_before == 0
|
|
|
|
min_idx = closest_index - posts_before
|
|
min_idx = 0 if min_idx < 0
|
|
max_idx = min_idx + (SiteSetting.posts_per_page - 1)
|
|
|
|
# Get a full page even if at the end
|
|
upper_limit = (filtered_post_ids.length - 1)
|
|
if max_idx >= upper_limit
|
|
max_idx = upper_limit
|
|
min_idx = (upper_limit - SiteSetting.posts_per_page) + 1
|
|
end
|
|
|
|
filter_posts_in_range(min_idx, max_idx)
|
|
end
|
|
|
|
def filtered_post_ids
|
|
@filtered_post_ids ||= @filtered_posts.order(:sort_order).pluck(:id)
|
|
end
|
|
|
|
def filter_posts_paged(page)
|
|
page = [page, 1].max
|
|
min = SiteSetting.posts_per_page * (page - 1)
|
|
max = min + SiteSetting.posts_per_page
|
|
filter_posts_in_range(min, max)
|
|
end
|
|
|
|
# Filter to all posts before a particular post number
|
|
def filter_posts_before(post_number)
|
|
@initial_load = false
|
|
|
|
sort_order = sort_order_for_post_number(post_number)
|
|
return nil unless sort_order
|
|
|
|
# Find posts before the `sort_order`
|
|
@posts = @filtered_posts.order('sort_order desc').where("sort_order < ?", sort_order)
|
|
@index_offset = @posts.count
|
|
@index_reverse = true
|
|
|
|
@posts = @posts.includes(:reply_to_user).includes(:topic).joins(:user).limit(@limit)
|
|
end
|
|
|
|
# Filter to all posts after a particular post number
|
|
def filter_posts_after(post_number)
|
|
@initial_load = false
|
|
|
|
sort_order = sort_order_for_post_number(post_number)
|
|
return nil unless sort_order
|
|
|
|
@index_offset = @filtered_posts.where("sort_order <= ?", sort_order).count
|
|
@posts = @filtered_posts.order('sort_order').where("sort_order > ?", sort_order)
|
|
@posts = @posts.includes(:reply_to_user).includes(:topic).joins(:user).limit(@limit)
|
|
end
|
|
|
|
def filter_best(max, opts={})
|
|
@index_offset = 0
|
|
|
|
if opts[:min_replies] && @topic.posts_count < opts[:min_replies] + 1
|
|
@posts = []
|
|
return
|
|
end
|
|
|
|
@posts = @filtered_posts.order('percent_rank asc, sort_order asc')
|
|
.where("post_number > 1")
|
|
@posts = @posts.includes(:reply_to_user).includes(:topic).joins(:user).limit(max)
|
|
|
|
min_trust_level = opts[:min_trust_level]
|
|
if min_trust_level && min_trust_level > 0
|
|
@posts = @posts.where('COALESCE(users.trust_level,0) >= ?', min_trust_level)
|
|
end
|
|
|
|
min_score = opts[:min_score]
|
|
if min_score && min_score > 0
|
|
@posts = @posts.where('posts.score >= ?', min_score)
|
|
end
|
|
|
|
@posts = @posts.to_a
|
|
@posts.sort!{|a,b| a.post_number <=> b.post_number}
|
|
@posts
|
|
end
|
|
|
|
def read?(post_number)
|
|
read_posts_set.include?(post_number)
|
|
end
|
|
|
|
def topic_user
|
|
@topic_user ||= begin
|
|
return nil if @user.blank?
|
|
@topic.topic_users.where(user_id: @user.id).first
|
|
end
|
|
end
|
|
|
|
def post_counts_by_user
|
|
@post_counts_by_user ||= Post.where(topic_id: @topic.id).group(:user_id).order('count_all desc').limit(24).count
|
|
end
|
|
|
|
def participants
|
|
@participants ||= begin
|
|
participants = {}
|
|
User.where(id: post_counts_by_user.map {|k,v| k}).each {|u| participants[u.id] = u}
|
|
participants
|
|
end
|
|
end
|
|
|
|
def all_post_actions
|
|
@all_post_actions ||= PostAction.counts_for(posts, @user)
|
|
end
|
|
|
|
def voted_in_topic?
|
|
return false
|
|
|
|
# all post_actions is not the way to do this, cut down on the query, roll it up into topic if we need it
|
|
|
|
@voted_in_topic ||= begin
|
|
return false unless all_post_actions.present?
|
|
all_post_actions.values.flatten.map {|ac| ac.keys}.flatten.include?(PostActionType.types[:vote])
|
|
end
|
|
end
|
|
|
|
def post_action_visibility
|
|
@post_action_visibility ||= begin
|
|
result = []
|
|
PostActionType.types.each do |k, v|
|
|
result << v if guardian.can_see_post_actors?(@topic, v)
|
|
end
|
|
result
|
|
end
|
|
end
|
|
|
|
def links
|
|
@links ||= TopicLink.topic_summary(guardian, @topic.id)
|
|
end
|
|
|
|
def link_counts
|
|
@link_counts ||= TopicLink.counts_for(guardian,@topic, posts)
|
|
end
|
|
|
|
# Are we the initial page load? If so, we can return extra information like
|
|
# user post counts, etc.
|
|
def initial_load?
|
|
@initial_load
|
|
end
|
|
|
|
def suggested_topics
|
|
return nil if topic.private_message?
|
|
@suggested_topics ||= TopicQuery.new(@user).list_suggested_for(topic)
|
|
end
|
|
|
|
# This is pending a larger refactor, that allows custom orders
|
|
# for now we need to look for the highest_post_number in the stream
|
|
# the cache on topics is not correct if there are deleted posts at
|
|
# the end of the stream (for mods), nor is it correct for filtered
|
|
# streams
|
|
def highest_post_number
|
|
@highest_post_number ||= @filtered_posts.maximum(:post_number)
|
|
end
|
|
|
|
def recent_posts
|
|
@filtered_posts.by_newest.with_user.first(25)
|
|
end
|
|
|
|
|
|
def current_post_ids
|
|
@current_post_ids ||= if @posts.is_a?(Array)
|
|
@posts.map {|p| p.id }
|
|
else
|
|
@posts.pluck(:post_number)
|
|
end
|
|
end
|
|
|
|
protected
|
|
|
|
def read_posts_set
|
|
@read_posts_set ||= begin
|
|
result = Set.new
|
|
return result unless @user.present?
|
|
return result unless topic_user.present?
|
|
|
|
post_numbers = PostTiming.select(:post_number)
|
|
.where(topic_id: @topic.id, user_id: @user.id)
|
|
.where(post_number: current_post_ids)
|
|
.pluck(:post_number)
|
|
|
|
post_numbers.each {|pn| result << pn}
|
|
result
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def filter_posts_in_range(min, max)
|
|
post_count = (filtered_post_ids.length - 1)
|
|
|
|
max = [max, post_count].min
|
|
|
|
return @posts = [] if min > max
|
|
|
|
min = [[min, max].min, 0].max
|
|
|
|
@index_offset = min
|
|
|
|
# TODO: Sort might be off
|
|
@posts = Post.where(id: filtered_post_ids[min..max])
|
|
.includes(:user)
|
|
.includes(:reply_to_user)
|
|
.order('sort_order')
|
|
@posts = @posts.with_deleted if @user.try(:staff?)
|
|
|
|
@posts
|
|
end
|
|
|
|
def find_topic(topic_id)
|
|
Topic.where(id: topic_id).includes(:category).first
|
|
end
|
|
end
|