Wie bekomme ich alle Beiträge von einem bestimmten Benutzer

Question

Ich erstelle meinen eigenen Blog auf Rails mit Posts und Benutzern. Ich muss alle Beiträge von bestimmten Autoren zeigen, wenn ich auf ihn klicke (hier das Konzept: link). Was soll ich dafür tun? Bitte sagen, was zusätzliche Informationen oder Code sollte ich

users_controller hinzufügen:

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 

Benutzermodell:

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 Modell:

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

Dies ist eine recht geradlinig Verwendung von Ruby on Rails. Ich empfehle, Active Record Basics zu lesen, um auf die Geschwindigkeit zu kommen.

Zunächst sollten Sie eine belongs_to Beziehung zwischen Beiträge und Benutzer haben, die wie folgt aussieht:

class User < ActiveRecord::Base 
    has_many :posts 
end 

class Post < ActiveRecord::Base 
    belongs_to :user 
end 

Dies fügt eine .posts Methode zum Benutzer Instanz und ein .user Verfahren zum Beitrag Instanz.

Dann müssen Sie eine Entscheidung darüber treffen, wie die URL-Struktur Ihrer Anwendung funktionieren soll. Hier sind ein paar Optionen aus der Spitze von meinem Kopf:

1. /posts user =: User_ID
2. /posts/von /: user_id
3. /users /: id/Beiträge

Angesichts der Beziehung zwischen einem Benutzer und seinen Posts, meine Empfehlung (und ich glaube, der allgemeine "Rails Way") wäre # 3.So lassen Sie uns die Routen zu config/routes.rb hinzufügen:

Der kurze Weg nur, dass Route zu erstellen:

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

Der lange Weg der Route auf resources Basis zu erstellen:

resources :users do 
    member do 
    get :posts 
    end 
end 

Beide Ansätze werden stellen Sie eine Hilfsmethode mit der Bezeichnung user_posts_path und eine mit der Bezeichnung user_posts_url bereit, die in Ihrer Ansicht verwendet werden kann, um mit der Liste der Benutzerbeiträge unter Verwendung der link_to zu verknüpfen Hilfsmethode:

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

Jetzt haben Sie die Controller-Aktion in app/controllers/users_controller.rb hinzuzufügen:

class UsersController < ActionController::Base 

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

end 

und dann app/views/users/posts.html.erb

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

zu Ihrem HTML/ERB Code hinzufügen, sollten Sie geben die grundlegende Fähigkeit, die Beiträge eines Benutzers anzuzeigen. Sie können es verbessern, indem Sie einen postpartalen oder einige andere nette Abkürzungen wiederverwenden, aber ich überlasse das als eine Übung für Sie, um herauszufinden.

Answer 2

Sie benötigen 2 Modelle: Benutzer und Post. Es gibt eine Beziehung zwischen ihnen: Benutzer hat viele Beiträge, Post gehört zu Benutzer. Um diese Beziehung in einer Datenbank zu erstellen, sollten Sie der Tabelle posts die Spalte user_id hinzufügen. Um dies zu tun einfach den folgenden Befehl ausführen:

rails generate migration AddUserIdToPosts user_id: integer 

Vergessen Sie nicht, rake db auszuführen: wandern nach diesen

Assoziation zu schaffen zwischen den Modellen mit dem User-Modell hinzufügen:

has_many :posts, dependent: :destroy 

Und zu Post-Modell:

belongs_to :user 

Jetzt können Sie 'Benutzer' Methode auf Post und 'Posts' Methode auf Benutzer. Zum Beispiel in show-Aktion von Benutzern Controller:

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

Diese Links werden Ihnen helfen: http://guides.rubyonrails.org/association_basics.html http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html