How can I get all posts from a specific user

Question

I'm creating my own blog on Rails with posts and users. I need to show all posts from specific author when I click on him (here the concept:link). What should I do for this? Please say what extra information or code should I add

users_controller:

class UsersController < ApplicationController
def show
@user = User.find(params[:id])
@posts = @user.posts
  end

end

posts_controller:

class PostsController < ApplicationController
before_filter :authenticate_user!, :except => [:show, :index]

# GET /posts
# GET /posts.json



def index
 @posts = Post.all

  respond_to do |format|
  format.html # index.html.erb
  format.json { render json: @posts }
  end
end

# GET /posts/1
# GET /posts/1.json
def show
@post = Post.find(params[:id])

respond_to do |format|
  format.html # show.html.erb
  format.json { render json: @post }
  end
end

# GET /posts/new
# GET /posts/new.json
def new
 @post = Post.new

  respond_to do |format|
  format.html # new.html.erb
  format.json { render json: @post }
  end
end

# GET /posts/1/edit
def edit
  @post = Post.find(params[:id])
 end

 # POST /posts
# POST /posts.json
 def create
#@post = Post.new(params[:post])
@post = current_user.posts.build(params[:post])
respond_to do |format|
  if @post.save
    format.html { redirect_to @post, notice: 'Post was successfully created.' }
    format.json { render json: @post, status: :created, location: @post }
  else
    format.html { render action: "new" }
    format.json { render json: @post.errors, status: :unprocessable_entity }
    end
  end
 end

# PUT /posts/1
# PUT /posts/1.json
def update
 @post = Post.find(params[:id])

 respond_to do |format|
  if @post.update_attributes(params[:post])
    format.html { redirect_to @post, notice: 'Post was successfully updated.' }
    format.json { head :no_content }
  else
    format.html { render action: "edit" }
    format.json { render json: @post.errors, status: :unprocessable_entity }
    end
  end
end

# DELETE /posts/1
# DELETE /posts/1.json
def destroy
@post = Post.find(params[:id])
@post.destroy

 respond_to do |format|
  format.html { redirect_to posts_url }
  format.json { head :no_content }
  end
 end
end

user model:

class User < ActiveRecord::Base
# Include default devise modules. Others available are:
# :token_authenticatable, :confirmable,
# :lockable, :timeoutable and :omniauthable
has_many :posts, :dependent => :destroy
validates :fullname,      :presence => true, :uniqueness => true
validates :password,      :presence => true
validates :email,         :presence => true, :uniqueness => true


devise :database_authenticatable, :registerable,
     :recoverable, :rememberable, :trackable, :validatable

attr_accessible :email, :password, :password_confirmation, :fullname


end

post model:

class Post < ActiveRecord::Base
attr_accessible :text, :title

validates :user_id, :presence => true
validates :title,   :presence => true
validates :text, :presence => true

belongs_to :user
has_many :comments
end

Answer 1

This is a fairly straight forward use of Ruby on Rails. I recommend reading Active Record Basics to get up to speed.

First, you should have a belongs_to relationship between Posts and Users that looks like this:

class User < ActiveRecord::Base
  has_many :posts
end

class Post < ActiveRecord::Base
  belongs_to :user
end

This adds a .posts method to the User instance and a .user method to the Post instance.

Then you have to make a decision about how you want the URL structure of your application to work. Here are a few options from the top of my head:

1. /posts?user=:user_id
2. /posts/by/:user_id
3. /users/:id/posts

Given the relationship between a User and their Posts, my recommendation (and I believe the general "Rails Way") would be #3. So, let's add the routes to config/routes.rb:

The short way to create JUST that route:

get 'users/:id/posts' => 'users#posts', :as => :user_posts

The long way to create the route based on resources:

resources :users do
  member do
    get :posts
  end
end

Both approaches will provide a helper method called user_posts_path and one called user_posts_url which can be used in your view to link to the list of user posts using the link_to helper method:

<%= link_to post.user.name, user_posts_path(post.user) %>

Now, you have to add the controller action in app/controllers/users_controller.rb:

class UsersController < ActionController::Base

  def posts
    @user = User.find(params[:id])
    @posts = @user.posts
  end

end

and then add your HTML/ERB code to app/views/users/posts.html.erb

<% @posts.each do |post| %>
  <%= post.inspect %>
<% end %>

That should give you the basic ability to show a user's posts. You can enhance it by reusing a post partial or some other nice shortcuts, but I'll leave that as an exercise for you to figure out.

Answer 2

You need 2 models: User and Post. There is a relation between them: User HAS MANY posts, post BELONGS TO user. To create this relation in a database you should add user_id column to posts table. To do this simply run the following command:

rails generate migration AddUserIdToPosts user_id: integer

Don't forget to run rake db:migrate after that

To create association between models add to the User model:

has_many :posts, dependent: :destroy

And to Post model:

belongs_to :user

Now you can use 'user' method on post and 'posts' method on user. For example in show action of users controller:

@user = User.find(params[:id])
@posts = @user.posts

This links will help you: http://guides.rubyonrails.org/association_basics.html http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html