FEATURE: suggested messages for messages

FEATURE: clicking envelope takes you to inbox

Suggested messages works somewhat like suggested topics.

- New show up first (in either group inbox or inbox)
- Then unread (in either group inbox or inbox)
- Finally "related" which are messages with same participants as the current pm.

lib/topic_query.rb

@@ -6,6 +6,7 @@
 require_dependency 'topic_list'
 require_dependency 'suggested_topics_builder'
 require_dependency 'topic_query_sql'
+require_dependency 'avatar_lookup'
 
 class TopicQuery
   # Could be rewritten to %i if Ruby 1.9 is no longer supported
@@ -59,16 +60,62 @@ class TopicQuery
 
   # Return a list of suggested topics for a topic
   def list_suggested_for(topic)
+    return if topic.private_message? && !@user
+
     builder = SuggestedTopicsBuilder.new(topic)
 
+    pm_params =
+      if topic.private_message?
+
+        group_ids = topic.topic_allowed_groups
+                      .where('group_id IN (SELECT group_id FROM group_users WHERE user_id = :user_id)', user_id: @user.id)
+                      .pluck(:group_id)
+        {
+          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
+
     # When logged in we start with different results
     if @user
-      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
-    builder.add_results(random_suggested(topic, builder.results_left, builder.excluded_topic_ids)) unless builder.full?
+      if topic.private_message?
 
-    create_list(:suggested, {unordered: true}, builder.results)
+        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
+    end
+
+    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
+
+    params = {unordered: true}
+    if topic.private_message?
+      params[:preload_posters] = true
+    end
+    create_list(:suggested, params, builder.results)
   end
 
   # The latest view of topics
@@ -233,11 +280,26 @@ class TopicQuery
       topics = prioritize_pinned_topics(topics, options)
     end
 
-    topics = topics.to_a.each do |t|
+    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)
+      topics.each do |t|
+        t.posters = t.posters_summary(avatar_lookup: avatar_lookup)
+      end
+    end
+
+    topics.each do |t|
+
       t.allowed_user_ids = filter == :private_messages ? t.allowed_users.map{|u| u.id} : []
     end
 
-    list = TopicList.new(filter, @user, topics.to_a, options.merge(@options))
+    list = TopicList.new(filter, @user, topics, options.merge(@options))
     list.per_page = per_page_setting
     list
   end
@@ -496,6 +558,82 @@ class TopicQuery
       list
     end
 
+    def new_messages(params)
+
+      TopicQuery.new_filter(messages_for_groups_or_user(params[:my_group_ids]), 10.years.ago)
+                .limit(params[:count])
+
+    end
+
+    def unread_messages(params)
+      TopicQuery.unread_filter(messages_for_groups_or_user(params[:my_group_ids]))
+                .limit(params[:count])
+    end
+
+    def related_messages_user(params)
+      messages_for_user
+        .limit(params[:count])
+        .where('topics.id IN (
+                SELECT ta.topic_id
+                FROM topic_allowed_users ta
+                WHERE ta.user_id IN (:user_ids)
+              ) OR
+                topics.id IN (
+                  SELECT tg.topic_id
+                  FROM topic_allowed_groups tg
+                  WHERE tg.group_id IN (:group_ids)
+              )
+              ', user_ids: (params[:target_user_ids] || []) + [-10],
+                 group_ids: ((params[:target_group_ids] - params[:my_group_ids]) || []) + [-10])
+
+    end
+
+    def related_messages_group(params)
+      messages_for_groups_or_user(params[:my_group_ids])
+        .limit(params[:count])
+        .where('topics.id IN (
+                SELECT ta.topic_id
+                FROM topic_allowed_users ta
+                WHERE ta.user_id IN (:user_ids)
+              ) OR
+                topics.id IN (
+                  SELECT tg.topic_id
+                  FROM topic_allowed_groups tg
+                  WHERE tg.group_id IN (:group_ids)
+              )
+              ', user_ids: (params[:target_user_ids] || []) + [-10],
+                 group_ids: ((params[:target_group_ids] - params[:my_group_ids]) || []) + [-10])
+
+    end
+
+    def messages_for_groups_or_user(group_ids)
+      if group_ids.present?
+        base_messages
+          .where('topics.id IN (
+                                  SELECT topic_id
+                                    FROM topic_allowed_groups tg
+                                    JOIN group_users gu ON gu.user_id = :user_id AND gu.group_id = tg.group_id
+                                    WHERE gu.group_id IN (:group_ids)
+                 )', user_id: @user.id, group_ids: group_ids)
+      else
+        messages_for_user
+      end
+    end
+
+    def messages_for_user
+      base_messages.where('topics.id IN (
+                                  SELECT topic_id
+                                    FROM topic_allowed_users
+                                    WHERE user_id = :user_id
+                 )', user_id: @user.id)
+    end
+
+    def base_messages
+      Topic
+        .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}")
+        .order('topics.bumped_at DESC')
+    end
 
     def random_suggested(topic, count, excluded_topic_ids=[])
       result = default_results(unordered: true, per_page: count).where(closed: false, archived: false)