在Rails中列出用户配置文件中的相关帖子

Question

Rails v 3.1.3 Ruby v 1.8.7

我们希望在用户的pofile页面上获取所有微博的列表，其中微博的“belongs_to_id”与当前登录用户的“user_id”匹配。

我们数据库的微博表有“belongs_to_id”和“user_id”

保存微博时，登录用户的ID记录为“user_id”，发布的个人资料记录为“belongs_to_id”。

UsersController在这里：

class UsersController < ApplicationController
   before_filter :authenticate, :only => [:index, :edit, :update, :destroy]
   before_filter :correct_user, :only => [:edit, :update]
   before_filter :admin_user,   :only => :destroy

  def index
     @title = "All users"
     @users = User.paginate(:page => params[:page])
  end

  def show

      @user = User.find(params[:id])
      @microposts = @user.microposts.paginate(:page => params[:page])
      @title = @user.name
      @micropost  = current_user.microposts.build(params[:micropost])
end

用户模型：

require 'digest'
class User < ActiveRecord::Base

  has_many :authentications

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

  # Setup accessible (or protected) attributes for your model
  attr_accessible :email, :password, :password_confirmation, :remember_me




   attr_accessible :name, :email, :password, :password_confirmation
    has_many :microposts, :dependent => :destroy
    has_many :relationships, :foreign_key => "follower_id",
                           :dependent => :destroy
    has_many :following, :through => :relationships, :source => :followed
    has_many :reverse_relationships, :foreign_key => "followed_id",
                                   :class_name => "Relationship",
                                   :dependent => :destroy
    has_many :followers, :through => :reverse_relationships, :source => :follower

  email_regex = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i

  validates :name,  :presence => true,
                :length   => { :maximum => 50 }
  validates :email, :presence   => true,
                :format     => { :with => email_regex },
                :uniqueness => { :case_sensitive => false }

  validates :password, :presence     => true,
                                       :confirmation => true,
                                       :length       => { :within => 6..40 }

                                        before_save :encrypt_password





    def has_password?(submitted_password)
      encrypted_password == encrypt(submitted_password)
    end

def self.authenticate(email, submitted_password)
  user = find_by_email(email)
  return nil  if user.nil?
  return user if user.has_password?(submitted_password)
end

def self.authenticate_with_salt(id, cookie_salt)
  user = find_by_id(id)
  (user && user.salt == cookie_salt) ? user : nil
end

def following?(followed)
    relationships.find_by_followed_id(followed)
end

def follow!(followed)
    relationships.create!(:followed_id => followed.id)
end

def unfollow!(followed)
   relationships.find_by_followed_id(followed).destroy
end

def feed
    Micropost.from_users_followed_by(self)
end

def globalfeed
  Micropost.from_users
end

  private

def encrypt_password
  self.salt = make_salt unless has_password?(password)
  self.encrypted_password = encrypt(password)
end

def encrypt(string)
  secure_hash("#{salt}--#{string}")
end

def make_salt
  secure_hash("#{Time.now.utc}--#{password}")
end

def secure_hash(string)
  Digest::SHA2.hexdigest(string)
end
  end

Micropost模型：

class Micropost < ActiveRecord::Base
  attr_accessible :content, :belongs_to_id

  belongs_to :user


  validates :content, :presence => true, :length => { :maximum => 240 }
  validates :user_id, :presence => true

  default_scope :order => 'microposts.created_at DESC'

    # Return microposts from the users being followed by the given user.
    scope :from_users_followed_by, lambda { |user| followed_by(user) }

    private

      # Return an SQL condition for users followed by the given user.
      # We include the user's own id as well.
      def self.followed_by(user)
        following_ids = %(SELECT followed_id FROM relationships
                      WHERE follower_id = :user_id)
        where("user_id IN (#{following_ids}) OR user_id = :user_id",
          { :user_id => user })
    end
  end

MicropostsController：

class MicropostsController < ApplicationController
  before_filter :authenticate, :only => [:create, :destroy]

  def create

    @micropost  = current_user.microposts.build(params[:micropost])
    if @micropost.save
      flash[:success] = "Truth posted!"
      redirect_to current_user
    else
      @feed_items = []
      render 'pages/home'
    end
  end


  def destroy
      @micropost.destroy
      redirect_to root_path
    end
end