Ruby on rails 如何通过与其他模型（用户）的关系提取模型（事件）列表？

这有点复杂，我不知道如何实现它。我有一个用户模型和一个关系模型。用户可以互相“跟踪”（就像推特一样）。关系模型设置正确，效果良好

接下来，我有一个事件模型。每个用户都有多个事件（用户和事件之间的多对多关联）。用户“参加”活动

我想做的是拉一个列表，列出所有

当前用户正在参与

当前用户正在跟踪的用户正在参与

如果可能的话，我想通过用户模型访问这个列表，这样我就可以说是current_User.event_feed，它将列出上面提到的所有事件

以下是我的模型：

class Event < ActiveRecord::Base
  attr_accessible :name, 
                  :description, 
                  :event_date, 
                  :location, 
                  :owner_id,
                  :category,
                  :photo

  CATEGORIES = ['Music', 'Outdoors', 'Party']

  has_and_belongs_to_many :users

class事件

和关系模型：

class Relationship < ActiveRecord::Base
  attr_accessible :followed_id

  belongs_to :follower, :class_name => "User"
  belongs_to :followed, :class_name => "User"

  validates :follower_id, :presence => true
  validates :followed_id, :presence => true
end

类关系“用户”
属于：后跟：class\u name=>“用户”
验证：follower_id，：presence=>true
验证：跟在后面的\u id，：presence=>true
结束

和用户模型：

class User < ActiveRecord::Base
  # Include default devise modules. Others available are:
  # :token_authenticatable, :encryptable, :confirmable, :lockable, :timeoutable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :trackable, :validatable

  attr_accessible :email, :password, :password_confirmation, :remember_me
  attr_accessor :password
  attr_accessible :name, :email, :password, :password_confirmation, :time_zone

  has_and_belongs_to_many :events

  has_many :relationships, :dependent => :destroy,
                             :foreign_key => "follower_id"
  has_many :reverse_relationships, :dependent => :destroy,
                                   :foreign_key => "followed_id",
                                   :class_name => "Relationship"
  has_many :following, :through => :relationships, 
                       :source  => :followed
  has_many :followers, :through => :reverse_relationships,
                       :source  => :follower

class用户：破坏，
：foreign\u key=>“follower\u id”
有很多：反向关系，：依赖=>：销毁，
：foreign\u key=>“后跟\u id”，
：class_name=>“关系”
有很多：以下，：通过=>：关系，
：source=>：后面跟着
拥有多个：追随者，：通过=>：反向关系，
：source=>：follower

谢谢

事件模型：

scope :attended, where("event_date < #{Date.today}")

范围：出席，地点（“活动日期<{date.today}”）

用户模型：

# Returns collection of events that are attended by user and users she follows
def attended events
  attended_events = []
  attended_events << events.attended
  followers.each do |follower|
    attended_events << follower.events.attended
  end
  attended_events
end

#返回用户及其关注的用户参与的事件集合
def参加了一些活动
参加的_活动=[]
参加的_活动活动模式：

scope :attended, where("event_date < #{Date.today}")

范围：出席，地点（“活动日期<{date.today}”）

用户模型：

# Returns collection of events that are attended by user and users she follows
def attended events
  attended_events = []
  attended_events << events.attended
  followers.each do |follower|
    attended_events << follower.events.attended
  end
  attended_events
end

#返回用户及其关注的用户参与的事件集合
def参加了一些活动
参加的_活动=[]
当前用户和当前用户参加的已参加\u活动
只需调用
current\u user.events

2）正在由当前用户正在跟踪的用户参与。
这有点棘手。您希望以其他用户事件的扁平化列表结束：
current_user.following.collect{{| friend | friend.events}.flant#=>返回追随者事件数组

由于您希望在一个列表中显示所有事件（根据我收集的信息），我认为presenter类将非常有用：

class EventFeed
    attr_accessor :event, :display_name

   def initialize(event, name)
     self.event = event
     self.name  =  name
   end
end

现在，将它们添加到一起，以访问
当前用户.event\u feed

class User
   def event_feed; []; end
end

把它们粘在一起：

current_user.events.each { |e| current_user.event_feed << EventFeed.new(e, 'YOU') }
current_user.following.each do |friend| 
   friend.events.each { |e| current_user.event_feed << EventFeed.new(e, friend.name) }
end

current_user.event_feed #=> an array of EventFeed objects where you can display "You are going to #{event.name}"

current_user.events.each{e|current_user.event_feed
1）由当前_用户和
只需调用
current\u user.events

2）正在由当前用户正在跟踪的用户参与。
这有点棘手。您希望最终得到其他用户事件的扁平化列表：
current_user.following.collect{{| friend | friend.events}。扁平化#=>返回追随者事件数组

由于您希望在一个列表中显示所有事件（根据我收集的信息），我认为presenter类将非常有用：

class EventFeed
    attr_accessor :event, :display_name

   def initialize(event, name)
     self.event = event
     self.name  =  name
   end
end

现在，将它们添加到一起，以访问
当前用户.event\u feed

class User
   def event_feed; []; end
end

把它们粘在一起：

current_user.events.each { |e| current_user.event_feed << EventFeed.new(e, 'YOU') }
current_user.following.each do |friend| 
   friend.events.each { |e| current_user.event_feed << EventFeed.new(e, friend.name) }
end

current_user.event_feed #=> an array of EventFeed objects where you can display "You are going to #{event.name}"

current|u user.events.each{e|current|u user.event_feed这只是rails 3，但非常优雅（未经测试，希望我对habtm关系的记忆还可以）

class用户ids=self.followers.collect（&:id）这只是Rails3，但相当优雅（未经测试，希望我对habtm关系的记忆还不错）

class用户ids=self.followers.collect（&:id）这很有效。谢谢。有没有办法知道哪个用户与哪个事件相关？这样我就可以有一个事件列表（event\u feed）还可以说哪个用户当前用户正在跟踪列表中生成的事件？这很好。谢谢。有没有办法知道哪个用户与哪个事件相关？这样我就可以有一个事件列表（事件提要），还可以说哪个用户当前用户正在跟踪列表中生成的事件？