Last User Contacted

Question

I have a User model and a Message one with sender_id and recipient_id.

I would like to retrieve all users I have contacted or have been contacted by.

I tried :

  has_many :message_received_by_user, class_name: 'Message', foreign_key: :recipient_id, select: "DISTINCT ON (messages.sender_id) messages.sender_id, messages.created_at, messages.body" , order: "messages.sender_id, messages.created_at DESC"

But this only give me one side (those who contacted me).

How can I have both sides ?

Many thanks

Answer 1

Below this section is my original answer; I mis-read the question and thought the OP only wanted a list of users who had RECEIVED messages from the specified user; I didn't notice the part about also users who SENT messages to the specified user as well. Here is my update. I'll leave the original answer below in case it helps.

In this version of the answer, I would alter the join and the where clause so that the query examines either the sender_id or recipient_id column:

User.joins("INNER JOIN messages ON (messages.sender_id = users.id OR messages.recipient_id = users.id)")
    .where("messages.sender_id = ? OR messages.recipient_id = ?", current_user.id, current_user.id).uniq

Apologies for the misunderstanding.

---

ORIGINAL ANSWER:

In order to get all the users you've contacted, I am thinking the easiest approach is to do this through the normal active record query methods. First, set up the has_many in your User model like so:

In your User model

has_many :messages_sent, class_name: "Message", foreign_key: :sender_id
has_many :messages_received, class_name: "Message", foreign_key: :recipient_id 

And then, you can simply query using the relationship like so:

User.joins(:messages_received).where(:messages=>{sender_id: current_user.id}).uniq

Note: replace current_user with whatever you use to store the target user.

Edit

Someone asked why this is better than using the direct :messages_sent relationship. The advantage this approach has is that it is all done on the database level, where proper indexing can do its job. If you have a very large table, and this user has sent a large number of messages, using the active record has_many relationship will require you to iterate over a large collection, attempting to find unique users.

Just to add a bit more clarification, this query should render an SQL query that looks something like this:

SELECT users.* 
FROM users INNER JOIN messages ON messages.recipient_id = users.id 
WHERE messages.sender_id = 1

In plain English, this is basically saying to the database: "Please give me all the users who RECEIVED a message SENT by user #1".

Answer 2

You can do like this:

your migration will look like this:

class CreateMessages < ActiveRecord::Migration
  create_table :messages do |t|
    def up
      t.references :sender
      t.references :recipient
      t.string :message
    end
  end
end

You model:-

class Message < ActiveRecord::Base
  belongs_to :sender, class_name => 'User'
  belongs_to :recipient, class_name => 'User'
end

And these other are the associations on the other side (the user model):

class User < ActiveRecord::Base
 has_many :sent_messages, :class_name => 'Message', :foreign_key => 'sender_id'
 has_many :received_messages, :class_name => 'Message', :foreign_key => 'recipient_id'
end

This will allow you to get all of a user's sent or received messages like this:

@user.sent_messages
@user.received_messages

Thanks

Answer 3

refer railscast http://railscasts.com/episodes/163-self-referential-association or How to Implement a Friendship Model in Rails 3 for a Social Networking Application?

I implement it in mongoid as

User model

has_many :friendships, inverse_of: :owner

def friends
  #retrive all the friendships and collect users have sent me a request or being sent a  request.
  fs = Friendship.any_of({:friend_id.in => [self.id]}, {:owner_id.in => [self.id]}).where(state: 'accepted')
  User.in(id: fs.collect{|i| [i.friend_id, i.owner_id]}.flatten - [self.id])
end

Friendship model

 belongs_to :owner, class_name: 'User' #user who sent friend request is the owner
 belongs_to :friend, class_name: "User" #user to whom request is sent.