2013-02-05 14:16:51 -05:00
|
|
|
require_dependency 'guardian'
|
|
|
|
require_dependency 'topic_query'
|
2013-07-12 04:33:45 -04:00
|
|
|
require_dependency 'filter_best_posts'
|
2013-12-04 15:56:09 -05:00
|
|
|
require_dependency 'gaps'
|
2013-02-05 14:16:51 -05:00
|
|
|
|
|
|
|
class TopicView
|
|
|
|
|
2016-08-01 01:06:55 -04:00
|
|
|
attr_reader :topic, :posts, :guardian, :filtered_posts, :chunk_size, :print
|
2015-04-23 13:33:29 -04:00
|
|
|
attr_accessor :draft, :draft_key, :draft_sequence, :user_custom_fields, :post_custom_fields
|
2013-02-05 14:16:51 -05:00
|
|
|
|
2014-12-14 18:57:34 -05:00
|
|
|
def self.slow_chunk_size
|
|
|
|
10
|
|
|
|
end
|
|
|
|
|
2016-08-01 00:45:05 -04:00
|
|
|
def self.print_chunk_size
|
|
|
|
1000
|
|
|
|
end
|
|
|
|
|
2014-12-14 18:57:34 -05:00
|
|
|
def self.chunk_size
|
|
|
|
20
|
|
|
|
end
|
|
|
|
|
2016-01-11 06:42:06 -05:00
|
|
|
def self.default_post_custom_fields
|
|
|
|
@default_post_custom_fields ||= ["action_code_who"]
|
|
|
|
end
|
|
|
|
|
2015-04-23 13:33:29 -04:00
|
|
|
def self.post_custom_fields_whitelisters
|
|
|
|
@post_custom_fields_whitelisters ||= Set.new
|
|
|
|
end
|
|
|
|
|
|
|
|
def self.add_post_custom_fields_whitelister(&block)
|
|
|
|
post_custom_fields_whitelisters << block
|
|
|
|
end
|
|
|
|
|
|
|
|
def self.whitelisted_post_custom_fields(user)
|
2016-01-11 06:42:06 -05:00
|
|
|
wpcf = default_post_custom_fields + post_custom_fields_whitelisters.map { |w| w.call(user) }
|
|
|
|
wpcf.flatten.uniq
|
2015-04-23 13:33:29 -04:00
|
|
|
end
|
|
|
|
|
2013-02-05 14:16:51 -05:00
|
|
|
def initialize(topic_id, user=nil, options={})
|
2013-07-11 16:38:46 -04:00
|
|
|
@user = user
|
|
|
|
@guardian = Guardian.new(@user)
|
2014-07-15 17:02:43 -04:00
|
|
|
@topic = find_topic(topic_id)
|
2016-08-01 01:06:55 -04:00
|
|
|
@print = options[:print].present?
|
2013-07-12 04:33:45 -04:00
|
|
|
check_and_raise_exceptions
|
2013-06-20 17:20:08 -04:00
|
|
|
|
2013-08-13 10:29:25 -04:00
|
|
|
options.each do |key, value|
|
2013-10-28 02:12:07 -04:00
|
|
|
self.instance_variable_set("@#{key}".to_sym, value)
|
2013-08-13 10:29:25 -04:00
|
|
|
end
|
|
|
|
|
2016-02-24 22:32:16 -05:00
|
|
|
@page = 1 if (!@page || @page.zero?)
|
2016-08-01 00:45:05 -04:00
|
|
|
@chunk_size = case
|
|
|
|
when options[:slow_platform] then TopicView.slow_chunk_size
|
2016-08-05 01:12:35 -04:00
|
|
|
when @print then TopicView.print_chunk_size
|
2016-08-01 00:45:05 -04:00
|
|
|
else TopicView.chunk_size
|
|
|
|
end
|
2014-12-12 11:47:20 -05:00
|
|
|
@limit ||= @chunk_size
|
2013-02-05 14:16:51 -05:00
|
|
|
|
2013-07-12 04:33:45 -04:00
|
|
|
setup_filtered_posts
|
2013-02-05 14:16:51 -05:00
|
|
|
|
|
|
|
@initial_load = true
|
2013-03-26 14:18:35 -04:00
|
|
|
@index_reverse = false
|
2013-02-05 14:16:51 -05:00
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
filter_posts(options)
|
|
|
|
|
2016-03-11 15:52:18 -05:00
|
|
|
if @posts
|
|
|
|
added_fields = User.whitelisted_user_custom_fields(@guardian)
|
|
|
|
if added_fields.present?
|
|
|
|
@user_custom_fields = User.custom_fields_for_ids(@posts.map(&:user_id), added_fields)
|
|
|
|
end
|
2015-03-03 01:51:01 -05:00
|
|
|
end
|
|
|
|
|
2015-04-23 13:33:29 -04:00
|
|
|
whitelisted_fields = TopicView.whitelisted_post_custom_fields(@user)
|
|
|
|
if whitelisted_fields.present? && @posts
|
|
|
|
@post_custom_fields = Post.custom_fields_for_ids(@posts.map(&:id), whitelisted_fields)
|
|
|
|
end
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
@draft_key = @topic.draft_key
|
2013-07-11 16:38:46 -04:00
|
|
|
@draft_sequence = DraftSequence.current(@user, @draft_key)
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
def canonical_path
|
2016-08-04 00:15:22 -04:00
|
|
|
path = relative_url
|
2013-02-10 13:50:26 -05:00
|
|
|
path << if @post_number
|
2014-01-03 12:52:24 -05:00
|
|
|
page = ((@post_number.to_i - 1) / @limit) + 1
|
2013-02-10 13:50:26 -05:00
|
|
|
(page > 1) ? "?page=#{page}" : ""
|
|
|
|
else
|
|
|
|
(@page && @page.to_i > 1) ? "?page=#{@page}" : ""
|
|
|
|
end
|
|
|
|
path
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
|
|
|
|
2013-12-04 15:56:09 -05:00
|
|
|
def contains_gaps?
|
|
|
|
@contains_gaps
|
|
|
|
end
|
|
|
|
|
|
|
|
def gaps
|
|
|
|
return unless @contains_gaps
|
|
|
|
Gaps.new(filtered_post_ids, unfiltered_posts.order(:sort_order).pluck(:id))
|
|
|
|
end
|
|
|
|
|
2013-07-05 14:45:54 -04:00
|
|
|
def last_post
|
|
|
|
return nil if @posts.blank?
|
|
|
|
@last_post ||= @posts.last
|
|
|
|
end
|
|
|
|
|
2014-03-03 12:56:37 -05:00
|
|
|
def prev_page
|
2014-05-13 10:15:08 -04:00
|
|
|
if @page && @page > 1 && posts.length > 0
|
2014-03-03 12:56:37 -05:00
|
|
|
@page - 1
|
|
|
|
else
|
|
|
|
nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
def next_page
|
2013-07-05 14:45:54 -04:00
|
|
|
@next_page ||= begin
|
|
|
|
if last_post && (@topic.highest_post_number > last_post.post_number)
|
|
|
|
@page + 1
|
|
|
|
end
|
2013-02-10 13:50:26 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-03-03 12:56:37 -05:00
|
|
|
def prev_page_path
|
|
|
|
if prev_page > 1
|
2016-08-04 00:15:22 -04:00
|
|
|
"#{relative_url}?page=#{prev_page}"
|
2014-03-03 12:56:37 -05:00
|
|
|
else
|
2016-08-04 00:15:22 -04:00
|
|
|
relative_url
|
2014-03-03 12:56:37 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
def next_page_path
|
2016-08-04 00:15:22 -04:00
|
|
|
"#{relative_url}?page=#{next_page}"
|
2013-02-10 13:50:26 -05:00
|
|
|
end
|
|
|
|
|
2013-03-07 17:31:06 -05:00
|
|
|
def absolute_url
|
2016-08-04 00:15:22 -04:00
|
|
|
"#{Discourse.base_url}#{relative_url}"
|
2013-03-07 17:31:06 -05:00
|
|
|
end
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
def relative_url
|
2016-08-08 23:53:08 -04:00
|
|
|
"#{@topic.relative_url}#{@print ? '/print' : ''}"
|
2013-02-10 13:50:26 -05:00
|
|
|
end
|
|
|
|
|
2015-07-21 20:26:58 -04:00
|
|
|
def page_title
|
|
|
|
title = @topic.title
|
2016-04-11 16:44:10 -04:00
|
|
|
if SiteSetting.topic_page_title_includes_category && @topic.category_id != SiteSetting.uncategorized_category_id && @topic.category_id && @topic.category
|
2015-07-21 20:26:58 -04:00
|
|
|
title += " - #{topic.category.name}"
|
|
|
|
end
|
|
|
|
title
|
|
|
|
end
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
def title
|
|
|
|
@topic.title
|
|
|
|
end
|
|
|
|
|
2013-07-08 12:21:39 -04:00
|
|
|
def desired_post
|
|
|
|
return @desired_post if @desired_post.present?
|
2013-03-07 17:31:06 -05:00
|
|
|
return nil if posts.blank?
|
2013-07-08 12:21:39 -04:00
|
|
|
|
|
|
|
@desired_post = posts.detect {|p| p.post_number == @post_number.to_i}
|
|
|
|
@desired_post ||= posts.first
|
|
|
|
@desired_post
|
|
|
|
end
|
|
|
|
|
|
|
|
def summary
|
|
|
|
return nil if desired_post.blank?
|
2013-09-04 19:33:30 -04:00
|
|
|
# TODO, this is actually quite slow, should be cached in the post table
|
2014-12-07 18:23:53 -05:00
|
|
|
excerpt = desired_post.excerpt(500, strip_links: true, text_entities: true)
|
|
|
|
(excerpt || "").gsub(/\n/, ' ').strip
|
2013-03-07 17:31:06 -05:00
|
|
|
end
|
|
|
|
|
2015-12-28 07:52:31 -05:00
|
|
|
def read_time
|
|
|
|
return nil if @post_number.present? && @post_number.to_i != 1 # only show for topic URLs
|
2015-12-30 01:45:17 -05:00
|
|
|
(@topic.word_count/SiteSetting.read_time_word_count).floor if @topic.word_count
|
2015-12-28 07:52:31 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def like_count
|
|
|
|
return nil if @post_number.present? && @post_number.to_i != 1 # only show for topic URLs
|
|
|
|
@topic.like_count
|
|
|
|
end
|
|
|
|
|
2013-03-08 15:58:37 -05:00
|
|
|
def image_url
|
2016-04-14 14:31:20 -04:00
|
|
|
if @post_number.present? && @post_number.to_i != 1 && @desired_post.present?
|
2016-10-31 05:41:33 -04:00
|
|
|
if @desired_post.image_url.present?
|
|
|
|
@desired_post.image_url
|
|
|
|
elsif @desired_post.user
|
|
|
|
# show poster avatar
|
2016-11-26 12:25:39 -05:00
|
|
|
@desired_post.user.avatar_template_url.gsub("{size}", "200")
|
2016-10-31 05:41:33 -04:00
|
|
|
end
|
2016-04-14 14:31:20 -04:00
|
|
|
else
|
2016-08-19 07:34:43 -04:00
|
|
|
@topic.image_url
|
2016-04-14 14:31:20 -04:00
|
|
|
end
|
2013-03-08 15:58:37 -05:00
|
|
|
end
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
def filter_posts(opts = {})
|
2013-03-26 11:58:49 -04:00
|
|
|
return filter_posts_near(opts[:post_number].to_i) if opts[:post_number].present?
|
2013-06-20 17:20:08 -04:00
|
|
|
return filter_posts_by_ids(opts[:post_ids]) if opts[:post_ids].present?
|
|
|
|
return filter_best(opts[:best], opts) if opts[:best].present?
|
2013-07-01 07:29:45 -04:00
|
|
|
|
2016-02-24 22:32:16 -05:00
|
|
|
filter_posts_paged(@page)
|
2013-03-26 11:58:49 -04:00
|
|
|
end
|
|
|
|
|
2014-02-10 16:59:36 -05:00
|
|
|
def primary_group_names
|
|
|
|
return @group_names if @group_names
|
|
|
|
|
|
|
|
primary_group_ids = Set.new
|
|
|
|
@posts.each do |p|
|
|
|
|
primary_group_ids << p.user.primary_group_id if p.user.try(:primary_group_id)
|
|
|
|
end
|
|
|
|
|
|
|
|
result = {}
|
|
|
|
unless primary_group_ids.empty?
|
|
|
|
Group.where(id: primary_group_ids.to_a).pluck(:id, :name).each do |g|
|
|
|
|
result[g[0]] = g[1]
|
|
|
|
end
|
|
|
|
end
|
2015-09-28 02:38:34 -04:00
|
|
|
|
|
|
|
@group_names = result
|
2014-02-10 16:59:36 -05:00
|
|
|
end
|
2013-03-28 01:53:11 -04:00
|
|
|
|
2013-03-26 11:58:49 -04:00
|
|
|
# Find the sort order for a post in the topic
|
|
|
|
def sort_order_for_post_number(post_number)
|
2015-09-10 16:01:23 -04:00
|
|
|
posts = Post.where(topic_id: @topic.id, post_number: post_number).with_deleted
|
|
|
|
posts = filter_post_types(posts)
|
|
|
|
posts.select(:sort_order).first.try(:sort_order)
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
# Filter to all posts near a particular post number
|
|
|
|
def filter_posts_near(post_number)
|
2013-08-13 10:29:25 -04:00
|
|
|
min_idx, max_idx = get_minmax_ids(post_number)
|
2013-03-26 11:58:49 -04:00
|
|
|
filter_posts_in_range(min_idx, max_idx)
|
2013-02-10 13:50:26 -05:00
|
|
|
end
|
2013-02-05 14:16:51 -05:00
|
|
|
|
|
|
|
|
|
|
|
def filter_posts_paged(page)
|
2013-04-03 18:12:27 -04:00
|
|
|
page = [page, 1].max
|
2014-01-03 12:52:24 -05:00
|
|
|
min = @limit * (page - 1)
|
|
|
|
|
|
|
|
# Sometimes we don't care about the OP, for example when embedding comments
|
|
|
|
min = 1 if min == 0 && @exclude_first
|
|
|
|
|
|
|
|
max = (min + @limit) - 1
|
2013-07-05 14:45:54 -04:00
|
|
|
|
2013-03-26 11:58:49 -04:00
|
|
|
filter_posts_in_range(min, max)
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
|
|
|
|
2013-07-01 07:29:45 -04:00
|
|
|
def filter_best(max, opts={})
|
2013-07-12 04:33:45 -04:00
|
|
|
filter = FilterBestPosts.new(@topic, @filtered_posts, max, opts)
|
|
|
|
@posts = filter.posts
|
|
|
|
@filtered_posts = filter.filtered_posts
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def read?(post_number)
|
2014-06-02 21:48:52 -04:00
|
|
|
return true unless @user
|
2013-02-05 14:16:51 -05:00
|
|
|
read_posts_set.include?(post_number)
|
|
|
|
end
|
|
|
|
|
2014-07-15 17:02:43 -04:00
|
|
|
def has_deleted?
|
2014-08-04 11:29:01 -04:00
|
|
|
@predelete_filtered_posts.with_deleted
|
|
|
|
.where("posts.deleted_at IS NOT NULL")
|
2014-08-07 13:12:35 -04:00
|
|
|
.where("posts.post_number > 1")
|
2014-08-04 11:29:01 -04:00
|
|
|
.exists?
|
2014-07-15 17:02:43 -04:00
|
|
|
end
|
|
|
|
|
2013-02-05 14:16:51 -05:00
|
|
|
def topic_user
|
|
|
|
@topic_user ||= begin
|
|
|
|
return nil if @user.blank?
|
2014-05-06 09:41:59 -04:00
|
|
|
@topic.topic_users.find_by(user_id: @user.id)
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-03-26 14:06:24 -04:00
|
|
|
def post_counts_by_user
|
2014-08-04 11:29:01 -04:00
|
|
|
@post_counts_by_user ||= Post.where(topic_id: @topic.id)
|
2015-01-15 15:39:26 -05:00
|
|
|
.where("user_id IS NOT NULL")
|
2014-08-04 11:29:01 -04:00
|
|
|
.group(:user_id)
|
|
|
|
.order("count_all DESC")
|
|
|
|
.limit(24)
|
|
|
|
.count
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def participants
|
|
|
|
@participants ||= begin
|
|
|
|
participants = {}
|
2013-03-26 14:06:24 -04:00
|
|
|
User.where(id: post_counts_by_user.map {|k,v| k}).each {|u| participants[u.id] = u}
|
2013-02-05 14:16:51 -05:00
|
|
|
participants
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def all_post_actions
|
2014-06-04 11:41:11 -04:00
|
|
|
@all_post_actions ||= PostAction.counts_for(@posts, @user)
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
|
|
|
|
2014-08-04 11:29:01 -04:00
|
|
|
def all_active_flags
|
|
|
|
@all_active_flags ||= PostAction.active_flags_counts_for(@posts)
|
|
|
|
end
|
|
|
|
|
2013-02-05 14:16:51 -05:00
|
|
|
def links
|
2013-11-15 12:15:46 -05:00
|
|
|
@links ||= TopicLink.topic_map(guardian, @topic.id)
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def link_counts
|
2013-06-05 02:10:26 -04:00
|
|
|
@link_counts ||= TopicLink.counts_for(guardian,@topic, posts)
|
2013-02-25 11:42:20 -05:00
|
|
|
end
|
2013-02-05 14:16:51 -05:00
|
|
|
|
|
|
|
# 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
|
|
|
|
@suggested_topics ||= TopicQuery.new(@user).list_suggested_for(topic)
|
|
|
|
end
|
|
|
|
|
2013-02-14 20:58:14 -05:00
|
|
|
# This is pending a larger refactor, that allows custom orders
|
2013-02-25 11:42:20 -05:00
|
|
|
# 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
|
2013-02-14 20:58:14 -05:00
|
|
|
# streams
|
|
|
|
def highest_post_number
|
2013-03-26 11:58:49 -04:00
|
|
|
@highest_post_number ||= @filtered_posts.maximum(:post_number)
|
2013-02-14 20:58:14 -05:00
|
|
|
end
|
|
|
|
|
2013-02-21 13:20:00 -05:00
|
|
|
def recent_posts
|
2013-03-26 11:58:49 -04:00
|
|
|
@filtered_posts.by_newest.with_user.first(25)
|
2013-02-21 13:20:00 -05:00
|
|
|
end
|
|
|
|
|
2013-06-28 12:20:06 -04:00
|
|
|
def current_post_ids
|
|
|
|
@current_post_ids ||= if @posts.is_a?(Array)
|
|
|
|
@posts.map {|p| p.id }
|
|
|
|
else
|
2013-10-04 04:06:32 -04:00
|
|
|
@posts.pluck(:post_number)
|
2013-06-28 12:20:06 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-05-17 13:03:08 -04:00
|
|
|
# Returns an array of [id, post_number, days_ago] tuples. `days_ago` is there for the timeline
|
|
|
|
# calculations.
|
|
|
|
def filtered_post_stream
|
|
|
|
@filtered_post_stream ||= @filtered_posts.order(:sort_order)
|
|
|
|
.pluck(:id,
|
|
|
|
:post_number,
|
|
|
|
'EXTRACT(DAYS FROM CURRENT_TIMESTAMP - created_at)::INT AS days_ago')
|
|
|
|
end
|
|
|
|
|
2013-08-13 10:29:25 -04:00
|
|
|
def filtered_post_ids
|
2016-05-17 13:03:08 -04:00
|
|
|
@filtered_post_ids ||= filtered_post_stream.map {|tuple| tuple[0]}
|
2013-08-13 10:29:25 -04:00
|
|
|
end
|
|
|
|
|
2013-02-05 14:16:51 -05:00
|
|
|
protected
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
def read_posts_set
|
|
|
|
@read_posts_set ||= begin
|
|
|
|
result = Set.new
|
|
|
|
return result unless @user.present?
|
|
|
|
return result unless topic_user.present?
|
2013-02-05 14:16:51 -05:00
|
|
|
|
2013-10-04 04:06:32 -04:00
|
|
|
post_numbers = PostTiming
|
2013-03-26 11:58:49 -04:00
|
|
|
.where(topic_id: @topic.id, user_id: @user.id)
|
2013-06-28 12:20:06 -04:00
|
|
|
.where(post_number: current_post_ids)
|
2013-03-26 11:58:49 -04:00
|
|
|
.pluck(:post_number)
|
2013-02-05 14:16:51 -05:00
|
|
|
|
2013-03-26 11:58:49 -04:00
|
|
|
post_numbers.each {|pn| result << pn}
|
2013-02-10 13:50:26 -05:00
|
|
|
result
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|
2013-02-10 13:50:26 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
private
|
|
|
|
|
2015-09-10 16:01:23 -04:00
|
|
|
def filter_post_types(posts)
|
2015-09-21 18:50:52 -04:00
|
|
|
visible_types = Topic.visible_post_types(@user)
|
2015-09-10 16:01:23 -04:00
|
|
|
|
|
|
|
if @user.present?
|
2016-04-20 15:29:27 -04:00
|
|
|
posts.where("posts.user_id = ? OR post_type IN (?)", @user.id, visible_types)
|
2015-09-10 16:01:23 -04:00
|
|
|
else
|
|
|
|
posts.where(post_type: visible_types)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-06-20 17:20:08 -04:00
|
|
|
def filter_posts_by_ids(post_ids)
|
|
|
|
# TODO: Sort might be off
|
2014-05-29 07:55:55 -04:00
|
|
|
@posts = Post.where(id: post_ids, topic_id: @topic.id)
|
2016-04-20 15:29:27 -04:00
|
|
|
.includes(:user, :reply_to_user, :incoming_email)
|
2013-06-20 17:20:08 -04:00
|
|
|
.order('sort_order')
|
2015-09-10 16:01:23 -04:00
|
|
|
@posts = filter_post_types(@posts)
|
2014-07-15 17:02:43 -04:00
|
|
|
@posts = @posts.with_deleted if @guardian.can_see_deleted_posts?
|
2013-06-20 17:20:08 -04:00
|
|
|
@posts
|
|
|
|
end
|
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
def filter_posts_in_range(min, max)
|
2013-05-18 16:11:01 -04:00
|
|
|
post_count = (filtered_post_ids.length - 1)
|
2013-03-26 11:58:49 -04:00
|
|
|
|
2013-05-18 16:11:01 -04:00
|
|
|
max = [max, post_count].min
|
2013-05-19 20:29:49 -04:00
|
|
|
|
|
|
|
return @posts = [] if min > max
|
|
|
|
|
2013-05-18 16:11:01 -04:00
|
|
|
min = [[min, max].min, 0].max
|
2013-03-26 11:58:49 -04:00
|
|
|
|
2013-06-20 17:20:08 -04:00
|
|
|
@posts = filter_posts_by_ids(filtered_post_ids[min..max])
|
2013-03-26 11:58:49 -04:00
|
|
|
@posts
|
2013-02-10 13:50:26 -05:00
|
|
|
end
|
2013-02-05 14:16:51 -05:00
|
|
|
|
2013-02-10 13:50:26 -05:00
|
|
|
def find_topic(topic_id)
|
2015-09-11 11:29:44 -04:00
|
|
|
# with_deleted covered in #check_and_raise_exceptions
|
|
|
|
finder = Topic.with_deleted.where(id: topic_id).includes(:category)
|
2013-07-11 16:38:46 -04:00
|
|
|
finder.first
|
2013-02-10 13:50:26 -05:00
|
|
|
end
|
2013-07-12 04:33:45 -04:00
|
|
|
|
2013-12-04 15:56:09 -05:00
|
|
|
def unfiltered_posts
|
2015-09-10 16:01:23 -04:00
|
|
|
result = filter_post_types(@topic.posts)
|
2014-07-15 17:02:43 -04:00
|
|
|
result = result.with_deleted if @guardian.can_see_deleted_posts?
|
2016-05-03 15:19:59 -04:00
|
|
|
result = result.where("user_id IS NOT NULL") if @exclude_deleted_users
|
|
|
|
result = result.where(hidden: false) if @exclude_hidden
|
2013-12-04 15:56:09 -05:00
|
|
|
result
|
|
|
|
end
|
|
|
|
|
2013-07-12 04:33:45 -04:00
|
|
|
def setup_filtered_posts
|
2013-12-04 15:56:09 -05:00
|
|
|
# Certain filters might leave gaps between posts. If that's true, we can return a gap structure
|
|
|
|
@contains_gaps = false
|
|
|
|
@filtered_posts = unfiltered_posts
|
|
|
|
|
|
|
|
# Filters
|
|
|
|
if @filter == 'summary'
|
2015-01-30 01:19:42 -05:00
|
|
|
@filtered_posts = @filtered_posts.summary(@topic.id)
|
2013-12-04 15:56:09 -05:00
|
|
|
@contains_gaps = true
|
|
|
|
end
|
|
|
|
|
|
|
|
if @best.present?
|
2015-07-24 16:39:03 -04:00
|
|
|
@filtered_posts = @filtered_posts.where('posts.post_type = ?', Post.types[:regular])
|
2013-12-04 15:56:09 -05:00
|
|
|
@contains_gaps = true
|
|
|
|
end
|
|
|
|
|
2014-07-15 17:02:43 -04:00
|
|
|
# Username filters
|
2013-12-04 15:56:09 -05:00
|
|
|
if @username_filters.present?
|
|
|
|
usernames = @username_filters.map{|u| u.downcase}
|
2014-08-04 11:29:01 -04:00
|
|
|
@filtered_posts = @filtered_posts.where('post_number = 1 OR posts.user_id IN (SELECT u.id FROM users u WHERE username_lower IN (?))', usernames)
|
2013-12-04 15:56:09 -05:00
|
|
|
@contains_gaps = true
|
|
|
|
end
|
|
|
|
|
2014-07-15 17:02:43 -04:00
|
|
|
# Deleted
|
|
|
|
# This should be last - don't want to tell the admin about deleted posts that clicking the button won't show
|
|
|
|
# copy the filter for has_deleted? method
|
|
|
|
@predelete_filtered_posts = @filtered_posts.spawn
|
|
|
|
if @guardian.can_see_deleted_posts? && !@show_deleted && has_deleted?
|
2014-08-07 13:12:35 -04:00
|
|
|
@filtered_posts = @filtered_posts.where("deleted_at IS NULL OR post_number = 1")
|
2014-07-15 17:02:43 -04:00
|
|
|
@contains_gaps = true
|
|
|
|
end
|
|
|
|
|
2013-07-12 04:33:45 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def check_and_raise_exceptions
|
|
|
|
raise Discourse::NotFound if @topic.blank?
|
|
|
|
# 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
|
2015-09-18 03:14:10 -04:00
|
|
|
raise Discourse::InvalidAccess.new("can't see #{@topic}", @topic) unless guardian.can_see?(@topic)
|
2013-07-12 04:33:45 -04:00
|
|
|
end
|
|
|
|
|
2013-08-13 10:29:25 -04:00
|
|
|
def get_minmax_ids(post_number)
|
|
|
|
# Find the closest number we have
|
|
|
|
closest_index = closest_post_to(post_number)
|
|
|
|
return nil if closest_index.nil?
|
|
|
|
|
|
|
|
# Make sure to get at least one post before, even with rounding
|
2014-01-03 12:52:24 -05:00
|
|
|
posts_before = (@limit.to_f / 4).floor
|
2013-08-13 10:29:25 -04:00
|
|
|
posts_before = 1 if posts_before.zero?
|
|
|
|
|
|
|
|
min_idx = closest_index - posts_before
|
|
|
|
min_idx = 0 if min_idx < 0
|
2014-01-03 12:52:24 -05:00
|
|
|
max_idx = min_idx + (@limit - 1)
|
2013-08-13 10:29:25 -04:00
|
|
|
|
|
|
|
# Get a full page even if at the end
|
|
|
|
ensure_full_page(min_idx, max_idx)
|
|
|
|
end
|
|
|
|
|
|
|
|
def ensure_full_page(min, max)
|
|
|
|
upper_limit = (filtered_post_ids.length - 1)
|
|
|
|
if max >= upper_limit
|
2014-01-03 12:52:24 -05:00
|
|
|
return (upper_limit - @limit) + 1, upper_limit
|
2013-08-13 10:29:25 -04:00
|
|
|
else
|
|
|
|
return min, max
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def closest_post_to(post_number)
|
2015-05-04 02:11:04 -04:00
|
|
|
# happy path
|
|
|
|
closest_post = @filtered_posts.where("post_number = ?", post_number).limit(1).pluck(:id)
|
|
|
|
|
|
|
|
if closest_post.empty?
|
|
|
|
# less happy path, missing post
|
|
|
|
closest_post = @filtered_posts.order("@(post_number - #{post_number})").limit(1).pluck(:id)
|
|
|
|
end
|
|
|
|
|
2015-04-22 10:10:09 -04:00
|
|
|
return nil if closest_post.empty?
|
2013-08-13 10:29:25 -04:00
|
|
|
|
2015-04-22 10:10:09 -04:00
|
|
|
filtered_post_ids.index(closest_post.first) || filtered_post_ids[0]
|
2013-08-13 10:29:25 -04:00
|
|
|
end
|
|
|
|
|
2013-02-05 14:16:51 -05:00
|
|
|
end
|