Module: TopicQuery::PrivateMessageLists

Included in:
TopicQuery
Defined in:
lib/topic_query/private_message_lists.rb

Instance Method Summary collapse

Instance Method Details

#filter_private_message_new(user, type) ⇒ Object 



157
158
159
160
161
162
 
# File 'lib/topic_query/private_message_lists.rb', line 157

def filter_private_message_new(user, type)
  TopicQuery.new_filter(
    private_messages_for(user, type),
    treat_as_new_topic_start_date: user.user_option.treat_as_new_topic_start_date,
  )
end

#filter_private_messages_unread(user, type) ⇒ Object 



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/topic_query/private_message_lists.rb', line 135

def filter_private_messages_unread(user, type)
  list = TopicQuery.unread_filter(private_messages_for(user, type), whisperer: user.whisperer?)

  first_unread_pm_at =
    case type
    when :user
      user_first_unread_pm_at(user)
    when :group
      GroupUser.where(user: user, group: group).pick(:first_unread_pm_at)
    else
      user_first_unread_pm_at = user_first_unread_pm_at(user)

      group_first_unread_pm_at = GroupUser.where(user: user).minimum(:first_unread_pm_at)

      [user_first_unread_pm_at, group_first_unread_pm_at].compact.min
    end

  list = list.where("topics.updated_at >= ?", first_unread_pm_at) if first_unread_pm_at

  list
end

#list_private_messages(user, &blk) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/topic_query/private_message_lists.rb', line 5

def list_private_messages(user, &blk)
  list = user_personal_private_messages(user)
  list = not_archived(list, user)
  list = have_posts_from_others(list, user)

  create_list(:private_messages, {}, list, &blk)
end

#list_private_messages_archive(user) ⇒ Object 



27
28
29
30
31
32
33
34
 
# File 'lib/topic_query/private_message_lists.rb', line 27

def list_private_messages_archive(user)
  list = user_personal_private_messages(user)

  list =
    list.joins(:user_archived_messages).where("user_archived_messages.user_id = ?", user.id)

  create_list(:private_messages, {}, list)
end

#list_private_messages_direct_and_groups(user, groups_messages_notification_level: nil, &blk) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/topic_query/private_message_lists.rb', line 13

def list_private_messages_direct_and_groups(user, groups_messages_notification_level: nil, &blk)
  list =
    user_personal_and_groups_private_messages(
      user,
      groups_messages_notification_level: groups_messages_notification_level,
    )

  list = not_archived(list, user)
  list = not_archived_in_groups(list)
  list = have_posts_from_others(list, user)

  create_list(:private_messages, {}, list, &blk)
end

#list_private_messages_group(user) ⇒ Object 



63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/topic_query/private_message_lists.rb', line 63

def list_private_messages_group(user)
  list = user_groups_private_messages(user)

  list = list.joins(<<~SQL)
  LEFT JOIN group_archived_messages gm
  ON gm.topic_id = topics.id AND gm.group_id = #{group.id.to_i}
  SQL

  list = list.where("gm.id IS NULL")
  publish_read_state = !!group.publish_read_state
  list = append_read_state(list, group) if publish_read_state
  create_list(:private_messages, { publish_read_state: publish_read_state, group: group }, list)
end

#list_private_messages_group_archive(user) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/topic_query/private_message_lists.rb', line 77

def list_private_messages_group_archive(user)
  list = user_groups_private_messages(user)

  list = list.joins(<<~SQL)
  INNER JOIN group_archived_messages gm
  ON gm.topic_id = topics.id AND gm.group_id = #{group.id.to_i}
  SQL

  publish_read_state = !!group.publish_read_state
  list = append_read_state(list, group) if publish_read_state
  create_list(:private_messages, { publish_read_state: publish_read_state, group: group }, list)
end

#list_private_messages_group_new(user) ⇒ Object 



90
91
92
93
94
95
96
 
# File 'lib/topic_query/private_message_lists.rb', line 90

def list_private_messages_group_new(user)
  list = filter_private_message_new(user, :group)
  list = remove_dismissed(list, user)
  publish_read_state = !!group.publish_read_state
  list = append_read_state(list, group) if publish_read_state
  create_list(:private_messages, { publish_read_state: publish_read_state, group: group }, list)
end

#list_private_messages_group_unread(user) ⇒ Object 



98
99
100
101
102
103
 
# File 'lib/topic_query/private_message_lists.rb', line 98

def list_private_messages_group_unread(user)
  list = filter_private_messages_unread(user, :group)
  publish_read_state = !!group.publish_read_state
  list = append_read_state(list, group) if publish_read_state
  create_list(:private_messages, { publish_read_state: publish_read_state, group: group }, list)
end

#list_private_messages_new(user, type = :user) ⇒ Object 



50
51
52
53
54
55
56
 
# File 'lib/topic_query/private_message_lists.rb', line 50

def list_private_messages_new(user, type = :user)
  list = filter_private_message_new(user, type)
  list = TopicQuery.remove_muted_tags(list, user, skip_categories: true)
  list = remove_dismissed(list, user)

  create_list(:private_messages, {}, list)
end

#list_private_messages_sent(user) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/topic_query/private_message_lists.rb', line 36

def list_private_messages_sent(user)
  list = user_personal_private_messages(user)

  list = list.where(<<~SQL, user.id)
  EXISTS (
    SELECT 1 FROM posts
    WHERE posts.topic_id = topics.id AND posts.user_id = ?
  )
  SQL

  list = not_archived(list, user)
  create_list(:private_messages, {}, list)
end

#list_private_messages_tag(user) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/topic_query/private_message_lists.rb', line 123

def list_private_messages_tag(user)
  list = user_personal_and_groups_private_messages(user)

  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]}'",
    )

  create_list(:private_messages, {}, list)
end

#list_private_messages_unread(user, type = :user) ⇒ Object 



58
59
60
61
 
# File 'lib/topic_query/private_message_lists.rb', line 58

def list_private_messages_unread(user, type = :user)
  list = filter_private_messages_unread(user, type)
  create_list(:private_messages, {}, list)
end

#list_private_messages_warnings(user) ⇒ Object 



105
106
107
108
109
110
111
 
# File 'lib/topic_query/private_message_lists.rb', line 105

def list_private_messages_warnings(user)
  list = user_personal_private_messages(user)
  list = list.where("topics.subtype = ?", TopicSubtype.moderator_warning)
  # Exclude official warnings that the user created, instead of received
  list = list.where("topics.user_id <> ?", user.id)
  create_list(:private_messages, {}, list)
end

#private_messages_for(user, type) ⇒ Object 



113
114
115
116
117
118
119
120
121
 
# File 'lib/topic_query/private_message_lists.rb', line 113

def private_messages_for(user, type)
  if type == :group
    user_groups_private_messages(user)
  elsif type == :user
    user_personal_private_messages(user)
  elsif type == :all
    user_personal_and_groups_private_messages(user)
  end
end