2013-02-25 11:42:20 -05:00
#
2015-09-02 14:25:18 -04:00
# Helps us find topics.
# Returns a TopicList object containing the topics found.
2013-02-05 14:16:51 -05:00
#
2015-09-02 14:25:18 -04:00
2013-02-05 14:16:51 -05:00
require_dependency 'topic_list'
2013-07-12 14:38:20 -04:00
require_dependency 'suggested_topics_builder'
2013-11-13 12:26:32 -05:00
require_dependency 'topic_query_sql'
2016-02-03 02:50:05 -05:00
require_dependency 'avatar_lookup'
2013-02-05 14:16:51 -05:00
class TopicQuery
2017-02-15 15:25:43 -05:00
2017-02-15 17:27:10 -05:00
def self . public_valid_options
@public_valid_options || =
% i ( page
2017-03-02 14:54:26 -05:00
before
2017-03-02 15:11:38 -05:00
bumped_before
2017-02-15 15:25:43 -05:00
topic_ids
2017-02-15 17:27:10 -05:00
exclude_category_ids
2017-02-15 15:25:43 -05:00
category
order
ascending
2017-02-15 17:27:10 -05:00
min_posts
max_posts
2017-02-15 15:25:43 -05:00
status
2017-02-15 17:27:10 -05:00
filter
2017-02-15 15:25:43 -05:00
state
search
2017-02-15 17:27:10 -05:00
q
2017-02-15 15:25:43 -05:00
group_name
2017-02-15 17:27:10 -05:00
tags
match_all_tags
no_subcategories
slow_platform
2018-03-11 00:29:34 -05:00
no_tags )
2017-02-15 17:27:10 -05:00
end
def self . valid_options
@valid_options || =
public_valid_options +
% i ( except_topic_ids
limit
page
per_page
visible
2018-01-15 00:13:29 -05:00
guardian
2018-03-13 15:59:12 -04:00
no_definitions
destination_category_id )
2017-02-15 15:25:43 -05:00
end
2014-04-16 12:05:54 -04:00
# Maps `order` to a columns in `topics`
2013-11-13 14:17:06 -05:00
SORTABLE_MAPPING = {
'likes' = > 'like_count' ,
2014-10-02 23:16:53 -04:00
'op_likes' = > 'op_likes' ,
2013-11-13 14:17:06 -05:00
'views' = > 'views' ,
'posts' = > 'posts_count' ,
2014-08-18 13:26:12 -04:00
'activity' = > 'bumped_at' ,
2013-11-14 15:50:36 -05:00
'posters' = > 'participant_count' ,
2014-08-27 12:42:54 -04:00
'category' = > 'category_id' ,
'created' = > 'created_at'
2013-11-13 14:17:06 -05:00
}
2015-12-21 11:43:17 -05:00
cattr_accessor :results_filter_callbacks
self . results_filter_callbacks = [ ]
2017-02-15 15:25:43 -05:00
attr_accessor :options , :user , :guardian
def self . add_custom_filter ( key , & blk )
@custom_filters || = { }
valid_options << key
2017-02-15 17:27:10 -05:00
public_valid_options << key
2017-02-15 15:25:43 -05:00
@custom_filters [ key ] = blk
end
def self . remove_custom_filter ( key )
@custom_filters . delete ( key )
2017-02-15 17:27:10 -05:00
public_valid_options . delete ( key )
2017-02-15 15:25:43 -05:00
valid_options . delete ( key )
@custom_filters = nil if @custom_filters . length == 0
end
def self . apply_custom_filters ( results , topic_query )
if @custom_filters
2017-07-27 21:20:09 -04:00
@custom_filters . each do | key , filter |
2017-02-15 15:25:43 -05:00
results = filter . call ( results , topic_query )
end
end
results
end
2017-07-27 21:20:09 -04:00
def initialize ( user = nil , options = { } )
2017-02-15 15:25:43 -05:00
options . assert_valid_keys ( TopicQuery . valid_options )
2015-09-21 15:14:05 -04:00
@options = options . dup
2013-07-16 15:20:18 -04:00
@user = user
2018-01-15 00:13:29 -05:00
@guardian = options [ :guardian ] || Guardian . new ( @user )
2013-02-05 14:16:51 -05:00
end
2017-07-27 21:20:09 -04:00
def joined_topic_user ( list = nil )
2014-02-21 14:17:45 -05:00
( list || Topic ) . joins ( " LEFT OUTER JOIN topic_users AS tu ON (topics.id = tu.topic_id AND tu.user_id = #{ @user . id . to_i } ) " )
end
2013-02-05 14:16:51 -05:00
# Return a list of suggested topics for a topic
2013-02-25 11:42:20 -05:00
def list_suggested_for ( topic )
2018-01-23 12:05:44 -05:00
# Don't suggest messages unless we have a user, and private messages are
# enabled.
return if topic . private_message? &&
2018-01-31 01:03:12 -05:00
( @user . blank? || ! SiteSetting . enable_personal_messages? )
2016-02-03 02:50:05 -05:00
2013-07-12 14:38:20 -04:00
builder = SuggestedTopicsBuilder . new ( topic )
2013-02-05 14:16:51 -05:00
2016-02-03 02:50:05 -05:00
pm_params =
if topic . private_message?
group_ids = topic . topic_allowed_groups
PERF: Avoid `NOT IN (<subquery>>` which can get really slow.
```
EXPLAIN ANALYZE SELECT "topics".*
FROM "topics" LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND
tu.user_id = 13455
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (
topics.id IN (
SELECT topic_id
FROM topic_allowed_users
WHERE user_id = 13455
)
)
AND (
topics.id IN (
SELECT ta.topic_id
FROM topic_allowed_users ta
WHERE ta.user_id IN (2,1995,8307,17621,22980,-10)
)
OR
topics.id IN (
SELECT tg.topic_id
FROM topic_allowed_groups tg
WHERE tg.group_id IN (-10)
)
)
AND (topics.id NOT IN (68559,60069,42145))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at
DESC LIMIT 5;
```
Planning time: 1.196 ms
Execution time: 21.176 ms
```
EXPLAIN ANALYZE SELECT "topics".*
FROM "topics"
LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND tu.user_id =
13455
LEFT JOIN topic_allowed_users ta ON topics.id = ta.topic_id AND
ta.user_id = 13455
LEFT JOIN topic_allowed_users ta2 ON topics.id = ta2.topic_id AND
ta2.user_id IN (2,1995,8307,17621,22980,-10)
LEFT JOIN topic_allowed_groups tg ON topics.id = tg.topic_id AND
tg.group_id IN (-10)
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (ta.topic_id IS NOT NULL)
AND (ta2.topic_id IS NOT NULL OR tg.topic_id IS NOT NULL)
AND (topics.id NOT IN (68559,60069,42145))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at DESC
LIMIT 5;
```
Planning time: 1.792 ms
Execution time: 2.546 ms
2017-09-13 10:22:33 -04:00
. joins ( "
LEFT JOIN group_users gu
ON topic_allowed_groups . group_id = gu . group_id
AND user_id = #{@user.id.to_i}
" )
2017-09-15 10:45:01 -04:00
. where ( " gu.group_id IS NOT NULL " )
2017-07-27 21:20:09 -04:00
. pluck ( :group_id )
PERF: Avoid `NOT IN (<subquery>>` which can get really slow.
```
EXPLAIN ANALYZE SELECT "topics".*
FROM "topics" LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND
tu.user_id = 13455
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (
topics.id IN (
SELECT topic_id
FROM topic_allowed_users
WHERE user_id = 13455
)
)
AND (
topics.id IN (
SELECT ta.topic_id
FROM topic_allowed_users ta
WHERE ta.user_id IN (2,1995,8307,17621,22980,-10)
)
OR
topics.id IN (
SELECT tg.topic_id
FROM topic_allowed_groups tg
WHERE tg.group_id IN (-10)
)
)
AND (topics.id NOT IN (68559,60069,42145))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at
DESC LIMIT 5;
```
Planning time: 1.196 ms
Execution time: 21.176 ms
```
EXPLAIN ANALYZE SELECT "topics".*
FROM "topics"
LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND tu.user_id =
13455
LEFT JOIN topic_allowed_users ta ON topics.id = ta.topic_id AND
ta.user_id = 13455
LEFT JOIN topic_allowed_users ta2 ON topics.id = ta2.topic_id AND
ta2.user_id IN (2,1995,8307,17621,22980,-10)
LEFT JOIN topic_allowed_groups tg ON topics.id = tg.topic_id AND
tg.group_id IN (-10)
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (ta.topic_id IS NOT NULL)
AND (ta2.topic_id IS NOT NULL OR tg.topic_id IS NOT NULL)
AND (topics.id NOT IN (68559,60069,42145))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at DESC
LIMIT 5;
```
Planning time: 1.792 ms
Execution time: 2.546 ms
2017-09-13 10:22:33 -04:00
2016-02-03 02:50:05 -05:00
{
topic : topic ,
my_group_ids : group_ids ,
target_group_ids : topic . topic_allowed_groups . pluck ( :group_id ) ,
target_user_ids : topic . topic_allowed_users . pluck ( :user_id ) - [ @user . id ]
}
end
2013-07-12 14:38:20 -04:00
# When logged in we start with different results
2013-07-16 15:20:18 -04:00
if @user
2016-02-03 02:50:05 -05:00
if topic . private_message?
builder . add_results ( new_messages (
pm_params . merge ( count : builder . results_left )
) ) unless builder . full?
builder . add_results ( unread_messages (
pm_params . merge ( count : builder . results_left )
) ) unless builder . full?
else
builder . add_results ( unread_results ( topic : topic , per_page : builder . results_left ) , :high )
builder . add_results ( new_results ( topic : topic , per_page : builder . category_results_left ) ) unless builder . full?
end
2013-02-05 14:16:51 -05:00
end
2016-02-03 02:50:05 -05:00
if topic . private_message?
builder . add_results ( related_messages_group (
pm_params . merge ( count : [ 3 , builder . results_left ] . max ,
exclude : builder . excluded_topic_ids )
) ) if pm_params [ :my_group_ids ] . present?
builder . add_results ( related_messages_user (
pm_params . merge ( count : [ 3 , builder . results_left ] . max ,
exclude : builder . excluded_topic_ids )
) )
else
builder . add_results ( random_suggested ( topic , builder . results_left , builder . excluded_topic_ids ) ) unless builder . full?
end
2017-07-27 21:20:09 -04:00
params = { unordered : true }
2016-02-03 02:50:05 -05:00
if topic . private_message?
params [ :preload_posters ] = true
end
create_list ( :suggested , params , builder . results )
2013-02-05 14:16:51 -05:00
end
2013-03-27 16:17:49 -04:00
# The latest view of topics
def list_latest
2014-10-08 12:44:47 -04:00
create_list ( :latest , { } , latest_results )
2013-02-05 14:16:51 -05:00
end
def list_read
2013-04-02 16:52:51 -04:00
create_list ( :read , unordered : true ) do | topics |
2017-04-26 12:26:37 -04:00
topics . where ( 'tu.last_visited_at IS NOT NULL' ) . order ( 'tu.last_visited_at DESC' )
2013-02-05 14:16:51 -05:00
end
end
def list_new
2017-07-27 21:20:09 -04:00
create_list ( :new , { unordered : true } , new_results )
2013-02-05 14:16:51 -05:00
end
def list_unread
2017-07-27 21:20:09 -04:00
create_list ( :unread , { unordered : true } , unread_results )
2013-02-05 14:16:51 -05:00
end
def list_posted
2017-07-27 21:20:09 -04:00
create_list ( :posted ) { | l | l . where ( 'tu.posted' ) }
2013-02-05 14:16:51 -05:00
end
2015-01-24 23:53:11 -05:00
def list_bookmarks
2017-07-27 21:20:09 -04:00
create_list ( :bookmarks ) { | l | l . where ( 'tu.bookmarked' ) }
2015-01-24 23:53:11 -05:00
end
2013-12-27 12:10:35 -05:00
def list_top_for ( period )
score = " #{ period } _score "
2013-12-23 18:50:36 -05:00
create_list ( :top , unordered : true ) do | topics |
2014-01-18 13:03:09 -05:00
topics = topics . joins ( :top_topic ) . where ( " top_topics. #{ score } > 0 " )
2014-09-05 01:20:39 -04:00
if period == :yearly && @user . try ( :trust_level ) == TrustLevel [ 0 ]
2014-01-18 13:03:09 -05:00
topics . order ( TopicQuerySQL . order_top_with_pinned_category_for ( score ) )
else
topics . order ( TopicQuerySQL . order_top_for ( score ) )
end
2013-12-23 18:50:36 -05:00
end
2014-01-13 19:02:14 -05:00
end
2013-07-24 17:15:21 -04:00
def list_topics_by ( user )
2015-03-23 18:12:37 -04:00
@options [ :filtered_to_user ] = user . id
2013-07-24 17:15:21 -04:00
create_list ( :user_topics ) do | topics |
topics . where ( user_id : user . id )
end
end
2015-12-22 19:09:17 -05:00
def not_archived ( list , user )
list . joins ( " LEFT JOIN user_archived_messages um
ON um . user_id = #{user.id.to_i} AND um.topic_id = topics.id")
2017-07-27 21:20:09 -04:00
. where ( 'um.user_id IS NULL' )
2015-12-22 19:09:17 -05:00
end
2018-03-14 07:40:28 -04:00
def list_group_topics ( group )
list = default_results . where ( "
topics . user_id IN (
SELECT user_id FROM group_users gu WHERE gu . group_id = #{group.id.to_i}
)
" )
create_list ( :group_topics , { } , list )
end
2013-08-24 16:58:16 -04:00
def list_private_messages ( user )
2015-12-07 12:37:03 -05:00
list = private_messages_for ( user , :user )
2015-12-22 19:09:17 -05:00
list = not_archived ( list , user )
2017-07-27 21:20:09 -04:00
. where ( 'NOT (topics.participant_count = 1 AND topics.user_id = ?)' , user . id )
2015-12-22 19:09:17 -05:00
create_list ( :private_messages , { } , list )
end
def list_private_messages_archive ( user )
list = private_messages_for ( user , :user )
list = list . joins ( :user_archived_messages ) . where ( 'user_archived_messages.user_id = ?' , user . id )
2014-10-08 12:44:47 -04:00
create_list ( :private_messages , { } , list )
2013-08-24 16:58:16 -04:00
end
def list_private_messages_sent ( user )
2015-12-07 12:37:03 -05:00
list = private_messages_for ( user , :user )
2015-12-22 19:09:17 -05:00
list = list . where ( ' EXISTS (
SELECT 1 FROM posts
WHERE posts . topic_id = topics . id AND
posts . user_id = ?
) ' , user . id )
list = not_archived ( list , user )
2014-10-08 12:44:47 -04:00
create_list ( :private_messages , { } , list )
2013-08-24 16:58:16 -04:00
end
2013-08-30 12:32:05 -04:00
def list_private_messages_unread ( user )
2015-12-07 12:37:03 -05:00
list = private_messages_for ( user , :user )
2014-05-02 16:36:52 -04:00
list = list . where ( " tu.last_read_post_number IS NULL OR tu.last_read_post_number < topics.highest_post_number " )
2014-10-08 12:44:47 -04:00
create_list ( :private_messages , { } , list )
2013-08-30 12:32:05 -04:00
end
2013-07-24 17:15:21 -04:00
2015-12-09 19:39:33 -05:00
def list_private_messages_group ( user )
2015-12-07 12:37:03 -05:00
list = private_messages_for ( user , :group )
2015-12-22 19:09:17 -05:00
group_id = Group . where ( 'name ilike ?' , @options [ :group_name ] ) . pluck ( :id ) . first
list = list . joins ( " LEFT JOIN group_archived_messages gm ON gm.topic_id = topics.id AND
gm . group_id = #{group_id.to_i}")
list = list . where ( " gm.id IS NULL " )
create_list ( :private_messages , { } , list )
end
def list_private_messages_group_archive ( user )
list = private_messages_for ( user , :group )
group_id = Group . where ( 'name ilike ?' , @options [ :group_name ] ) . pluck ( :id ) . first
list = list . joins ( " JOIN group_archived_messages gm ON gm.topic_id = topics.id AND
gm . group_id = #{group_id.to_i}")
2015-12-07 12:37:03 -05:00
create_list ( :private_messages , { } , list )
end
2018-02-13 15:46:25 -05:00
def list_private_messages_tag ( user )
list = private_messages_for ( user , :all )
2018-02-22 09:57:02 -05:00
list = list . joins ( " JOIN topic_tags tt ON tt.topic_id = topics.id
JOIN tags t ON t . id = tt . tag_id AND t . name = '#{@options[:tags][0]}' " )
2018-02-13 15:46:25 -05:00
create_list ( :private_messages , { } , list )
end
2015-02-23 00:50:52 -05:00
def list_category_topic_ids ( category )
2015-02-24 22:24:25 -05:00
query = default_results ( category : category . id )
2018-03-22 16:38:53 -04:00
pinned_ids = query . where ( 'topics.pinned_at IS NOT NULL AND topics.category_id = ?' , category . id ) . limit ( nil ) . order ( 'pinned_at DESC' ) . pluck ( :id )
non_pinned_ids = query . where ( 'topics.pinned_at IS NULL OR topics.category_id <> ?' , category . id ) . pluck ( :id )
2015-06-10 14:36:47 -04:00
( pinned_ids + non_pinned_ids )
2013-02-05 14:16:51 -05:00
end
2013-02-27 22:36:12 -05:00
def list_new_in_category ( category )
2014-02-04 15:55:30 -05:00
create_list ( :new_in_category , unordered : true , category : category . id ) do | list |
list . by_newest . first ( 25 )
2014-01-17 17:52:06 -05:00
end
2013-02-27 22:36:12 -05:00
end
2013-07-16 15:20:18 -04:00
def self . new_filter ( list , treat_as_new_topic_start_date )
2013-05-23 01:21:07 -04:00
list . where ( " topics.created_at >= :created_at " , created_at : treat_as_new_topic_start_date )
2017-07-27 21:20:09 -04:00
. where ( " tu.last_read_post_number IS NULL " )
. where ( " COALESCE(tu.notification_level, :tracking) >= :tracking " , tracking : TopicUser . notification_levels [ :tracking ] )
2013-05-23 01:21:07 -04:00
end
2017-05-25 15:07:12 -04:00
def self . unread_filter ( list , user_id , opts )
2016-12-02 01:03:31 -05:00
col_name = opts [ :staff ] ? " highest_staff_post_number " : " highest_post_number "
2017-05-25 15:07:12 -04:00
list
2017-07-27 21:20:09 -04:00
. where ( " tu.last_read_post_number < topics. #{ col_name } " )
2017-11-19 22:49:09 -05:00
. where ( " COALESCE(tu.notification_level, :regular) >= :tracking " ,
regular : TopicUser . notification_levels [ :regular ] , tracking : TopicUser . notification_levels [ :tracking ] )
2013-05-21 02:39:51 -04:00
end
2015-02-23 00:50:52 -05:00
def prioritize_pinned_topics ( topics , options )
2015-03-11 19:42:26 -04:00
pinned_clause = options [ :category_id ] ? " topics.category_id = #{ options [ :category_id ] . to_i } AND " : " pinned_globally AND "
2015-02-23 00:50:52 -05:00
pinned_clause << " pinned_at IS NOT NULL "
if @user
pinned_clause << " AND (topics.pinned_at > tu.cleared_pinned_at OR tu.cleared_pinned_at IS NULL) "
end
unpinned_topics = topics . where ( " NOT ( #{ pinned_clause } ) " )
2015-06-25 16:25:50 -04:00
pinned_topics = topics . dup . offset ( nil ) . where ( pinned_clause )
2015-02-23 00:50:52 -05:00
per_page = options [ :per_page ] || per_page_setting
limit = per_page unless options [ :limit ] == false
page = options [ :page ] . to_i
if page == 0
( pinned_topics + unpinned_topics ) [ 0 ... limit ] if limit
else
2017-08-31 00:06:56 -04:00
offset = ( page * per_page ) - pinned_topics . length
2015-02-25 22:48:56 -05:00
offset = 0 unless offset > 0
unpinned_topics . offset ( offset ) . to_a
2015-02-23 00:50:52 -05:00
end
end
2017-07-27 21:20:09 -04:00
def create_list ( filter , options = { } , topics = nil )
2015-01-08 16:44:27 -05:00
topics || = default_results ( options )
topics = yield ( topics ) if block_given?
2015-02-23 00:50:52 -05:00
options = options . merge ( @options )
2017-07-27 21:20:09 -04:00
if [ " activity " , " default " ] . include? ( options [ :order ] || " activity " ) &&
2015-12-22 19:09:17 -05:00
! options [ :unordered ] &&
filter != :private_messages
2015-02-23 00:50:52 -05:00
topics = prioritize_pinned_topics ( topics , options )
end
2016-02-03 02:50:05 -05:00
topics = topics . to_a
if options [ :preload_posters ]
user_ids = [ ]
topics . each do | ft |
user_ids << ft . user_id << ft . last_post_user_id << ft . featured_user_ids << ft . allowed_user_ids
end
avatar_lookup = AvatarLookup . new ( user_ids )
2017-09-14 00:07:35 -04:00
primary_group_lookup = PrimaryGroupLookup . new ( user_ids )
2016-02-03 02:50:05 -05:00
topics . each do | t |
2017-09-14 00:07:35 -04:00
t . posters = t . posters_summary (
avatar_lookup : avatar_lookup ,
primary_group_lookup : primary_group_lookup
)
2016-02-03 02:50:05 -05:00
end
end
topics . each do | t |
2017-07-27 21:20:09 -04:00
t . allowed_user_ids = filter == :private_messages ? t . allowed_users . map { | u | u . id } : [ ]
2015-02-23 00:50:52 -05:00
end
2016-02-03 02:50:05 -05:00
list = TopicList . new ( filter , @user , topics , options . merge ( @options ) )
2015-01-08 16:44:27 -05:00
list . per_page = per_page_setting
list
end
2017-07-27 21:20:09 -04:00
def latest_results ( options = { } )
2015-01-08 16:44:27 -05:00
result = default_results ( options )
2015-11-01 23:05:08 -05:00
result = remove_muted_topics ( result , @user ) unless options && options [ :state ] == " muted " . freeze
2015-01-08 16:44:27 -05:00
result = remove_muted_categories ( result , @user , exclude : options [ :category ] )
2016-04-25 15:55:15 -04:00
result = remove_muted_tags ( result , @user , options )
2015-12-21 11:43:17 -05:00
# plugins can remove topics here:
self . class . results_filter_callbacks . each do | filter_callback |
result = filter_callback . call ( :latest , result , @user , options )
end
2015-01-08 16:44:27 -05:00
result
end
2017-07-27 21:20:09 -04:00
def unread_results ( options = { } )
2017-05-25 15:07:12 -04:00
result = TopicQuery . unread_filter (
2017-07-27 21:20:09 -04:00
default_results ( options . reverse_merge ( unordered : true ) ) ,
2017-05-25 15:07:12 -04:00
@user & . id ,
staff : @user & . staff? )
2017-07-27 21:20:09 -04:00
. order ( 'CASE WHEN topics.user_id = tu.user_id THEN 1 ELSE 2 END' )
2015-12-21 11:43:17 -05:00
self . class . results_filter_callbacks . each do | filter_callback |
result = filter_callback . call ( :unread , result , @user , options )
end
2015-01-08 16:44:27 -05:00
suggested_ordering ( result , options )
end
2017-07-27 21:20:09 -04:00
def new_results ( options = { } )
2015-02-23 00:50:52 -05:00
# TODO does this make sense or should it be ordered on created_at
# it is ordering on bumped_at now
2017-07-27 21:20:09 -04:00
result = TopicQuery . new_filter ( default_results ( options . reverse_merge ( unordered : true ) ) , @user . user_option . treat_as_new_topic_start_date )
2015-11-01 17:20:22 -05:00
result = remove_muted_topics ( result , @user )
2015-01-08 16:44:27 -05:00
result = remove_muted_categories ( result , @user , exclude : options [ :category ] )
2016-04-25 15:55:15 -04:00
result = remove_muted_tags ( result , @user , options )
2015-12-21 11:43:17 -05:00
self . class . results_filter_callbacks . each do | filter_callback |
result = filter_callback . call ( :new , result , @user , options )
end
2015-01-08 16:44:27 -05:00
suggested_ordering ( result , options )
end
2013-02-05 14:16:51 -05:00
protected
2014-12-15 11:54:26 -05:00
def per_page_setting
2014-12-19 13:18:26 -05:00
@options [ :slow_platform ] ? 15 : 30
2014-12-15 11:54:26 -05:00
end
2015-12-07 12:37:03 -05:00
def private_messages_for ( user , type )
2013-08-24 16:58:16 -04:00
options = @options
2014-12-15 11:54:26 -05:00
options . reverse_merge! ( per_page : per_page_setting )
2013-08-24 16:58:16 -04:00
2016-06-27 22:01:00 -04:00
result = Topic . includes ( :tags )
2015-12-07 12:37:03 -05:00
if type == :group
2016-06-27 22:01:00 -04:00
result = result . includes ( :allowed_users )
2018-03-19 02:12:01 -04:00
result = result . where ( "
topics . id IN (
SELECT topic_id FROM topic_allowed_groups
WHERE (
group_id IN (
SELECT group_id
FROM group_users
WHERE user_id = #{user.id.to_i}
OR #{user.staff?}
)
)
AND group_id IN ( SELECT id FROM groups WHERE name ilike ?)
) " ,
@options [ :group_name ]
)
2015-12-07 12:37:03 -05:00
elsif type == :user
result = result . includes ( :allowed_users )
result = result . where ( " topics.id IN (SELECT topic_id FROM topic_allowed_users WHERE user_id = #{ user . id . to_i } ) " )
2017-03-02 09:42:56 -05:00
elsif type == :all
result = result . includes ( :allowed_users )
result = result . where ( " topics.id IN (
SELECT topic_id
FROM topic_allowed_users
WHERE user_id = #{user.id.to_i}
UNION ALL
SELECT topic_id FROM topic_allowed_groups
WHERE group_id IN (
SELECT group_id FROM group_users WHERE user_id = #{user.id.to_i}
)
) " )
2015-12-07 12:37:03 -05:00
end
result = result . joins ( " LEFT OUTER JOIN topic_users AS tu ON (topics.id = tu.topic_id AND tu.user_id = #{ user . id . to_i } ) " )
2017-07-27 21:20:09 -04:00
. order ( " topics.bumped_at DESC " )
. private_messages
2013-08-24 16:58:16 -04:00
result = result . limit ( options [ :per_page ] ) unless options [ :limit ] == false
result = result . visible if options [ :visible ] || @user . nil? || @user . regular?
2016-05-09 16:33:55 -04:00
if options [ :page ]
offset = options [ :page ] . to_i * options [ :per_page ]
result = result . offset ( offset ) if offset > 0
end
2013-08-24 16:58:16 -04:00
result
end
2018-03-26 10:43:30 -04:00
def apply_shared_drafts ( result , category_id , options )
viewing_shared = category_id && category_id == SiteSetting . shared_drafts_category . to_i
if guardian . can_create_shared_draft?
result = result . includes ( :shared_draft ) . references ( :shared_draft )
if options [ :destination_category_id ]
destination_category_id = get_category_id ( options [ :destination_category_id ] )
return result . where ( " shared_drafts.category_id " = > destination_category_id )
end
return result . where ( " shared_drafts.id IS NULL " ) unless viewing_shared
end
result
end
2013-11-13 14:17:06 -05:00
def apply_ordering ( result , options )
2014-04-16 12:05:54 -04:00
sort_column = SORTABLE_MAPPING [ options [ :order ] ] || 'default'
sort_dir = ( options [ :ascending ] == " true " ) ? " ASC " : " DESC "
2013-11-13 14:17:06 -05:00
# If we are sorting in the default order desc, we should consider including pinned
# topics. Otherwise, just use bumped_at.
if sort_column == 'default'
2013-11-14 15:50:36 -05:00
if sort_dir == 'DESC'
# If something requires a custom order, for example "unread" which sorts the least read
# to the top, do nothing
return result if options [ :unordered ]
end
2013-11-13 14:17:06 -05:00
sort_column = 'bumped_at'
end
2013-11-14 15:50:36 -05:00
# If we are sorting by category, actually use the name
if sort_column == 'category_id'
2015-02-23 00:50:52 -05:00
# TODO forces a table scan, slow
2013-11-14 15:50:36 -05:00
return result . references ( :categories ) . order ( TopicQuerySQL . order_by_category_sql ( sort_dir ) )
end
2014-10-02 23:16:53 -04:00
if sort_column == 'op_likes'
2015-01-05 01:39:49 -05:00
return result . includes ( :first_post ) . order ( " (SELECT like_count FROM posts p3 WHERE p3.topic_id = topics.id AND p3.post_number = 1) #{ sort_dir } " )
2014-10-02 23:16:53 -04:00
end
2016-02-25 11:22:23 -05:00
if sort_column . start_with? ( 'custom_fields' )
field = sort_column . split ( '.' ) [ 1 ]
return result . order ( " (SELECT CASE WHEN EXISTS (SELECT true FROM topic_custom_fields tcf WHERE tcf.topic_id::integer = topics.id::integer AND tcf.name = ' #{ field } ') THEN (SELECT value::integer FROM topic_custom_fields tcf WHERE tcf.topic_id::integer = topics.id::integer AND tcf.name = ' #{ field } ') ELSE 0 END) #{ sort_dir } " )
end
2013-11-13 14:17:06 -05:00
result . order ( " topics. #{ sort_column } #{ sort_dir } " )
end
2014-06-17 21:23:31 -04:00
def get_category_id ( category_id_or_slug )
return nil unless category_id_or_slug
category_id = category_id_or_slug . to_i
category_id = Category . where ( slug : category_id_or_slug ) . pluck ( :id ) . first if category_id == 0
category_id
end
2013-07-16 15:20:18 -04:00
# Create results based on a bunch of default options
2017-07-27 21:20:09 -04:00
def default_results ( options = { } )
2013-07-16 15:20:18 -04:00
options . reverse_merge! ( @options )
2014-12-15 11:54:26 -05:00
options . reverse_merge! ( per_page : per_page_setting )
2013-02-05 14:16:51 -05:00
2015-03-23 18:12:37 -04:00
# Whether to return visible topics
options [ :visible ] = true if @user . nil? || @user . regular?
options [ :visible ] = false if @user && @user . id == options [ :filtered_to_user ]
2013-03-06 15:17:07 -05:00
# Start with a list of all topics
2014-11-19 17:46:55 -05:00
result = Topic . unscoped
2013-03-06 15:17:07 -05:00
2013-07-16 15:20:18 -04:00
if @user
result = result . joins ( " LEFT OUTER JOIN topic_users AS tu ON (topics.id = tu.topic_id AND tu.user_id = #{ @user . id . to_i } ) " )
2017-07-27 21:20:09 -04:00
. references ( 'tu' )
2013-03-06 15:17:07 -05:00
end
2014-06-17 21:23:31 -04:00
category_id = get_category_id ( options [ :category ] )
2014-10-08 12:44:47 -04:00
@options [ :category_id ] = category_id
2014-06-17 21:23:31 -04:00
if category_id
if options [ :no_subcategories ]
result = result . where ( 'categories.id = ?' , category_id )
else
2018-01-15 00:38:58 -05:00
sql = << ~ SQL
categories . id IN (
SELECT c2 . id FROM categories c2 WHERE c2 . parent_category_id = :category_id
UNION ALL
SELECT :category_id
) AND
topics . id NOT IN (
SELECT c3 . topic_id FROM categories c3 WHERE c3 . parent_category_id = :category_id
)
SQL
result = result . where ( sql , category_id : category_id )
2013-11-08 15:05:14 -05:00
end
2014-06-17 21:23:31 -04:00
result = result . references ( :categories )
2016-11-01 12:18:31 -04:00
if ! @options [ :order ]
# category default sort order
sort_order , sort_ascending = Category . where ( id : category_id ) . pluck ( :sort_order , :sort_ascending ) . first
if sort_order
options [ :order ] = sort_order
options [ :ascending ] = ! ! sort_ascending ? 'true' : 'false'
end
end
2013-11-08 15:05:14 -05:00
end
2016-05-04 14:02:47 -04:00
# ALL TAGS: something like this?
# Topic.joins(:tags).where('tags.name in (?)', @options[:tags]).group('topic_id').having('count(*)=?', @options[:tags].size).select('topic_id')
2016-05-26 18:03:36 -04:00
if SiteSetting . tagging_enabled
result = result . preload ( :tags )
if @options [ :tags ] && @options [ :tags ] . size > 0
2016-08-11 01:38:16 -04:00
if @options [ :match_all_tags ]
2016-08-12 15:56:56 -04:00
# ALL of the given tags:
2016-08-15 15:30:17 -04:00
tags_count = @options [ :tags ] . length
2016-08-11 01:38:16 -04:00
@options [ :tags ] = Tag . where ( name : @options [ :tags ] ) . pluck ( :id ) unless @options [ :tags ] [ 0 ] . is_a? ( Integer )
2016-08-15 15:30:17 -04:00
if tags_count == @options [ :tags ] . length
@options [ :tags ] . each_with_index do | tag , index |
sql_alias = [ 't' , index ] . join
result = result . joins ( " INNER JOIN topic_tags #{ sql_alias } ON #{ sql_alias } .topic_id = topics.id AND #{ sql_alias } .tag_id = #{ tag } " )
end
else
result = result . none # don't return any results unless all tags exist in the database
2016-08-11 01:38:16 -04:00
end
2016-05-26 18:03:36 -04:00
else
2016-08-11 01:38:16 -04:00
# ANY of the given tags:
2016-08-19 11:37:32 -04:00
result = result . joins ( :tags )
2016-08-11 01:38:16 -04:00
if @options [ :tags ] [ 0 ] . is_a? ( Integer )
result = result . where ( " tags.id in (?) " , @options [ :tags ] )
else
result = result . where ( " tags.name in (?) " , @options [ :tags ] )
end
2016-05-26 18:03:36 -04:00
end
2016-07-20 16:21:43 -04:00
elsif @options [ :no_tags ]
# the following will do: ("topics"."id" NOT IN (SELECT DISTINCT "topic_tags"."topic_id" FROM "topic_tags"))
2017-08-31 00:06:56 -04:00
result = result . where . not ( id : TopicTag . distinct . pluck ( :topic_id ) )
2016-05-04 14:02:47 -04:00
end
end
2013-11-14 15:50:36 -05:00
result = apply_ordering ( result , options )
2014-09-10 22:55:10 -04:00
result = result . listable_topics . includes ( :category )
2018-03-26 10:43:30 -04:00
result = apply_shared_drafts ( result , category_id , options )
2018-03-13 15:59:12 -04:00
2015-09-02 14:25:18 -04:00
if options [ :exclude_category_ids ] && options [ :exclude_category_ids ] . is_a? ( Array ) && options [ :exclude_category_ids ] . size > 0
result = result . where ( " categories.id NOT IN (?) " , options [ :exclude_category_ids ] ) . references ( :categories )
end
2013-10-31 16:10:54 -04:00
2014-02-10 18:06:20 -05:00
# Don't include the category topics if excluded
if options [ :no_definitions ]
2014-02-04 15:55:30 -05:00
result = result . where ( 'COALESCE(categories.topic_id, 0) <> topics.id' )
end
2013-07-16 15:20:18 -04:00
result = result . limit ( options [ :per_page ] ) unless options [ :limit ] == false
2015-03-23 18:12:37 -04:00
result = result . visible if options [ :visible ]
2017-07-27 21:20:09 -04:00
result = result . where . not ( topics : { id : options [ :except_topic_ids ] } ) . references ( :topics ) if options [ :except_topic_ids ]
2016-05-09 16:33:55 -04:00
if options [ :page ]
offset = options [ :page ] . to_i * options [ :per_page ]
2016-05-11 13:39:21 -04:00
result = result . offset ( offset ) if offset > 0
2016-05-09 16:33:55 -04:00
end
2013-07-16 15:20:18 -04:00
if options [ :topic_ids ]
2013-08-16 08:53:40 -04:00
result = result . where ( 'topics.id in (?)' , options [ :topic_ids ] ) . references ( :topics )
2013-05-28 03:52:52 -04:00
end
2014-05-15 10:31:45 -04:00
if search = options [ :search ]
2018-02-20 04:47:44 -05:00
result = result . where ( " topics.id in (select pp.topic_id from post_search_data pd join posts pp on pp.id = pd.post_id where pd.search_data @@ #{ Search . ts_query ( term : search . to_s ) } ) " )
2014-05-15 10:31:45 -04:00
end
2014-07-16 19:29:09 -04:00
# NOTE protect against SYM attack can be removed with Ruby 2.2
#
state = options [ :state ]
if @user && state &&
TopicUser . notification_levels . keys . map ( & :to_s ) . include? ( state )
level = TopicUser . notification_levels [ state . to_sym ]
result = result . where ( ' topics . id IN (
SELECT topic_id
FROM topic_users
WHERE user_id = ? AND
notification_level = ?) ' , @user . id , level )
end
2014-11-19 17:46:55 -05:00
require_deleted_clause = true
2017-03-02 14:54:26 -05:00
if before = options [ :before ]
if ( before = before . to_i ) > 0
result = result . where ( 'topics.created_at < ?' , before . to_i . days . ago )
end
end
2017-03-02 15:11:38 -05:00
if bumped_before = options [ :bumped_before ]
if ( bumped_before = bumped_before . to_i ) > 0
result = result . where ( 'topics.bumped_at < ?' , bumped_before . to_i . days . ago )
end
end
2014-01-12 22:40:21 -05:00
if status = options [ :status ]
case status
when 'open'
result = result . where ( 'NOT topics.closed AND NOT topics.archived' )
when 'closed'
result = result . where ( 'topics.closed' )
when 'archived'
result = result . where ( 'topics.archived' )
2015-01-12 04:00:45 -05:00
when 'listed'
2014-09-11 19:17:16 -04:00
result = result . where ( 'topics.visible' )
2015-01-12 04:00:45 -05:00
when 'unlisted'
2014-09-11 19:21:25 -04:00
result = result . where ( 'NOT topics.visible' )
2014-11-19 17:46:55 -05:00
when 'deleted'
2015-09-22 23:13:34 -04:00
guardian = @guardian
2014-11-19 17:46:55 -05:00
if guardian . is_staff?
result = result . where ( 'topics.deleted_at IS NOT NULL' )
require_deleted_clause = false
end
2014-01-12 22:40:21 -05:00
end
end
2017-07-27 21:20:09 -04:00
if ( filter = options [ :filter ] ) && @user
2015-01-07 02:20:10 -05:00
action =
if filter == " bookmarked "
PostActionType . types [ :bookmark ]
elsif filter == " liked "
PostActionType . types [ :like ]
end
if action
result = result . where ( ' topics . id IN ( SELECT pp . topic_id
2015-01-06 21:58:34 -05:00
FROM post_actions pa
JOIN posts pp ON pp . id = pa . post_id
WHERE pa . user_id = :user_id AND
2015-01-07 02:20:10 -05:00
pa . post_action_type_id = :action AND
2015-01-06 21:58:34 -05:00
pa . deleted_at IS NULL
) ' , user_id : @user . id ,
2015-01-07 02:20:10 -05:00
action : action
2015-01-06 21:58:34 -05:00
)
2015-01-07 02:20:10 -05:00
end
2015-01-06 21:58:34 -05:00
end
2014-11-19 17:46:55 -05:00
result = result . where ( 'topics.deleted_at IS NULL' ) if require_deleted_clause
2014-06-05 09:30:24 -04:00
result = result . where ( 'topics.posts_count <= ?' , options [ :max_posts ] ) if options [ :max_posts ] . present?
result = result . where ( 'topics.posts_count >= ?' , options [ :min_posts ] ) if options [ :min_posts ] . present?
2017-07-27 21:20:09 -04:00
result = TopicQuery . apply_custom_filters ( result , self )
2017-02-15 15:25:43 -05:00
2015-09-22 23:13:34 -04:00
@guardian . filter_allowed_categories ( result )
2013-02-05 14:16:51 -05:00
end
2015-11-01 17:20:22 -05:00
def remove_muted_topics ( list , user )
if user
2015-11-01 22:59:10 -05:00
list = list . where ( 'COALESCE(tu.notification_level,1) > :muted' , muted : TopicUser . notification_levels [ :muted ] )
2015-11-01 17:20:22 -05:00
end
list
end
2017-07-27 21:20:09 -04:00
def remove_muted_categories ( list , user , opts = nil )
2014-06-17 21:23:31 -04:00
category_id = get_category_id ( opts [ :exclude ] ) if opts
2015-09-02 14:25:18 -04:00
2014-02-03 00:05:49 -05:00
if user
2015-09-02 14:25:18 -04:00
list = list . references ( " cu " )
2017-07-27 21:20:09 -04:00
. where ( "
2015-09-02 14:25:18 -04:00
NOT EXISTS (
SELECT 1
FROM category_users cu
WHERE cu . user_id = :user_id
AND cu . category_id = topics . category_id
AND cu . notification_level = :muted
AND cu . category_id < > :category_id
2015-10-13 02:54:31 -04:00
AND ( tu . notification_level IS NULL OR tu . notification_level < :tracking )
2015-09-02 14:25:18 -04:00
) " , user_id: user.id,
muted : CategoryUser . notification_levels [ :muted ] ,
2015-10-13 02:54:31 -04:00
tracking : TopicUser . notification_levels [ :tracking ] ,
2015-09-02 14:25:18 -04:00
category_id : category_id || - 1 )
2014-02-03 00:05:49 -05:00
end
list
end
2017-07-27 21:20:09 -04:00
def remove_muted_tags ( list , user , opts = nil )
2016-04-25 15:55:15 -04:00
if user . nil? || ! SiteSetting . tagging_enabled || ! SiteSetting . remove_muted_tags_from_latest
list
else
2016-08-04 11:54:39 -04:00
if ! TagUser . lookup ( user , :muted ) . exists?
2016-04-25 15:55:15 -04:00
list
else
showing_tag = if opts [ :filter ]
f = opts [ :filter ] . split ( '/' )
f [ 0 ] == 'tags' ? f [ 1 ] : nil
else
nil
end
2016-08-04 11:54:39 -04:00
if TagUser . lookup ( user , :muted ) . joins ( :tag ) . where ( 'tags.name = ?' , showing_tag ) . exists?
2016-04-25 15:55:15 -04:00
list # if viewing the topic list for a muted tag, show all the topics
else
2016-08-04 11:54:39 -04:00
muted_tag_ids = TagUser . lookup ( user , :muted ) . pluck ( :tag_id )
list = list . where ( "
EXISTS (
SELECT 1
FROM topic_tags tt
WHERE tt . tag_id NOT IN ( :tag_ids )
AND tt . topic_id = topics . id
) OR NOT EXISTS ( SELECT 1 FROM topic_tags tt WHERE tt . topic_id = topics . id ) " , tag_ids: muted_tag_ids)
2016-04-25 15:55:15 -04:00
end
end
end
end
2014-02-03 00:05:49 -05:00
2016-02-03 02:50:05 -05:00
def new_messages ( params )
2017-05-26 11:00:31 -04:00
TopicQuery . new_filter ( messages_for_groups_or_user ( params [ :my_group_ids ] ) , Time . at ( SiteSetting . min_new_topics_time ) . to_datetime )
2017-07-27 21:20:09 -04:00
. limit ( params [ :count ] )
2016-02-03 02:50:05 -05:00
end
def unread_messages ( params )
2017-05-25 15:07:12 -04:00
TopicQuery . unread_filter (
messages_for_groups_or_user ( params [ :my_group_ids ] ) ,
@user & . id ,
staff : @user & . staff? )
2017-07-27 21:20:09 -04:00
. limit ( params [ :count ] )
2016-02-03 02:50:05 -05:00
end
def related_messages_user ( params )
2017-09-15 10:45:01 -04:00
messages = messages_for_user . limit ( params [ :count ] )
messages = allowed_messages ( messages , params )
PERF: Avoid unnecessary expensive joins if possible.
```
EXPLAIN ANALYZE SELECT "topics".* FROM "topics"
LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND tu.user_id =
13455
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (
topics.id IN (
SELECT topic_id
FROM topic_allowed_groups tg
JOIN group_users gu ON gu.user_id = 13455 AND gu.group_id =
tg.group_id
WHERE gu.group_id IN (47)
)
)
AND (
topics.id IN (
SELECT ta.topic_id
FROM topic_allowed_users ta
WHERE ta.user_id IN (32852,-10)
)
OR
topics.id IN (
SELECT tg.topic_id
FROM topic_allowed_groups tg
WHERE tg.group_id IN (-10)
)
)
AND (topics.id NOT IN (69933,69995,69988,69984,69968,69973,69971,69952))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at DESC
LIMIT 3;
```
Planning time: 1.277 ms
Execution time: 71.577 ms
```
EXPLAIN ANALYZE SELECT "topics".* FROM "topics"
LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND tu.user_id =
13455
LEFT JOIN (
SELECT * FROM topic_allowed_groups _tg
LEFT JOIN group_users gu
ON gu.user_id = 13455
AND gu.group_id = _tg.group_id
AND gu.group_id IN (47)
) tg ON topics.id = tg.topic_id
LEFT JOIN topic_allowed_users ta2 ON topics.id = ta2.topic_id AND
ta2.user_id IN (32852)
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (tg.topic_id IS NOT NULL)
AND (ta2.topic_id IS NOT NULL)
AND (topics.id NOT IN (69933,69995,69988,69984,69968,69973,69971,69952))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at DESC
LIMIT 3;
```
Planning time: 1.191 ms
Execution time: 0.129 ms
2017-09-13 23:12:59 -04:00
end
2017-09-15 10:21:05 -04:00
def related_messages_group ( params )
2017-09-15 10:45:01 -04:00
messages = messages_for_groups_or_user ( params [ :my_group_ids ] ) . limit ( params [ :count ] )
messages = allowed_messages ( messages , params )
end
def allowed_messages ( messages , params )
user_ids = ( params [ :target_user_ids ] || [ ] )
group_ids = ( ( params [ :target_group_ids ] - params [ :my_group_ids ] ) || [ ] )
if user_ids . present?
messages =
messages . joins ( "
LEFT JOIN topic_allowed_users ta2
ON topics . id = ta2 . topic_id
AND ta2 . user_id IN ( #{sanitize_sql_array(user_ids)})
" )
end
PERF: Avoid unnecessary expensive joins if possible.
```
EXPLAIN ANALYZE SELECT "topics".* FROM "topics"
LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND tu.user_id =
13455
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (
topics.id IN (
SELECT topic_id
FROM topic_allowed_groups tg
JOIN group_users gu ON gu.user_id = 13455 AND gu.group_id =
tg.group_id
WHERE gu.group_id IN (47)
)
)
AND (
topics.id IN (
SELECT ta.topic_id
FROM topic_allowed_users ta
WHERE ta.user_id IN (32852,-10)
)
OR
topics.id IN (
SELECT tg.topic_id
FROM topic_allowed_groups tg
WHERE tg.group_id IN (-10)
)
)
AND (topics.id NOT IN (69933,69995,69988,69984,69968,69973,69971,69952))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at DESC
LIMIT 3;
```
Planning time: 1.277 ms
Execution time: 71.577 ms
```
EXPLAIN ANALYZE SELECT "topics".* FROM "topics"
LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND tu.user_id =
13455
LEFT JOIN (
SELECT * FROM topic_allowed_groups _tg
LEFT JOIN group_users gu
ON gu.user_id = 13455
AND gu.group_id = _tg.group_id
AND gu.group_id IN (47)
) tg ON topics.id = tg.topic_id
LEFT JOIN topic_allowed_users ta2 ON topics.id = ta2.topic_id AND
ta2.user_id IN (32852)
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (tg.topic_id IS NOT NULL)
AND (ta2.topic_id IS NOT NULL)
AND (topics.id NOT IN (69933,69995,69988,69984,69968,69973,69971,69952))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at DESC
LIMIT 3;
```
Planning time: 1.191 ms
Execution time: 0.129 ms
2017-09-13 23:12:59 -04:00
2017-09-15 10:45:01 -04:00
if group_ids . present?
messages =
messages . joins ( "
LEFT JOIN topic_allowed_groups tg2
ON topics . id = tg2 . topic_id
AND tg2 . group_id IN ( #{sanitize_sql_array(group_ids)})
" )
end
messages =
if user_ids . present? && group_ids . present?
messages . where ( " ta2.topic_id IS NOT NULL OR tg2.topic_id IS NOT NULL " )
elsif user_ids . present?
messages . where ( " ta2.topic_id IS NOT NULL " )
elsif group_ids . present?
messages . where ( " tg2.topic_id IS NOT NULL " )
end
2016-02-03 02:50:05 -05:00
end
def messages_for_groups_or_user ( group_ids )
if group_ids . present?
base_messages
2017-09-15 10:45:01 -04:00
. joins ( "
LEFT JOIN (
SELECT * FROM topic_allowed_groups _tg
LEFT JOIN group_users gu
ON gu . user_id = #{@user.id.to_i}
AND gu . group_id = _tg . group_id
WHERE gu . group_id IN ( #{sanitize_sql_array(group_ids)})
) tg ON topics . id = tg . topic_id
" )
. where ( " tg.topic_id IS NOT NULL " )
2016-02-03 02:50:05 -05:00
else
messages_for_user
end
end
def messages_for_user
PERF: Avoid `NOT IN (<subquery>>` which can get really slow.
```
EXPLAIN ANALYZE SELECT "topics".*
FROM "topics" LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND
tu.user_id = 13455
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (
topics.id IN (
SELECT topic_id
FROM topic_allowed_users
WHERE user_id = 13455
)
)
AND (
topics.id IN (
SELECT ta.topic_id
FROM topic_allowed_users ta
WHERE ta.user_id IN (2,1995,8307,17621,22980,-10)
)
OR
topics.id IN (
SELECT tg.topic_id
FROM topic_allowed_groups tg
WHERE tg.group_id IN (-10)
)
)
AND (topics.id NOT IN (68559,60069,42145))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at
DESC LIMIT 5;
```
Planning time: 1.196 ms
Execution time: 21.176 ms
```
EXPLAIN ANALYZE SELECT "topics".*
FROM "topics"
LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND tu.user_id =
13455
LEFT JOIN topic_allowed_users ta ON topics.id = ta.topic_id AND
ta.user_id = 13455
LEFT JOIN topic_allowed_users ta2 ON topics.id = ta2.topic_id AND
ta2.user_id IN (2,1995,8307,17621,22980,-10)
LEFT JOIN topic_allowed_groups tg ON topics.id = tg.topic_id AND
tg.group_id IN (-10)
WHERE ("topics"."deleted_at" IS NULL)
AND (topics.archetype = 'private_message')
AND (ta.topic_id IS NOT NULL)
AND (ta2.topic_id IS NOT NULL OR tg.topic_id IS NOT NULL)
AND (topics.id NOT IN (68559,60069,42145))
AND "topics"."visible" = 't'
ORDER BY topics.bumped_at DESC
LIMIT 5;
```
Planning time: 1.792 ms
Execution time: 2.546 ms
2017-09-13 10:22:33 -04:00
base_messages
. joins ( "
LEFT JOIN topic_allowed_users ta
ON topics . id = ta . topic_id
AND ta . user_id = #{@user.id.to_i}
" )
. where ( " ta.topic_id IS NOT NULL " )
2016-02-03 02:50:05 -05:00
end
def base_messages
2017-05-22 06:05:38 -04:00
query = Topic
2016-02-03 02:50:05 -05:00
. where ( 'topics.archetype = ?' , Archetype . private_message )
. joins ( " LEFT JOIN topic_users tu ON topics.id = tu.topic_id AND tu.user_id = #{ @user . id . to_i } " )
2017-05-22 06:05:38 -04:00
query = query . includes ( :tags ) if SiteSetting . tagging_enabled
query . order ( 'topics.bumped_at DESC' )
2016-02-03 02:50:05 -05:00
end
2014-02-03 00:05:49 -05:00
2017-07-27 21:20:09 -04:00
def random_suggested ( topic , count , excluded_topic_ids = [ ] )
2014-02-04 12:26:38 -05:00
result = default_results ( unordered : true , per_page : count ) . where ( closed : false , archived : false )
2018-01-14 23:32:25 -05:00
if SiteSetting . limit_suggested_to_category
excluded_topic_ids += Category . where ( id : topic . category_id ) . pluck ( :id )
else
excluded_topic_ids += Category . topic_ids . to_a
end
2014-01-28 18:15:36 -05:00
result = result . where ( " topics.id NOT IN (?) " , excluded_topic_ids ) unless excluded_topic_ids . empty?
2013-02-05 14:16:51 -05:00
2014-07-29 00:34:54 -04:00
result = remove_muted_categories ( result , @user )
2013-07-12 14:38:20 -04:00
# If we are in a category, prefer it for the random results
2013-07-16 15:20:18 -04:00
if topic . category_id
2013-07-18 14:47:59 -04:00
result = result . order ( " CASE WHEN topics.category_id = #{ topic . category_id . to_i } THEN 0 ELSE 1 END " )
2013-02-27 18:30:14 -05:00
end
2015-02-25 01:19:12 -05:00
# Best effort, it over selects, however if you have a high number
# of muted categories there is tiny chance we will not select enough
# in particular this can happen if current category is empty and tons
# of muted, big edge case
#
# we over select in case cache is stale
2017-07-27 21:20:09 -04:00
max = ( count * 1 . 3 ) . to_i
2018-01-14 23:32:25 -05:00
ids = SiteSetting . limit_suggested_to_category ? [ ] : RandomTopicSelector . next ( max )
ids . concat ( RandomTopicSelector . next ( max , topic . category ) )
2015-02-25 01:19:12 -05:00
2015-03-02 18:20:42 -05:00
result . where ( id : ids . uniq )
2013-02-05 14:16:51 -05:00
end
2013-08-08 13:18:52 -04:00
def suggested_ordering ( result , options )
# Prefer unread in the same category
if options [ :topic ] && options [ :topic ] . category_id
result = result . order ( " CASE WHEN topics.category_id = #{ options [ :topic ] . category_id . to_i } THEN 0 ELSE 1 END " )
end
2015-02-23 00:50:52 -05:00
result . order ( 'topics.bumped_at DESC' )
2013-08-08 13:18:52 -04:00
end
2017-09-15 10:45:01 -04:00
private
def sanitize_sql_array ( input )
ActiveRecord :: Base . send ( :sanitize_sql_array , input . join ( ',' ) )
end
2013-02-05 14:16:51 -05:00
end