Jak mogę uzyskać wszystkie posty od określonego użytkownika?

Question

Tworzę własny blog na temat Railsów z wpisami i użytkownikami. Muszę pokazać wszystkie posty od konkretnego autora, kiedy go klikam (tutaj koncepcja: link). Co powinienem zrobić? Proszę powiedzieć jakie dodatkowe informacje lub kod Dodam

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 

model użytkownika:

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 

modelu postu:

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

Jest to dość proste korzystanie z Ruby on Rails. Polecam lekturę Active Record Basics, aby uzyskać szybki wzrost.

Po pierwsze, trzeba mieć związek belongs_to między słupkami i Użytkowników, który wygląda tak:

class User < ActiveRecord::Base 
    has_many :posts 
end 

class Post < ActiveRecord::Base 
    belongs_to :user 
end 

To dodaje .posts metody do instancji użytkownika i .user metody do instancji post.

Następnie należy podjąć decyzję dotyczącą sposobu działania struktury adresów URL aplikacji. Oto kilka opcji, od szczytu głowy:

1. /postów użytkownika =: user_id
2. /posty/o /: user_id
3. /users /: id/posty

Biorąc pod uwagę relacje między użytkownikiem a ich postami, moje zalecenie (i uważam, że ogólne "Rails Way") byłoby # 3.Tak, dodajmy trasy do config/routes.rb:

Krótka droga do tworzenia tylko, że trasy:

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

długą drogę, aby utworzyć trasę w oparciu o resources:

resources :users do 
    member do 
    get :posts 
    end 
end 

Oba podejścia będzie udostępnić metodę pomocniczą o nazwie user_posts_path i jedną o nazwie user_posts_url, której można użyć w widoku w celu utworzenia łącza do listy postów użytkownika przy użyciu adresu link_to Metoda pomocnik:

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

Teraz trzeba dodać działanie kontrolera w app/controllers/users_controller.rb:

class UsersController < ActionController::Base 

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

end 

a następnie dodać kod HTML/ERB do app/views/users/posts.html.erb

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

To powinno dać podstawowa zdolność do wyświetlania postów użytkownika. Możesz go ulepszyć, ponownie wykorzystując częściowe lub inne przyjemne skróty, ale zostawię to jako ćwiczenie, abyś mógł to zrozumieć.

Answer 2

Potrzebujesz 2 modele: użytkownik i post. Istnieje między nimi relacja: Użytkownik MA WIELE postów, wysyła BIAŁKI DO użytkownika. Aby utworzyć tę relację w bazie danych, należy dodać kolumnę user_id do tabeli postów. Aby to zrobić, po prostu uruchom następujące polecenie:

rails generate migration AddUserIdToPosts user_id: integer 

Nie zapomnij uruchomić rake db: migrować po tym

Aby utworzyć stowarzyszenie między modelami dodać do modelu użytkownika:

has_many :posts, dependent: :destroy 

I na Post model:

belongs_to :user 

Teraz możesz użyć metody "użytkownika" w post i "postu" na użytkownik. Na przykład w show działania kontrolera użytkownicy:

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

Ten link pomoże: http://guides.rubyonrails.org/association_basics.html http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html